- 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.
- acceptEither(CompletableFuture<? extends T>, Consumer<? super T>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when either this or the other given CompletableFuture completes,
after performing the given action with the result of either this
or the other CompletableFuture's result.
- acceptEitherAsync(CompletableFuture<? extends T>, Consumer<? super T>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when either this or the other given CompletableFuture completes,
after performing the given action with the result of either this
or the other CompletableFuture's result from a task running in
the
ForkJoinPool.commonPool().
- acceptEitherAsync(CompletableFuture<? extends T>, Consumer<? super T>, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when either this or the other given CompletableFuture completes,
after performing the given action with the result of either this
or the other CompletableFuture's result from a task running in
the given executor.
- accumulate(double) - Method in class java.util.concurrent.atomic.DoubleAccumulator
-
Updates with the given value.
- accumulate(long) - Method in class java.util.concurrent.atomic.LongAccumulator
-
Updates with the given value.
- accumulateAndGet(int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically updates the current value with the results of
applying the given function to the current and given values,
returning the updated value.
- accumulateAndGet(int, int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically updates the element at index i with the
results of applying the given function to the current and
given values, returning the updated value.
- accumulateAndGet(T, int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically updates the field of the given object managed by this
updater with the results of applying the given function to the
current and given values, returning the updated value.
- accumulateAndGet(long, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically updates the current value with the results of
applying the given function to the current and given values,
returning the updated value.
- accumulateAndGet(int, int, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically updates the element at index i with the
results of applying the given function to the current and
given values, returning the updated value.
- accumulateAndGet(T, long, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically updates the field of the given object managed by this
updater with the results of applying the given function to the
current and given values, returning the updated value.
- accumulateAndGet(V, BinaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReference
-
Atomically updates the current value with the results of
applying the given function to the current and given values,
returning the updated value.
- accumulateAndGet(int, E, BinaryOperator<E>) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
-
Atomically updates the element at index i with the
results of applying the given function to the current and
given values, returning the updated value.
- accumulateAndGet(T, V, BinaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-
Atomically updates the field of the given object managed by this
updater with the results of applying the given function to the
current and given values, returning the updated value.
- 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(double) - Method in class java.util.concurrent.atomic.DoubleAdder
-
Adds the given value.
- add(long) - Method in class java.util.concurrent.atomic.LongAdder
-
Adds the given value.
- 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(K) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
-
Adds the specified key to this set view by mapping the key to
the default mapped value in the backing map, if defined.
- 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 K>) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
-
- 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,
throwing an IllegalStateException if no space is currently
available.
- addIfAbsent(E) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
Appends 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,
throwing an IllegalStateException if no space is currently
available.
- addToPendingCount(int) - Method in class java.util.concurrent.CountedCompleter
-
Adds (atomically) the given value to the pending count.
- afterExecute(Runnable, Throwable) - Method in class java.util.concurrent.ThreadPoolExecutor
-
Method invoked upon completion of execution of the given Runnable.
- allOf(CompletableFuture<?>...) - Static method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed when all of
the given CompletableFutures complete.
- 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.
- anyOf(CompletableFuture<?>...) - Static method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed when any of
the given CompletableFutures complete, with the same result.
- applyToEither(CompletableFuture<? extends T>, Function<? super T, U>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when either this or the other given CompletableFuture completes,
with the result of the given function of either this or the other
CompletableFuture's result.
- applyToEitherAsync(CompletableFuture<? extends T>, Function<? super T, U>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when either this or the other given CompletableFuture completes,
with the result of the given function of either this or the other
CompletableFuture's result from a task running in the
ForkJoinPool.commonPool().
- applyToEitherAsync(CompletableFuture<? extends T>, Function<? super T, U>, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when either this or the other given CompletableFuture completes,
with the result of the given function of either this or the other
CompletableFuture's result from a task running in the
given executor.
- 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.
- asReadLock() - Method in class java.util.concurrent.locks.StampedLock
-
- asReadWriteLock() - Method in class java.util.concurrent.locks.StampedLock
-
- asWriteLock() - Method in class java.util.concurrent.locks.StampedLock
-
- 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.
- awaitQuiescence(long, TimeUnit) - Method in class java.util.concurrent.ForkJoinPool
-
- 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.CompletableFuture
-
- 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.
- commonPool() - Static method in class java.util.concurrent.ForkJoinPool
-
Returns the common pool instance.
- 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.
- compareAndSetForkJoinTaskTag(short, short) - Method in class java.util.concurrent.ForkJoinTask
-
Atomically conditionally sets the tag value for this task.
- compareAndSetPendingCount(int, int) - Method in class java.util.concurrent.CountedCompleter
-
Sets (atomically) the pending count to the given count only if
it currently holds the given expected value.
- 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.
- CompletableFuture<T> - Class in java.util.concurrent
-
A
Future that may be explicitly completed (setting its
value and status), and may include dependent functions and actions
that trigger upon its completion.
- CompletableFuture() - Constructor for class java.util.concurrent.CompletableFuture
-
Creates a new incomplete CompletableFuture.
- CompletableFuture.AsynchronousCompletionTask - Interface in java.util.concurrent
-
A marker interface identifying asynchronous tasks produced by
async methods.
- complete(T) - Method in class java.util.concurrent.CompletableFuture
-
If not already completed, sets the value returned by
CompletableFuture.get() and related methods to the given value.
- complete(T) - Method in class java.util.concurrent.CountedCompleter
-
- 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.
- completedFuture(U) - Static method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is already completed with
the given value.
- completeExceptionally(Throwable) - Method in class java.util.concurrent.CompletableFuture
-
If not already completed, causes invocations of
CompletableFuture.get()
and related methods to throw the given exception.
- 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.
- CompletionException - Exception in java.util.concurrent
-
Exception thrown when an error or other exception is encountered
in the course of completing a result or task.
- CompletionException() - Constructor for exception java.util.concurrent.CompletionException
-
Constructs a CompletionException with no detail message.
- CompletionException(String) - Constructor for exception java.util.concurrent.CompletionException
-
Constructs a CompletionException with the specified detail
message.
- CompletionException(String, Throwable) - Constructor for exception java.util.concurrent.CompletionException
-
Constructs a CompletionException with the specified detail
message and cause.
- CompletionException(Throwable) - Constructor for exception java.util.concurrent.CompletionException
-
Constructs a CompletionException with the specified cause.
- 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(K, BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Attempts to compute a mapping for the specified key and its
current mapped value (or null if there is no current
mapping).
- compute(K, BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Attempts to compute a mapping for the specified key and its
current mapped value (or null if there is no current
mapping).
- compute() - Method in class java.util.concurrent.CountedCompleter
-
The main computation performed by this task.
- 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.
- computeIfAbsent(K, Function<? super K, ? extends V>) - Method in class java.util.concurrent.ConcurrentHashMap
-
If the specified key is not already associated with a value (or
is mapped to null), attempts to compute its value using
the given mapping function and enters it into this map unless
null.
- computeIfAbsent(K, Function<? super K, ? extends V>) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
If the specified key is not already associated with a value,
attempts to compute its value using the given mapping function
and enters it into this map unless null.
- computeIfPresent(K, BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentHashMap
-
If the value for the specified key is present and non-null,
attempts to compute a new mapping given the key and its current
mapped value.
- computeIfPresent(K, BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
If the value for the specified key is present, attempts to
compute a new mapping given the key and its current mapped
value.
- ConcurrentHashMap<K,V> - Class in java.util.concurrent
-
A hash table supporting full concurrency of retrievals and
high expected concurrency for updates.
- ConcurrentHashMap() - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new, empty map with the default initial table size (16).
- ConcurrentHashMap(int) - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new, empty map with an initial table size
accommodating the specified number of elements without the need
to dynamically resize.
- 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.
- ConcurrentHashMap(int, float) - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new, empty map with an initial table size based on
the given number of elements (initialCapacity) and
initial table density (loadFactor).
- ConcurrentHashMap(int, float, int) - Constructor for class java.util.concurrent.ConcurrentHashMap
-
Creates a new, empty map with an initial table size based on
the given number of elements (initialCapacity), table
density (loadFactor), and number of concurrently
updating threads (concurrencyLevel).
- ConcurrentHashMap.KeySetView<K,V> - Class in java.util.concurrent
-
A view of a ConcurrentHashMap as a
Set of keys, in
which additions may optionally be enabled by mapping to a
common value.
- 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
-
Deprecated.
- contains(Object) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
-
Returns true if this collection contains the specified element.
- 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.
- CountedCompleter<T> - Class in java.util.concurrent
-
A
ForkJoinTask with a completion action performed when
triggered and there are no remaining pending
actions.
- CountedCompleter(CountedCompleter<?>, int) - Constructor for class java.util.concurrent.CountedCompleter
-
Creates a new CountedCompleter with the given completer
and initial pending count.
- CountedCompleter(CountedCompleter<?>) - Constructor for class java.util.concurrent.CountedCompleter
-
Creates a new CountedCompleter with the given completer
and an initial pending count of zero.
- CountedCompleter() - Constructor for class java.util.concurrent.CountedCompleter
-
Creates a new CountedCompleter with no completer
and an initial pending count of zero.
- 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() - Method in class java.util.concurrent.atomic.DoubleAccumulator
-
Returns the current value.
- get() - Method in class java.util.concurrent.atomic.LongAccumulator
-
Returns the current value.
- get() - Method in class java.util.concurrent.CompletableFuture
-
Waits if necessary for this future to complete, and then
returns its result.
- get(long, TimeUnit) - Method in class java.util.concurrent.CompletableFuture
-
Waits if necessary for at most the given time for this future
to complete, and then returns its result, if available.
- 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
-
Returns the element at the specified position in this list.
- 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.
- getAndAccumulate(int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically updates the current value with the results of
applying the given function to the current and given values,
returning the previous value.
- getAndAccumulate(int, int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically updates the element at index i with the
results of applying the given function to the current and
given values, returning the previous value.
- getAndAccumulate(T, int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically updates the field of the given object managed by this
updater with the results of applying the given function to the
current and given values, returning the previous value.
- getAndAccumulate(long, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically updates the current value with the results of
applying the given function to the current and given values,
returning the previous value.
- getAndAccumulate(int, int, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically updates the element at index i with the
results of applying the given function to the current and
given values, returning the previous value.
- getAndAccumulate(T, long, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically updates the field of the given object managed by this
updater with the results of applying the given function to the
current and given values, returning the previous value.
- getAndAccumulate(V, BinaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReference
-
Atomically updates the current value with the results of
applying the given function to the current and given values,
returning the previous value.
- getAndAccumulate(int, E, BinaryOperator<E>) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
-
Atomically updates the element at index i with the
results of applying the given function to the current and
given values, returning the previous value.
- getAndAccumulate(T, V, BinaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-
Atomically updates the field of the given object managed by this
updater with the results of applying the given function to the
current and given values, returning the previous value.
- 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.
- getAndUpdate(IntUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicInteger
-
Atomically updates the current value with the results of
applying the given function, returning the previous value.
- getAndUpdate(int, IntUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
-
Atomically updates the element at index i with the results
of applying the given function, returning the previous value.
- getAndUpdate(T, IntUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
-
Atomically updates the field of the given object managed by this updater
with the results of applying the given function, returning the previous
value.
- getAndUpdate(LongUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicLong
-
Atomically updates the current value with the results of
applying the given function, returning the previous value.
- getAndUpdate(int, LongUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongArray
-
Atomically updates the element at index i with the results
of applying the given function, returning the previous value.
- getAndUpdate(T, LongUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
-
Atomically updates the field of the given object managed by this updater
with the results of applying the given function, returning the previous
value.
- getAndUpdate(UnaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReference
-
Atomically updates the current value with the results of
applying the given function, returning the previous value.
- getAndUpdate(int, UnaryOperator<E>) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
-
Atomically updates the element at index i with the results
of applying the given function, returning the previous value.
- getAndUpdate(T, UnaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-
Atomically updates the field of the given object managed by this updater
with the results of applying the given function, returning the previous
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.
- getCommonPoolParallelism() - Static method in class java.util.concurrent.ForkJoinPool
-
Returns the targeted parallelism level of the common pool.
- getCompletedTaskCount() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the approximate total number of tasks that have
completed execution.
- getCompleter() - Method in class java.util.concurrent.CountedCompleter
-
Returns the completer established in this task's constructor,
or null if none.
- 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.
- getForkJoinTaskTag() - Method in class java.util.concurrent.ForkJoinTask
-
Returns the tag for this task.
- 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.
- getMappedValue() - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
-
Returns the default mapped value for additions,
or null if additions are not supported.
- getMaximumPoolSize() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the maximum allowed number of threads.
- getNow(T) - Method in class java.util.concurrent.CompletableFuture
-
Returns the result value (or throws any encountered exception)
if completed, else returns the given valueIfAbsent.
- getNumberOfDependents() - Method in class java.util.concurrent.CompletableFuture
-
Returns the estimated number of CompletableFutures whose
completions are awaiting completion of this CompletableFuture.
- getNumberWaiting() - Method in class java.util.concurrent.CyclicBarrier
-
Returns the number of parties currently waiting at the barrier.
- getOrDefault(Object, V) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the value to which the specified key is mapped,
or the given defaultValue if this map contains no mapping for the key.
- getOrDefault(Object, V) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
Returns the value to which the specified key is mapped,
or the given defaultValue if this map contains no mapping for the key.
- 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.
- getPendingCount() - Method in class java.util.concurrent.CountedCompleter
-
Returns the current pending count.
- 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 unique 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.CountedCompleter
-
Returns the result of the computation.
- 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.
- getReadLockCount() - Method in class java.util.concurrent.locks.StampedLock
-
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.CountedCompleter
-
Returns the root of the current computation; i.e., this
task if it has no completer, else its completer's root.
- 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, or zero if this thread is not
operating in a ForkJoinPool.
- getTaskCount() - Method in class java.util.concurrent.ThreadPoolExecutor
-
Returns the approximate total number of tasks that have ever been
scheduled for execution.
- getThenReset() - Method in class java.util.concurrent.atomic.DoubleAccumulator
-
- getThenReset() - Method in class java.util.concurrent.atomic.LongAccumulator
-
- 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.
- increment() - Method in class java.util.concurrent.atomic.LongAdder
-
Equivalent to add(1).
- 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
-
Returns the index of the first occurrence of the specified element
in this list, or -1 if this list does not contain the element.
- 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
-
Returns the value of this AtomicInteger as an int.
- intValue() - Method in class java.util.concurrent.atomic.AtomicLong
-
Returns the value of this AtomicLong as an int
after a narrowing primitive conversion.
- intValue() - Method in class java.util.concurrent.atomic.DoubleAccumulator
-
Returns the
current value as an
int
after a narrowing primitive conversion.
- intValue() - Method in class java.util.concurrent.atomic.DoubleAdder
-
- intValue() - Method in class java.util.concurrent.atomic.LongAccumulator
-
Returns the
current value as an
int
after a narrowing primitive conversion.
- intValue() - Method in class java.util.concurrent.atomic.LongAdder
-
Returns the
sum() as an
int after a narrowing
primitive conversion.
- 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.CompletableFuture
-
Returns true if this CompletableFuture was cancelled
before it completed normally.
- 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.CompletableFuture
-
Returns true if completed in any fashion: normally,
exceptionally, or via cancellation.
- 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 task is periodic.
- 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.
- isReadLocked() - Method in class java.util.concurrent.locks.StampedLock
-
Returns true if the lock is currently held non-exclusively.
- 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.
- isWriteLocked() - Method in class java.util.concurrent.locks.StampedLock
-
Returns true if the lock is currently held exclusively.
- 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.ConcurrentHashMap.KeySetView
-
- 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.
- obtrudeException(Throwable) - Method in class java.util.concurrent.CompletableFuture
-
Forcibly causes subsequent invocations of method
CompletableFuture.get()
and related methods to throw the given exception, whether or
not already completed.
- obtrudeValue(T) - Method in class java.util.concurrent.CompletableFuture
-
Forcibly sets or resets the value subsequently returned by
method
CompletableFuture.get() and related methods, whether or not
already completed.
- 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.
- onCompletion(CountedCompleter<?>) - Method in class java.util.concurrent.CountedCompleter
-
- onExceptionalCompletion(Throwable, CountedCompleter<?>) - Method in class java.util.concurrent.CountedCompleter
-
- 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, if the
current thread is operating in a ForkJoinPool.
- 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
-
If the current thread is operating in a ForkJoinPool,
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.
- propagateCompletion() - Method in class java.util.concurrent.CountedCompleter
-
- 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 (in other
words, at the head of this deque) if it is possible to do so
immediately without violating capacity restrictions, throwing an
IllegalStateException if no space is currently available.
- 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, 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
-
- readLock() - Method in class java.util.concurrent.locks.StampedLock
-
Non-exclusively acquires the lock, blocking if necessary
until available.
- readLockInterruptibly() - Method in class java.util.concurrent.locks.StampedLock
-
Non-exclusively acquires the lock, blocking if necessary
until available or the current thread is interrupted.
- 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
-
- reduce(long, BiFunction<? super K, ? super V, ? extends U>, BiFunction<? super U, ? super U, ? extends U>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all (key, value) pairs using the given reducer to
combine values, or null if none.
- reduceEntries(long, BiFunction<Map.Entry<K, V>, Map.Entry<K, V>, ? extends Map.Entry<K, V>>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating all entries using the
given reducer to combine values, or null if none.
- reduceEntries(long, Function<Map.Entry<K, V>, ? extends U>, BiFunction<? super U, ? super U, ? extends U>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all entries using the given reducer to combine values,
or null if none.
- reduceEntriesToDouble(long, ToDoubleFunction<Map.Entry<K, V>>, double, DoubleBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all entries using the given reducer to combine values,
and the given basis as an identity value.
- reduceEntriesToInt(long, ToIntFunction<Map.Entry<K, V>>, int, IntBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all entries using the given reducer to combine values,
and the given basis as an identity value.
- reduceEntriesToLong(long, ToLongFunction<Map.Entry<K, V>>, long, LongBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all entries using the given reducer to combine values,
and the given basis as an identity value.
- reduceKeys(long, BiFunction<? super K, ? super K, ? extends K>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating all keys using the given
reducer to combine values, or null if none.
- reduceKeys(long, Function<? super K, ? extends U>, BiFunction<? super U, ? super U, ? extends U>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all keys using the given reducer to combine values, or
null if none.
- reduceKeysToDouble(long, ToDoubleFunction<? super K>, double, DoubleBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all keys using the given reducer to combine values, and
the given basis as an identity value.
- reduceKeysToInt(long, ToIntFunction<? super K>, int, IntBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all keys using the given reducer to combine values, and
the given basis as an identity value.
- reduceKeysToLong(long, ToLongFunction<? super K>, long, LongBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all keys using the given reducer to combine values, and
the given basis as an identity value.
- reducePermits(int) - Method in class java.util.concurrent.Semaphore
-
Shrinks the number of available permits by the indicated
reduction.
- reduceToDoubleIn(long, ToDoubleBiFunction<? super K, ? super V>, double, DoubleBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all (key, value) pairs using the given reducer to
combine values, and the given basis as an identity value.
- reduceToInt(long, ToIntBiFunction<? super K, ? super V>, int, IntBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all (key, value) pairs using the given reducer to
combine values, and the given basis as an identity value.
- reduceToLong(long, ToLongBiFunction<? super K, ? super V>, long, LongBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all (key, value) pairs using the given reducer to
combine values, and the given basis as an identity value.
- reduceValues(long, BiFunction<? super V, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating all values using the
given reducer to combine values, or null if none.
- reduceValues(long, Function<? super V, ? extends U>, BiFunction<? super U, ? super U, ? extends U>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all values using the given reducer to combine values, or
null if none.
- reduceValuesToDouble(long, ToDoubleFunction<? super V>, double, DoubleBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all values using the given reducer to combine values,
and the given basis as an identity value.
- reduceValuesToInt(long, ToIntFunction<? super V>, int, IntBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all values using the given reducer to combine values,
and the given basis as an identity value.
- reduceValuesToLong(long, ToLongFunction<? super V>, long, LongBinaryOperator) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns the result of accumulating the given transformation
of all values using the given reducer to combine values,
and the given basis as an identity value.
- 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.KeySetView
-
Removes the key from this map view, by removing the key (and its
corresponding value) from the backing map.
- 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.
- removeIf(Predicate<? super E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
- removeIf(Predicate<? super E>) - Method in class java.util.concurrent.CopyOnWriteArraySet
-
- 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.
- replaceAll(BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentHashMap
-
- replaceAll(BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentSkipListMap
-
- replaceAll(UnaryOperator<E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
- reset() - Method in class java.util.concurrent.atomic.DoubleAccumulator
-
Resets variables maintaining updates to the identity value.
- reset() - Method in class java.util.concurrent.atomic.DoubleAdder
-
Resets variables maintaining the sum to zero.
- reset() - Method in class java.util.concurrent.atomic.LongAccumulator
-
Resets variables maintaining updates to the identity value.
- reset() - Method in class java.util.concurrent.atomic.LongAdder
-
Resets variables maintaining the sum to zero.
- 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
-
- run() - Method in interface java.util.concurrent.RunnableFuture
-
Sets this Future to the result of its computation
unless it has been cancelled.
- runAfterBoth(CompletableFuture<?>, Runnable) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when both this and the other given CompletableFuture complete,
after performing the given action.
- runAfterBothAsync(CompletableFuture<?>, Runnable) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when both this and the other given CompletableFuture complete,
after performing the given action from a task running in the
ForkJoinPool.commonPool().
- runAfterBothAsync(CompletableFuture<?>, Runnable, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when both this and the other given CompletableFuture complete,
after performing the given action from a task running in the
given executor.
- runAfterEither(CompletableFuture<?>, Runnable) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when either this or the other given CompletableFuture completes,
after performing the given action.
- runAfterEitherAsync(CompletableFuture<?>, Runnable) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when either this or the other given CompletableFuture completes,
after performing the given action from a task running in the
ForkJoinPool.commonPool().
- runAfterEitherAsync(CompletableFuture<?>, Runnable, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when either this or the other given CompletableFuture completes,
after performing the given action from a task running in the
given executor.
- 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.
- runAsync(Runnable) - Static method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
by a task running in the
ForkJoinPool.commonPool() after
it runs the given action.
- runAsync(Runnable, Executor) - Static method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
by a task running in the given executor after it runs the given
action.
- 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
-
- search(long, BiFunction<? super K, ? super V, ? extends U>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns a non-null result from applying the given search
function on each (key, value), or null if none.
- searchEntries(long, Function<Map.Entry<K, V>, ? extends U>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns a non-null result from applying the given search
function on each entry, or null if none.
- searchKeys(long, Function<? super K, ? extends U>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns a non-null result from applying the given search
function on each key, or null if none.
- searchValues(long, Function<? super V, ? extends U>) - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns a non-null result from applying the given search
function on each value, or null if none.
- 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.
- setForkJoinTaskTag(short) - Method in class java.util.concurrent.ForkJoinTask
-
Atomically sets the tag value for this task.
- 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.
- setPendingCount(int) - Method in class java.util.concurrent.CountedCompleter
-
Sets the pending count to the given value.
- setRawResult(T) - Method in class java.util.concurrent.CountedCompleter
-
A method that result-bearing CountedCompleters may optionally
use to help maintain result data.
- 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
-
Possibly 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
-
Possibly 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
-
- sort(Comparator<? super E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
-
- spliterator() - Method in class java.util.ArrayDeque
-
- spliterator() - Method in class java.util.concurrent.ArrayBlockingQueue
-
- spliterator() - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
-
- spliterator() - Method in class java.util.concurrent.ConcurrentLinkedDeque
-
- spliterator() - Method in class java.util.concurrent.ConcurrentLinkedQueue
-
- spliterator() - Method in class java.util.concurrent.ConcurrentSkipListSet
-
- spliterator() - Method in class java.util.concurrent.CopyOnWriteArrayList
-
- spliterator() - Method in class java.util.concurrent.CopyOnWriteArraySet
-
- spliterator() - Method in class java.util.concurrent.LinkedBlockingDeque
-
- spliterator() - Method in class java.util.concurrent.LinkedBlockingQueue
-
- spliterator() - Method in class java.util.concurrent.LinkedTransferQueue
-
- spliterator() - Method in class java.util.concurrent.PriorityBlockingQueue
-
- spliterator() - Method in class java.util.concurrent.SynchronousQueue
-
- spliterator() - Method in class java.util.PriorityQueue
-
- StampedLock - Class in java.util.concurrent.locks
-
A capability-based lock with three modes for controlling read/write
access.
- StampedLock() - Constructor for class java.util.concurrent.locks.StampedLock
-
Creates a new lock, initially in unlocked state.
- 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
-
Returns a view of the portion of this map whose keys range from
fromKey, inclusive, to toKey, exclusive.
- 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
-
Returns a view of the portion of this set whose elements range
from fromElement, inclusive, to toElement,
exclusive.
- sum() - Method in class java.util.concurrent.atomic.DoubleAdder
-
Returns the current sum.
- sum() - Method in class java.util.concurrent.atomic.LongAdder
-
Returns the current sum.
- sumThenReset() - Method in class java.util.concurrent.atomic.DoubleAdder
-
- sumThenReset() - Method in class java.util.concurrent.atomic.LongAdder
-
- supplyAsync(Supplier<U>) - Static method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
by a task running in the
ForkJoinPool.commonPool() with
the value obtained by calling the given Supplier.
- supplyAsync(Supplier<U>, Executor) - Static method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
by a task running in the given executor with the value obtained
by calling the given Supplier.
- 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
-
Returns a view of the portion of this map whose keys are
greater than or equal to fromKey.
- 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
-
Returns a view of the portion of this set whose elements are
greater than or equal to fromElement.
- 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.
- thenAccept(Consumer<? super T>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when this CompletableFuture completes, after performing the given
action with this CompletableFuture's result.
- thenAcceptAsync(Consumer<? super T>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when this CompletableFuture completes, after performing the given
action with this CompletableFuture's result from a task running
in the
ForkJoinPool.commonPool().
- thenAcceptAsync(Consumer<? super T>, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when this CompletableFuture completes, after performing the given
action with this CompletableFuture's result from a task running
in the given executor.
- thenAcceptBoth(CompletableFuture<? extends U>, BiConsumer<? super T, ? super U>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when both this and the other given CompletableFuture complete,
after performing the given action with the results of the two
CompletableFutures.
- thenAcceptBothAsync(CompletableFuture<? extends U>, BiConsumer<? super T, ? super U>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when both this and the other given CompletableFuture complete,
after performing the given action with the results of the two
CompletableFutures from a task running in the
ForkJoinPool.commonPool().
- thenAcceptBothAsync(CompletableFuture<? extends U>, BiConsumer<? super T, ? super U>, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when both this and the other given CompletableFuture complete,
after performing the given action with the results of the two
CompletableFutures from a task running in the given executor.
- thenApply(Function<? super T, ? extends U>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when this CompletableFuture completes, with the result of the
given function of this CompletableFuture's result.
- thenApplyAsync(Function<? super T, ? extends U>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when this CompletableFuture completes, with the result of the
given function of this CompletableFuture's result from a
task running in the
ForkJoinPool.commonPool().
- thenApplyAsync(Function<? super T, ? extends U>, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when this CompletableFuture completes, with the result of the
given function of this CompletableFuture's result from a
task running in the given executor.
- thenCombine(CompletableFuture<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when both this and the other given CompletableFuture complete,
with the result of the given function of the results of the two
CompletableFutures.
- thenCombineAsync(CompletableFuture<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when both this and the other given CompletableFuture complete,
with the result of the given function of the results of the two
CompletableFutures from a task running in the
ForkJoinPool.commonPool().
- thenCombineAsync(CompletableFuture<? extends U>, BiFunction<? super T, ? super U, ? extends V>, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when both this and the other given CompletableFuture complete,
with the result of the given function of the results of the two
CompletableFutures from a task running in the given executor.
- thenCompose(Function<? super T, CompletableFuture<U>>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a CompletableFuture that upon completion, has the same
value as produced by the given function of the result of this
CompletableFuture.
- thenComposeAsync(Function<? super T, CompletableFuture<U>>) - Method in class java.util.concurrent.CompletableFuture
-
Returns a CompletableFuture that upon completion, has the same
value as that produced asynchronously using the
ForkJoinPool.commonPool() by the given function of the result
of this CompletableFuture.
- thenComposeAsync(Function<? super T, CompletableFuture<U>>, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a CompletableFuture that upon completion, has the same
value as that produced asynchronously using the given executor
by the given function of this CompletableFuture.
- thenRun(Runnable) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is completed
when this CompletableFuture completes, after performing the given
action.
- thenRunAsync(Runnable) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when this CompletableFuture completes, after performing the given
action from a task running in the
ForkJoinPool.commonPool().
- thenRunAsync(Runnable, Executor) - Method in class java.util.concurrent.CompletableFuture
-
Returns a new CompletableFuture that is asynchronously completed
when this CompletableFuture completes, after performing the given
action from a task running in the given executor.
- 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
-
- toHours(long) - Method in enum java.util.concurrent.TimeUnit
-
- toMicros(long) - Method in enum java.util.concurrent.TimeUnit
-
- toMillis(long) - Method in enum java.util.concurrent.TimeUnit
-
- toMinutes(long) - Method in enum java.util.concurrent.TimeUnit
-
- toNanos(long) - Method in enum java.util.concurrent.TimeUnit
-
- toSeconds(long) - Method in enum java.util.concurrent.TimeUnit
-
- 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.atomic.DoubleAccumulator
-
Returns the String representation of the current value.
- toString() - Method in class java.util.concurrent.atomic.DoubleAdder
-
- toString() - Method in class java.util.concurrent.atomic.LongAccumulator
-
Returns the String representation of the current value.
- toString() - Method in class java.util.concurrent.atomic.LongAdder
-
Returns the String representation of the
sum().
- toString() - Method in class java.util.concurrent.CompletableFuture
-
Returns a string identifying this CompletableFuture, as well as
its completion state.
- toString() - Method in class java.util.concurrent.ConcurrentHashMap
-
Returns a string representation of this map.
- 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.locks.StampedLock
-
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.
- tryComplete() - Method in class java.util.concurrent.CountedCompleter
-
- tryConvertToOptimisticRead(long) - Method in class java.util.concurrent.locks.StampedLock
-
If the lock state matches the given stamp then, if the stamp
represents holding a lock, releases it and returns an
observation stamp.
- tryConvertToReadLock(long) - Method in class java.util.concurrent.locks.StampedLock
-
If the lock state matches the given stamp, performs one of
the following actions.
- tryConvertToWriteLock(long) - Method in class java.util.concurrent.locks.StampedLock
-
If the lock state matches the given stamp, performs one of
the following actions.
- 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.
- tryOptimisticRead() - Method in class java.util.concurrent.locks.StampedLock
-
Returns a stamp that can later be validated, or zero
if exclusively locked.
- tryReadLock() - Method in class java.util.concurrent.locks.StampedLock
-
Non-exclusively acquires the lock if it is immediately available.
- tryReadLock(long, TimeUnit) - Method in class java.util.concurrent.locks.StampedLock
-
Non-exclusively acquires the lock if it is available within the
given 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.
- tryUnlockRead() - Method in class java.util.concurrent.locks.StampedLock
-
Releases one hold of the read lock if it is held, without
requiring a stamp value.
- tryUnlockWrite() - Method in class java.util.concurrent.locks.StampedLock
-
Releases the write lock if it is held, without requiring a
stamp value.
- tryWriteLock() - Method in class java.util.concurrent.locks.StampedLock
-
Exclusively acquires the lock if it is immediately available.
- tryWriteLock(long, TimeUnit) - Method in class java.util.concurrent.locks.StampedLock
-
Exclusively acquires the lock if it is available within the
given time and the current thread has not been interrupted.