- AbstractExecutorService - Class in java.util.concurrent
-
- AbstractExecutorService() - Constructor for class java.util.concurrent.AbstractExecutorService
-
- AbstractOwnableSynchronizer - Class in java.util.concurrent.locks
-
A synchronizer that may be exclusively owned by a thread.
- AbstractOwnableSynchronizer() - Constructor for class java.util.concurrent.locks.AbstractOwnableSynchronizer
-
Empty constructor for use by subclasses.
- AbstractQueue<E> - Class in java.util
-
This class provides skeletal implementations of some
Queue
operations.
- AbstractQueue() - Constructor for class java.util.AbstractQueue
-
Constructor for use by subclasses.
- AbstractQueuedLongSynchronizer - Class in java.util.concurrent.locks
-
- AbstractQueuedLongSynchronizer() - Constructor for class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Creates a new AbstractQueuedLongSynchronizer instance
with initial synchronization state of zero.
- AbstractQueuedLongSynchronizer.ConditionObject - Class in java.util.concurrent.locks
-
- AbstractQueuedLongSynchronizer.ConditionObject() - Constructor for class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Creates a new ConditionObject instance.
- AbstractQueuedSynchronizer - Class in java.util.concurrent.locks
-
Provides a framework for implementing blocking locks and related
synchronizers (semaphores, events, etc) that rely on
first-in-first-out (FIFO) wait queues.
- AbstractQueuedSynchronizer() - Constructor for class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Creates a new AbstractQueuedSynchronizer instance
with initial synchronization state of zero.
- AbstractQueuedSynchronizer.ConditionObject - Class in java.util.concurrent.locks
-
- AbstractQueuedSynchronizer.ConditionObject() - Constructor for class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Creates a new ConditionObject instance.
- acquire(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Acquires in exclusive mode, ignoring interrupts.
- acquire(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Acquires in exclusive mode, ignoring interrupts.
- acquire() - Method in class java.util.concurrent.Semaphore
-
Acquires a permit from this semaphore, blocking until one is
available, or the thread is
interrupted.
- acquire(int) - Method in class java.util.concurrent.Semaphore
-
Acquires the given number of permits from this semaphore,
blocking until all are available,
or the thread is
interrupted.
- acquireInterruptibly(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Acquires in exclusive mode, aborting if interrupted.
- acquireInterruptibly(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Acquires in exclusive mode, aborting if interrupted.
- acquireShared(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Acquires in shared mode, ignoring interrupts.
- acquireShared(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Acquires in shared mode, ignoring interrupts.
- acquireSharedInterruptibly(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Acquires in shared mode, aborting if interrupted.
- acquireSharedInterruptibly(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Acquires in shared mode, aborting if interrupted.
- acquireUninterruptibly() - Method in class java.util.concurrent.Semaphore
-
Acquires a permit from this semaphore, blocking until one is
available.
- acquireUninterruptibly(int) - Method in class java.util.concurrent.Semaphore
-
Acquires the given number of permits from this semaphore,
blocking until all are available.
- adapt(Runnable) - Static method in class java.util.concurrent.ForkJoinTask
-
Returns a new
ForkJoinTask
that performs the
run
method of the given
Runnable
as its action, and returns
a null result upon
ForkJoinTask.join()
.
- adapt(Runnable, T) - Static method in class java.util.concurrent.ForkJoinTask
-
Returns a new
ForkJoinTask
that performs the
run
method of the given
Runnable
as its action, and returns
the given result upon
ForkJoinTask.join()
.
- adapt(Callable<? extends T>) - Static method in class java.util.concurrent.ForkJoinTask
-
Returns a new
ForkJoinTask
that performs the
call
method of the given
Callable
as its action, and returns
its result upon
ForkJoinTask.join()
, translating any checked exceptions
encountered into
RuntimeException
.
- add(E) - Method in class java.util.AbstractQueue
-
Inserts the specified element into this queue if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and throwing an IllegalStateException
if no space is currently available.
- add(E) - Method in class java.util.ArrayDeque
-
Inserts the specified element at the end of this deque.
- add(E) - Method in class java.util.concurrent.ArrayBlockingQueue
-
Inserts the specified element at the tail of this queue if it is
possible to do so immediately without exceeding the queue's capacity,
returning true
upon success and throwing an
IllegalStateException
if this queue is full.
- add(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and throwing an
IllegalStateException if no space is currently available.
- add(E) - Method in interface java.util.concurrent.BlockingQueue
-
Inserts the specified element into this queue if it is possible to do
so immediately without violating capacity restrictions, returning
true upon success and throwing an
IllegalStateException if no space is currently available.
- add(E) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Inserts the specified element at the tail of this deque.
- add(E) - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Inserts the specified element at the tail of this queue.
- add(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Adds the specified element to this set if it is not already present.
- add(E) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Appends the specified element to the end of this list.
- add(int, E) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Inserts the specified element at the specified position in this
list.
- add(E) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Adds the specified element to this set if it is not already present.
- add(E) - Method in class java.util.concurrent.DelayQueue
-
Inserts the specified element into this delay queue.
- add(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
Inserts the specified element at the end of this deque unless it would
violate capacity restrictions.
- add(E) - Method in class java.util.concurrent.LinkedTransferQueue
-
Inserts the specified element at the tail of this queue.
- add(E) - Method in class java.util.concurrent.PriorityBlockingQueue
-
Inserts the specified element into this priority queue.
- add(E) - Method in interface java.util.Deque
-
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and throwing an
IllegalStateException if no space is currently available.
- add(E) - Method in class java.util.PriorityQueue
-
Inserts the specified element into this priority queue.
- add(E) - Method in interface java.util.Queue
-
Inserts the specified element into this queue if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and throwing an IllegalStateException
if no space is currently available.
- addAll(Collection<? extends E>) - Method in class java.util.AbstractQueue
-
Adds all of the elements in the specified collection to this
queue.
- addAll(Collection<? extends E>) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Appends all of the elements in the specified collection to the end of
this deque, in the order that they are returned by the specified
collection's iterator.
- addAll(Collection<? extends E>) - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Appends all of the elements in the specified collection to the end of
this queue, in the order that they are returned by the specified
collection's iterator.
- addAll(Collection<? extends E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Appends all of the elements in the specified collection to the end
of this list, in the order that they are returned by the specified
collection's iterator.
- addAll(int, Collection<? extends E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Inserts all of the elements in the specified collection into this
list, starting at the specified position.
- addAll(Collection<? extends E>) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Adds all of the elements in the specified collection to this set if
they're not already present.
- addAllAbsent(Collection<? extends E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Appends all of the elements in the specified collection that
are not already contained in this list, to the end of
this list, in the order that they are returned by the
specified collection's iterator.
- addAndGet(int) - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically adds the given value to the current value.
- addAndGet(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically adds the given value to the element at index i
.
- addAndGet(T, int) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically adds the given value to the current value of the field of
the given object managed by this updater.
- addAndGet(long) - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically adds the given value to the current value.
- addAndGet(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically adds the given value to the element at index i
.
- addAndGet(T, long) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically adds the given value to the current value of the field of
the given object managed by this updater.
- addFirst(E) - Method in class java.util.ArrayDeque
-
Inserts the specified element at the front of this deque.
- addFirst(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element at the front of this deque if it is
possible to do so immediately without violating capacity restrictions,
throwing an IllegalStateException if no space is currently
available.
- addFirst(E) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Inserts the specified element at the front of this deque.
- addFirst(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- addFirst(E) - Method in interface java.util.Deque
-
Inserts the specified element at the front of this deque if it is
possible to do so immediately without violating capacity restrictions.
- addIfAbsent(E) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Append the element if not present.
- addLast(E) - Method in class java.util.ArrayDeque
-
Inserts the specified element at the end of this deque.
- addLast(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element at the end of this deque if it is
possible to do so immediately without violating capacity restrictions,
throwing an IllegalStateException if no space is currently
available.
- addLast(E) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Inserts the specified element at the end of this deque.
- addLast(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- addLast(E) - Method in interface java.util.Deque
-
Inserts the specified element at the end of this deque if it is
possible to do so immediately without violating capacity restrictions.
- afterExecute(Runnable, Throwable) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Method invoked upon completion of execution of the given Runnable.
- allowCoreThreadTimeOut(boolean) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Sets the policy governing whether core threads may time out and
terminate if no tasks arrive within the keep-alive time, being
replaced if needed when new tasks arrive.
- allowsCoreThreadTimeOut() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns true if this pool allows core threads to time out and
terminate if no tasks arrive within the keepAlive time, being
replaced if needed when new tasks arrive.
- ArrayBlockingQueue<E> - Class in java.util.concurrent
-
- ArrayBlockingQueue(int) - Constructor for class java.util.concurrent.ArrayBlockingQueue
-
Creates an ArrayBlockingQueue
with the given (fixed)
capacity and default access policy.
- ArrayBlockingQueue(int, boolean) - Constructor for class java.util.concurrent.ArrayBlockingQueue
-
Creates an ArrayBlockingQueue
with the given (fixed)
capacity and the specified access policy.
- ArrayBlockingQueue(int, boolean, Collection<? extends E>) - Constructor for class java.util.concurrent.ArrayBlockingQueue
-
Creates an ArrayBlockingQueue
with the given (fixed)
capacity, the specified access policy and initially containing the
elements of the given collection,
added in traversal order of the collection's iterator.
- ArrayDeque<E> - Class in java.util
-
Resizable-array implementation of the
Deque
interface.
- ArrayDeque() - Constructor for class java.util.ArrayDeque
-
Constructs an empty array deque with an initial capacity
sufficient to hold 16 elements.
- ArrayDeque(int) - Constructor for class java.util.ArrayDeque
-
Constructs an empty array deque with an initial capacity
sufficient to hold the specified number of elements.
- ArrayDeque(Collection<? extends E>) - Constructor for class java.util.ArrayDeque
-
Constructs a deque containing the elements of the specified
collection, in the order they are returned by the collection's
iterator.
- arrive() - Method in class java.util.concurrent.Phaser
-
Arrives at this phaser, without waiting for others to arrive.
- arriveAndAwaitAdvance() - Method in class java.util.concurrent.Phaser
-
Arrives at this phaser and awaits others.
- arriveAndDeregister() - Method in class java.util.concurrent.Phaser
-
Arrives at this phaser and deregisters from it without waiting
for others to arrive.
- AtomicBoolean - Class in java.util.concurrent.atomic
-
A boolean
value that may be updated atomically.
- AtomicBoolean(boolean) - Constructor for class java.util.concurrent.atomic.AtomicBoolean
-
Creates a new AtomicBoolean
with the given initial value.
- AtomicBoolean() - Constructor for class java.util.concurrent.atomic.AtomicBoolean
-
Creates a new AtomicBoolean
with initial value false
.
- AtomicInteger - Class in java.util.concurrent.atomic
-
An int
value that may be updated atomically.
- AtomicInteger(int) - Constructor for class java.util.concurrent.atomic.AtomicInteger
-
Creates a new AtomicInteger with the given initial value.
- AtomicInteger() - Constructor for class java.util.concurrent.atomic.AtomicInteger
-
Creates a new AtomicInteger with initial value 0
.
- AtomicIntegerArray - Class in java.util.concurrent.atomic
-
An int
array in which elements may be updated atomically.
- AtomicIntegerArray(int) - Constructor for class java.util.concurrent.atomic.AtomicIntegerArray
-
Creates a new AtomicIntegerArray of the given length, with all
elements initially zero.
- AtomicIntegerArray(int[]) - Constructor for class java.util.concurrent.atomic.AtomicIntegerArray
-
Creates a new AtomicIntegerArray with the same length as, and
all elements copied from, the given array.
- AtomicIntegerFieldUpdater<T> - Class in java.util.concurrent.atomic
-
A reflection-based utility that enables atomic updates to
designated volatile int
fields of designated classes.
- AtomicIntegerFieldUpdater() - Constructor for class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Protected do-nothing constructor for use by subclasses.
- AtomicLong - Class in java.util.concurrent.atomic
-
A long
value that may be updated atomically.
- AtomicLong(long) - Constructor for class java.util.concurrent.atomic.AtomicLong
-
Creates a new AtomicLong with the given initial value.
- AtomicLong() - Constructor for class java.util.concurrent.atomic.AtomicLong
-
Creates a new AtomicLong with initial value 0
.
- AtomicLongArray - Class in java.util.concurrent.atomic
-
A long
array in which elements may be updated atomically.
- AtomicLongArray(int) - Constructor for class java.util.concurrent.atomic.AtomicLongArray
-
Creates a new AtomicLongArray of the given length, with all
elements initially zero.
- AtomicLongArray(long[]) - Constructor for class java.util.concurrent.atomic.AtomicLongArray
-
Creates a new AtomicLongArray with the same length as, and
all elements copied from, the given array.
- AtomicLongFieldUpdater<T> - Class in java.util.concurrent.atomic
-
A reflection-based utility that enables atomic updates to
designated volatile long
fields of designated classes.
- AtomicLongFieldUpdater() - Constructor for class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Protected do-nothing constructor for use by subclasses.
- AtomicMarkableReference<V> - Class in java.util.concurrent.atomic
-
An AtomicMarkableReference
maintains an object reference
along with a mark bit, that can be updated atomically.
- AtomicMarkableReference(V, boolean) - Constructor for class java.util.concurrent.atomic.AtomicMarkableReference
-
Creates a new AtomicMarkableReference
with the given
initial values.
- AtomicReference<V> - Class in java.util.concurrent.atomic
-
An object reference that may be updated atomically.
- AtomicReference(V) - Constructor for class java.util.concurrent.atomic.AtomicReference
-
Creates a new AtomicReference with the given initial value.
- AtomicReference() - Constructor for class java.util.concurrent.atomic.AtomicReference
-
Creates a new AtomicReference with null initial value.
- AtomicReferenceArray<E> - Class in java.util.concurrent.atomic
-
An array of object references in which elements may be updated
atomically.
- AtomicReferenceArray(int) - Constructor for class java.util.concurrent.atomic.AtomicReferenceArray
-
Creates a new AtomicReferenceArray of the given length, with all
elements initially null.
- AtomicReferenceArray(E[]) - Constructor for class java.util.concurrent.atomic.AtomicReferenceArray
-
Creates a new AtomicReferenceArray with the same length as, and
all elements copied from, the given array.
- AtomicReferenceFieldUpdater<T,V> - Class in java.util.concurrent.atomic
-
A reflection-based utility that enables atomic updates to
designated volatile
reference fields of designated
classes.
- AtomicReferenceFieldUpdater() - Constructor for class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-
Protected do-nothing constructor for use by subclasses.
- AtomicStampedReference<V> - Class in java.util.concurrent.atomic
-
An AtomicStampedReference
maintains an object reference
along with an integer "stamp", that can be updated atomically.
- AtomicStampedReference(V, int) - Constructor for class java.util.concurrent.atomic.AtomicStampedReference
-
Creates a new AtomicStampedReference
with the given
initial values.
- attemptMark(V, boolean) - Method in class java.util.concurrent.atomic.AtomicMarkableReference
-
Atomically sets the value of the mark to the given update value
if the current reference is ==
to the expected
reference.
- attemptStamp(V, int) - Method in class java.util.concurrent.atomic.AtomicStampedReference
-
Atomically sets the value of the stamp to the given update value
if the current reference is ==
to the expected
reference.
- availablePermits() - Method in class java.util.concurrent.Semaphore
-
Returns the current number of permits available in this semaphore.
- await() - Method in class java.util.concurrent.CountDownLatch
-
Causes the current thread to wait until the latch has counted down to
zero, unless the thread is
interrupted.
- await(long, TimeUnit) - Method in class java.util.concurrent.CountDownLatch
-
Causes the current thread to wait until the latch has counted down to
zero, unless the thread is
interrupted,
or the specified waiting time elapses.
- await() - Method in class java.util.concurrent.CyclicBarrier
-
Waits until all
parties have invoked
await on this barrier.
- await(long, TimeUnit) - Method in class java.util.concurrent.CyclicBarrier
-
Waits until all
parties have invoked
await on this barrier, or the specified waiting time elapses.
- await() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Implements interruptible condition wait.
- await(long, TimeUnit) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Implements timed condition wait.
- await() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Implements interruptible condition wait.
- await(long, TimeUnit) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Implements timed condition wait.
- await() - Method in interface java.util.concurrent.locks.Condition
-
Causes the current thread to wait until it is signalled or
interrupted.
- await(long, TimeUnit) - Method in interface java.util.concurrent.locks.Condition
-
Causes the current thread to wait until it is signalled or interrupted,
or the specified waiting time elapses.
- awaitAdvance(int) - Method in class java.util.concurrent.Phaser
-
Awaits the phase of this phaser to advance from the given phase
value, returning immediately if the current phase is not equal
to the given phase value or this phaser is terminated.
- awaitAdvanceInterruptibly(int) - Method in class java.util.concurrent.Phaser
-
Awaits the phase of this phaser to advance from the given phase
value, throwing InterruptedException
if interrupted
while waiting, or returning immediately if the current phase is
not equal to the given phase value or this phaser is
terminated.
- awaitAdvanceInterruptibly(int, long, TimeUnit) - Method in class java.util.concurrent.Phaser
-
Awaits the phase of this phaser to advance from the given phase
value or the given timeout to elapse, throwing InterruptedException
if interrupted while waiting, or
returning immediately if the current phase is not equal to the
given phase value or this phaser is terminated.
- awaitNanos(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Implements timed condition wait.
- awaitNanos(long) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Implements timed condition wait.
- awaitNanos(long) - Method in interface java.util.concurrent.locks.Condition
-
Causes the current thread to wait until it is signalled or interrupted,
or the specified waiting time elapses.
- awaitTermination(long, TimeUnit) - Method in interface java.util.concurrent.ExecutorService
-
Blocks until all tasks have completed execution after a shutdown
request, or the timeout occurs, or the current thread is
interrupted, whichever happens first.
- awaitTermination(long, TimeUnit) - Method in class java.util.concurrent.ForkJoinPool
-
Blocks until all tasks have completed execution after a shutdown
request, or the timeout occurs, or the current thread is
interrupted, whichever happens first.
- awaitTermination(long, TimeUnit) - Method in class java.util.concurrent.ThreadPoolExecutor
-
- awaitUninterruptibly() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Implements uninterruptible condition wait.
- awaitUninterruptibly() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Implements uninterruptible condition wait.
- awaitUninterruptibly() - Method in interface java.util.concurrent.locks.Condition
-
Causes the current thread to wait until it is signalled.
- awaitUntil(Date) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Implements absolute timed condition wait.
- awaitUntil(Date) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Implements absolute timed condition wait.
- awaitUntil(Date) - Method in interface java.util.concurrent.locks.Condition
-
Causes the current thread to wait until it is signalled or interrupted,
or the specified deadline elapses.
- call() - Method in interface java.util.concurrent.Callable
-
Computes a result, or throws an exception if unable to do so.
- Callable<V> - Interface in java.util.concurrent
-
A task that returns a result and may throw an exception.
- callable(Runnable, T) - Static method in class java.util.concurrent.Executors
-
Returns a
Callable
object that, when
called, runs the given task and returns the given result.
- callable(Runnable) - Static method in class java.util.concurrent.Executors
-
Returns a
Callable
object that, when
called, runs the given task and returns
null.
- callable(PrivilegedAction<?>) - Static method in class java.util.concurrent.Executors
-
Returns a
Callable
object that, when
called, runs the given privileged action and returns its result.
- callable(PrivilegedExceptionAction<?>) - Static method in class java.util.concurrent.Executors
-
Returns a
Callable
object that, when
called, runs the given privileged exception action and returns
its result.
- cancel(boolean) - Method in class java.util.concurrent.ForkJoinTask
-
Attempts to cancel execution of this task.
- cancel(boolean) - Method in interface java.util.concurrent.Future
-
Attempts to cancel execution of this task.
- cancel(boolean) - Method in class java.util.concurrent.FutureTask
-
- CancellationException - Exception in java.util.concurrent
-
Exception indicating that the result of a value-producing task,
such as a
FutureTask
, cannot be retrieved because the task
was cancelled.
- CancellationException() - Constructor for exception java.util.concurrent.CancellationException
-
Constructs a CancellationException with no detail message.
- CancellationException(String) - Constructor for exception java.util.concurrent.CancellationException
-
Constructs a CancellationException with the specified detail
message.
- ceiling(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- ceiling(E) - Method in interface java.util.NavigableSet
-
Returns the least element in this set greater than or equal to
the given element, or null
if there is no such element.
- ceilingEntry(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Returns a key-value mapping associated with the least key
greater than or equal to the given key, or null if
there is no such entry.
- ceilingEntry(K) - Method in interface java.util.NavigableMap
-
Returns a key-value mapping associated with the least key
greater than or equal to the given key, or null
if
there is no such key.
- ceilingKey(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
- ceilingKey(K) - Method in interface java.util.NavigableMap
-
Returns the least key greater than or equal to the given key,
or null
if there is no such key.
- clear() - Method in class java.util.AbstractQueue
-
Removes all of the elements from this queue.
- clear() - Method in class java.util.ArrayDeque
-
Removes all of the elements from this deque.
- clear() - Method in class java.util.concurrent.ArrayBlockingQueue
-
Atomically removes all of the elements from this queue.
- clear() - Method in class java.util.concurrent.ConcurrentHashMap
-
Removes all of the mappings from this map.
- clear() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Removes all of the elements from this deque.
- clear() - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Removes all of the mappings from this map.
- clear() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Removes all of the elements from this set.
- clear() - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Removes all of the elements from this list.
- clear() - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Removes all of the elements from this set.
- clear() - Method in class java.util.concurrent.DelayQueue
-
Atomically removes all of the elements from this delay queue.
- clear() - Method in class java.util.concurrent.LinkedBlockingDeque
-
Atomically removes all of the elements from this deque.
- clear() - Method in class java.util.concurrent.LinkedBlockingQueue
-
Atomically removes all of the elements from this queue.
- clear() - Method in class java.util.concurrent.PriorityBlockingQueue
-
Atomically removes all of the elements from this queue.
- clear() - Method in class java.util.concurrent.SynchronousQueue
-
Does nothing.
- clear() - Method in class java.util.PriorityQueue
-
Removes all of the elements from this priority queue.
- clone() - Method in class java.util.ArrayDeque
-
Returns a copy of this deque.
- clone() - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Returns a shallow copy of this ConcurrentSkipListMap
instance.
- clone() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Returns a shallow copy of this ConcurrentSkipListSet
instance.
- clone() - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns a shallow copy of this list.
- comparator() - Method in class java.util.concurrent.ConcurrentSkipListMap
-
- comparator() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- comparator() - Method in class java.util.concurrent.PriorityBlockingQueue
-
Returns the comparator used to order the elements in this queue,
or
null
if this queue uses the
natural ordering of its elements.
- comparator() - Method in class java.util.PriorityQueue
-
Returns the comparator used to order the elements in this
queue, or
null
if this queue is sorted according to
the
natural ordering of its elements.
- compareAndSet(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
-
Atomically sets the value to the given updated value
if the current value ==
the expected value.
- compareAndSet(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically sets the value to the given updated value
if the current value ==
the expected value.
- compareAndSet(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically sets the element at position i
to the given
updated value if the current value ==
the expected value.
- compareAndSet(T, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically sets the field of the given object managed by this updater
to the given updated value if the current value ==
the
expected value.
- compareAndSet(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically sets the value to the given updated value
if the current value ==
the expected value.
- compareAndSet(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically sets the element at position i
to the given
updated value if the current value ==
the expected value.
- compareAndSet(T, long, long) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically sets the field of the given object managed by this updater
to the given updated value if the current value ==
the
expected value.
- compareAndSet(V, V, boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicMarkableReference
-
Atomically sets the value of both the reference and mark
to the given update values if the
current reference is ==
to the expected reference
and the current mark is equal to the expected mark.
- compareAndSet(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
-
Atomically sets the value to the given updated value
if the current value ==
the expected value.
- compareAndSet(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
-
Atomically sets the element at position i
to the given
updated value if the current value ==
the expected value.
- compareAndSet(T, V, V) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-
Atomically sets the field of the given object managed by this updater
to the given updated value if the current value ==
the
expected value.
- compareAndSet(V, V, int, int) - Method in class java.util.concurrent.atomic.AtomicStampedReference
-
Atomically sets the value of both the reference and stamp
to the given update values if the
current reference is ==
to the expected reference
and the current stamp is equal to the expected stamp.
- compareAndSetState(long, long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Atomically sets synchronization state to the given updated
value if the current state value equals the expected value.
- compareAndSetState(int, int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Atomically sets synchronization state to the given updated
value if the current state value equals the expected value.
- complete(V) - Method in class java.util.concurrent.ForkJoinTask
-
Completes this task, and if not already aborted or cancelled,
returning the given value as the result of subsequent
invocations of join
and related operations.
- completeExceptionally(Throwable) - Method in class java.util.concurrent.ForkJoinTask
-
Completes this task abnormally, and if not already aborted or
cancelled, causes it to throw the given exception upon
join
and related operations.
- CompletionService<V> - Interface in java.util.concurrent
-
A service that decouples the production of new asynchronous tasks
from the consumption of the results of completed tasks.
- compute() - Method in class java.util.concurrent.RecursiveAction
-
The main computation performed by this task.
- compute() - Method in class java.util.concurrent.RecursiveTask
-
The main computation performed by this task.
- ConcurrentHashMap<K,V> - Class in java.util.concurrent
-
A hash table supporting full concurrency of retrievals and
adjustable expected concurrency for updates.
- ConcurrentHashMap(int, float, int) - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new, empty map with the specified initial
capacity, load factor and concurrency level.
- ConcurrentHashMap(int, float) - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new, empty map with the specified initial capacity
and load factor and with the default concurrencyLevel (16).
- ConcurrentHashMap(int) - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new, empty map with the specified initial capacity,
and with default load factor (0.75) and concurrencyLevel (16).
- ConcurrentHashMap() - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new, empty map with a default initial capacity (16),
load factor (0.75) and concurrencyLevel (16).
- ConcurrentHashMap(Map<? extends K, ? extends V>) - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new map with the same mappings as the given map.
- ConcurrentLinkedDeque<E> - Class in java.util.concurrent
-
An unbounded concurrent
deque based on linked nodes.
- ConcurrentLinkedDeque() - Constructor for class java.util.concurrent.ConcurrentLinkedDeque
-
Constructs an empty deque.
- ConcurrentLinkedDeque(Collection<? extends E>) - Constructor for class java.util.concurrent.ConcurrentLinkedDeque
-
Constructs a deque initially containing the elements of
the given collection, added in traversal order of the
collection's iterator.
- ConcurrentLinkedQueue<E> - Class in java.util.concurrent
-
An unbounded thread-safe
queue based on linked nodes.
- ConcurrentLinkedQueue() - Constructor for class java.util.concurrent.ConcurrentLinkedQueue
-
Creates a ConcurrentLinkedQueue
that is initially empty.
- ConcurrentLinkedQueue(Collection<? extends E>) - Constructor for class java.util.concurrent.ConcurrentLinkedQueue
-
Creates a ConcurrentLinkedQueue
initially containing the elements of the given collection,
added in traversal order of the collection's iterator.
- ConcurrentMap<K,V> - Interface in java.util.concurrent
-
A
Map
providing additional atomic
putIfAbsent,
remove, and
replace methods.
- ConcurrentNavigableMap<K,V> - Interface in java.util.concurrent
-
- ConcurrentSkipListMap<K,V> - Class in java.util.concurrent
-
- ConcurrentSkipListMap() - Constructor for class java.util.concurrent.ConcurrentSkipListMap
-
Constructs a new, empty map, sorted according to the
natural ordering of the keys.
- ConcurrentSkipListMap(Comparator<? super K>) - Constructor for class java.util.concurrent.ConcurrentSkipListMap
-
Constructs a new, empty map, sorted according to the specified
comparator.
- ConcurrentSkipListMap(Map<? extends K, ? extends V>) - Constructor for class java.util.concurrent.ConcurrentSkipListMap
-
Constructs a new map containing the same mappings as the given map,
sorted according to the
natural ordering of
the keys.
- ConcurrentSkipListMap(SortedMap<K, ? extends V>) - Constructor for class java.util.concurrent.ConcurrentSkipListMap
-
Constructs a new map containing the same mappings and using the
same ordering as the specified sorted map.
- ConcurrentSkipListSet<E> - Class in java.util.concurrent
-
- ConcurrentSkipListSet() - Constructor for class java.util.concurrent.ConcurrentSkipListSet
-
Constructs a new, empty set that orders its elements according to
their
natural ordering.
- ConcurrentSkipListSet(Comparator<? super E>) - Constructor for class java.util.concurrent.ConcurrentSkipListSet
-
Constructs a new, empty set that orders its elements according to
the specified comparator.
- ConcurrentSkipListSet(Collection<? extends E>) - Constructor for class java.util.concurrent.ConcurrentSkipListSet
-
Constructs a new set containing the elements in the specified
collection, that orders its elements according to their
natural ordering.
- ConcurrentSkipListSet(SortedSet<E>) - Constructor for class java.util.concurrent.ConcurrentSkipListSet
-
Constructs a new set containing the same elements and using the
same ordering as the specified sorted set.
- Condition - Interface in java.util.concurrent.locks
-
Condition
factors out the
Object
monitor
methods (
wait
,
notify
and
notifyAll
) into distinct objects to
give the effect of having multiple wait-sets per object, by
combining them with the use of arbitrary
Lock
implementations.
- contains(Object) - Method in class java.util.ArrayDeque
-
Returns true if this deque contains the specified element.
- contains(Object) - Method in class java.util.concurrent.ArrayBlockingQueue
-
Returns true
if this queue contains the specified element.
- contains(Object) - Method in interface java.util.concurrent.BlockingDeque
-
Returns true if this deque contains the specified element.
- contains(Object) - Method in interface java.util.concurrent.BlockingQueue
-
Returns true if this queue contains the specified element.
- contains(Object) - Method in class java.util.concurrent.ConcurrentHashMap
-
Legacy method testing if some key maps into the specified value
in this table.
- contains(Object) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Returns true
if this deque contains at least one
element e
such that o.equals(e)
.
- contains(Object) - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Returns true
if this queue contains the specified element.
- contains(Object) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Returns true if this set contains the specified element.
- contains(Object) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns true if this list contains the specified element.
- contains(Object) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Returns true if this set contains the specified element.
- contains(Object) - Method in class java.util.concurrent.LinkedBlockingDeque
-
Returns true
if this deque contains the specified element.
- contains(Object) - Method in class java.util.concurrent.LinkedBlockingQueue
-
Returns true
if this queue contains the specified element.
- contains(Object) - Method in class java.util.concurrent.LinkedTransferQueue
-
Returns true
if this queue contains the specified element.
- contains(Object) - Method in class java.util.concurrent.PriorityBlockingQueue
-
Returns true
if this queue contains the specified element.
- contains(Object) - Method in class java.util.concurrent.SynchronousQueue
-
Always returns false.
- contains(Object) - Method in interface java.util.Deque
-
Returns true if this deque contains the specified element.
- contains(Object) - Method in class java.util.PriorityQueue
-
Returns true
if this queue contains the specified element.
- containsAll(Collection<?>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns true if this list contains all of the elements of the
specified collection.
- containsAll(Collection<?>) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Returns true if this set contains all of the elements of the
specified collection.
- containsAll(Collection<?>) - Method in class java.util.concurrent.SynchronousQueue
-
Returns false unless the given collection is empty.
- containsKey(Object) - Method in class java.util.concurrent.ConcurrentHashMap
-
Tests if the specified object is a key in this table.
- containsKey(Object) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Returns true if this map contains a mapping for the specified
key.
- containsValue(Object) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns true if this map maps one or more keys to the
specified value.
- containsValue(Object) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Returns true if this map maps one or more keys to the
specified value.
- convert(long, TimeUnit) - Method in enum java.util.concurrent.TimeUnit
-
Convert the given time duration in the given unit to this
unit.
- CopyOnWriteArrayList<E> - Class in java.util.concurrent
-
A thread-safe variant of
ArrayList
in which all mutative
operations (
add,
set, and so on) are implemented by
making a fresh copy of the underlying array.
- CopyOnWriteArrayList() - Constructor for class java.util.concurrent.CopyOnWriteArrayList
-
Creates an empty list.
- CopyOnWriteArrayList(Collection<? extends E>) - Constructor for class java.util.concurrent.CopyOnWriteArrayList
-
Creates a list containing the elements of the specified
collection, in the order they are returned by the collection's
iterator.
- CopyOnWriteArrayList(E[]) - Constructor for class java.util.concurrent.CopyOnWriteArrayList
-
Creates a list holding a copy of the given array.
- CopyOnWriteArraySet<E> - Class in java.util.concurrent
-
- CopyOnWriteArraySet() - Constructor for class java.util.concurrent.CopyOnWriteArraySet
-
Creates an empty set.
- CopyOnWriteArraySet(Collection<? extends E>) - Constructor for class java.util.concurrent.CopyOnWriteArraySet
-
Creates a set containing all of the elements of the specified
collection.
- countDown() - Method in class java.util.concurrent.CountDownLatch
-
Decrements the count of the latch, releasing all waiting threads if
the count reaches zero.
- CountDownLatch - Class in java.util.concurrent
-
A synchronization aid that allows one or more threads to wait until
a set of operations being performed in other threads completes.
- CountDownLatch(int) - Constructor for class java.util.concurrent.CountDownLatch
-
Constructs a CountDownLatch
initialized with the given count.
- current() - Static method in class java.util.concurrent.ThreadLocalRandom
-
Returns the current thread's ThreadLocalRandom
.
- CyclicBarrier - Class in java.util.concurrent
-
A synchronization aid that allows a set of threads to all wait for
each other to reach a common barrier point.
- CyclicBarrier(int, Runnable) - Constructor for class java.util.concurrent.CyclicBarrier
-
Creates a new CyclicBarrier that will trip when the
given number of parties (threads) are waiting upon it, and which
will execute the given barrier action when the barrier is tripped,
performed by the last thread entering the barrier.
- CyclicBarrier(int) - Constructor for class java.util.concurrent.CyclicBarrier
-
Creates a new CyclicBarrier that will trip when the
given number of parties (threads) are waiting upon it, and
does not perform a predefined action when the barrier is tripped.
- get() - Method in class java.util.concurrent.atomic.AtomicBoolean
-
Returns the current value.
- get() - Method in class java.util.concurrent.atomic.AtomicInteger
-
Gets the current value.
- get(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Gets the current value at position i
.
- get(T) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Gets the current value held in the field of the given object managed
by this updater.
- get() - Method in class java.util.concurrent.atomic.AtomicLong
-
Gets the current value.
- get(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Gets the current value at position i
.
- get(T) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Gets the current value held in the field of the given object managed
by this updater.
- get(boolean[]) - Method in class java.util.concurrent.atomic.AtomicMarkableReference
-
Returns the current values of both the reference and the mark.
- get() - Method in class java.util.concurrent.atomic.AtomicReference
-
Gets the current value.
- get(int) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
-
Gets the current value at position i
.
- get(T) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-
Gets the current value held in the field of the given object managed
by this updater.
- get(int[]) - Method in class java.util.concurrent.atomic.AtomicStampedReference
-
Returns the current values of both the reference and the stamp.
- get(Object) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the value to which the specified key is mapped,
or null
if this map contains no mapping for the key.
- get(Object) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Returns the value to which the specified key is mapped,
or null
if this map contains no mapping for the key.
- get(int) - Method in class java.util.concurrent.CopyOnWriteArrayList
- get() - Method in class java.util.concurrent.ForkJoinTask
-
Waits if necessary for the computation to complete, and then
retrieves its result.
- get(long, TimeUnit) - Method in class java.util.concurrent.ForkJoinTask
-
Waits if necessary for at most the given time for the computation
to complete, and then retrieves its result, if available.
- get() - Method in interface java.util.concurrent.Future
-
Waits if necessary for the computation to complete, and then
retrieves its result.
- get(long, TimeUnit) - Method in interface java.util.concurrent.Future
-
Waits if necessary for at most the given time for the computation
to complete, and then retrieves its result, if available.
- get() - Method in class java.util.concurrent.FutureTask
-
- get(long, TimeUnit) - Method in class java.util.concurrent.FutureTask
-
- getActiveCount() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the approximate number of threads that are actively
executing tasks.
- getActiveThreadCount() - Method in class java.util.concurrent.ForkJoinPool
-
Returns an estimate of the number of threads that are currently
stealing or executing tasks.
- getAndAdd(int) - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically adds the given value to the current value.
- getAndAdd(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically adds the given value to the element at index i
.
- getAndAdd(T, int) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically adds the given value to the current value of the field of
the given object managed by this updater.
- getAndAdd(long) - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically adds the given value to the current value.
- getAndAdd(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically adds the given value to the element at index i
.
- getAndAdd(T, long) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically adds the given value to the current value of the field of
the given object managed by this updater.
- getAndDecrement() - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically decrements by one the current value.
- getAndDecrement(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically decrements by one the element at index i
.
- getAndDecrement(T) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically decrements by one the current value of the field of the
given object managed by this updater.
- getAndDecrement() - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically decrements by one the current value.
- getAndDecrement(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically decrements by one the element at index i
.
- getAndDecrement(T) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically decrements by one the current value of the field of the
given object managed by this updater.
- getAndIncrement() - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically increments by one the current value.
- getAndIncrement(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically increments by one the element at index i
.
- getAndIncrement(T) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically increments by one the current value of the field of the
given object managed by this updater.
- getAndIncrement() - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically increments by one the current value.
- getAndIncrement(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically increments by one the element at index i
.
- getAndIncrement(T) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically increments by one the current value of the field of the
given object managed by this updater.
- getAndSet(boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
-
Atomically sets to the given value and returns the previous value.
- getAndSet(int) - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically sets to the given value and returns the old value.
- getAndSet(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically sets the element at position i
to the given
value and returns the old value.
- getAndSet(T, int) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically sets the field of the given object managed by this updater
to the given value and returns the old value.
- getAndSet(long) - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically sets to the given value and returns the old value.
- getAndSet(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically sets the element at position i
to the given value
and returns the old value.
- getAndSet(T, long) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically sets the field of the given object managed by this updater
to the given value and returns the old value.
- getAndSet(V) - Method in class java.util.concurrent.atomic.AtomicReference
-
Atomically sets to the given value and returns the old value.
- getAndSet(int, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
-
Atomically sets the element at position i
to the given
value and returns the old value.
- getAndSet(T, V) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-
Atomically sets the field of the given object managed by this updater
to the given value and returns the old value.
- getArrivedParties() - Method in class java.util.concurrent.Phaser
-
Returns the number of registered parties that have arrived at
the current phase of this phaser.
- getAsyncMode() - Method in class java.util.concurrent.ForkJoinPool
-
Returns true
if this pool uses local first-in-first-out
scheduling mode for forked tasks that are never joined.
- getBlocker(Thread) - Static method in class java.util.concurrent.locks.LockSupport
-
Returns the blocker object supplied to the most recent
invocation of a park method that has not yet unblocked, or null
if not blocked.
- getCompletedTaskCount() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the approximate total number of tasks that have
completed execution.
- getContinueExistingPeriodicTasksAfterShutdownPolicy() - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Gets the policy on whether to continue executing existing
periodic tasks even when this executor has been shutdown
.
- getCorePoolSize() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the core number of threads.
- getCount() - Method in class java.util.concurrent.CountDownLatch
-
Returns the current count.
- getDelay(TimeUnit) - Method in interface java.util.concurrent.Delayed
-
Returns the remaining delay associated with this object, in the
given time unit.
- getException() - Method in class java.util.concurrent.ForkJoinTask
-
Returns the exception thrown by the base computation, or a
CancellationException
if cancelled, or null
if
none or if the method has not yet completed.
- getExclusiveOwnerThread() - Method in class java.util.concurrent.locks.AbstractOwnableSynchronizer
-
Returns the thread last set by
setExclusiveOwnerThread, or null if never
set.
- getExclusiveQueuedThreads() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns a collection containing threads that may be waiting to
acquire in exclusive mode.
- getExclusiveQueuedThreads() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns a collection containing threads that may be waiting to
acquire in exclusive mode.
- getExecuteExistingDelayedTasksAfterShutdownPolicy() - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Gets the policy on whether to execute existing delayed
tasks even when this executor has been shutdown
.
- getFactory() - Method in class java.util.concurrent.ForkJoinPool
-
Returns the factory used for constructing new workers.
- getFirst() - Method in class java.util.ArrayDeque
-
- getFirst() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- getFirst() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- getFirst() - Method in interface java.util.Deque
-
Retrieves, but does not remove, the first element of this deque.
- getFirstQueuedThread() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns the first (longest-waiting) thread in the queue, or
null
if no threads are currently queued.
- getFirstQueuedThread() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns the first (longest-waiting) thread in the queue, or
null
if no threads are currently queued.
- getHoldCount() - Method in class java.util.concurrent.locks.ReentrantLock
-
Queries the number of holds on this lock by the current thread.
- getHoldCount() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
-
Queries the number of holds on this write lock by the current
thread.
- getKeepAliveTime(TimeUnit) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the thread keep-alive time, which is the amount of time
that threads in excess of the core pool size may remain
idle before being terminated.
- getLargestPoolSize() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the largest number of threads that have ever
simultaneously been in the pool.
- getLast() - Method in class java.util.ArrayDeque
-
- getLast() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- getLast() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- getLast() - Method in interface java.util.Deque
-
Retrieves, but does not remove, the last element of this deque.
- getMaximumPoolSize() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the maximum allowed number of threads.
- getNumberWaiting() - Method in class java.util.concurrent.CyclicBarrier
-
Returns the number of parties currently waiting at the barrier.
- getOwner() - Method in class java.util.concurrent.locks.ReentrantLock
-
Returns the thread that currently owns this lock, or
null
if not owned.
- getOwner() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns the thread that currently owns the write lock, or
null
if not owned.
- getParallelism() - Method in class java.util.concurrent.ForkJoinPool
-
Returns the targeted parallelism level of this pool.
- getParent() - Method in class java.util.concurrent.Phaser
-
Returns the parent of this phaser, or null
if none.
- getParties() - Method in class java.util.concurrent.CyclicBarrier
-
Returns the number of parties required to trip this barrier.
- getPhase() - Method in class java.util.concurrent.Phaser
-
Returns the current phase number.
- getPool() - Static method in class java.util.concurrent.ForkJoinTask
-
Returns the pool hosting the current task execution, or null
if this task is executing outside of any ForkJoinPool.
- getPool() - Method in class java.util.concurrent.ForkJoinWorkerThread
-
Returns the pool hosting this thread.
- getPoolIndex() - Method in class java.util.concurrent.ForkJoinWorkerThread
-
Returns the index number of this thread in its pool.
- getPoolSize() - Method in class java.util.concurrent.ForkJoinPool
-
Returns the number of worker threads that have started but not
yet terminated.
- getPoolSize() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the current number of threads in the pool.
- getQueue() - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Returns the task queue used by this executor.
- getQueue() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the task queue used by this executor.
- getQueuedReaderThreads() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns a collection containing threads that may be waiting to
acquire the read lock.
- getQueuedSubmissionCount() - Method in class java.util.concurrent.ForkJoinPool
-
Returns an estimate of the number of tasks submitted to this
pool that have not yet begun executing.
- getQueuedTaskCount() - Method in class java.util.concurrent.ForkJoinPool
-
Returns an estimate of the total number of tasks currently held
in queues by worker threads (but not including tasks submitted
to the pool that have not begun executing).
- getQueuedTaskCount() - Static method in class java.util.concurrent.ForkJoinTask
-
Returns an estimate of the number of tasks that have been
forked by the current worker thread but not yet executed.
- getQueuedThreads() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns a collection containing threads that may be waiting to
acquire.
- getQueuedThreads() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns a collection containing threads that may be waiting to
acquire.
- getQueuedThreads() - Method in class java.util.concurrent.locks.ReentrantLock
-
Returns a collection containing threads that may be waiting to
acquire this lock.
- getQueuedThreads() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns a collection containing threads that may be waiting to
acquire either the read or write lock.
- getQueuedThreads() - Method in class java.util.concurrent.Semaphore
-
Returns a collection containing threads that may be waiting to acquire.
- getQueuedWriterThreads() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns a collection containing threads that may be waiting to
acquire the write lock.
- getQueueLength() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns an estimate of the number of threads waiting to
acquire.
- getQueueLength() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns an estimate of the number of threads waiting to
acquire.
- getQueueLength() - Method in class java.util.concurrent.locks.ReentrantLock
-
Returns an estimate of the number of threads waiting to
acquire this lock.
- getQueueLength() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns an estimate of the number of threads waiting to acquire
either the read or write lock.
- getQueueLength() - Method in class java.util.concurrent.Semaphore
-
Returns an estimate of the number of threads waiting to acquire.
- getRawResult() - Method in class java.util.concurrent.ForkJoinTask
-
Returns the result that would be returned by
ForkJoinTask.join()
, even
if this task completed abnormally, or
null
if this task
is not known to have been completed.
- getRawResult() - Method in class java.util.concurrent.RecursiveAction
-
Always returns null
.
- getRawResult() - Method in class java.util.concurrent.RecursiveTask
-
- getReadHoldCount() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Queries the number of reentrant read holds on this lock by the
current thread.
- getReadLockCount() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Queries the number of read locks held for this lock.
- getReference() - Method in class java.util.concurrent.atomic.AtomicMarkableReference
-
Returns the current value of the reference.
- getReference() - Method in class java.util.concurrent.atomic.AtomicStampedReference
-
Returns the current value of the reference.
- getRegisteredParties() - Method in class java.util.concurrent.Phaser
-
Returns the number of parties registered at this phaser.
- getRejectedExecutionHandler() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the current handler for unexecutable tasks.
- getRemoveOnCancelPolicy() - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Gets the policy on whether cancelled tasks should be immediately
removed from the work queue at time of cancellation.
- getRoot() - Method in class java.util.concurrent.Phaser
-
Returns the root ancestor of this phaser, which is the same as
this phaser if it has no parent.
- getRunningThreadCount() - Method in class java.util.concurrent.ForkJoinPool
-
Returns an estimate of the number of worker threads that are
not blocked waiting to join tasks or for other managed
synchronization.
- getSharedQueuedThreads() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns a collection containing threads that may be waiting to
acquire in shared mode.
- getSharedQueuedThreads() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns a collection containing threads that may be waiting to
acquire in shared mode.
- getStamp() - Method in class java.util.concurrent.atomic.AtomicStampedReference
-
Returns the current value of the stamp.
- getState() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns the current value of synchronization state.
- getState() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns the current value of synchronization state.
- getStealCount() - Method in class java.util.concurrent.ForkJoinPool
-
Returns an estimate of the total number of tasks stolen from
one thread's work queue by another.
- getSurplusQueuedTaskCount() - Static method in class java.util.concurrent.ForkJoinTask
-
Returns an estimate of how many more locally queued tasks are
held by the current worker thread than there are other worker
threads that might steal them.
- getTaskCount() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the approximate total number of tasks that have ever been
scheduled for execution.
- getThreadFactory() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the thread factory used to create new threads.
- getUnarrivedParties() - Method in class java.util.concurrent.Phaser
-
Returns the number of registered parties that have not yet
arrived at the current phase of this phaser.
- getUncaughtExceptionHandler() - Method in class java.util.concurrent.ForkJoinPool
-
Returns the handler for internal worker threads that terminate
due to unrecoverable errors encountered while executing tasks.
- getWaitingConsumerCount() - Method in class java.util.concurrent.LinkedTransferQueue
-
- getWaitingConsumerCount() - Method in interface java.util.concurrent.TransferQueue
-
- getWaitingThreads() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Returns a collection containing those threads that may be
waiting on this Condition.
- getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns a collection containing those threads that may be
waiting on the given condition associated with this
synchronizer.
- getWaitingThreads() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Returns a collection containing those threads that may be
waiting on this Condition.
- getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns a collection containing those threads that may be
waiting on the given condition associated with this
synchronizer.
- getWaitingThreads(Condition) - Method in class java.util.concurrent.locks.ReentrantLock
-
Returns a collection containing those threads that may be
waiting on the given condition associated with this lock.
- getWaitingThreads(Condition) - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns a collection containing those threads that may be
waiting on the given condition associated with the write lock.
- getWaitQueueLength() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Returns an estimate of the number of threads waiting on
this condition.
- getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns an estimate of the number of threads waiting on the
given condition associated with this synchronizer.
- getWaitQueueLength() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Returns an estimate of the number of threads waiting on
this condition.
- getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns an estimate of the number of threads waiting on the
given condition associated with this synchronizer.
- getWaitQueueLength(Condition) - Method in class java.util.concurrent.locks.ReentrantLock
-
Returns an estimate of the number of threads waiting on the
given condition associated with this lock.
- getWaitQueueLength(Condition) - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns an estimate of the number of threads waiting on the
given condition associated with the write lock.
- getWriteHoldCount() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Queries the number of reentrant write holds on this lock by the
current thread.
- incrementAndGet() - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically increments by one the current value.
- incrementAndGet(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically increments by one the element at index i
.
- incrementAndGet(T) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically increments by one the current value of the field of the
given object managed by this updater.
- incrementAndGet() - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically increments by one the current value.
- incrementAndGet(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically increments by one the element at index i
.
- incrementAndGet(T) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically increments by one the current value of the field of the
given object managed by this updater.
- indexOf(Object) - Method in class java.util.concurrent.CopyOnWriteArrayList
- indexOf(E, int) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns the index of the first occurrence of the specified element in
this list, searching forwards from index, or returns -1 if
the element is not found.
- inForkJoinPool() - Static method in class java.util.concurrent.ForkJoinTask
-
Returns
true
if the current thread is a
ForkJoinWorkerThread
executing as a ForkJoinPool computation.
- intValue() - Method in class java.util.concurrent.atomic.AtomicInteger
-
- intValue() - Method in class java.util.concurrent.atomic.AtomicLong
-
- invoke(ForkJoinTask<T>) - Method in class java.util.concurrent.ForkJoinPool
-
Performs the given task, returning its result upon completion.
- invoke() - Method in class java.util.concurrent.ForkJoinTask
-
Commences performing this task, awaits its completion if
necessary, and returns its result, or throws an (unchecked)
RuntimeException
or Error
if the underlying
computation did so.
- invokeAll(Collection<? extends Callable<T>>) - Method in class java.util.concurrent.AbstractExecutorService
-
- invokeAll(Collection<? extends Callable<T>>, long, TimeUnit) - Method in class java.util.concurrent.AbstractExecutorService
-
- invokeAll(Collection<? extends Callable<T>>) - Method in interface java.util.concurrent.ExecutorService
-
Executes the given tasks, returning a list of Futures holding
their status and results when all complete.
- invokeAll(Collection<? extends Callable<T>>, long, TimeUnit) - Method in interface java.util.concurrent.ExecutorService
-
Executes the given tasks, returning a list of Futures holding
their status and results
when all complete or the timeout expires, whichever happens first.
- invokeAll(Collection<? extends Callable<T>>) - Method in class java.util.concurrent.ForkJoinPool
-
- invokeAll(ForkJoinTask<?>, ForkJoinTask<?>) - Static method in class java.util.concurrent.ForkJoinTask
-
Forks the given tasks, returning when isDone
holds for
each task or an (unchecked) exception is encountered, in which
case the exception is rethrown.
- invokeAll(ForkJoinTask<?>...) - Static method in class java.util.concurrent.ForkJoinTask
-
Forks the given tasks, returning when isDone
holds for
each task or an (unchecked) exception is encountered, in which
case the exception is rethrown.
- invokeAll(Collection<T>) - Static method in class java.util.concurrent.ForkJoinTask
-
Forks all tasks in the specified collection, returning when
isDone
holds for each task or an (unchecked) exception
is encountered, in which case the exception is rethrown.
- invokeAny(Collection<? extends Callable<T>>) - Method in class java.util.concurrent.AbstractExecutorService
-
- invokeAny(Collection<? extends Callable<T>>, long, TimeUnit) - Method in class java.util.concurrent.AbstractExecutorService
-
- invokeAny(Collection<? extends Callable<T>>) - Method in interface java.util.concurrent.ExecutorService
-
Executes the given tasks, returning the result
of one that has completed successfully (i.e., without throwing
an exception), if any do.
- invokeAny(Collection<? extends Callable<T>>, long, TimeUnit) - Method in interface java.util.concurrent.ExecutorService
-
Executes the given tasks, returning the result
of one that has completed successfully (i.e., without throwing
an exception), if any do before the given timeout elapses.
- isBroken() - Method in class java.util.concurrent.CyclicBarrier
-
Queries if this barrier is in a broken state.
- isCancelled() - Method in class java.util.concurrent.ForkJoinTask
-
- isCancelled() - Method in interface java.util.concurrent.Future
-
Returns true if this task was cancelled before it completed
normally.
- isCancelled() - Method in class java.util.concurrent.FutureTask
-
- isCompletedAbnormally() - Method in class java.util.concurrent.ForkJoinTask
-
Returns true
if this task threw an exception or was cancelled.
- isCompletedNormally() - Method in class java.util.concurrent.ForkJoinTask
-
Returns true
if this task completed without throwing an
exception and was not cancelled.
- isDone() - Method in class java.util.concurrent.ForkJoinTask
-
- isDone() - Method in interface java.util.concurrent.Future
-
Returns true if this task completed.
- isDone() - Method in class java.util.concurrent.FutureTask
-
- isEmpty() - Method in class java.util.ArrayDeque
-
Returns true if this deque contains no elements.
- isEmpty() - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns true if this map contains no key-value mappings.
- isEmpty() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Returns true
if this collection contains no elements.
- isEmpty() - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Returns true
if this queue contains no elements.
- isEmpty() - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Returns true if this map contains no key-value mappings.
- isEmpty() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Returns true if this set contains no elements.
- isEmpty() - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns true if this list contains no elements.
- isEmpty() - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Returns true if this set contains no elements.
- isEmpty() - Method in class java.util.concurrent.LinkedTransferQueue
-
Returns true
if this queue contains no elements.
- isEmpty() - Method in class java.util.concurrent.SynchronousQueue
-
Always returns true.
- isFair() - Method in class java.util.concurrent.locks.ReentrantLock
-
Returns true
if this lock has fairness set true.
- isFair() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns true
if this lock has fairness set true.
- isFair() - Method in class java.util.concurrent.Semaphore
-
Returns true
if this semaphore has fairness set true.
- isHeldByCurrentThread() - Method in class java.util.concurrent.locks.ReentrantLock
-
Queries if this lock is held by the current thread.
- isHeldByCurrentThread() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
-
Queries if this write lock is held by the current thread.
- isHeldExclusively() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns true
if synchronization is held exclusively with
respect to the current (calling) thread.
- isHeldExclusively() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns true
if synchronization is held exclusively with
respect to the current (calling) thread.
- isLocked() - Method in class java.util.concurrent.locks.ReentrantLock
-
Queries if this lock is held by any thread.
- isMarked() - Method in class java.util.concurrent.atomic.AtomicMarkableReference
-
Returns the current value of the mark.
- isPeriodic() - Method in interface java.util.concurrent.RunnableScheduledFuture
-
Returns true if this is a periodic task.
- isQueued(Thread) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns true if the given thread is currently queued.
- isQueued(Thread) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns true if the given thread is currently queued.
- isQuiescent() - Method in class java.util.concurrent.ForkJoinPool
-
Returns true
if all worker threads are currently idle.
- isReleasable() - Method in interface java.util.concurrent.ForkJoinPool.ManagedBlocker
-
Returns true
if blocking is unnecessary.
- isShutdown() - Method in interface java.util.concurrent.ExecutorService
-
Returns true if this executor has been shut down.
- isShutdown() - Method in class java.util.concurrent.ForkJoinPool
-
Returns true
if this pool has been shut down.
- isShutdown() - Method in class java.util.concurrent.ThreadPoolExecutor
-
- isTerminated() - Method in interface java.util.concurrent.ExecutorService
-
Returns true if all tasks have completed following shut down.
- isTerminated() - Method in class java.util.concurrent.ForkJoinPool
-
Returns true
if all tasks have completed following shut down.
- isTerminated() - Method in class java.util.concurrent.Phaser
-
Returns true
if this phaser has been terminated.
- isTerminated() - Method in class java.util.concurrent.ThreadPoolExecutor
-
- isTerminating() - Method in class java.util.concurrent.ForkJoinPool
-
Returns true
if the process of termination has
commenced but not yet completed.
- isTerminating() - Method in class java.util.concurrent.ThreadPoolExecutor
-
- isWriteLocked() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Queries if the write lock is held by any thread.
- isWriteLockedByCurrentThread() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Queries if the write lock is held by the current thread.
- iterator() - Method in class java.util.ArrayDeque
-
Returns an iterator over the elements in this deque.
- iterator() - Method in class java.util.concurrent.ArrayBlockingQueue
-
Returns an iterator over the elements in this queue in proper sequence.
- iterator() - Method in interface java.util.concurrent.BlockingDeque
-
Returns an iterator over the elements in this deque in proper sequence.
- iterator() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Returns an iterator over the elements in this deque in proper sequence.
- iterator() - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Returns an iterator over the elements in this queue in proper sequence.
- iterator() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Returns an iterator over the elements in this set in ascending order.
- iterator() - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns an iterator over the elements in this list in proper sequence.
- iterator() - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Returns an iterator over the elements contained in this set
in the order in which these elements were added.
- iterator() - Method in class java.util.concurrent.DelayQueue
-
Returns an iterator over all the elements (both expired and
unexpired) in this queue.
- iterator() - Method in class java.util.concurrent.LinkedBlockingDeque
-
Returns an iterator over the elements in this deque in proper sequence.
- iterator() - Method in class java.util.concurrent.LinkedBlockingQueue
-
Returns an iterator over the elements in this queue in proper sequence.
- iterator() - Method in class java.util.concurrent.LinkedTransferQueue
-
Returns an iterator over the elements in this queue in proper sequence.
- iterator() - Method in class java.util.concurrent.PriorityBlockingQueue
-
Returns an iterator over the elements in this queue.
- iterator() - Method in class java.util.concurrent.SynchronousQueue
-
Returns an empty iterator in which hasNext always returns
false.
- iterator() - Method in interface java.util.Deque
-
Returns an iterator over the elements in this deque in proper sequence.
- iterator() - Method in interface java.util.NavigableSet
-
Returns an iterator over the elements in this set, in ascending order.
- iterator() - Method in class java.util.PriorityQueue
-
Returns an iterator over the elements in this queue.
- offer(E) - Method in class java.util.ArrayDeque
-
Inserts the specified element at the end of this deque.
- offer(E) - Method in class java.util.concurrent.ArrayBlockingQueue
-
Inserts the specified element at the tail of this queue if it is
possible to do so immediately without exceeding the queue's capacity,
returning true
upon success and false
if this queue
is full.
- offer(E, long, TimeUnit) - Method in class java.util.concurrent.ArrayBlockingQueue
-
Inserts the specified element at the tail of this queue, waiting
up to the specified wait time for space to become available if
the queue is full.
- offer(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and false if no space is currently
available.
- offer(E, long, TimeUnit) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque), waiting up to the
specified wait time if necessary for space to become available.
- offer(E) - Method in interface java.util.concurrent.BlockingQueue
-
Inserts the specified element into this queue if it is possible to do
so immediately without violating capacity restrictions, returning
true upon success and false if no space is currently
available.
- offer(E, long, TimeUnit) - Method in interface java.util.concurrent.BlockingQueue
-
Inserts the specified element into this queue, waiting up to the
specified wait time if necessary for space to become available.
- offer(E) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Inserts the specified element at the tail of this deque.
- offer(E) - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Inserts the specified element at the tail of this queue.
- offer(E) - Method in class java.util.concurrent.DelayQueue
-
Inserts the specified element into this delay queue.
- offer(E, long, TimeUnit) - Method in class java.util.concurrent.DelayQueue
-
Inserts the specified element into this delay queue.
- offer(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- offer(E, long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- offer(E, long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingQueue
-
Inserts the specified element at the tail of this queue, waiting if
necessary up to the specified wait time for space to become available.
- offer(E) - Method in class java.util.concurrent.LinkedBlockingQueue
-
Inserts the specified element at the tail of this queue if it is
possible to do so immediately without exceeding the queue's capacity,
returning true
upon success and false
if this queue
is full.
- offer(E, long, TimeUnit) - Method in class java.util.concurrent.LinkedTransferQueue
-
Inserts the specified element at the tail of this queue.
- offer(E) - Method in class java.util.concurrent.LinkedTransferQueue
-
Inserts the specified element at the tail of this queue.
- offer(E) - Method in class java.util.concurrent.PriorityBlockingQueue
-
Inserts the specified element into this priority queue.
- offer(E, long, TimeUnit) - Method in class java.util.concurrent.PriorityBlockingQueue
-
Inserts the specified element into this priority queue.
- offer(E, long, TimeUnit) - Method in class java.util.concurrent.SynchronousQueue
-
Inserts the specified element into this queue, waiting if necessary
up to the specified wait time for another thread to receive it.
- offer(E) - Method in class java.util.concurrent.SynchronousQueue
-
Inserts the specified element into this queue, if another thread is
waiting to receive it.
- offer(E) - Method in interface java.util.Deque
-
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque) if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and false if no space is currently
available.
- offer(E) - Method in class java.util.PriorityQueue
-
Inserts the specified element into this priority queue.
- offer(E) - Method in interface java.util.Queue
-
Inserts the specified element into this queue if it is possible to do
so immediately without violating capacity restrictions.
- offerFirst(E) - Method in class java.util.ArrayDeque
-
Inserts the specified element at the front of this deque.
- offerFirst(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element at the front of this deque if it is
possible to do so immediately without violating capacity restrictions,
returning true upon success and false if no space is
currently available.
- offerFirst(E, long, TimeUnit) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element at the front of this deque,
waiting up to the specified wait time if necessary for space to
become available.
- offerFirst(E) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Inserts the specified element at the front of this deque.
- offerFirst(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- offerFirst(E, long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- offerFirst(E) - Method in interface java.util.Deque
-
Inserts the specified element at the front of this deque unless it would
violate capacity restrictions.
- offerLast(E) - Method in class java.util.ArrayDeque
-
Inserts the specified element at the end of this deque.
- offerLast(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element at the end of this deque if it is
possible to do so immediately without violating capacity restrictions,
returning true upon success and false if no space is
currently available.
- offerLast(E, long, TimeUnit) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element at the end of this deque,
waiting up to the specified wait time if necessary for space to
become available.
- offerLast(E) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Inserts the specified element at the end of this deque.
- offerLast(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- offerLast(E, long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- offerLast(E) - Method in interface java.util.Deque
-
Inserts the specified element at the end of this deque unless it would
violate capacity restrictions.
- onAdvance(int, int) - Method in class java.util.concurrent.Phaser
-
Overridable method to perform an action upon impending phase
advance, and to control termination.
- onStart() - Method in class java.util.concurrent.ForkJoinWorkerThread
-
Initializes internal state after construction but before
processing any tasks.
- onTermination(Throwable) - Method in class java.util.concurrent.ForkJoinWorkerThread
-
Performs cleanup associated with termination of this worker
thread.
- orderAccesses(T) - Static method in class java.util.concurrent.atomic.Fences
-
Informally: Ensures that accesses (reads or writes) using the
given reference prior to the invocation of this method occur
before subsequent accesses.
- orderReads(T) - Static method in class java.util.concurrent.atomic.Fences
-
Informally: Ensures that a read of the given reference prior to
the invocation of this method occurs before a subsequent use of
the given reference with the effect of reading or writing a
field (or if an array, element) of the referenced object.
- orderWrites(T) - Static method in class java.util.concurrent.atomic.Fences
-
Informally: Ensures that a use of the given reference with the
effect of reading or writing a field (or if an array, element)
of the referenced object, prior to the invocation of this
method occur before a subsequent write of the reference.
- owns(AbstractQueuedLongSynchronizer.ConditionObject) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Queries whether the given ConditionObject
uses this synchronizer as its lock.
- owns(AbstractQueuedSynchronizer.ConditionObject) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Queries whether the given ConditionObject
uses this synchronizer as its lock.
- park(Object) - Static method in class java.util.concurrent.locks.LockSupport
-
Disables the current thread for thread scheduling purposes unless the
permit is available.
- park() - Static method in class java.util.concurrent.locks.LockSupport
-
Disables the current thread for thread scheduling purposes unless the
permit is available.
- parkNanos(Object, long) - Static method in class java.util.concurrent.locks.LockSupport
-
Disables the current thread for thread scheduling purposes, for up to
the specified waiting time, unless the permit is available.
- parkNanos(long) - Static method in class java.util.concurrent.locks.LockSupport
-
Disables the current thread for thread scheduling purposes, for up to
the specified waiting time, unless the permit is available.
- parkUntil(Object, long) - Static method in class java.util.concurrent.locks.LockSupport
-
Disables the current thread for thread scheduling purposes, until
the specified deadline, unless the permit is available.
- parkUntil(long) - Static method in class java.util.concurrent.locks.LockSupport
-
Disables the current thread for thread scheduling purposes, until
the specified deadline, unless the permit is available.
- peek() - Method in class java.util.ArrayDeque
-
Retrieves, but does not remove, the head of the queue represented by
this deque, or returns null if this deque is empty.
- peek() - Method in class java.util.concurrent.ArrayBlockingQueue
-
- peek() - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque), or
returns null if this deque is empty.
- peek() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- peek() - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
- peek() - Method in class java.util.concurrent.DelayQueue
-
Retrieves, but does not remove, the head of this queue, or
returns null if this queue is empty.
- peek() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- peek() - Method in class java.util.concurrent.LinkedBlockingQueue
-
- peek() - Method in class java.util.concurrent.LinkedTransferQueue
-
- peek() - Method in class java.util.concurrent.PriorityBlockingQueue
-
- peek() - Method in class java.util.concurrent.SynchronousQueue
-
Always returns null.
- peek() - Method in interface java.util.Deque
-
Retrieves, but does not remove, the head of the queue represented by
this deque (in other words, the first element of this deque), or
returns null if this deque is empty.
- peek() - Method in class java.util.PriorityQueue
-
- peek() - Method in interface java.util.Queue
-
Retrieves, but does not remove, the head of this queue,
or returns null if this queue is empty.
- peekFirst() - Method in class java.util.ArrayDeque
-
- peekFirst() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- peekFirst() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- peekFirst() - Method in interface java.util.Deque
-
Retrieves, but does not remove, the first element of this deque,
or returns null if this deque is empty.
- peekLast() - Method in class java.util.ArrayDeque
-
- peekLast() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- peekLast() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- peekLast() - Method in interface java.util.Deque
-
Retrieves, but does not remove, the last element of this deque,
or returns null if this deque is empty.
- peekNextLocalTask() - Static method in class java.util.concurrent.ForkJoinTask
-
Returns, but does not unschedule or execute, a task queued by
the current thread but not yet executed, if one is immediately
available.
- Phaser - Class in java.util.concurrent
-
- Phaser() - Constructor for class java.util.concurrent.Phaser
-
Creates a new phaser with no initially registered parties, no
parent, and initial phase number 0.
- Phaser(int) - Constructor for class java.util.concurrent.Phaser
-
Creates a new phaser with the given number of registered
unarrived parties, no parent, and initial phase number 0.
- Phaser(Phaser) - Constructor for class java.util.concurrent.Phaser
-
- Phaser(Phaser, int) - Constructor for class java.util.concurrent.Phaser
-
Creates a new phaser with the given parent and number of
registered unarrived parties.
- poll() - Method in class java.util.ArrayDeque
-
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), or returns
null if this deque is empty.
- poll() - Method in class java.util.concurrent.ArrayBlockingQueue
-
- poll(long, TimeUnit) - Method in class java.util.concurrent.ArrayBlockingQueue
-
- poll() - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), or returns
null if this deque is empty.
- poll(long, TimeUnit) - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), waiting up to the
specified wait time if necessary for an element to become available.
- poll(long, TimeUnit) - Method in interface java.util.concurrent.BlockingQueue
-
Retrieves and removes the head of this queue, waiting up to the
specified wait time if necessary for an element to become available.
- poll() - Method in interface java.util.concurrent.CompletionService
-
Retrieves and removes the Future representing the next
completed task or null if none are present.
- poll(long, TimeUnit) - Method in interface java.util.concurrent.CompletionService
-
Retrieves and removes the Future representing the next
completed task, waiting if necessary up to the specified wait
time if none are yet present.
- poll() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- poll() - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
- poll() - Method in class java.util.concurrent.DelayQueue
-
Retrieves and removes the head of this queue, or returns null
if this queue has no elements with an expired delay.
- poll(long, TimeUnit) - Method in class java.util.concurrent.DelayQueue
-
Retrieves and removes the head of this queue, waiting if necessary
until an element with an expired delay is available on this queue,
or the specified wait time expires.
- poll() - Method in class java.util.concurrent.ExecutorCompletionService
-
- poll(long, TimeUnit) - Method in class java.util.concurrent.ExecutorCompletionService
-
- poll() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- poll(long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- poll(long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingQueue
-
- poll() - Method in class java.util.concurrent.LinkedBlockingQueue
-
- poll(long, TimeUnit) - Method in class java.util.concurrent.LinkedTransferQueue
-
- poll() - Method in class java.util.concurrent.LinkedTransferQueue
-
- poll() - Method in class java.util.concurrent.PriorityBlockingQueue
-
- poll(long, TimeUnit) - Method in class java.util.concurrent.PriorityBlockingQueue
-
- poll(long, TimeUnit) - Method in class java.util.concurrent.SynchronousQueue
-
Retrieves and removes the head of this queue, waiting
if necessary up to the specified wait time, for another thread
to insert it.
- poll() - Method in class java.util.concurrent.SynchronousQueue
-
Retrieves and removes the head of this queue, if another thread
is currently making an element available.
- poll() - Method in interface java.util.Deque
-
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), or returns
null if this deque is empty.
- poll() - Method in class java.util.PriorityQueue
-
- poll() - Method in interface java.util.Queue
-
Retrieves and removes the head of this queue,
or returns null if this queue is empty.
- pollFirst() - Method in class java.util.ArrayDeque
-
- pollFirst(long, TimeUnit) - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves and removes the first element of this deque, waiting
up to the specified wait time if necessary for an element to
become available.
- pollFirst() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- pollFirst() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- pollFirst() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- pollFirst(long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- pollFirst() - Method in interface java.util.Deque
-
Retrieves and removes the first element of this deque,
or returns null if this deque is empty.
- pollFirst() - Method in interface java.util.NavigableSet
-
Retrieves and removes the first (lowest) element,
or returns null
if this set is empty.
- pollFirstEntry() - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Removes and returns a key-value mapping associated with
the least key in this map, or null if the map is empty.
- pollFirstEntry() - Method in interface java.util.NavigableMap
-
Removes and returns a key-value mapping associated with
the least key in this map, or null
if the map is empty.
- pollLast() - Method in class java.util.ArrayDeque
-
- pollLast(long, TimeUnit) - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves and removes the last element of this deque, waiting
up to the specified wait time if necessary for an element to
become available.
- pollLast() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- pollLast() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- pollLast() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- pollLast(long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- pollLast() - Method in interface java.util.Deque
-
Retrieves and removes the last element of this deque,
or returns null if this deque is empty.
- pollLast() - Method in interface java.util.NavigableSet
-
Retrieves and removes the last (highest) element,
or returns null
if this set is empty.
- pollLastEntry() - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Removes and returns a key-value mapping associated with
the greatest key in this map, or null if the map is empty.
- pollLastEntry() - Method in interface java.util.NavigableMap
-
Removes and returns a key-value mapping associated with
the greatest key in this map, or null
if the map is empty.
- pollNextLocalTask() - Static method in class java.util.concurrent.ForkJoinTask
-
Unschedules and returns, without executing, the next task
queued by the current thread but not yet executed.
- pollSubmission() - Method in class java.util.concurrent.ForkJoinPool
-
Removes and returns the next unexecuted submission if one is
available.
- pollTask() - Static method in class java.util.concurrent.ForkJoinTask
-
Unschedules and returns, without executing, the next task
queued by the current thread but not yet executed, if one is
available, or if not available, a task that was forked by some
other thread, if available.
- pop() - Method in class java.util.ArrayDeque
-
Pops an element from the stack represented by this deque.
- pop() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- pop() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- pop() - Method in interface java.util.Deque
-
Pops an element from the stack represented by this deque.
- prestartAllCoreThreads() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Starts all core threads, causing them to idly wait for work.
- prestartCoreThread() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Starts a core thread, causing it to idly wait for work.
- PriorityBlockingQueue<E> - Class in java.util.concurrent
-
- PriorityBlockingQueue() - Constructor for class java.util.concurrent.PriorityBlockingQueue
-
Creates a
PriorityBlockingQueue
with the default
initial capacity (11) that orders its elements according to
their
natural ordering.
- PriorityBlockingQueue(int) - Constructor for class java.util.concurrent.PriorityBlockingQueue
-
Creates a
PriorityBlockingQueue
with the specified
initial capacity that orders its elements according to their
natural ordering.
- PriorityBlockingQueue(int, Comparator<? super E>) - Constructor for class java.util.concurrent.PriorityBlockingQueue
-
Creates a PriorityBlockingQueue
with the specified initial
capacity that orders its elements according to the specified
comparator.
- PriorityBlockingQueue(Collection<? extends E>) - Constructor for class java.util.concurrent.PriorityBlockingQueue
-
Creates a PriorityBlockingQueue
containing the elements
in the specified collection.
- PriorityQueue<E> - Class in java.util
-
An unbounded priority
queue based on a priority heap.
- PriorityQueue() - Constructor for class java.util.PriorityQueue
-
Creates a
PriorityQueue
with the default initial
capacity (11) that orders its elements according to their
natural ordering.
- PriorityQueue(int) - Constructor for class java.util.PriorityQueue
-
Creates a
PriorityQueue
with the specified initial
capacity that orders its elements according to their
natural ordering.
- PriorityQueue(int, Comparator<? super E>) - Constructor for class java.util.PriorityQueue
-
Creates a PriorityQueue
with the specified initial capacity
that orders its elements according to the specified comparator.
- PriorityQueue(Collection<? extends E>) - Constructor for class java.util.PriorityQueue
-
Creates a PriorityQueue
containing the elements in the
specified collection.
- PriorityQueue(PriorityQueue<? extends E>) - Constructor for class java.util.PriorityQueue
-
Creates a PriorityQueue
containing the elements in the
specified priority queue.
- PriorityQueue(SortedSet<? extends E>) - Constructor for class java.util.PriorityQueue
-
Creates a PriorityQueue
containing the elements in the
specified sorted set.
- privilegedCallable(Callable<T>) - Static method in class java.util.concurrent.Executors
-
Returns a
Callable
object that will, when
called, execute the given
callable under the current
access control context.
- privilegedCallableUsingCurrentClassLoader(Callable<T>) - Static method in class java.util.concurrent.Executors
-
Returns a
Callable
object that will, when
called, execute the given
callable under the current
access control context, with the current context class loader
as the context class loader.
- privilegedThreadFactory() - Static method in class java.util.concurrent.Executors
-
Returns a thread factory used to create new threads that
have the same permissions as the current thread.
- purge() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Tries to remove from the work queue all
Future
tasks that have been cancelled.
- push(E) - Method in class java.util.ArrayDeque
-
Pushes an element onto the stack represented by this deque.
- push(E) - Method in interface java.util.concurrent.BlockingDeque
-
Pushes an element onto the stack represented by this deque.
- push(E) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- push(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- push(E) - Method in interface java.util.Deque
-
Pushes an element onto the stack represented by this deque (in other
words, at the head of this deque) if it is possible to do so
immediately without violating capacity restrictions, returning
true upon success and throwing an
IllegalStateException if no space is currently available.
- put(E) - Method in class java.util.concurrent.ArrayBlockingQueue
-
Inserts the specified element at the tail of this queue, waiting
for space to become available if the queue is full.
- put(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element into the queue represented by this deque
(in other words, at the tail of this deque), waiting if necessary for
space to become available.
- put(E) - Method in interface java.util.concurrent.BlockingQueue
-
Inserts the specified element into this queue, waiting if necessary
for space to become available.
- put(K, V) - Method in class java.util.concurrent.ConcurrentHashMap
-
Maps the specified key to the specified value in this table.
- put(K, V) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Associates the specified value with the specified key in this map.
- put(E) - Method in class java.util.concurrent.DelayQueue
-
Inserts the specified element into this delay queue.
- put(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- put(E) - Method in class java.util.concurrent.LinkedBlockingQueue
-
Inserts the specified element at the tail of this queue, waiting if
necessary for space to become available.
- put(E) - Method in class java.util.concurrent.LinkedTransferQueue
-
Inserts the specified element at the tail of this queue.
- put(E) - Method in class java.util.concurrent.PriorityBlockingQueue
-
Inserts the specified element into this priority queue.
- put(E) - Method in class java.util.concurrent.SynchronousQueue
-
Adds the specified element to this queue, waiting if necessary for
another thread to receive it.
- putAll(Map<? extends K, ? extends V>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Copies all of the mappings from the specified map to this one.
- putFirst(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element at the front of this deque,
waiting if necessary for space to become available.
- putFirst(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- putIfAbsent(K, V) - Method in class java.util.concurrent.ConcurrentHashMap
-
If the specified key is not already associated
with a value, associate it with the given value.
- putIfAbsent(K, V) - Method in interface java.util.concurrent.ConcurrentMap
-
If the specified key is not already associated
with a value, associate it with the given value.
- putIfAbsent(K, V) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
If the specified key is not already associated
with a value, associate it with the given value.
- putLast(E) - Method in interface java.util.concurrent.BlockingDeque
-
Inserts the specified element at the end of this deque,
waiting if necessary for space to become available.
- putLast(E) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- reachabilityFence(Object) - Static method in class java.util.concurrent.atomic.Fences
-
Ensures that the object referenced by the given reference
remains
strongly reachable (as defined in the
java.lang.ref
package documentation), regardless of any prior
actions of the program that might otherwise cause the object to
become unreachable; thus, the referenced object is not
reclaimable by garbage collection at least until after the
invocation of this method.
- readLock() - Method in interface java.util.concurrent.locks.ReadWriteLock
-
Returns the lock used for reading.
- readLock() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
- ReadWriteLock - Interface in java.util.concurrent.locks
-
A
ReadWriteLock maintains a pair of associated
locks
, one for read-only operations and one for writing.
- RecursiveAction - Class in java.util.concurrent
-
- RecursiveAction() - Constructor for class java.util.concurrent.RecursiveAction
-
- RecursiveTask<V> - Class in java.util.concurrent
-
- RecursiveTask() - Constructor for class java.util.concurrent.RecursiveTask
-
- reducePermits(int) - Method in class java.util.concurrent.Semaphore
-
Shrinks the number of available permits by the indicated
reduction.
- ReentrantLock - Class in java.util.concurrent.locks
-
A reentrant mutual exclusion
Lock
with the same basic
behavior and semantics as the implicit monitor lock accessed using
synchronized
methods and statements, but with extended
capabilities.
- ReentrantLock() - Constructor for class java.util.concurrent.locks.ReentrantLock
-
Creates an instance of ReentrantLock
.
- ReentrantLock(boolean) - Constructor for class java.util.concurrent.locks.ReentrantLock
-
Creates an instance of ReentrantLock
with the
given fairness policy.
- ReentrantReadWriteLock - Class in java.util.concurrent.locks
-
- ReentrantReadWriteLock() - Constructor for class java.util.concurrent.locks.ReentrantReadWriteLock
-
Creates a new ReentrantReadWriteLock
with
default (nonfair) ordering properties.
- ReentrantReadWriteLock(boolean) - Constructor for class java.util.concurrent.locks.ReentrantReadWriteLock
-
Creates a new ReentrantReadWriteLock
with
the given fairness policy.
- ReentrantReadWriteLock.ReadLock - Class in java.util.concurrent.locks
-
- ReentrantReadWriteLock.ReadLock(ReentrantReadWriteLock) - Constructor for class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
-
Constructor for use by subclasses
- ReentrantReadWriteLock.WriteLock - Class in java.util.concurrent.locks
-
- ReentrantReadWriteLock.WriteLock(ReentrantReadWriteLock) - Constructor for class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
-
Constructor for use by subclasses
- register() - Method in class java.util.concurrent.Phaser
-
Adds a new unarrived party to this phaser.
- reinitialize() - Method in class java.util.concurrent.ForkJoinTask
-
Resets the internal bookkeeping state of this task, allowing a
subsequent fork
.
- rejectedExecution(Runnable, ThreadPoolExecutor) - Method in interface java.util.concurrent.RejectedExecutionHandler
-
- rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class java.util.concurrent.ThreadPoolExecutor.AbortPolicy
-
Always throws RejectedExecutionException.
- rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
-
Executes task r in the caller's thread, unless the executor
has been shut down, in which case the task is discarded.
- rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy
-
Obtains and ignores the next task that the executor
would otherwise execute, if one is immediately available,
and then retries execution of task r, unless the executor
is shut down, in which case task r is instead discarded.
- rejectedExecution(Runnable, ThreadPoolExecutor) - Method in class java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
-
Does nothing, which has the effect of discarding task r.
- RejectedExecutionException - Exception in java.util.concurrent
-
Exception thrown by an
Executor
when a task cannot be
accepted for execution.
- RejectedExecutionException() - Constructor for exception java.util.concurrent.RejectedExecutionException
-
Constructs a RejectedExecutionException with no detail message.
- RejectedExecutionException(String) - Constructor for exception java.util.concurrent.RejectedExecutionException
-
Constructs a RejectedExecutionException with the
specified detail message.
- RejectedExecutionException(String, Throwable) - Constructor for exception java.util.concurrent.RejectedExecutionException
-
Constructs a RejectedExecutionException with the
specified detail message and cause.
- RejectedExecutionException(Throwable) - Constructor for exception java.util.concurrent.RejectedExecutionException
-
Constructs a RejectedExecutionException with the
specified cause.
- RejectedExecutionHandler - Interface in java.util.concurrent
-
- release(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Releases in exclusive mode.
- release(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Releases in exclusive mode.
- release() - Method in class java.util.concurrent.Semaphore
-
Releases a permit, returning it to the semaphore.
- release(int) - Method in class java.util.concurrent.Semaphore
-
Releases the given number of permits, returning them to the semaphore.
- releaseShared(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Releases in shared mode.
- releaseShared(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Releases in shared mode.
- remainingCapacity() - Method in class java.util.concurrent.ArrayBlockingQueue
-
Returns the number of additional elements that this queue can ideally
(in the absence of memory or resource constraints) accept without
blocking.
- remainingCapacity() - Method in interface java.util.concurrent.BlockingQueue
-
Returns the number of additional elements that this queue can ideally
(in the absence of memory or resource constraints) accept without
blocking, or Integer.MAX_VALUE if there is no intrinsic
limit.
- remainingCapacity() - Method in class java.util.concurrent.DelayQueue
-
Always returns Integer.MAX_VALUE because
a DelayQueue is not capacity constrained.
- remainingCapacity() - Method in class java.util.concurrent.LinkedBlockingDeque
-
Returns the number of additional elements that this deque can ideally
(in the absence of memory or resource constraints) accept without
blocking.
- remainingCapacity() - Method in class java.util.concurrent.LinkedBlockingQueue
-
Returns the number of additional elements that this queue can ideally
(in the absence of memory or resource constraints) accept without
blocking.
- remainingCapacity() - Method in class java.util.concurrent.LinkedTransferQueue
-
Always returns Integer.MAX_VALUE
because a
LinkedTransferQueue
is not capacity constrained.
- remainingCapacity() - Method in class java.util.concurrent.PriorityBlockingQueue
-
Always returns Integer.MAX_VALUE
because
a PriorityBlockingQueue
is not capacity constrained.
- remainingCapacity() - Method in class java.util.concurrent.SynchronousQueue
-
Always returns zero.
- remove() - Method in class java.util.AbstractQueue
-
Retrieves and removes the head of this queue.
- remove() - Method in class java.util.ArrayDeque
-
Retrieves and removes the head of the queue represented by this deque.
- remove(Object) - Method in class java.util.ArrayDeque
-
Removes a single instance of the specified element from this deque.
- remove(Object) - Method in class java.util.concurrent.ArrayBlockingQueue
-
Removes a single instance of the specified element from this queue,
if it is present.
- remove() - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque).
- remove(Object) - Method in interface java.util.concurrent.BlockingDeque
-
Removes the first occurrence of the specified element from this deque.
- remove(Object) - Method in interface java.util.concurrent.BlockingQueue
-
Removes a single instance of the specified element from this queue,
if it is present.
- remove(Object) - Method in class java.util.concurrent.ConcurrentHashMap
-
Removes the key (and its corresponding value) from this map.
- remove(Object, Object) - Method in class java.util.concurrent.ConcurrentHashMap
-
Removes the entry for a key only if currently mapped to a given value.
- remove() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- remove(Object) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Removes the first element e
such that
o.equals(e)
, if such an element exists in this deque.
- remove(Object) - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Removes a single instance of the specified element from this queue,
if it is present.
- remove(Object, Object) - Method in interface java.util.concurrent.ConcurrentMap
-
Removes the entry for a key only if currently mapped to a given value.
- remove(Object) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Removes the mapping for the specified key from this map if present.
- remove(Object, Object) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Removes the entry for a key only if currently mapped to a given value.
- remove(Object) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Removes the specified element from this set if it is present.
- remove(int) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Removes the element at the specified position in this list.
- remove(Object) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Removes the first occurrence of the specified element from this list,
if it is present.
- remove(Object) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Removes the specified element from this set if it is present.
- remove(Object) - Method in class java.util.concurrent.DelayQueue
-
Removes a single instance of the specified element from this
queue, if it is present, whether or not it has expired.
- remove() - Method in class java.util.concurrent.LinkedBlockingDeque
-
Retrieves and removes the head of the queue represented by this deque.
- remove(Object) - Method in class java.util.concurrent.LinkedBlockingDeque
-
Removes the first occurrence of the specified element from this deque.
- remove(Object) - Method in class java.util.concurrent.LinkedBlockingQueue
-
Removes a single instance of the specified element from this queue,
if it is present.
- remove(Object) - Method in class java.util.concurrent.LinkedTransferQueue
-
Removes a single instance of the specified element from this queue,
if it is present.
- remove(Object) - Method in class java.util.concurrent.PriorityBlockingQueue
-
Removes a single instance of the specified element from this queue,
if it is present.
- remove(Object) - Method in class java.util.concurrent.SynchronousQueue
-
Always returns false.
- remove(Runnable) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Removes this task from the executor's internal queue if it is
present, thus causing it not to be run if it has not already
started.
- remove() - Method in interface java.util.Deque
-
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque).
- remove(Object) - Method in interface java.util.Deque
-
Removes the first occurrence of the specified element from this deque.
- remove(Object) - Method in class java.util.PriorityQueue
-
Removes a single instance of the specified element from this queue,
if it is present.
- remove() - Method in interface java.util.Queue
-
Retrieves and removes the head of this queue.
- removeAll(Collection<?>) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Removes from this set all of its elements that are contained in
the specified collection.
- removeAll(Collection<?>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Removes from this list all of its elements that are contained in
the specified collection.
- removeAll(Collection<?>) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Removes from this set all of its elements that are contained in the
specified collection.
- removeAll(Collection<?>) - Method in class java.util.concurrent.SynchronousQueue
-
Always returns false.
- removeFirst() - Method in class java.util.ArrayDeque
-
- removeFirst() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- removeFirst() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- removeFirst() - Method in interface java.util.Deque
-
Retrieves and removes the first element of this deque.
- removeFirstOccurrence(Object) - Method in class java.util.ArrayDeque
-
Removes the first occurrence of the specified element in this
deque (when traversing the deque from head to tail).
- removeFirstOccurrence(Object) - Method in interface java.util.concurrent.BlockingDeque
-
Removes the first occurrence of the specified element from this deque.
- removeFirstOccurrence(Object) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Removes the first element e
such that
o.equals(e)
, if such an element exists in this deque.
- removeFirstOccurrence(Object) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- removeFirstOccurrence(Object) - Method in interface java.util.Deque
-
Removes the first occurrence of the specified element from this deque.
- removeLast() - Method in class java.util.ArrayDeque
-
- removeLast() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- removeLast() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- removeLast() - Method in interface java.util.Deque
-
Retrieves and removes the last element of this deque.
- removeLastOccurrence(Object) - Method in class java.util.ArrayDeque
-
Removes the last occurrence of the specified element in this
deque (when traversing the deque from head to tail).
- removeLastOccurrence(Object) - Method in interface java.util.concurrent.BlockingDeque
-
Removes the last occurrence of the specified element from this deque.
- removeLastOccurrence(Object) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Removes the last element e
such that
o.equals(e)
, if such an element exists in this deque.
- removeLastOccurrence(Object) - Method in class java.util.concurrent.LinkedBlockingDeque
-
- removeLastOccurrence(Object) - Method in interface java.util.Deque
-
Removes the last occurrence of the specified element from this deque.
- replace(K, V, V) - Method in class java.util.concurrent.ConcurrentHashMap
-
Replaces the entry for a key only if currently mapped to a given value.
- replace(K, V) - Method in class java.util.concurrent.ConcurrentHashMap
-
Replaces the entry for a key only if currently mapped to some value.
- replace(K, V, V) - Method in interface java.util.concurrent.ConcurrentMap
-
Replaces the entry for a key only if currently mapped to a given value.
- replace(K, V) - Method in interface java.util.concurrent.ConcurrentMap
-
Replaces the entry for a key only if currently mapped to some value.
- replace(K, V, V) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Replaces the entry for a key only if currently mapped to a given value.
- replace(K, V) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Replaces the entry for a key only if currently mapped to some value.
- reset() - Method in class java.util.concurrent.CyclicBarrier
-
Resets the barrier to its initial state.
- retainAll(Collection<?>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Retains only the elements in this list that are contained in the
specified collection.
- retainAll(Collection<?>) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Retains only the elements in this set that are contained in the
specified collection.
- retainAll(Collection<?>) - Method in class java.util.concurrent.SynchronousQueue
-
Always returns false.
- run() - Method in class java.util.concurrent.ForkJoinWorkerThread
-
This method is required to be public, but should never be
called explicitly.
- run() - Method in class java.util.concurrent.FutureTask
-
Sets this Future to the result of its computation
unless it has been cancelled.
- run() - Method in interface java.util.concurrent.RunnableFuture
-
Sets this Future to the result of its computation
unless it has been cancelled.
- runAndReset() - Method in class java.util.concurrent.FutureTask
-
Executes the computation without setting its result, and then
resets this Future to initial state, failing to do so if the
computation encounters an exception or is cancelled.
- RunnableFuture<V> - Interface in java.util.concurrent
-
- RunnableScheduledFuture<V> - Interface in java.util.concurrent
-
- schedule(Runnable, long, TimeUnit) - Method in interface java.util.concurrent.ScheduledExecutorService
-
Creates and executes a one-shot action that becomes enabled
after the given delay.
- schedule(Callable<V>, long, TimeUnit) - Method in interface java.util.concurrent.ScheduledExecutorService
-
Creates and executes a ScheduledFuture that becomes enabled after the
given delay.
- schedule(Runnable, long, TimeUnit) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
- schedule(Callable<V>, long, TimeUnit) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
- scheduleAtFixedRate(Runnable, long, long, TimeUnit) - Method in interface java.util.concurrent.ScheduledExecutorService
-
Creates and executes a periodic action that becomes enabled first
after the given initial delay, and subsequently with the given
period; that is executions will commence after
initialDelay then initialDelay+period, then
initialDelay + 2 * period, and so on.
- scheduleAtFixedRate(Runnable, long, long, TimeUnit) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
- ScheduledExecutorService - Interface in java.util.concurrent
-
An
ExecutorService
that can schedule commands to run after a given
delay, or to execute periodically.
- ScheduledFuture<V> - Interface in java.util.concurrent
-
A delayed result-bearing action that can be cancelled.
- ScheduledThreadPoolExecutor - Class in java.util.concurrent
-
A
ThreadPoolExecutor
that can additionally schedule
commands to run after a given delay, or to execute
periodically.
- ScheduledThreadPoolExecutor(int) - Constructor for class java.util.concurrent.ScheduledThreadPoolExecutor
-
Creates a new ScheduledThreadPoolExecutor
with the
given core pool size.
- ScheduledThreadPoolExecutor(int, ThreadFactory) - Constructor for class java.util.concurrent.ScheduledThreadPoolExecutor
-
Creates a new ScheduledThreadPoolExecutor
with the
given initial parameters.
- ScheduledThreadPoolExecutor(int, RejectedExecutionHandler) - Constructor for class java.util.concurrent.ScheduledThreadPoolExecutor
-
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
- ScheduledThreadPoolExecutor(int, ThreadFactory, RejectedExecutionHandler) - Constructor for class java.util.concurrent.ScheduledThreadPoolExecutor
-
Creates a new ScheduledThreadPoolExecutor with the given
initial parameters.
- scheduleWithFixedDelay(Runnable, long, long, TimeUnit) - Method in interface java.util.concurrent.ScheduledExecutorService
-
Creates and executes a periodic action that becomes enabled first
after the given initial delay, and subsequently with the
given delay between the termination of one execution and the
commencement of the next.
- scheduleWithFixedDelay(Runnable, long, long, TimeUnit) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
- Semaphore - Class in java.util.concurrent
-
A counting semaphore.
- Semaphore(int) - Constructor for class java.util.concurrent.Semaphore
-
Creates a Semaphore
with the given number of
permits and nonfair fairness setting.
- Semaphore(int, boolean) - Constructor for class java.util.concurrent.Semaphore
-
Creates a Semaphore
with the given number of
permits and the given fairness setting.
- set(boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
-
Unconditionally sets to the given value.
- set(int) - Method in class java.util.concurrent.atomic.AtomicInteger
-
Sets to the given value.
- set(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Sets the element at position i
to the given value.
- set(T, int) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Sets the field of the given object managed by this updater to the
given updated value.
- set(long) - Method in class java.util.concurrent.atomic.AtomicLong
-
Sets to the given value.
- set(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Sets the element at position i
to the given value.
- set(T, long) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Sets the field of the given object managed by this updater to the
given updated value.
- set(V, boolean) - Method in class java.util.concurrent.atomic.AtomicMarkableReference
-
Unconditionally sets the value of both the reference and mark.
- set(V) - Method in class java.util.concurrent.atomic.AtomicReference
-
Sets to the given value.
- set(int, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
-
Sets the element at position i
to the given value.
- set(T, V) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-
Sets the field of the given object managed by this updater to the
given updated value.
- set(V, int) - Method in class java.util.concurrent.atomic.AtomicStampedReference
-
Unconditionally sets the value of both the reference and stamp.
- set(int, E) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Replaces the element at the specified position in this list with the
specified element.
- set(V) - Method in class java.util.concurrent.FutureTask
-
Sets the result of this Future to the given value unless
this future has already been set or has been cancelled.
- setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Sets the policy on whether to continue executing existing
periodic tasks even when this executor has been shutdown
.
- setCorePoolSize(int) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Sets the core number of threads.
- setException(Throwable) - Method in class java.util.concurrent.FutureTask
-
Causes this future to report an ExecutionException
with the given throwable as its cause, unless this Future has
already been set or has been cancelled.
- setExclusiveOwnerThread(Thread) - Method in class java.util.concurrent.locks.AbstractOwnableSynchronizer
-
Sets the thread that currently owns exclusive access.
- setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Sets the policy on whether to execute existing delayed
tasks even when this executor has been shutdown
.
- setKeepAliveTime(long, TimeUnit) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Sets the time limit for which threads may remain idle before
being terminated.
- setMaximumPoolSize(int) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Sets the maximum allowed number of threads.
- setRawResult(V) - Method in class java.util.concurrent.ForkJoinTask
-
Forces the given value to be returned as a result.
- setRawResult(Void) - Method in class java.util.concurrent.RecursiveAction
-
Requires null completion value.
- setRawResult(V) - Method in class java.util.concurrent.RecursiveTask
-
- setRejectedExecutionHandler(RejectedExecutionHandler) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Sets a new handler for unexecutable tasks.
- setRemoveOnCancelPolicy(boolean) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Sets the policy on whether cancelled tasks should be immediately
removed from the work queue at time of cancellation.
- setSeed(long) - Method in class java.util.concurrent.ThreadLocalRandom
-
Throws UnsupportedOperationException
.
- setState(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Sets the value of synchronization state.
- setState(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Sets the value of synchronization state.
- setThreadFactory(ThreadFactory) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Sets the thread factory used to create new threads.
- shutdown() - Method in interface java.util.concurrent.ExecutorService
-
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted.
- shutdown() - Method in class java.util.concurrent.ForkJoinPool
-
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted.
- shutdown() - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted.
- shutdown() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Initiates an orderly shutdown in which previously submitted
tasks are executed, but no new tasks will be accepted.
- shutdownNow() - Method in interface java.util.concurrent.ExecutorService
-
Attempts to stop all actively executing tasks, halts the
processing of waiting tasks, and returns a list of the tasks
that were awaiting execution.
- shutdownNow() - Method in class java.util.concurrent.ForkJoinPool
-
Attempts to cancel and/or stop all tasks, and reject all
subsequently submitted tasks.
- shutdownNow() - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
Attempts to stop all actively executing tasks, halts the
processing of waiting tasks, and returns a list of the tasks
that were awaiting execution.
- shutdownNow() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Attempts to stop all actively executing tasks, halts the
processing of waiting tasks, and returns a list of the tasks
that were awaiting execution.
- signal() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Moves the longest-waiting thread, if one exists, from the
wait queue for this condition to the wait queue for the
owning lock.
- signal() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Moves the longest-waiting thread, if one exists, from the
wait queue for this condition to the wait queue for the
owning lock.
- signal() - Method in interface java.util.concurrent.locks.Condition
-
Wakes up one waiting thread.
- signalAll() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
-
Moves all threads from the wait queue for this condition to
the wait queue for the owning lock.
- signalAll() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
-
Moves all threads from the wait queue for this condition to
the wait queue for the owning lock.
- signalAll() - Method in interface java.util.concurrent.locks.Condition
-
Wakes up all waiting threads.
- size() - Method in class java.util.ArrayDeque
-
Returns the number of elements in this deque.
- size() - Method in class java.util.concurrent.ArrayBlockingQueue
-
Returns the number of elements in this queue.
- size() - Method in interface java.util.concurrent.BlockingDeque
-
Returns the number of elements in this deque.
- size() - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the number of key-value mappings in this map.
- size() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Returns the number of elements in this deque.
- size() - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Returns the number of elements in this queue.
- size() - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Returns the number of key-value mappings in this map.
- size() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
Returns the number of elements in this set.
- size() - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns the number of elements in this list.
- size() - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Returns the number of elements in this set.
- size() - Method in class java.util.concurrent.DelayQueue
-
- size() - Method in class java.util.concurrent.LinkedBlockingDeque
-
Returns the number of elements in this deque.
- size() - Method in class java.util.concurrent.LinkedBlockingQueue
-
Returns the number of elements in this queue.
- size() - Method in class java.util.concurrent.LinkedTransferQueue
-
Returns the number of elements in this queue.
- size() - Method in class java.util.concurrent.PriorityBlockingQueue
-
- size() - Method in class java.util.concurrent.SynchronousQueue
-
Always returns zero.
- size() - Method in interface java.util.Deque
-
Returns the number of elements in this deque.
- size() - Method in class java.util.PriorityQueue
-
- sleep(long) - Method in enum java.util.concurrent.TimeUnit
-
- subList(int, int) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns a view of the portion of this list between
fromIndex, inclusive, and toIndex, exclusive.
- subMap(K, boolean, K, boolean) - Method in interface java.util.concurrent.ConcurrentNavigableMap
-
- subMap(K, K) - Method in interface java.util.concurrent.ConcurrentNavigableMap
-
- subMap(K, boolean, K, boolean) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
- subMap(K, K) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
- subMap(K, boolean, K, boolean) - Method in interface java.util.NavigableMap
-
Returns a view of the portion of this map whose keys range from
fromKey
to toKey
.
- subMap(K, K) - Method in interface java.util.NavigableMap
- submit(Runnable) - Method in class java.util.concurrent.AbstractExecutorService
-
- submit(Runnable, T) - Method in class java.util.concurrent.AbstractExecutorService
-
- submit(Callable<T>) - Method in class java.util.concurrent.AbstractExecutorService
-
- submit(Callable<V>) - Method in interface java.util.concurrent.CompletionService
-
Submits a value-returning task for execution and returns a Future
representing the pending results of the task.
- submit(Runnable, V) - Method in interface java.util.concurrent.CompletionService
-
Submits a Runnable task for execution and returns a Future
representing that task.
- submit(Callable<V>) - Method in class java.util.concurrent.ExecutorCompletionService
-
- submit(Runnable, V) - Method in class java.util.concurrent.ExecutorCompletionService
-
- submit(Callable<T>) - Method in interface java.util.concurrent.ExecutorService
-
Submits a value-returning task for execution and returns a
Future representing the pending results of the task.
- submit(Runnable, T) - Method in interface java.util.concurrent.ExecutorService
-
Submits a Runnable task for execution and returns a Future
representing that task.
- submit(Runnable) - Method in interface java.util.concurrent.ExecutorService
-
Submits a Runnable task for execution and returns a Future
representing that task.
- submit(ForkJoinTask<T>) - Method in class java.util.concurrent.ForkJoinPool
-
Submits a ForkJoinTask for execution.
- submit(Callable<T>) - Method in class java.util.concurrent.ForkJoinPool
-
- submit(Runnable, T) - Method in class java.util.concurrent.ForkJoinPool
-
- submit(Runnable) - Method in class java.util.concurrent.ForkJoinPool
-
- submit(Runnable) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
- submit(Runnable, T) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
- submit(Callable<T>) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
-
- subSet(E, boolean, E, boolean) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- subSet(E, E) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- subSet(E, boolean, E, boolean) - Method in interface java.util.NavigableSet
-
Returns a view of the portion of this set whose elements range from
fromElement
to toElement
.
- subSet(E, E) - Method in interface java.util.NavigableSet
- SynchronousQueue<E> - Class in java.util.concurrent
-
A
blocking queue in which each insert
operation must wait for a corresponding remove operation by another
thread, and vice versa.
- SynchronousQueue() - Constructor for class java.util.concurrent.SynchronousQueue
-
Creates a SynchronousQueue with nonfair access policy.
- SynchronousQueue(boolean) - Constructor for class java.util.concurrent.SynchronousQueue
-
Creates a SynchronousQueue with the specified fairness policy.
- tailMap(K, boolean) - Method in interface java.util.concurrent.ConcurrentNavigableMap
-
- tailMap(K) - Method in interface java.util.concurrent.ConcurrentNavigableMap
-
- tailMap(K, boolean) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
- tailMap(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
- tailMap(K, boolean) - Method in interface java.util.NavigableMap
-
Returns a view of the portion of this map whose keys are greater than (or
equal to, if inclusive
is true) fromKey
.
- tailMap(K) - Method in interface java.util.NavigableMap
- tailSet(E, boolean) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- tailSet(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- tailSet(E, boolean) - Method in interface java.util.NavigableSet
-
Returns a view of the portion of this set whose elements are greater
than (or equal to, if inclusive
is true) fromElement
.
- tailSet(E) - Method in interface java.util.NavigableSet
- take() - Method in class java.util.concurrent.ArrayBlockingQueue
-
- take() - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves and removes the head of the queue represented by this deque
(in other words, the first element of this deque), waiting if
necessary until an element becomes available.
- take() - Method in interface java.util.concurrent.BlockingQueue
-
Retrieves and removes the head of this queue, waiting if necessary
until an element becomes available.
- take() - Method in interface java.util.concurrent.CompletionService
-
Retrieves and removes the Future representing the next
completed task, waiting if none are yet present.
- take() - Method in class java.util.concurrent.DelayQueue
-
Retrieves and removes the head of this queue, waiting if necessary
until an element with an expired delay is available on this queue.
- take() - Method in class java.util.concurrent.ExecutorCompletionService
-
- take() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- take() - Method in class java.util.concurrent.LinkedBlockingQueue
-
- take() - Method in class java.util.concurrent.LinkedTransferQueue
-
- take() - Method in class java.util.concurrent.PriorityBlockingQueue
-
- take() - Method in class java.util.concurrent.SynchronousQueue
-
Retrieves and removes the head of this queue, waiting if necessary
for another thread to insert it.
- takeFirst() - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves and removes the first element of this deque, waiting
if necessary until an element becomes available.
- takeFirst() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- takeLast() - Method in interface java.util.concurrent.BlockingDeque
-
Retrieves and removes the last element of this deque, waiting
if necessary until an element becomes available.
- takeLast() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- terminated() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Method invoked when the Executor has terminated.
- ThreadFactory - Interface in java.util.concurrent
-
An object that creates new threads on demand.
- ThreadLocalRandom - Class in java.util.concurrent
-
A random number generator isolated to the current thread.
- ThreadPoolExecutor - Class in java.util.concurrent
-
An
ExecutorService
that executes each submitted task using
one of possibly several pooled threads, normally configured
using
Executors
factory methods.
- ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>) - Constructor for class java.util.concurrent.ThreadPoolExecutor
-
Creates a new ThreadPoolExecutor
with the given initial
parameters and default thread factory and rejected execution handler.
- ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>, ThreadFactory) - Constructor for class java.util.concurrent.ThreadPoolExecutor
-
Creates a new ThreadPoolExecutor
with the given initial
parameters and default rejected execution handler.
- ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>, RejectedExecutionHandler) - Constructor for class java.util.concurrent.ThreadPoolExecutor
-
Creates a new ThreadPoolExecutor
with the given initial
parameters and default thread factory.
- ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue<Runnable>, ThreadFactory, RejectedExecutionHandler) - Constructor for class java.util.concurrent.ThreadPoolExecutor
-
Creates a new ThreadPoolExecutor
with the given initial
parameters.
- ThreadPoolExecutor.AbortPolicy - Class in java.util.concurrent
-
A handler for rejected tasks that throws a
RejectedExecutionException
.
- ThreadPoolExecutor.AbortPolicy() - Constructor for class java.util.concurrent.ThreadPoolExecutor.AbortPolicy
-
Creates an AbortPolicy
.
- ThreadPoolExecutor.CallerRunsPolicy - Class in java.util.concurrent
-
A handler for rejected tasks that runs the rejected task
directly in the calling thread of the execute
method,
unless the executor has been shut down, in which case the task
is discarded.
- ThreadPoolExecutor.CallerRunsPolicy() - Constructor for class java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
-
Creates a CallerRunsPolicy
.
- ThreadPoolExecutor.DiscardOldestPolicy - Class in java.util.concurrent
-
A handler for rejected tasks that discards the oldest unhandled
request and then retries execute
, unless the executor
is shut down, in which case the task is discarded.
- ThreadPoolExecutor.DiscardOldestPolicy() - Constructor for class java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy
-
Creates a DiscardOldestPolicy
for the given executor.
- ThreadPoolExecutor.DiscardPolicy - Class in java.util.concurrent
-
A handler for rejected tasks that silently discards the
rejected task.
- ThreadPoolExecutor.DiscardPolicy() - Constructor for class java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
-
Creates a DiscardPolicy
.
- timedJoin(Thread, long) - Method in enum java.util.concurrent.TimeUnit
-
- timedWait(Object, long) - Method in enum java.util.concurrent.TimeUnit
-
- TimeoutException - Exception in java.util.concurrent
-
Exception thrown when a blocking operation times out.
- TimeoutException() - Constructor for exception java.util.concurrent.TimeoutException
-
Constructs a TimeoutException with no specified detail
message.
- TimeoutException(String) - Constructor for exception java.util.concurrent.TimeoutException
-
Constructs a TimeoutException with the specified detail
message.
- TimeUnit - Enum in java.util.concurrent
-
A TimeUnit represents time durations at a given unit of
granularity and provides utility methods to convert across units,
and to perform timing and delay operations in these units.
- toArray() - Method in class java.util.ArrayDeque
-
Returns an array containing all of the elements in this deque
in proper sequence (from first to last element).
- toArray(T[]) - Method in class java.util.ArrayDeque
-
Returns an array containing all of the elements in this deque in
proper sequence (from first to last element); the runtime type of the
returned array is that of the specified array.
- toArray() - Method in class java.util.concurrent.ArrayBlockingQueue
-
Returns an array containing all of the elements in this queue, in
proper sequence.
- toArray(T[]) - Method in class java.util.concurrent.ArrayBlockingQueue
-
Returns an array containing all of the elements in this queue, in
proper sequence; the runtime type of the returned array is that of
the specified array.
- toArray() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Returns an array containing all of the elements in this deque, in
proper sequence (from first to last element).
- toArray(T[]) - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
Returns an array containing all of the elements in this deque,
in proper sequence (from first to last element); the runtime
type of the returned array is that of the specified array.
- toArray() - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Returns an array containing all of the elements in this queue, in
proper sequence.
- toArray(T[]) - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
Returns an array containing all of the elements in this queue, in
proper sequence; the runtime type of the returned array is that of
the specified array.
- toArray() - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns an array containing all of the elements in this list
in proper sequence (from first to last element).
- toArray(T[]) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns an array containing all of the elements in this list in
proper sequence (from first to last element); the runtime type of
the returned array is that of the specified array.
- toArray() - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Returns an array containing all of the elements in this set.
- toArray(T[]) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
Returns an array containing all of the elements in this set; the
runtime type of the returned array is that of the specified array.
- toArray() - Method in class java.util.concurrent.DelayQueue
-
Returns an array containing all of the elements in this queue.
- toArray(T[]) - Method in class java.util.concurrent.DelayQueue
-
Returns an array containing all of the elements in this queue; the
runtime type of the returned array is that of the specified array.
- toArray() - Method in class java.util.concurrent.LinkedBlockingDeque
-
Returns an array containing all of the elements in this deque, in
proper sequence (from first to last element).
- toArray(T[]) - Method in class java.util.concurrent.LinkedBlockingDeque
-
Returns an array containing all of the elements in this deque, in
proper sequence; the runtime type of the returned array is that of
the specified array.
- toArray() - Method in class java.util.concurrent.LinkedBlockingQueue
-
Returns an array containing all of the elements in this queue, in
proper sequence.
- toArray(T[]) - Method in class java.util.concurrent.LinkedBlockingQueue
-
Returns an array containing all of the elements in this queue, in
proper sequence; the runtime type of the returned array is that of
the specified array.
- toArray() - Method in class java.util.concurrent.PriorityBlockingQueue
-
Returns an array containing all of the elements in this queue.
- toArray(T[]) - Method in class java.util.concurrent.PriorityBlockingQueue
-
Returns an array containing all of the elements in this queue; the
runtime type of the returned array is that of the specified array.
- toArray() - Method in class java.util.concurrent.SynchronousQueue
-
Returns a zero-length array.
- toArray(T[]) - Method in class java.util.concurrent.SynchronousQueue
-
Sets the zeroeth element of the specified array to null
(if the array has non-zero length) and returns it.
- toArray() - Method in class java.util.PriorityQueue
-
Returns an array containing all of the elements in this queue.
- toArray(T[]) - Method in class java.util.PriorityQueue
-
Returns an array containing all of the elements in this queue; the
runtime type of the returned array is that of the specified array.
- toDays(long) - Method in enum java.util.concurrent.TimeUnit
-
Equivalent to DAYS.convert(duration, this).
- toHours(long) - Method in enum java.util.concurrent.TimeUnit
-
Equivalent to HOURS.convert(duration, this).
- toMicros(long) - Method in enum java.util.concurrent.TimeUnit
-
Equivalent to MICROSECONDS.convert(duration, this).
- toMillis(long) - Method in enum java.util.concurrent.TimeUnit
-
Equivalent to MILLISECONDS.convert(duration, this).
- toMinutes(long) - Method in enum java.util.concurrent.TimeUnit
-
Equivalent to MINUTES.convert(duration, this).
- toNanos(long) - Method in enum java.util.concurrent.TimeUnit
-
Equivalent to NANOSECONDS.convert(duration, this).
- toSeconds(long) - Method in enum java.util.concurrent.TimeUnit
-
Equivalent to SECONDS.convert(duration, this).
- toString() - Method in class java.util.concurrent.ArrayBlockingQueue
-
- toString() - Method in class java.util.concurrent.atomic.AtomicBoolean
-
Returns the String representation of the current value.
- toString() - Method in class java.util.concurrent.atomic.AtomicInteger
-
Returns the String representation of the current value.
- toString() - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Returns the String representation of the current values of array.
- toString() - Method in class java.util.concurrent.atomic.AtomicLong
-
Returns the String representation of the current value.
- toString() - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Returns the String representation of the current values of array.
- toString() - Method in class java.util.concurrent.atomic.AtomicReference
-
Returns the String representation of the current value.
- toString() - Method in class java.util.concurrent.atomic.AtomicReferenceArray
-
Returns the String representation of the current values of array.
- toString() - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Returns a string representation of this list.
- toString() - Method in class java.util.concurrent.CountDownLatch
-
Returns a string identifying this latch, as well as its state.
- toString() - Method in class java.util.concurrent.ForkJoinPool
-
Returns a string identifying this pool, as well as its state,
including indications of run state, parallelism level, and
worker and task counts.
- toString() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- toString() - Method in class java.util.concurrent.LinkedBlockingQueue
-
- toString() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Returns a string identifying this synchronizer, as well as its state.
- toString() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Returns a string identifying this synchronizer, as well as its state.
- toString() - Method in class java.util.concurrent.locks.ReentrantLock
-
Returns a string identifying this lock, as well as its lock state.
- toString() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
-
Returns a string identifying this lock, as well as its lock state.
- toString() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
-
Returns a string identifying this lock, as well as its lock state.
- toString() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
-
Returns a string identifying this lock, as well as its lock
state.
- toString() - Method in class java.util.concurrent.Phaser
-
Returns a string identifying this phaser, as well as its
state.
- toString() - Method in class java.util.concurrent.PriorityBlockingQueue
-
- toString() - Method in class java.util.concurrent.Semaphore
-
Returns a string identifying this semaphore, as well as its state.
- toString() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns a string identifying this pool, as well as its state,
including indications of run state and estimated worker and
task counts.
- transfer(E) - Method in class java.util.concurrent.LinkedTransferQueue
-
Transfers the element to a consumer, waiting if necessary to do so.
- transfer(E) - Method in interface java.util.concurrent.TransferQueue
-
Transfers the element to a consumer, waiting if necessary to do so.
- TransferQueue<E> - Interface in java.util.concurrent
-
A
BlockingQueue
in which producers may wait for consumers
to receive elements.
- tryAcquire(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Attempts to acquire in exclusive mode.
- tryAcquire(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Attempts to acquire in exclusive mode.
- tryAcquire() - Method in class java.util.concurrent.Semaphore
-
Acquires a permit from this semaphore, only if one is available at the
time of invocation.
- tryAcquire(long, TimeUnit) - Method in class java.util.concurrent.Semaphore
-
Acquires a permit from this semaphore, if one becomes available
within the given waiting time and the current thread has not
been
interrupted.
- tryAcquire(int) - Method in class java.util.concurrent.Semaphore
-
Acquires the given number of permits from this semaphore, only
if all are available at the time of invocation.
- tryAcquire(int, long, TimeUnit) - Method in class java.util.concurrent.Semaphore
-
Acquires the given number of permits from this semaphore, if all
become available within the given waiting time and the current
thread has not been
interrupted.
- tryAcquireNanos(long, long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Attempts to acquire in exclusive mode, aborting if interrupted,
and failing if the given timeout elapses.
- tryAcquireNanos(int, long) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Attempts to acquire in exclusive mode, aborting if interrupted,
and failing if the given timeout elapses.
- tryAcquireShared(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Attempts to acquire in shared mode.
- tryAcquireShared(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Attempts to acquire in shared mode.
- tryAcquireSharedNanos(long, long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Attempts to acquire in shared mode, aborting if interrupted, and
failing if the given timeout elapses.
- tryAcquireSharedNanos(int, long) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Attempts to acquire in shared mode, aborting if interrupted, and
failing if the given timeout elapses.
- tryLock() - Method in interface java.util.concurrent.locks.Lock
-
Acquires the lock only if it is free at the time of invocation.
- tryLock(long, TimeUnit) - Method in interface java.util.concurrent.locks.Lock
-
Acquires the lock if it is free within the given waiting time and the
current thread has not been
interrupted.
- tryLock() - Method in class java.util.concurrent.locks.ReentrantLock
-
Acquires the lock only if it is not held by another thread at the time
of invocation.
- tryLock(long, TimeUnit) - Method in class java.util.concurrent.locks.ReentrantLock
-
Acquires the lock if it is not held by another thread within the given
waiting time and the current thread has not been
interrupted.
- tryLock() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
-
Acquires the read lock only if the write lock is not held by
another thread at the time of invocation.
- tryLock(long, TimeUnit) - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
-
Acquires the read lock if the write lock is not held by
another thread within the given waiting time and the
current thread has not been
interrupted.
- tryLock() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
-
Acquires the write lock only if it is not held by another thread
at the time of invocation.
- tryLock(long, TimeUnit) - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
-
Acquires the write lock if it is not held by another thread
within the given waiting time and the current thread has
not been
interrupted.
- tryRelease(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Attempts to set the state to reflect a release in exclusive
mode.
- tryRelease(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Attempts to set the state to reflect a release in exclusive
mode.
- tryReleaseShared(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
-
Attempts to set the state to reflect a release in shared mode.
- tryReleaseShared(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
-
Attempts to set the state to reflect a release in shared mode.
- tryTransfer(E) - Method in class java.util.concurrent.LinkedTransferQueue
-
Transfers the element to a waiting consumer immediately, if possible.
- tryTransfer(E, long, TimeUnit) - Method in class java.util.concurrent.LinkedTransferQueue
-
Transfers the element to a consumer if it is possible to do so
before the timeout elapses.
- tryTransfer(E) - Method in interface java.util.concurrent.TransferQueue
-
Transfers the element to a waiting consumer immediately, if possible.
- tryTransfer(E, long, TimeUnit) - Method in interface java.util.concurrent.TransferQueue
-
Transfers the element to a consumer if it is possible to do so
before the timeout elapses.
- tryUnfork() - Method in class java.util.concurrent.ForkJoinTask
-
Tries to unschedule this task for execution.