A B C D E F G H I J K L M N O P Q R S T U V W 

A

AbortPolicy() - Constructor for class java.util.concurrent.ThreadPoolExecutor.AbortPolicy
Creates an AbortPolicy.
AbstractExecutorService - Class in java.util.concurrent
Provides default implementations of ExecutorService execution methods.
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
A version of AbstractQueuedSynchronizer in which synchronization state is maintained as a long.
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
Condition implementation for a AbstractQueuedLongSynchronizer serving as the basis of a Lock implementation.
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
Condition implementation for a AbstractQueuedSynchronizer serving as the basis of a Lock implementation.
acceptEither(CompletionStage<? extends T>, Consumer<? super T>) - Method in class java.util.concurrent.CompletableFuture
 
acceptEither(CompletionStage<? extends T>, Consumer<? super T>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed with the corresponding result as argument to the supplied action.
acceptEitherAsync(CompletionStage<? extends T>, Consumer<? super T>) - Method in class java.util.concurrent.CompletableFuture
 
acceptEitherAsync(CompletionStage<? extends T>, Consumer<? super T>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using this stage's default asynchronous execution facility, with the corresponding result as argument to the supplied action.
acceptEitherAsync(CompletionStage<? extends T>, Consumer<? super T>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
acceptEitherAsync(CompletionStage<? extends T>, Consumer<? super T>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using the supplied executor, with the corresponding result as argument to the supplied action.
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, int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i with the results of applying the given function to the current and given values, returning the updated value.
accumulateAndGet(int, long, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i with the results of applying the given function to the current and given values, returning the updated value.
accumulateAndGet(int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) 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(T, long, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) 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(T, V, BinaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value with the results of applying the given function to the current and given values, returning the updated value.
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.locks.AbstractQueuedSynchronizer
Acquires in exclusive mode, ignoring interrupts.
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.
acquire(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Acquires in exclusive mode, ignoring interrupts.
acquireInterruptibly(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Acquires in exclusive mode, aborting if interrupted.
acquireInterruptibly(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Acquires in exclusive mode, aborting if interrupted.
acquireShared(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Acquires in shared mode, ignoring interrupts.
acquireShared(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Acquires in shared mode, ignoring interrupts.
acquireSharedInterruptibly(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Acquires in shared mode, aborting if interrupted.
acquireSharedInterruptibly(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
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(double) - Method in class java.util.concurrent.atomic.DoubleAdder
Adds the given value.
add(int, E) - Method in class java.util.ArrayList
Inserts the specified element at the specified position in this list.
add(int, E) - Method in class java.util.concurrent.CopyOnWriteArrayList
Inserts the specified element at the specified position in this list.
add(int, E) - Method in class java.util.Vector
Inserts the specified element at the specified position in this Vector.
add(long) - Method in class java.util.concurrent.atomic.LongAdder
Adds the given value.
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.ArrayList
Appends the specified element to the end of this list.
add(E) - Method in class java.util.concurrent.ArrayBlockingQueue
Inserts the specified element at the tail of this queue if it is possible to do so immediately without exceeding the queue's capacity, returning true upon success and throwing an IllegalStateException if this queue is full.
add(E) - Method in interface java.util.concurrent.BlockingDeque
Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
add(E) - Method in interface java.util.concurrent.BlockingQueue
Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
add(E) - Method in class java.util.concurrent.ConcurrentLinkedDeque
Inserts the specified element at the tail of this deque.
add(E) - Method in class java.util.concurrent.ConcurrentLinkedQueue
Inserts the specified element at the tail of this queue.
add(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
Adds the specified element to this set if it is not already present.
add(E) - Method in class java.util.concurrent.CopyOnWriteArrayList
Appends the specified element to the end of this list.
add(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.
add(E) - Method in class java.util.Vector
Appends the specified element to the end of this Vector.
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.
addAll(int, Collection<? extends E>) - Method in class java.util.ArrayList
Inserts all of the elements in the specified collection into this list, starting at the specified position.
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(int, Collection<? extends E>) - Method in class java.util.Vector
Inserts all of the elements in the specified Collection into this Vector at the specified position.
addAll(Collection<? extends E>) - Method in class java.util.AbstractQueue
Adds all of the elements in the specified collection to this queue.
addAll(Collection<? extends E>) - Method in class java.util.ArrayDeque
Adds all of the elements in the specified collection at the end of this deque, as if by calling ArrayDeque.addLast(E) on each one, in the order that they are returned by the collection's iterator.
addAll(Collection<? extends E>) - Method in class java.util.ArrayList
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(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(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.
addAll(Collection<? extends E>) - Method in class java.util.concurrent.LinkedBlockingDeque
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 interface java.util.Deque
Adds all of the elements in the specified collection at the end of this deque, as if by calling Deque.addLast(E) on each one, in the order that they are returned by the collection's iterator.
addAll(Collection<? extends E>) - Method in class java.util.Vector
Appends all of the elements in the specified Collection to the end of this Vector, in the order that they are returned by the specified Collection's Iterator.
addAll(Collection<? extends K>) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
Adds all of the elements in the specified collection to this set, as if by calling ConcurrentHashMap.KeySetView.add(K) on each one.
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, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
addAndGet(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically adds the given value to the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
addAndGet(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically adds the given value to the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
addAndGet(long) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically adds the given value to the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
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(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.
addElement(E) - Method in class java.util.Vector
Adds the specified component to the end of this vector, increasing its size by one.
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(CompletionStage<? extends T>, Function<? super T, U>) - Method in class java.util.concurrent.CompletableFuture
 
applyToEither(CompletionStage<? extends T>, Function<? super T, U>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed with the corresponding result as argument to the supplied function.
applyToEitherAsync(CompletionStage<? extends T>, Function<? super T, U>) - Method in class java.util.concurrent.CompletableFuture
 
applyToEitherAsync(CompletionStage<? extends T>, Function<? super T, U>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using this stage's default asynchronous execution facility, with the corresponding result as argument to the supplied function.
applyToEitherAsync(CompletionStage<? extends T>, Function<? super T, U>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
applyToEitherAsync(CompletionStage<? extends T>, Function<? super T, U>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using the supplied executor, with the corresponding result as argument to the supplied function.
ArrayBlockingQueue<E> - Class in java.util.concurrent
A bounded blocking queue backed by an array.
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.
ArrayList<E> - Class in java.util
Resizable-array implementation of the List interface.
ArrayList() - Constructor for class java.util.ArrayList
Constructs an empty list with an initial capacity of ten.
ArrayList(int) - Constructor for class java.util.ArrayList
Constructs an empty list with the specified initial capacity.
ArrayList(Collection<? extends E>) - Constructor for class java.util.ArrayList
Constructs a list 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
Returns a plain Lock view of this StampedLock in which the Lock.lock() method is mapped to readLock(), and similarly for other methods.
asReadWriteLock() - Method in class java.util.concurrent.locks.StampedLock
Returns a ReadWriteLock view of this StampedLock in which the ReadWriteLock.readLock() method is mapped to asReadLock(), and ReadWriteLock.writeLock() to asWriteLock().
asWriteLock() - Method in class java.util.concurrent.locks.StampedLock
Returns a plain Lock view of this StampedLock in which the Lock.lock() method is mapped to writeLock(), and similarly for other methods.
AtomicBoolean - Class in java.util.concurrent.atomic
A boolean value that may be updated atomically.
AtomicBoolean() - Constructor for class java.util.concurrent.atomic.AtomicBoolean
Creates a new AtomicBoolean with initial value false.
AtomicBoolean(boolean) - Constructor for class java.util.concurrent.atomic.AtomicBoolean
Creates a new AtomicBoolean with the given initial value.
AtomicInteger - Class in java.util.concurrent.atomic
An int value that may be updated atomically.
AtomicInteger() - Constructor for class java.util.concurrent.atomic.AtomicInteger
Creates a new AtomicInteger with initial value 0.
AtomicInteger(int) - Constructor for class java.util.concurrent.atomic.AtomicInteger
Creates a new AtomicInteger with the given initial value.
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() - Constructor for class java.util.concurrent.atomic.AtomicLong
Creates a new AtomicLong with initial value 0.
AtomicLong(long) - Constructor for class java.util.concurrent.atomic.AtomicLong
Creates a new AtomicLong with the given initial value.
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() - Constructor for class java.util.concurrent.atomic.AtomicReference
Creates a new AtomicReference with null initial value.
AtomicReference(V) - Constructor for class java.util.concurrent.atomic.AtomicReference
Creates a new AtomicReference with the given 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() - Method in class java.util.concurrent.CyclicBarrier
Waits until all parties have invoked await on this barrier.
await() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
Implements interruptible condition wait.
await() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
Implements interruptible 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 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(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(long, TimeUnit) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
Implements timed condition wait.
await(long, TimeUnit) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
Implements timed condition wait.
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
If called by a ForkJoinTask operating in this pool, equivalent in effect to ForkJoinTask.helpQuiesce().
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.

B

beforeExecute(Thread, Runnable) - Method in class java.util.concurrent.ThreadPoolExecutor
Method invoked prior to executing the given Runnable in the given thread.
block() - Method in interface java.util.concurrent.ForkJoinPool.ManagedBlocker
Possibly blocks the current thread, for example waiting for a lock or condition.
BlockingDeque<E> - Interface in java.util.concurrent
A Deque that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for space to become available in the deque when storing an element.
BlockingQueue<E> - Interface in java.util.concurrent
A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.
BrokenBarrierException - Exception in java.util.concurrent
Exception thrown when a thread tries to wait upon a barrier that is in a broken state, or which enters the broken state while the thread is waiting.
BrokenBarrierException() - Constructor for exception java.util.concurrent.BrokenBarrierException
Constructs a BrokenBarrierException with no specified detail message.
BrokenBarrierException(String) - Constructor for exception java.util.concurrent.BrokenBarrierException
Constructs a BrokenBarrierException with the specified detail message.
bulkRegister(int) - Method in class java.util.concurrent.Phaser
Adds the given number of new unarrived parties to this phaser.

C

call() - Method in interface java.util.concurrent.Callable
Computes a result, or throws an exception if unable to do so.
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(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(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.
Callable<V> - Interface in java.util.concurrent
A task that returns a result and may throw an exception.
CallerRunsPolicy() - Constructor for class java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
Creates a CallerRunsPolicy.
cancel() - Method in interface java.util.concurrent.Flow.Subscription
Causes the Subscriber to (eventually) stop receiving messages.
cancel(boolean) - Method in class java.util.concurrent.CompletableFuture
If not already completed, completes this CompletableFuture with a CancellationException.
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.
capacity() - Method in class java.util.Vector
Returns the current capacity of this vector.
capacityIncrement - Variable in class java.util.Vector
The amount by which the capacity of the vector is automatically incremented when its size becomes greater than its capacity.
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.ArrayList
Removes all of the elements from this list.
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.ConcurrentLinkedQueue
 
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.LinkedTransferQueue
 
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.HashMap
Removes all of the mappings from this map.
clear() - Method in class java.util.PriorityQueue
Removes all of the elements from this priority queue.
clear() - Method in class java.util.Vector
Removes all of the elements from this Vector.
clone() - Method in class java.util.ArrayDeque
Returns a copy of this deque.
clone() - Method in class java.util.ArrayList
Returns a shallow copy of this ArrayList instance.
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.
clone() - Method in class java.util.HashMap
Returns a shallow copy of this HashMap instance: the keys and values themselves are not cloned.
clone() - Method in class java.util.Vector
Returns a clone of this vector.
close() - Method in class java.util.concurrent.SubmissionPublisher
Unless already closed, issues onComplete signals to current subscribers, and disallows subsequent attempts to publish.
closeExceptionally(Throwable) - Method in class java.util.concurrent.SubmissionPublisher
Unless already closed, issues onError signals to current subscribers with the given error, and disallows subsequent attempts to publish.
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.
compareAndExchange(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchange(java.lang.Object...).
compareAndExchange(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchange(java.lang.Object...).
compareAndExchange(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchange(java.lang.Object...).
compareAndExchange(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchange(java.lang.Object...).
compareAndExchange(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchange(java.lang.Object...).
compareAndExchange(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchange(java.lang.Object...).
compareAndExchange(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchange(java.lang.Object...).
compareAndExchangeAcquire(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeAcquire(java.lang.Object...).
compareAndExchangeAcquire(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeAcquire(java.lang.Object...).
compareAndExchangeAcquire(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeAcquire(java.lang.Object...).
compareAndExchangeAcquire(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeAcquire(java.lang.Object...).
compareAndExchangeAcquire(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeAcquire(java.lang.Object...).
compareAndExchangeAcquire(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeAcquire(java.lang.Object...).
compareAndExchangeAcquire(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeAcquire(java.lang.Object...).
compareAndExchangeRelease(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeRelease(java.lang.Object...).
compareAndExchangeRelease(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeRelease(java.lang.Object...).
compareAndExchangeRelease(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeRelease(java.lang.Object...).
compareAndExchangeRelease(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeRelease(java.lang.Object...).
compareAndExchangeRelease(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Atomically sets the element at index i to newValue if the element's current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeRelease(java.lang.Object...).
compareAndExchangeRelease(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeRelease(java.lang.Object...).
compareAndExchangeRelease(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
Atomically sets the value to newValue if the current value, referred to as the witness value, == expectedValue, with memory effects as specified by VarHandle.compareAndExchangeRelease(java.lang.Object...).
compareAndSet(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...).
compareAndSet(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...).
compareAndSet(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...).
compareAndSet(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...).
compareAndSet(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...).
compareAndSet(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...).
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(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(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) - Method in class java.util.concurrent.atomic.AtomicReference
Atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...).
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, 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(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.
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.
CompletableFuture<T> - Class in java.util.concurrent
A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting 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
Regardless of pending count, invokes CountedCompleter.onCompletion(CountedCompleter), marks this task as complete and further triggers CountedCompleter.tryComplete() on this task's completer, if one exists.
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.
completeAsync(Supplier<? extends T>) - Method in class java.util.concurrent.CompletableFuture
Completes this CompletableFuture with the result of the given Supplier function invoked from an asynchronous task using the default executor.
completeAsync(Supplier<? extends T>, Executor) - Method in class java.util.concurrent.CompletableFuture
Completes this CompletableFuture with the result of the given Supplier function invoked from an asynchronous task using the given executor.
completedFuture(U) - Static method in class java.util.concurrent.CompletableFuture
Returns a new CompletableFuture that is already completed with the given value.
completedStage(U) - Static method in class java.util.concurrent.CompletableFuture
Returns a new CompletionStage that is already completed with the given value and supports only those methods in interface CompletionStage.
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.
completeOnTimeout(T, long, TimeUnit) - Method in class java.util.concurrent.CompletableFuture
Completes this CompletableFuture with the given value if not otherwise completed before the given timeout.
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.
CompletionStage<T> - Interface in java.util.concurrent
A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.
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.
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 interface java.util.concurrent.ConcurrentMap
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(K, BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.HashMap
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, 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 interface java.util.concurrent.ConcurrentMap
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.
computeIfAbsent(K, Function<? super K, ? extends V>) - Method in class java.util.HashMap
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, 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 interface java.util.concurrent.ConcurrentMap
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.
computeIfPresent(K, BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.HashMap
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(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(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.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 thread safety and atomicity guarantees.
ConcurrentNavigableMap<K,V> - Interface in java.util.concurrent
A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps.
ConcurrentSkipListMap<K,V> - Class in java.util.concurrent
A scalable concurrent ConcurrentNavigableMap implementation.
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
A scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap.
ConcurrentSkipListSet() - Constructor for class java.util.concurrent.ConcurrentSkipListSet
Constructs a new, empty set that orders its elements according to their natural ordering.
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(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(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.
ConditionObject() - Constructor for class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
Creates a new ConditionObject instance.
ConditionObject() - Constructor for class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
Creates a new ConditionObject instance.
consume(Consumer<? super T>) - Method in class java.util.concurrent.SubmissionPublisher
Processes all published items using the given Consumer function.
contains(Object) - Method in class java.util.ArrayDeque
Returns true if this deque contains the specified element.
contains(Object) - Method in class java.util.ArrayList
Returns true if this list 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
Tests if some key maps into the specified value in this table.
contains(Object) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
contains(Object) - Method in class java.util.concurrent.ConcurrentLinkedDeque
Returns true if this deque contains the specified element.
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.
contains(Object) - Method in class java.util.Vector
Returns true if this vector 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.
containsAll(Collection<?>) - Method in class java.util.Vector
Returns true if this Vector contains all of the elements in the specified Collection.
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.
containsKey(Object) - Method in class java.util.HashMap
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.
containsValue(Object) - Method in class java.util.HashMap
Returns true if this map maps one or more keys to the specified value.
convert(long, TimeUnit) - Method in enum java.util.concurrent.TimeUnit
Converts the given time duration in the given unit to this unit.
copy() - Method in class java.util.concurrent.CompletableFuture
Returns a new CompletableFuture that is completed normally with the same value as this CompletableFuture when it completes normally.
copyInto(Object[]) - Method in class java.util.Vector
Copies the components of this vector into the specified array.
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(E[]) - Constructor for class java.util.concurrent.CopyOnWriteArrayList
Creates a list holding a copy of the given array.
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.
CopyOnWriteArraySet<E> - Class in java.util.concurrent
A Set that uses an internal CopyOnWriteArrayList for all of its operations.
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() - Constructor for class java.util.concurrent.CountedCompleter
Creates a new CountedCompleter with no completer and an initial pending count of zero.
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(CountedCompleter<?>, int) - Constructor for class java.util.concurrent.CountedCompleter
Creates a new CountedCompleter with the given completer and initial pending count.
current() - Static method in class java.util.concurrent.ThreadLocalRandom
Returns the current thread's ThreadLocalRandom.
CyclicBarrier - Class in java.util.concurrent
A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
CyclicBarrier(int) - 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.
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.

D

DAYS - java.util.concurrent.TimeUnit
Time unit representing twenty four hours.
decorateTask(Runnable, RunnableScheduledFuture<V>) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
Modifies or replaces the task used to execute a runnable.
decorateTask(Callable<V>, RunnableScheduledFuture<V>) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
Modifies or replaces the task used to execute a callable.
decrement() - Method in class java.util.concurrent.atomic.LongAdder
Equivalent to add(-1).
decrementAndGet() - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically decrements the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
decrementAndGet() - Method in class java.util.concurrent.atomic.AtomicLong
Atomically decrements the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
decrementAndGet(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically decrements the value of the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
decrementAndGet(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically decrements the value of the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
decrementAndGet(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.
decrementAndGet(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.
decrementPendingCountUnlessZero() - Method in class java.util.concurrent.CountedCompleter
If the pending count is nonzero, (atomically) decrements it.
defaultBufferSize() - Static method in class java.util.concurrent.Flow
Returns a default value for Publisher or Subscriber buffering, that may be used in the absence of other constraints.
defaultExecutor() - Method in class java.util.concurrent.CompletableFuture
Returns the default Executor used for async methods that do not specify an Executor.
defaultForkJoinWorkerThreadFactory - Static variable in class java.util.concurrent.ForkJoinPool
Creates a new ForkJoinWorkerThread.
defaultThreadFactory() - Static method in class java.util.concurrent.Executors
Returns a default thread factory used to create new threads.
Delayed - Interface in java.util.concurrent
A mix-in style interface for marking objects that should be acted upon after a given delay.
delayedExecutor(long, TimeUnit) - Static method in class java.util.concurrent.CompletableFuture
Returns a new Executor that submits a task to the default executor after the given delay (or no delay if non-positive).
delayedExecutor(long, TimeUnit, Executor) - Static method in class java.util.concurrent.CompletableFuture
Returns a new Executor that submits a task to the given base executor after the given delay (or no delay if non-positive).
DelayQueue<E extends Delayed> - Class in java.util.concurrent
An unbounded blocking queue of Delayed elements, in which an element can only be taken when its delay has expired.
DelayQueue() - Constructor for class java.util.concurrent.DelayQueue
Creates a new DelayQueue that is initially empty.
DelayQueue(Collection<? extends E>) - Constructor for class java.util.concurrent.DelayQueue
Creates a DelayQueue initially containing the elements of the given collection of Delayed instances.
Deque<E> - Interface in java.util
A linear collection that supports element insertion and removal at both ends.
descendingIterator() - Method in class java.util.ArrayDeque
 
descendingIterator() - Method in class java.util.concurrent.ConcurrentLinkedDeque
Returns an iterator over the elements in this deque in reverse sequential order.
descendingIterator() - Method in class java.util.concurrent.ConcurrentSkipListSet
Returns an iterator over the elements in this set in descending order.
descendingIterator() - Method in class java.util.concurrent.LinkedBlockingDeque
Returns an iterator over the elements in this deque in reverse sequential order.
descendingIterator() - Method in interface java.util.Deque
Returns an iterator over the elements in this deque in reverse sequential order.
descendingIterator() - Method in interface java.util.NavigableSet
Returns an iterator over the elements in this set, in descending order.
descendingKeySet() - Method in interface java.util.concurrent.ConcurrentNavigableMap
Returns a reverse order NavigableSet view of the keys contained in this map.
descendingKeySet() - Method in class java.util.concurrent.ConcurrentSkipListMap
 
descendingKeySet() - Method in interface java.util.NavigableMap
Returns a reverse order NavigableSet view of the keys contained in this map.
descendingMap() - Method in interface java.util.concurrent.ConcurrentNavigableMap
Returns a reverse order view of the mappings contained in this map.
descendingMap() - Method in class java.util.concurrent.ConcurrentSkipListMap
 
descendingMap() - Method in interface java.util.NavigableMap
Returns a reverse order view of the mappings contained in this map.
descendingSet() - Method in class java.util.concurrent.ConcurrentSkipListSet
Returns a reverse order view of the elements contained in this set.
descendingSet() - Method in interface java.util.NavigableSet
Returns a reverse order view of the elements contained in this set.
DiscardOldestPolicy() - Constructor for class java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy
Creates a DiscardOldestPolicy for the given executor.
DiscardPolicy() - Constructor for class java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
Creates a DiscardPolicy.
done() - Method in class java.util.concurrent.FutureTask
Protected method invoked when this task transitions to state isDone (whether normally or via cancellation).
DoubleAccumulator - Class in java.util.concurrent.atomic
One or more variables that together maintain a running double value updated using a supplied function.
DoubleAccumulator(DoubleBinaryOperator, double) - Constructor for class java.util.concurrent.atomic.DoubleAccumulator
Creates a new instance using the given accumulator function and identity element.
DoubleAdder - Class in java.util.concurrent.atomic
One or more variables that together maintain an initially zero double sum.
DoubleAdder() - Constructor for class java.util.concurrent.atomic.DoubleAdder
Creates a new adder with initial sum of zero.
doubles() - Method in class java.util.concurrent.ThreadLocalRandom
Returns an effectively unlimited stream of pseudorandom double values, each between zero (inclusive) and one (exclusive).
doubles() - Method in class java.util.SplittableRandom
Returns an effectively unlimited stream of pseudorandom double values from this generator and/or one split from it; each value is between zero (inclusive) and one (exclusive).
doubles(double, double) - Method in class java.util.concurrent.ThreadLocalRandom
Returns an effectively unlimited stream of pseudorandom double values, each conforming to the given origin (inclusive) and bound (exclusive).
doubles(double, double) - Method in class java.util.SplittableRandom
Returns an effectively unlimited stream of pseudorandom double values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
doubles(long) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a stream producing the given streamSize number of pseudorandom double values, each between zero (inclusive) and one (exclusive).
doubles(long) - Method in class java.util.SplittableRandom
Returns a stream producing the given streamSize number of pseudorandom double values from this generator and/or one split from it; each value is between zero (inclusive) and one (exclusive).
doubles(long, double, double) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a stream producing the given streamSize number of pseudorandom double values, each conforming to the given origin (inclusive) and bound (exclusive).
doubles(long, double, double) - Method in class java.util.SplittableRandom
Returns a stream producing the given streamSize number of pseudorandom double values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
doubleValue() - Method in class java.util.concurrent.atomic.AtomicInteger
Returns the current value of this AtomicInteger as a double after a widening primitive conversion, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
doubleValue() - Method in class java.util.concurrent.atomic.AtomicLong
Returns the current value of this AtomicLong as a double after a widening primitive conversion, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
doubleValue() - Method in class java.util.concurrent.atomic.DoubleAccumulator
doubleValue() - Method in class java.util.concurrent.atomic.DoubleAdder
Equivalent to DoubleAdder.sum().
doubleValue() - Method in class java.util.concurrent.atomic.LongAccumulator
Returns the current value as a double after a widening primitive conversion.
doubleValue() - Method in class java.util.concurrent.atomic.LongAdder
Returns the LongAdder.sum() as a double after a widening primitive conversion.
drainPermits() - Method in class java.util.concurrent.Semaphore
Acquires and returns all permits that are immediately available, or if negative permits are available, releases them.
drainTasksTo(Collection<? super ForkJoinTask<?>>) - Method in class java.util.concurrent.ForkJoinPool
Removes all available unexecuted submitted and forked tasks from scheduling queues and adds them to the given collection, without altering their execution status.
drainTo(Collection<? super E>) - Method in class java.util.concurrent.ArrayBlockingQueue
 
drainTo(Collection<? super E>) - Method in interface java.util.concurrent.BlockingQueue
Removes all available elements from this queue and adds them to the given collection.
drainTo(Collection<? super E>) - Method in class java.util.concurrent.DelayQueue
 
drainTo(Collection<? super E>) - Method in class java.util.concurrent.LinkedBlockingDeque
 
drainTo(Collection<? super E>) - Method in class java.util.concurrent.LinkedBlockingQueue
 
drainTo(Collection<? super E>) - Method in class java.util.concurrent.LinkedTransferQueue
 
drainTo(Collection<? super E>) - Method in class java.util.concurrent.PriorityBlockingQueue
 
drainTo(Collection<? super E>) - Method in class java.util.concurrent.SynchronousQueue
 
drainTo(Collection<? super E>, int) - Method in class java.util.concurrent.ArrayBlockingQueue
 
drainTo(Collection<? super E>, int) - Method in interface java.util.concurrent.BlockingQueue
Removes at most the given number of available elements from this queue and adds them to the given collection.
drainTo(Collection<? super E>, int) - Method in class java.util.concurrent.DelayQueue
 
drainTo(Collection<? super E>, int) - Method in class java.util.concurrent.LinkedBlockingDeque
 
drainTo(Collection<? super E>, int) - Method in class java.util.concurrent.LinkedBlockingQueue
 
drainTo(Collection<? super E>, int) - Method in class java.util.concurrent.LinkedTransferQueue
 
drainTo(Collection<? super E>, int) - Method in class java.util.concurrent.PriorityBlockingQueue
 
drainTo(Collection<? super E>, int) - Method in class java.util.concurrent.SynchronousQueue
 

E

element() - Method in class java.util.AbstractQueue
Retrieves, but does not remove, the head of this queue.
element() - Method in class java.util.ArrayDeque
Retrieves, but does not remove, the head of the queue represented by this deque.
element() - 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).
element() - Method in class java.util.concurrent.ConcurrentLinkedDeque
 
element() - Method in class java.util.concurrent.LinkedBlockingDeque
Retrieves, but does not remove, the head of the queue represented by this deque.
element() - 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).
element() - Method in interface java.util.Queue
Retrieves, but does not remove, the head of this queue.
elementAt(int) - Method in class java.util.Vector
Returns the component at the specified index.
elementCount - Variable in class java.util.Vector
The number of valid components in this Vector object.
elementData - Variable in class java.util.Vector
The array buffer into which the components of the vector are stored.
elements() - Method in class java.util.concurrent.ConcurrentHashMap
Returns an enumeration of the values in this table.
elements() - Method in class java.util.Vector
Returns an enumeration of the components of this vector.
ensureCapacity(int) - Method in class java.util.ArrayList
Increases the capacity of this ArrayList instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
ensureCapacity(int) - Method in class java.util.Vector
Increases the capacity of this vector, if necessary, to ensure that it can hold at least the number of components specified by the minimum capacity argument.
entrySet() - Method in class java.util.concurrent.ConcurrentHashMap
Returns a Set view of the mappings contained in this map.
entrySet() - Method in class java.util.concurrent.ConcurrentSkipListMap
Returns a Set view of the mappings contained in this map.
entrySet() - Method in class java.util.HashMap
Returns a Set view of the mappings contained in this map.
equals(Object) - Method in class java.util.concurrent.ConcurrentHashMap
Compares the specified object with this map for equality.
equals(Object) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
 
equals(Object) - Method in class java.util.concurrent.ConcurrentSkipListMap
Compares the specified object with this map for equality.
equals(Object) - Method in class java.util.concurrent.ConcurrentSkipListSet
Compares the specified object with this set for equality.
equals(Object) - Method in class java.util.concurrent.CopyOnWriteArrayList
Compares the specified object with this list for equality.
equals(Object) - Method in class java.util.concurrent.CopyOnWriteArraySet
Compares the specified object with this set for equality.
equals(Object) - Method in class java.util.Vector
Compares the specified Object with this Vector for equality.
estimateMaximumLag() - Method in class java.util.concurrent.SubmissionPublisher
Returns an estimate of the maximum number of items produced but not yet consumed among all current subscribers.
estimateMinimumDemand() - Method in class java.util.concurrent.SubmissionPublisher
Returns an estimate of the minimum number of items requested (via request) but not yet produced, among all current subscribers.
exceptionally(Function<Throwable, ? extends T>) - 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 the exception triggering this CompletableFuture's completion when it completes exceptionally; otherwise, if this CompletableFuture completes normally, then the returned CompletableFuture also completes normally with the same value.
exceptionally(Function<Throwable, ? extends T>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes exceptionally, is executed with this stage's exception as the argument to the supplied function.
exchange(V) - Method in class java.util.concurrent.Exchanger
Waits for another thread to arrive at this exchange point (unless the current thread is interrupted), and then transfers the given object to it, receiving its object in return.
exchange(V, long, TimeUnit) - Method in class java.util.concurrent.Exchanger
Waits for another thread to arrive at this exchange point (unless the current thread is interrupted or the specified waiting time elapses), and then transfers the given object to it, receiving its object in return.
Exchanger<V> - Class in java.util.concurrent
A synchronization point at which threads can pair and swap elements within pairs.
Exchanger() - Constructor for class java.util.concurrent.Exchanger
Creates a new Exchanger.
exec() - Method in class java.util.concurrent.CountedCompleter
Implements execution conventions for CountedCompleters.
exec() - Method in class java.util.concurrent.ForkJoinTask
Immediately performs the base action of this task and returns true if, upon return from this method, this task is guaranteed to have completed normally.
exec() - Method in class java.util.concurrent.RecursiveAction
Implements execution conventions for RecursiveActions.
exec() - Method in class java.util.concurrent.RecursiveTask
Implements execution conventions for RecursiveTask.
execute(Runnable) - Method in interface java.util.concurrent.Executor
Executes the given command at some time in the future.
execute(Runnable) - Method in class java.util.concurrent.ForkJoinPool
 
execute(Runnable) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
Executes command with zero required delay.
execute(Runnable) - Method in class java.util.concurrent.ThreadPoolExecutor
Executes the given task sometime in the future.
execute(ForkJoinTask<?>) - Method in class java.util.concurrent.ForkJoinPool
Arranges for (asynchronous) execution of the given task.
ExecutionException - Exception in java.util.concurrent
Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
ExecutionException() - Constructor for exception java.util.concurrent.ExecutionException
Constructs an ExecutionException with no detail message.
ExecutionException(String) - Constructor for exception java.util.concurrent.ExecutionException
Constructs an ExecutionException with the specified detail message.
ExecutionException(String, Throwable) - Constructor for exception java.util.concurrent.ExecutionException
Constructs an ExecutionException with the specified detail message and cause.
ExecutionException(Throwable) - Constructor for exception java.util.concurrent.ExecutionException
Constructs an ExecutionException with the specified cause.
Executor - Interface in java.util.concurrent
An object that executes submitted Runnable tasks.
ExecutorCompletionService<V> - Class in java.util.concurrent
A CompletionService that uses a supplied Executor to execute tasks.
ExecutorCompletionService(Executor) - Constructor for class java.util.concurrent.ExecutorCompletionService
Creates an ExecutorCompletionService using the supplied executor for base task execution and a LinkedBlockingQueue as a completion queue.
ExecutorCompletionService(Executor, BlockingQueue<Future<V>>) - Constructor for class java.util.concurrent.ExecutorCompletionService
Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.
Executors - Class in java.util.concurrent
Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package.
ExecutorService - Interface in java.util.concurrent
An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks.

F

failedFuture(Throwable) - Static method in class java.util.concurrent.CompletableFuture
Returns a new CompletableFuture that is already completed exceptionally with the given exception.
failedStage(Throwable) - Static method in class java.util.concurrent.CompletableFuture
Returns a new CompletionStage that is already completed exceptionally with the given exception and supports only those methods in interface CompletionStage.
first() - Method in class java.util.concurrent.ConcurrentSkipListSet
 
firstComplete() - Method in class java.util.concurrent.CountedCompleter
If this task's pending count is zero, returns this task; otherwise decrements its pending count and returns null.
firstElement() - Method in class java.util.Vector
Returns the first component (the item at index 0) of this vector.
firstEntry() - Method in class java.util.concurrent.ConcurrentSkipListMap
Returns a key-value mapping associated with the least key in this map, or null if the map is empty.
firstEntry() - Method in interface java.util.NavigableMap
Returns a key-value mapping associated with the least key in this map, or null if the map is empty.
firstKey() - Method in class java.util.concurrent.ConcurrentSkipListMap
 
floatValue() - Method in class java.util.concurrent.atomic.AtomicInteger
Returns the current value of this AtomicInteger as a float after a widening primitive conversion, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
floatValue() - Method in class java.util.concurrent.atomic.AtomicLong
Returns the current value of this AtomicLong as a float after a widening primitive conversion, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
floatValue() - Method in class java.util.concurrent.atomic.DoubleAccumulator
Returns the current value as a float after a narrowing primitive conversion.
floatValue() - Method in class java.util.concurrent.atomic.DoubleAdder
Returns the DoubleAdder.sum() as a float after a narrowing primitive conversion.
floatValue() - Method in class java.util.concurrent.atomic.LongAccumulator
Returns the current value as a float after a widening primitive conversion.
floatValue() - Method in class java.util.concurrent.atomic.LongAdder
Returns the LongAdder.sum() as a float after a widening primitive conversion.
floor(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
 
floor(E) - Method in interface java.util.NavigableSet
Returns the greatest element in this set less than or equal to the given element, or null if there is no such element.
floorEntry(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.
floorEntry(K) - Method in interface java.util.NavigableMap
Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.
floorKey(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
floorKey(K) - Method in interface java.util.NavigableMap
Returns the greatest key less than or equal to the given key, or null if there is no such key.
Flow - Class in java.util.concurrent
Interrelated interfaces and static methods for establishing flow-controlled components in which Publishers produce items consumed by one or more Subscribers, each managed by a Subscription.
Flow.Processor<T,R> - Interface in java.util.concurrent
A component that acts as both a Subscriber and Publisher.
Flow.Publisher<T> - Interface in java.util.concurrent
A producer of items (and related control messages) received by Subscribers.
Flow.Subscriber<T> - Interface in java.util.concurrent
A receiver of messages.
Flow.Subscription - Interface in java.util.concurrent
Message control linking a Flow.Publisher and Flow.Subscriber.
forceTermination() - Method in class java.util.concurrent.Phaser
Forces this phaser to enter termination state.
forEach(long, BiConsumer<? super K, ? super V>) - Method in class java.util.concurrent.ConcurrentHashMap
Performs the given action for each (key, value).
forEach(long, BiFunction<? super K, ? super V, ? extends U>, Consumer<? super U>) - Method in class java.util.concurrent.ConcurrentHashMap
Performs the given action for each non-null transformation of each (key, value).
forEach(BiConsumer<? super K, ? super V>) - Method in class java.util.concurrent.ConcurrentHashMap
 
forEach(BiConsumer<? super K, ? super V>) - Method in interface java.util.concurrent.ConcurrentMap
forEach(BiConsumer<? super K, ? super V>) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
forEach(BiConsumer<? super K, ? super V>) - Method in class java.util.HashMap
 
forEach(Consumer<? super E>) - Method in class java.util.ArrayDeque
 
forEach(Consumer<? super E>) - Method in class java.util.ArrayList
 
forEach(Consumer<? super E>) - Method in class java.util.concurrent.ArrayBlockingQueue
 
forEach(Consumer<? super E>) - Method in class java.util.concurrent.ConcurrentLinkedDeque
 
forEach(Consumer<? super E>) - Method in class java.util.concurrent.ConcurrentLinkedQueue
 
forEach(Consumer<? super E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
 
forEach(Consumer<? super E>) - Method in class java.util.concurrent.CopyOnWriteArraySet
 
forEach(Consumer<? super E>) - Method in class java.util.concurrent.LinkedBlockingDeque
 
forEach(Consumer<? super E>) - Method in class java.util.concurrent.LinkedBlockingQueue
 
forEach(Consumer<? super E>) - Method in class java.util.concurrent.LinkedTransferQueue
 
forEach(Consumer<? super E>) - Method in class java.util.Vector
 
forEach(Consumer<? super K>) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
 
forEachEntry(long, Consumer<? super Map.Entry<K, V>>) - Method in class java.util.concurrent.ConcurrentHashMap
Performs the given action for each entry.
forEachEntry(long, Function<Map.Entry<K, V>, ? extends U>, Consumer<? super U>) - Method in class java.util.concurrent.ConcurrentHashMap
Performs the given action for each non-null transformation of each entry.
forEachKey(long, Consumer<? super K>) - Method in class java.util.concurrent.ConcurrentHashMap
Performs the given action for each key.
forEachKey(long, Function<? super K, ? extends U>, Consumer<? super U>) - Method in class java.util.concurrent.ConcurrentHashMap
Performs the given action for each non-null transformation of each key.
forEachValue(long, Consumer<? super V>) - Method in class java.util.concurrent.ConcurrentHashMap
Performs the given action for each value.
forEachValue(long, Function<? super V, ? extends U>, Consumer<? super U>) - Method in class java.util.concurrent.ConcurrentHashMap
Performs the given action for each non-null transformation of each value.
fork() - Method in class java.util.concurrent.ForkJoinTask
Arranges to asynchronously execute this task in the pool the current task is running in, if applicable, or using the ForkJoinPool.commonPool() if not ForkJoinTask.inForkJoinPool().
ForkJoinPool - Class in java.util.concurrent
An ExecutorService for running ForkJoinTasks.
ForkJoinPool() - Constructor for class java.util.concurrent.ForkJoinPool
ForkJoinPool(int) - Constructor for class java.util.concurrent.ForkJoinPool
Creates a ForkJoinPool with the indicated parallelism level, using defaults for all other parameters (see ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
ForkJoinPool(int, ForkJoinPool.ForkJoinWorkerThreadFactory, Thread.UncaughtExceptionHandler, boolean) - Constructor for class java.util.concurrent.ForkJoinPool
Creates a ForkJoinPool with the given parameters (using defaults for others -- see ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
ForkJoinPool(int, ForkJoinPool.ForkJoinWorkerThreadFactory, Thread.UncaughtExceptionHandler, boolean, int, int, int, Predicate<? super ForkJoinPool>, long, TimeUnit) - Constructor for class java.util.concurrent.ForkJoinPool
Creates a ForkJoinPool with the given parameters.
ForkJoinPool.ForkJoinWorkerThreadFactory - Interface in java.util.concurrent
Factory for creating new ForkJoinWorkerThreads.
ForkJoinPool.ManagedBlocker - Interface in java.util.concurrent
Interface for extending managed parallelism for tasks running in ForkJoinPools.
ForkJoinTask<V> - Class in java.util.concurrent
Abstract base class for tasks that run within a ForkJoinPool.
ForkJoinTask() - Constructor for class java.util.concurrent.ForkJoinTask
 
ForkJoinWorkerThread - Class in java.util.concurrent
A thread managed by a ForkJoinPool, which executes ForkJoinTasks.
ForkJoinWorkerThread(ForkJoinPool) - Constructor for class java.util.concurrent.ForkJoinWorkerThread
Creates a ForkJoinWorkerThread operating in the given pool.
Future<V> - Interface in java.util.concurrent
A Future represents the result of an asynchronous computation.
FutureTask<V> - Class in java.util.concurrent
A cancellable asynchronous computation.
FutureTask(Runnable, V) - Constructor for class java.util.concurrent.FutureTask
Creates a FutureTask that will, upon running, execute the given Runnable, and arrange that get will return the given result on successful completion.
FutureTask(Callable<V>) - Constructor for class java.util.concurrent.FutureTask
Creates a FutureTask that will, upon running, execute the given Callable.

G

get() - Method in class java.util.concurrent.atomic.AtomicBoolean
Returns the current value, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
get() - Method in class java.util.concurrent.atomic.AtomicInteger
Returns the current value, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
get() - Method in class java.util.concurrent.atomic.AtomicLong
Returns the current value, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
get() - Method in class java.util.concurrent.atomic.AtomicReference
Returns the current value, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
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() - Method in class java.util.concurrent.ForkJoinTask
Waits if necessary for the computation to complete, and then retrieves its result.
get() - Method in interface java.util.concurrent.Future
Waits if necessary for the computation to complete, and then retrieves its result.
get() - Method in class java.util.concurrent.FutureTask
 
get(boolean[]) - Method in class java.util.concurrent.atomic.AtomicMarkableReference
Returns the current values of both the reference and the mark.
get(int) - Method in class java.util.ArrayList
Returns the element at the specified position in this list.
get(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
get(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
get(int) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
get(int) - Method in class java.util.concurrent.CopyOnWriteArrayList
get(int) - Method in class java.util.Vector
Returns the element at the specified position in this Vector.
get(int[]) - Method in class java.util.concurrent.atomic.AtomicStampedReference
Returns the current values of both the reference and the stamp.
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(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(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(long, TimeUnit) - Method in class java.util.concurrent.FutureTask
 
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(Object) - Method in class java.util.HashMap
Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
get(T) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
Returns the current value held in the field of the given object managed by this updater.
get(T) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
Returns the current value held in the field of the given object managed by this updater.
get(T) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
Returns the current value held in the field of the given object managed by this updater.
getAcquire() - Method in class java.util.concurrent.atomic.AtomicBoolean
Returns the current value, with memory effects as specified by VarHandle.getAcquire(java.lang.Object...).
getAcquire() - Method in class java.util.concurrent.atomic.AtomicInteger
Returns the current value, with memory effects as specified by VarHandle.getAcquire(java.lang.Object...).
getAcquire() - Method in class java.util.concurrent.atomic.AtomicLong
Returns the current value, with memory effects as specified by VarHandle.getAcquire(java.lang.Object...).
getAcquire() - Method in class java.util.concurrent.atomic.AtomicReference
Returns the current value, with memory effects as specified by VarHandle.getAcquire(java.lang.Object...).
getAcquire(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getAcquire(java.lang.Object...).
getAcquire(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getAcquire(java.lang.Object...).
getAcquire(int) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getAcquire(java.lang.Object...).
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, int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i with the results of applying the given function to the current and given values, returning the previous value.
getAndAccumulate(int, long, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i with the results of applying the given function to the current and given values, returning the previous value.
getAndAccumulate(int, IntBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) 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(T, long, LongBinaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) 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(T, V, BinaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value 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, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndAdd(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically adds the given value to the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndAdd(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically adds the given value to the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndAdd(long) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically adds the given value to the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
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(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 the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndDecrement() - Method in class java.util.concurrent.atomic.AtomicLong
Atomically decrements the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndDecrement(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically decrements the value of the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndDecrement(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically decrements the value of the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
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(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 the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndIncrement() - Method in class java.util.concurrent.atomic.AtomicLong
Atomically increments the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndIncrement(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically increments the value of the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
getAndIncrement(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically increments the value of the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
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(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 the value to newValue and returns the old value, with memory effects as specified by VarHandle.getAndSet(java.lang.Object...).
getAndSet(int) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically sets the value to newValue and returns the old value, with memory effects as specified by VarHandle.getAndSet(java.lang.Object...).
getAndSet(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically sets the element at index i to newValue and returns the old value, with memory effects as specified by VarHandle.getAndSet(java.lang.Object...).
getAndSet(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically sets the element at index i to newValue and returns the old value, with memory effects as specified by VarHandle.getAndSet(java.lang.Object...).
getAndSet(int, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Atomically sets the element at index i to newValue and returns the old value, with memory effects as specified by VarHandle.getAndSet(java.lang.Object...).
getAndSet(long) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically sets the value to newValue and returns the old value, with memory effects as specified by VarHandle.getAndSet(java.lang.Object...).
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(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(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.
getAndSet(V) - Method in class java.util.concurrent.atomic.AtomicReference
Atomically sets the value to newValue and returns the old value, with memory effects as specified by VarHandle.getAndSet(java.lang.Object...).
getAndUpdate(int, IntUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i with the results of applying the given function, returning the previous value.
getAndUpdate(IntUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value with the results of applying the given function, returning the previous value.
getAndUpdate(LongUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the field of the given object managed by this updater 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the field of the given object managed by this updater 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 (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) 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.
getClosedException() - Method in class java.util.concurrent.SubmissionPublisher
Returns the exception associated with closeExceptionally, or null if not closed or if closed normally.
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.
getExecutor() - Method in class java.util.concurrent.SubmissionPublisher
Returns the Executor used for asynchronous delivery.
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 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.
getMaxBufferCapacity() - Method in class java.util.concurrent.SubmissionPublisher
Returns the maximum per-subscriber buffer capacity.
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.
getNumberOfSubscribers() - Method in class java.util.concurrent.SubmissionPublisher
Returns the number of current subscribers.
getNumberWaiting() - Method in class java.util.concurrent.CyclicBarrier
Returns the number of parties currently waiting at the barrier.
getOpaque() - Method in class java.util.concurrent.atomic.AtomicBoolean
Returns the current value, with memory effects as specified by VarHandle.getOpaque(java.lang.Object...).
getOpaque() - Method in class java.util.concurrent.atomic.AtomicInteger
Returns the current value, with memory effects as specified by VarHandle.getOpaque(java.lang.Object...).
getOpaque() - Method in class java.util.concurrent.atomic.AtomicLong
Returns the current value, with memory effects as specified by VarHandle.getOpaque(java.lang.Object...).
getOpaque() - Method in class java.util.concurrent.atomic.AtomicReference
Returns the current value, with memory effects as specified by VarHandle.getOpaque(java.lang.Object...).
getOpaque(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getOpaque(java.lang.Object...).
getOpaque(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getOpaque(java.lang.Object...).
getOpaque(int) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Returns the current value of the element at index i, with memory effects as specified by VarHandle.getOpaque(java.lang.Object...).
getOrDefault(Object, V) - Method in class java.util.concurrent.ConcurrentHashMap
Returns the value to which the specified key is mapped, or the given default value if this map contains no mapping for the key.
getOrDefault(Object, V) - Method in interface java.util.concurrent.ConcurrentMap
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.
getOrDefault(Object, V) - Method in class java.util.HashMap
 
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.
getPlain() - Method in class java.util.concurrent.atomic.AtomicBoolean
Returns the current value, with memory semantics of reading as if the variable was declared non-volatile.
getPlain() - Method in class java.util.concurrent.atomic.AtomicInteger
Returns the current value, with memory semantics of reading as if the variable was declared non-volatile.
getPlain() - Method in class java.util.concurrent.atomic.AtomicLong
Returns the current value, with memory semantics of reading as if the variable was declared non-volatile.
getPlain() - Method in class java.util.concurrent.atomic.AtomicReference
Returns the current value, with memory semantics of reading as if the variable was declared non-volatile.
getPlain(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Returns the current value of the element at index i, with memory semantics of reading as if the variable was declared non-volatile.
getPlain(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
Returns the current value of the element at index i, with memory semantics of reading as if the variable was declared non-volatile.
getPlain(int) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Returns the current value of the element at index i, with memory semantics of reading as if the variable was declared non-volatile.
getPool() - Static method in class java.util.concurrent.ForkJoinTask
Returns the pool hosting the current thread, or null if the current thread 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.
getSubscribers() - Method in class java.util.concurrent.SubmissionPublisher
Returns a list of current subscribers for monitoring and tracking purposes, not for invoking Flow.Subscriber methods on the subscribers.
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
Equivalent in effect to DoubleAccumulator.get() followed by DoubleAccumulator.reset().
getThenReset() - Method in class java.util.concurrent.atomic.LongAccumulator
Equivalent in effect to LongAccumulator.get() followed by LongAccumulator.reset().
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
Returns an estimate of the number of consumers waiting to receive elements via BlockingQueue.take() or timed poll.
getWaitingThreads() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
Returns a collection containing those threads that may be waiting on this Condition.
getWaitingThreads() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.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(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() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.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(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.

H

handle(BiFunction<? super T, Throwable, ? extends U>) - Method in class java.util.concurrent.CompletableFuture
 
handle(BiFunction<? super T, Throwable, ? extends U>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes either normally or exceptionally, is executed with this stage's result and exception as arguments to the supplied function.
handleAsync(BiFunction<? super T, Throwable, ? extends U>) - Method in class java.util.concurrent.CompletableFuture
 
handleAsync(BiFunction<? super T, Throwable, ? extends U>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes either normally or exceptionally, is executed using this stage's default asynchronous execution facility, with this stage's result and exception as arguments to the supplied function.
handleAsync(BiFunction<? super T, Throwable, ? extends U>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
handleAsync(BiFunction<? super T, Throwable, ? extends U>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes either normally or exceptionally, is executed using the supplied executor, with this stage's result and exception as arguments to the supplied function.
hasContended() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Queries whether any threads have ever contended to acquire this synchronizer; that is, if an acquire method has ever blocked.
hasContended() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Queries whether any threads have ever contended to acquire this synchronizer; that is, if an acquire method has ever blocked.
hashCode() - Method in class java.util.concurrent.ConcurrentHashMap
Returns the hash code value for this Map, i.e., the sum of, for each key-value pair in the map, key.hashCode() ^ value.hashCode().
hashCode() - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
 
hashCode() - Method in class java.util.concurrent.CopyOnWriteArrayList
Returns the hash code value for this list.
hashCode() - Method in class java.util.Vector
Returns the hash code value for this Vector.
HashMap<K,V> - Class in java.util
Hash table based implementation of the Map interface.
HashMap() - Constructor for class java.util.HashMap
Constructs an empty HashMap with the default initial capacity (16) and the default load factor (0.75).
HashMap(int) - Constructor for class java.util.HashMap
Constructs an empty HashMap with the specified initial capacity and the default load factor (0.75).
HashMap(int, float) - Constructor for class java.util.HashMap
Constructs an empty HashMap with the specified initial capacity and load factor.
HashMap(Map<? extends K, ? extends V>) - Constructor for class java.util.HashMap
Constructs a new HashMap with the same mappings as the specified Map.
hasQueuedPredecessors() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Queries whether any threads have been waiting to acquire longer than the current thread.
hasQueuedPredecessors() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Queries whether any threads have been waiting to acquire longer than the current thread.
hasQueuedSubmissions() - Method in class java.util.concurrent.ForkJoinPool
Returns true if there are any tasks submitted to this pool that have not yet begun executing.
hasQueuedThread(Thread) - Method in class java.util.concurrent.locks.ReentrantLock
Queries whether the given thread is waiting to acquire this lock.
hasQueuedThread(Thread) - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
Queries whether the given thread is waiting to acquire either the read or write lock.
hasQueuedThreads() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Queries whether any threads are waiting to acquire.
hasQueuedThreads() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Queries whether any threads are waiting to acquire.
hasQueuedThreads() - Method in class java.util.concurrent.locks.ReentrantLock
Queries whether any threads are waiting to acquire this lock.
hasQueuedThreads() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
Queries whether any threads are waiting to acquire the read or write lock.
hasQueuedThreads() - Method in class java.util.concurrent.Semaphore
Queries whether any threads are waiting to acquire.
hasSubscribers() - Method in class java.util.concurrent.SubmissionPublisher
Returns true if this publisher has any subscribers.
hasWaiters() - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject
Queries whether any threads are waiting on this condition.
hasWaiters() - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject
Queries whether any threads are waiting on this condition.
hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Queries whether any threads are waiting on the given condition associated with this synchronizer.
hasWaiters(AbstractQueuedSynchronizer.ConditionObject) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Queries whether any threads are waiting on the given condition associated with this synchronizer.
hasWaiters(Condition) - Method in class java.util.concurrent.locks.ReentrantLock
Queries whether any threads are waiting on the given condition associated with this lock.
hasWaiters(Condition) - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
Queries whether any threads are waiting on the given condition associated with the write lock.
hasWaitingConsumer() - Method in class java.util.concurrent.LinkedTransferQueue
 
hasWaitingConsumer() - Method in interface java.util.concurrent.TransferQueue
Returns true if there is at least one consumer waiting to receive an element via BlockingQueue.take() or timed poll.
headMap(K) - Method in interface java.util.concurrent.ConcurrentNavigableMap
 
headMap(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
headMap(K) - Method in interface java.util.NavigableMap
headMap(K, boolean) - Method in interface java.util.concurrent.ConcurrentNavigableMap
 
headMap(K, boolean) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
headMap(K, boolean) - Method in interface java.util.NavigableMap
Returns a view of the portion of this map whose keys are less than (or equal to, if inclusive is true) toKey.
headSet(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
 
headSet(E) - Method in interface java.util.NavigableSet
headSet(E, boolean) - Method in class java.util.concurrent.ConcurrentSkipListSet
 
headSet(E, boolean) - Method in interface java.util.NavigableSet
Returns a view of the portion of this set whose elements are less than (or equal to, if inclusive is true) toElement.
helpComplete(int) - Method in class java.util.concurrent.CountedCompleter
If this task has not completed, attempts to process at most the given number of other unprocessed tasks for which this task is on the completion path, if any are known to exist.
helpQuiesce() - Static method in class java.util.concurrent.ForkJoinTask
Possibly executes tasks until the pool hosting the current task is quiescent.
higher(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
 
higher(E) - Method in interface java.util.NavigableSet
Returns the least element in this set strictly greater than the given element, or null if there is no such element.
higherEntry(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.
higherEntry(K) - Method in interface java.util.NavigableMap
Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.
higherKey(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
higherKey(K) - Method in interface java.util.NavigableMap
Returns the least key strictly greater than the given key, or null if there is no such key.
HOURS - java.util.concurrent.TimeUnit
Time unit representing sixty minutes.

I

increment() - Method in class java.util.concurrent.atomic.LongAdder
Equivalent to add(1).
incrementAndGet() - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically increments the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
incrementAndGet() - Method in class java.util.concurrent.atomic.AtomicLong
Atomically increments the current value, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
incrementAndGet(int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically increments the value of the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
incrementAndGet(int) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically increments the value of the element at index i, with memory effects as specified by VarHandle.getAndAdd(java.lang.Object...).
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(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(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.
indexOf(Object) - Method in class java.util.ArrayList
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(Object) - Method in class java.util.concurrent.CopyOnWriteArrayList
indexOf(Object) - Method in class java.util.Vector
Returns the index of the first occurrence of the specified element in this vector, or -1 if this vector does not contain the element.
indexOf(Object, int) - Method in class java.util.Vector
Returns the index of the first occurrence of the specified element in this vector, 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.
insertElementAt(E, int) - Method in class java.util.Vector
Inserts the specified object as a component in this vector at the specified index.
ints() - Method in class java.util.concurrent.ThreadLocalRandom
Returns an effectively unlimited stream of pseudorandom int values.
ints() - Method in class java.util.SplittableRandom
Returns an effectively unlimited stream of pseudorandom int values from this generator and/or one split from it.
ints(int, int) - Method in class java.util.concurrent.ThreadLocalRandom
Returns an effectively unlimited stream of pseudorandom int values, each conforming to the given origin (inclusive) and bound (exclusive).
ints(int, int) - Method in class java.util.SplittableRandom
Returns an effectively unlimited stream of pseudorandom int values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
ints(long) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a stream producing the given streamSize number of pseudorandom int values.
ints(long) - Method in class java.util.SplittableRandom
Returns a stream producing the given streamSize number of pseudorandom int values from this generator and/or one split from it.
ints(long, int, int) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a stream producing the given streamSize number of pseudorandom int values, each conforming to the given origin (inclusive) and bound (exclusive).
ints(long, int, int) - Method in class java.util.SplittableRandom
Returns a stream producing the given streamSize number of pseudorandom int values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
intValue() - Method in class java.util.concurrent.atomic.AtomicInteger
Returns the current value of this AtomicInteger as an int, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
intValue() - Method in class java.util.concurrent.atomic.AtomicLong
Returns the current value of this AtomicLong as an int after a narrowing primitive conversion, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
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
Returns the DoubleAdder.sum() as an int after a narrowing primitive conversion.
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 LongAdder.sum() as an int after a narrowing primitive conversion.
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.
invoke(ForkJoinTask<T>) - Method in class java.util.concurrent.ForkJoinPool
Performs the given task, returning its result upon completion.
invokeAll(Collection<? extends Callable<T>>) - 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>>) - Method in class java.util.concurrent.ForkJoinPool
 
invokeAll(Collection<? extends Callable<T>>, long, TimeUnit) - Method in class java.util.concurrent.AbstractExecutorService
 
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<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.
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(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.
invokeAny(Collection<? extends Callable<T>>) - 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 class java.util.concurrent.AbstractExecutorService
 
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
 
isClosed() - Method in class java.util.concurrent.SubmissionPublisher
Returns true if this publisher is not accepting submissions.
isCompletedAbnormally() - Method in class java.util.concurrent.ForkJoinTask
Returns true if this task threw an exception or was cancelled.
isCompletedExceptionally() - Method in class java.util.concurrent.CompletableFuture
Returns true if this CompletableFuture completed exceptionally, in any way.
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.ArrayList
Returns true if this list contains no elements.
isEmpty() - Method in class java.util.concurrent.ConcurrentHashMap
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
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.
isEmpty() - Method in class java.util.HashMap
Returns true if this map contains no key-value mappings.
isEmpty() - Method in class java.util.Vector
Tests if this vector has no components.
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.
isLockStamp(long) - Static method in class java.util.concurrent.locks.StampedLock
Tells whether a stamp represents holding a lock.
isMarked() - Method in class java.util.concurrent.atomic.AtomicMarkableReference
Returns the current value of the mark.
isOptimisticReadStamp(long) - Static method in class java.util.concurrent.locks.StampedLock
Tells whether a stamp represents a successful optimistic read.
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.
isReadLockStamp(long) - Static method in class java.util.concurrent.locks.StampedLock
Tells whether a stamp represents holding a lock 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
 
isSubscribed(Flow.Subscriber<? super T>) - Method in class java.util.concurrent.SubmissionPublisher
Returns true if the given Subscriber is currently subscribed.
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
Returns true if this executor is in the process of terminating after ThreadPoolExecutor.shutdown() or ThreadPoolExecutor.shutdownNow() but has not completely terminated.
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.
isWriteLockStamp(long) - Static method in class java.util.concurrent.locks.StampedLock
Tells whether a stamp represents holding a lock exclusively.
iterator() - Method in class java.util.ArrayDeque
Returns an iterator over the elements in this deque.
iterator() - Method in class java.util.ArrayList
Returns an iterator over the elements in this list in proper sequence.
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.
iterator() - Method in class java.util.Vector
Returns an iterator over the elements in this list in proper sequence.

J

java.base - module java.base
 
java.util - package java.util
 
java.util.concurrent - package java.util.concurrent
Utility classes commonly useful in concurrent programming.
java.util.concurrent.atomic - package java.util.concurrent.atomic
A small toolkit of classes that support lock-free thread-safe programming on single variables.
java.util.concurrent.locks - package java.util.concurrent.locks
Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.
join() - Method in class java.util.concurrent.CompletableFuture
Returns the result value when complete, or throws an (unchecked) exception if completed exceptionally.
join() - Method in class java.util.concurrent.ForkJoinTask
Returns the result of the computation when it is done.

K

keys() - Method in class java.util.concurrent.ConcurrentHashMap
Returns an enumeration of the keys in this table.
keySet() - Method in class java.util.concurrent.ConcurrentHashMap
Returns a Set view of the keys contained in this map.
keySet() - Method in interface java.util.concurrent.ConcurrentNavigableMap
Returns a NavigableSet view of the keys contained in this map.
keySet() - Method in class java.util.concurrent.ConcurrentSkipListMap
Returns a NavigableSet view of the keys contained in this map.
keySet() - Method in class java.util.HashMap
Returns a Set view of the keys contained in this map.
keySet(V) - Method in class java.util.concurrent.ConcurrentHashMap
Returns a Set view of the keys in this map, using the given common mapped value for any additions (i.e., Collection.add(E) and Collection.addAll(Collection)).

L

last() - Method in class java.util.concurrent.ConcurrentSkipListSet
 
lastElement() - Method in class java.util.Vector
Returns the last component of the vector.
lastEntry() - Method in class java.util.concurrent.ConcurrentSkipListMap
Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
lastEntry() - Method in interface java.util.NavigableMap
Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
lastIndexOf(E, int) - Method in class java.util.concurrent.CopyOnWriteArrayList
Returns the index of the last occurrence of the specified element in this list, searching backwards from index, or returns -1 if the element is not found.
lastIndexOf(Object) - Method in class java.util.ArrayList
Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
lastIndexOf(Object) - Method in class java.util.concurrent.CopyOnWriteArrayList
lastIndexOf(Object) - Method in class java.util.Vector
Returns the index of the last occurrence of the specified element in this vector, or -1 if this vector does not contain the element.
lastIndexOf(Object, int) - Method in class java.util.Vector
Returns the index of the last occurrence of the specified element in this vector, searching backwards from index, or returns -1 if the element is not found.
lastKey() - Method in class java.util.concurrent.ConcurrentSkipListMap
 
lazySet(boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Sets the value to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
lazySet(int) - Method in class java.util.concurrent.atomic.AtomicInteger
Sets the value to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
lazySet(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
lazySet(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
lazySet(int, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
lazySet(long) - Method in class java.util.concurrent.atomic.AtomicLong
Sets the value to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
lazySet(T, int) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
Eventually sets the field of the given object managed by this updater to the given updated value.
lazySet(T, long) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
Eventually sets the field of the given object managed by this updater to the given updated value.
lazySet(T, V) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
Eventually sets the field of the given object managed by this updater to the given updated value.
lazySet(V) - Method in class java.util.concurrent.atomic.AtomicReference
Sets the value to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
length() - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Returns the length of the array.
length() - Method in class java.util.concurrent.atomic.AtomicLongArray
Returns the length of the array.
length() - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Returns the length of the array.
LinkedBlockingDeque<E> - Class in java.util.concurrent
An optionally-bounded blocking deque based on linked nodes.
LinkedBlockingDeque() - Constructor for class java.util.concurrent.LinkedBlockingDeque
Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE.
LinkedBlockingDeque(int) - Constructor for class java.util.concurrent.LinkedBlockingDeque
Creates a LinkedBlockingDeque with the given (fixed) capacity.
LinkedBlockingDeque(Collection<? extends E>) - Constructor for class java.util.concurrent.LinkedBlockingDeque
Creates a LinkedBlockingDeque with a capacity of Integer.MAX_VALUE, initially containing the elements of the given collection, added in traversal order of the collection's iterator.
LinkedBlockingQueue<E> - Class in java.util.concurrent
An optionally-bounded blocking queue based on linked nodes.
LinkedBlockingQueue() - Constructor for class java.util.concurrent.LinkedBlockingQueue
Creates a LinkedBlockingQueue with a capacity of Integer.MAX_VALUE.
LinkedBlockingQueue(int) - Constructor for class java.util.concurrent.LinkedBlockingQueue
Creates a LinkedBlockingQueue with the given (fixed) capacity.
LinkedBlockingQueue(Collection<? extends E>) - Constructor for class java.util.concurrent.LinkedBlockingQueue
Creates a LinkedBlockingQueue with a capacity of Integer.MAX_VALUE, initially containing the elements of the given collection, added in traversal order of the collection's iterator.
LinkedTransferQueue<E> - Class in java.util.concurrent
An unbounded TransferQueue based on linked nodes.
LinkedTransferQueue() - Constructor for class java.util.concurrent.LinkedTransferQueue
Creates an initially empty LinkedTransferQueue.
LinkedTransferQueue(Collection<? extends E>) - Constructor for class java.util.concurrent.LinkedTransferQueue
Creates a LinkedTransferQueue initially containing the elements of the given collection, added in traversal order of the collection's iterator.
listIterator() - Method in class java.util.ArrayList
Returns a list iterator over the elements in this list (in proper sequence).
listIterator() - Method in class java.util.concurrent.CopyOnWriteArrayList
listIterator() - Method in class java.util.Vector
Returns a list iterator over the elements in this list (in proper sequence).
listIterator(int) - Method in class java.util.ArrayList
Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
listIterator(int) - Method in class java.util.concurrent.CopyOnWriteArrayList
listIterator(int) - Method in class java.util.Vector
Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
lock() - Method in interface java.util.concurrent.locks.Lock
Acquires the lock.
lock() - Method in class java.util.concurrent.locks.ReentrantLock
Acquires the lock.
lock() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
Acquires the read lock.
lock() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
Acquires the write lock.
Lock - Interface in java.util.concurrent.locks
Lock implementations provide more extensive locking operations than can be obtained using synchronized methods and statements.
lockInterruptibly() - Method in interface java.util.concurrent.locks.Lock
Acquires the lock unless the current thread is interrupted.
lockInterruptibly() - Method in class java.util.concurrent.locks.ReentrantLock
Acquires the lock unless the current thread is interrupted.
lockInterruptibly() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
Acquires the read lock unless the current thread is interrupted.
lockInterruptibly() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
Acquires the write lock unless the current thread is interrupted.
LockSupport - Class in java.util.concurrent.locks
Basic thread blocking primitives for creating locks and other synchronization classes.
LongAccumulator - Class in java.util.concurrent.atomic
One or more variables that together maintain a running long value updated using a supplied function.
LongAccumulator(LongBinaryOperator, long) - Constructor for class java.util.concurrent.atomic.LongAccumulator
Creates a new instance using the given accumulator function and identity element.
LongAdder - Class in java.util.concurrent.atomic
One or more variables that together maintain an initially zero long sum.
LongAdder() - Constructor for class java.util.concurrent.atomic.LongAdder
Creates a new adder with initial sum of zero.
longs() - Method in class java.util.concurrent.ThreadLocalRandom
Returns an effectively unlimited stream of pseudorandom long values.
longs() - Method in class java.util.SplittableRandom
Returns an effectively unlimited stream of pseudorandom long values from this generator and/or one split from it.
longs(long) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a stream producing the given streamSize number of pseudorandom long values.
longs(long) - Method in class java.util.SplittableRandom
Returns a stream producing the given streamSize number of pseudorandom long values from this generator and/or one split from it.
longs(long, long) - Method in class java.util.concurrent.ThreadLocalRandom
Returns an effectively unlimited stream of pseudorandom long values, each conforming to the given origin (inclusive) and bound (exclusive).
longs(long, long) - Method in class java.util.SplittableRandom
Returns an effectively unlimited stream of pseudorandom long values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
longs(long, long, long) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a stream producing the given streamSize number of pseudorandom long, each conforming to the given origin (inclusive) and bound (exclusive).
longs(long, long, long) - Method in class java.util.SplittableRandom
Returns a stream producing the given streamSize number of pseudorandom long values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
longValue() - Method in class java.util.concurrent.atomic.AtomicInteger
Returns the current value of this AtomicInteger as a long after a widening primitive conversion, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
longValue() - Method in class java.util.concurrent.atomic.AtomicLong
Returns the current value of this AtomicLong as a long, with memory effects as specified by VarHandle.getVolatile(java.lang.Object...).
longValue() - Method in class java.util.concurrent.atomic.DoubleAccumulator
Returns the current value as a long after a narrowing primitive conversion.
longValue() - Method in class java.util.concurrent.atomic.DoubleAdder
Returns the DoubleAdder.sum() as a long after a narrowing primitive conversion.
longValue() - Method in class java.util.concurrent.atomic.LongAccumulator
Equivalent to LongAccumulator.get().
longValue() - Method in class java.util.concurrent.atomic.LongAdder
Equivalent to LongAdder.sum().
lower(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
 
lower(E) - Method in interface java.util.NavigableSet
Returns the greatest element in this set strictly less than the given element, or null if there is no such element.
lowerEntry(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.
lowerEntry(K) - Method in interface java.util.NavigableMap
Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.
lowerKey(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
lowerKey(K) - Method in interface java.util.NavigableMap
Returns the greatest key strictly less than the given key, or null if there is no such key.

M

managedBlock(ForkJoinPool.ManagedBlocker) - Static method in class java.util.concurrent.ForkJoinPool
Runs the given possibly blocking task.
mappingCount() - Method in class java.util.concurrent.ConcurrentHashMap
Returns the number of mappings.
merge(K, V, BiFunction<? super V, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentHashMap
If the specified key is not already associated with a (non-null) value, associates it with the given value.
merge(K, V, BiFunction<? super V, ? super V, ? extends V>) - Method in interface java.util.concurrent.ConcurrentMap
merge(K, V, BiFunction<? super V, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentSkipListMap
If the specified key is not already associated with a value, associates it with the given value.
merge(K, V, BiFunction<? super V, ? super V, ? extends V>) - Method in class java.util.HashMap
MICROSECONDS - java.util.concurrent.TimeUnit
Time unit representing one thousandth of a millisecond.
MILLISECONDS - java.util.concurrent.TimeUnit
Time unit representing one thousandth of a second.
minimalCompletionStage() - Method in class java.util.concurrent.CompletableFuture
Returns a new CompletionStage that is completed normally with the same value as this CompletableFuture when it completes normally, and cannot be independently completed or otherwise used in ways not defined by the methods of interface CompletionStage.
MINUTES - java.util.concurrent.TimeUnit
Time unit representing sixty seconds.

N

NANOSECONDS - java.util.concurrent.TimeUnit
Time unit representing one thousandth of a microsecond.
navigableKeySet() - Method in interface java.util.concurrent.ConcurrentNavigableMap
Returns a NavigableSet view of the keys contained in this map.
navigableKeySet() - Method in class java.util.concurrent.ConcurrentSkipListMap
 
navigableKeySet() - Method in interface java.util.NavigableMap
Returns a NavigableSet view of the keys contained in this map.
NavigableMap<K,V> - Interface in java.util
A SortedMap extended with navigation methods returning the closest matches for given search targets.
NavigableSet<E> - Interface in java.util
A SortedSet extended with navigation methods reporting closest matches for given search targets.
newCachedThreadPool() - Static method in class java.util.concurrent.Executors
Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.
newCachedThreadPool(ThreadFactory) - Static method in class java.util.concurrent.Executors
Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available, and uses the provided ThreadFactory to create new threads when needed.
newCondition() - Method in interface java.util.concurrent.locks.Lock
Returns a new Condition instance that is bound to this Lock instance.
newCondition() - Method in class java.util.concurrent.locks.ReentrantLock
Returns a Condition instance for use with this Lock instance.
newCondition() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
Throws UnsupportedOperationException because ReadLocks do not support conditions.
newCondition() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
Returns a Condition instance for use with this Lock instance.
newFixedThreadPool(int) - Static method in class java.util.concurrent.Executors
Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.
newFixedThreadPool(int, ThreadFactory) - Static method in class java.util.concurrent.Executors
Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue, using the provided ThreadFactory to create new threads when needed.
newIncompleteFuture() - Method in class java.util.concurrent.CompletableFuture
Returns a new incomplete CompletableFuture of the type to be returned by a CompletionStage method.
newKeySet() - Static method in class java.util.concurrent.ConcurrentHashMap
Creates a new Set backed by a ConcurrentHashMap from the given type to Boolean.TRUE.
newKeySet(int) - Static method in class java.util.concurrent.ConcurrentHashMap
Creates a new Set backed by a ConcurrentHashMap from the given type to Boolean.TRUE.
newScheduledThreadPool(int) - Static method in class java.util.concurrent.Executors
Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.
newScheduledThreadPool(int, ThreadFactory) - Static method in class java.util.concurrent.Executors
Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.
newSingleThreadExecutor() - Static method in class java.util.concurrent.Executors
Creates an Executor that uses a single worker thread operating off an unbounded queue.
newSingleThreadExecutor(ThreadFactory) - Static method in class java.util.concurrent.Executors
Creates an Executor that uses a single worker thread operating off an unbounded queue, and uses the provided ThreadFactory to create a new thread when needed.
newSingleThreadScheduledExecutor() - Static method in class java.util.concurrent.Executors
Creates a single-threaded executor that can schedule commands to run after a given delay, or to execute periodically.
newSingleThreadScheduledExecutor(ThreadFactory) - Static method in class java.util.concurrent.Executors
Creates a single-threaded executor that can schedule commands to run after a given delay, or to execute periodically.
newTaskFor(Runnable, T) - Method in class java.util.concurrent.AbstractExecutorService
Returns a RunnableFuture for the given runnable and default value.
newTaskFor(Runnable, T) - Method in class java.util.concurrent.ForkJoinPool
 
newTaskFor(Callable<T>) - Method in class java.util.concurrent.AbstractExecutorService
Returns a RunnableFuture for the given callable task.
newTaskFor(Callable<T>) - Method in class java.util.concurrent.ForkJoinPool
 
newThread(Runnable) - Method in interface java.util.concurrent.ThreadFactory
Constructs a new Thread.
newThread(ForkJoinPool) - Method in interface java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory
Returns a new worker thread operating in the given pool.
newUpdater(Class<U>, Class<W>, String) - Static method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
Creates and returns an updater for objects with the given field.
newUpdater(Class<U>, String) - Static method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
Creates and returns an updater for objects with the given field.
newUpdater(Class<U>, String) - Static method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
Creates and returns an updater for objects with the given field.
newWorkStealingPool() - Static method in class java.util.concurrent.Executors
Creates a work-stealing thread pool using the number of available processors as its target parallelism level.
newWorkStealingPool(int) - Static method in class java.util.concurrent.Executors
Creates a thread pool that maintains enough threads to support the given parallelism level, and may use multiple queues to reduce contention.
next(int) - Method in class java.util.concurrent.ThreadLocalRandom
Generates a pseudorandom number with the indicated number of low-order bits.
nextBoolean() - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom boolean value.
nextBoolean() - Method in class java.util.SplittableRandom
Returns a pseudorandom boolean value.
nextBytes(byte[]) - Method in class java.util.SplittableRandom
Fills a user-supplied byte array with generated pseudorandom bytes.
nextComplete() - Method in class java.util.concurrent.CountedCompleter
If this task does not have a completer, invokes ForkJoinTask.quietlyComplete() and returns null.
nextDouble() - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom double value between zero (inclusive) and one (exclusive).
nextDouble() - Method in class java.util.SplittableRandom
Returns a pseudorandom double value between zero (inclusive) and one (exclusive).
nextDouble(double) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom double value between 0.0 (inclusive) and the specified bound (exclusive).
nextDouble(double) - Method in class java.util.SplittableRandom
Returns a pseudorandom double value between 0.0 (inclusive) and the specified bound (exclusive).
nextDouble(double, double) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom double value between the specified origin (inclusive) and bound (exclusive).
nextDouble(double, double) - Method in class java.util.SplittableRandom
Returns a pseudorandom double value between the specified origin (inclusive) and bound (exclusive).
nextFloat() - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom float value between zero (inclusive) and one (exclusive).
nextGaussian() - Method in class java.util.concurrent.ThreadLocalRandom
 
nextInt() - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom int value.
nextInt() - Method in class java.util.SplittableRandom
Returns a pseudorandom int value.
nextInt(int) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom int value between zero (inclusive) and the specified bound (exclusive).
nextInt(int) - Method in class java.util.SplittableRandom
Returns a pseudorandom int value between zero (inclusive) and the specified bound (exclusive).
nextInt(int, int) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom int value between the specified origin (inclusive) and the specified bound (exclusive).
nextInt(int, int) - Method in class java.util.SplittableRandom
Returns a pseudorandom int value between the specified origin (inclusive) and the specified bound (exclusive).
nextLong() - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom long value.
nextLong() - Method in class java.util.SplittableRandom
Returns a pseudorandom long value.
nextLong(long) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom long value between zero (inclusive) and the specified bound (exclusive).
nextLong(long) - Method in class java.util.SplittableRandom
Returns a pseudorandom long value between zero (inclusive) and the specified bound (exclusive).
nextLong(long, long) - Method in class java.util.concurrent.ThreadLocalRandom
Returns a pseudorandom long value between the specified origin (inclusive) and the specified bound (exclusive).
nextLong(long, long) - Method in class java.util.SplittableRandom
Returns a pseudorandom long value between the specified origin (inclusive) and the specified bound (exclusive).

O

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.
of(ChronoUnit) - Static method in enum java.util.concurrent.TimeUnit
Converts a ChronoUnit to the equivalent TimeUnit.
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) - 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) - 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) - 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) - Method in class java.util.concurrent.LinkedBlockingDeque
 
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) - 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) - 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.
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, 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, 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, long, TimeUnit) - 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.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, long, TimeUnit) - Method in class java.util.concurrent.LinkedTransferQueue
Inserts the specified element at the tail of this 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(T, long, TimeUnit, BiPredicate<Flow.Subscriber<? super T>, ? super T>) - Method in class java.util.concurrent.SubmissionPublisher
Publishes the given item, if possible, to each current subscriber by asynchronously invoking its onNext method, blocking while resources for any subscription are unavailable, up to the specified timeout or until the caller thread is interrupted, at which point the given handler (if non-null) is invoked, and if it returns true, retried once.
offer(T, BiPredicate<Flow.Subscriber<? super T>, ? super T>) - Method in class java.util.concurrent.SubmissionPublisher
Publishes the given item, if possible, to each current subscriber by asynchronously invoking its onNext method.
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) - 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) - Method in interface java.util.Deque
Inserts the specified element at the front of this deque unless it would violate capacity restrictions.
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, long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
 
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) - 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) - Method in interface java.util.Deque
Inserts the specified element at the end of this deque unless it would violate capacity restrictions.
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, long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
 
onAdvance(int, int) - Method in class java.util.concurrent.Phaser
Overridable method to perform an action upon impending phase advance, and to control termination.
onComplete() - Method in interface java.util.concurrent.Flow.Subscriber
Method invoked when it is known that no additional Subscriber method invocations will occur for a Subscription that is not already terminated by error, after which no other Subscriber methods are invoked by the Subscription.
onCompletion(CountedCompleter<?>) - Method in class java.util.concurrent.CountedCompleter
Performs an action when method CountedCompleter.tryComplete() is invoked and the pending count is zero, or when the unconditional method CountedCompleter.complete(T) is invoked.
onError(Throwable) - Method in interface java.util.concurrent.Flow.Subscriber
Method invoked upon an unrecoverable error encountered by a Publisher or Subscription, after which no other Subscriber methods are invoked by the Subscription.
onExceptionalCompletion(Throwable, CountedCompleter<?>) - Method in class java.util.concurrent.CountedCompleter
Performs an action when method ForkJoinTask.completeExceptionally(Throwable) is invoked or method CountedCompleter.compute() throws an exception, and this task has not already otherwise completed normally.
onNext(T) - Method in interface java.util.concurrent.Flow.Subscriber
Method invoked with a Subscription's next item.
onStart() - Method in class java.util.concurrent.ForkJoinWorkerThread
Initializes internal state after construction but before processing any tasks.
onSubscribe(Flow.Subscription) - Method in interface java.util.concurrent.Flow.Subscriber
Method invoked prior to invoking any other Subscriber methods for the given Subscription.
onTermination(Throwable) - Method in class java.util.concurrent.ForkJoinWorkerThread
Performs cleanup associated with termination of this worker thread.
orTimeout(long, TimeUnit) - Method in class java.util.concurrent.CompletableFuture
Exceptionally completes this CompletableFuture with a TimeoutException if not otherwise completed before the given timeout.
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.

P

park() - Static method in class java.util.concurrent.locks.LockSupport
Disables the current thread for thread scheduling purposes unless the permit is available.
park(Object) - Static method in class java.util.concurrent.locks.LockSupport
Disables the current thread for thread scheduling purposes 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.
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.
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.
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.
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
A reusable synchronization barrier, similar in functionality to CyclicBarrier and CountDownLatch but supporting more flexible usage.
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
Equivalent to Phaser(parent, 0).
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() - 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() - Method in interface java.util.concurrent.CompletionService
Retrieves and removes the Future representing the next completed task, or null if none are 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() - Method in class java.util.concurrent.ExecutorCompletionService
 
poll() - Method in class java.util.concurrent.LinkedBlockingDeque
 
poll() - Method in class java.util.concurrent.LinkedBlockingQueue
 
poll() - Method in class java.util.concurrent.LinkedTransferQueue
 
poll() - Method in class java.util.concurrent.PriorityBlockingQueue
 
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.
poll(long, TimeUnit) - Method in class java.util.concurrent.ArrayBlockingQueue
 
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(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(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(long, TimeUnit) - Method in class java.util.concurrent.ExecutorCompletionService
 
poll(long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
 
poll(long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingQueue
 
poll(long, TimeUnit) - Method in class java.util.concurrent.LinkedTransferQueue
 
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.
pollFirst() - Method in class java.util.ArrayDeque
 
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() - 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.
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(long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
 
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() - Method in class java.util.concurrent.ConcurrentLinkedDeque
 
pollLast() - Method in class java.util.concurrent.ConcurrentSkipListSet
 
pollLast() - 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.
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(long, TimeUnit) - Method in class java.util.concurrent.LinkedBlockingDeque
 
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.
pollSubmission() - Static method in class java.util.concurrent.ForkJoinTask
If the current thread is operating in a ForkJoinPool, unschedules and returns, without executing, a task externally submitted to the pool, 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
An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations.
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(Comparator<? super E>) - Constructor for class java.util.PriorityQueue
Creates a PriorityQueue with the default initial capacity and whose elements are ordered according to the specified comparator.
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
Equivalent to CountedCompleter.tryComplete() but does not invoke CountedCompleter.onCompletion(CountedCompleter) along the completion path: If the pending count is nonzero, decrements the count; otherwise, similarly tries to complete this task's completer, if one exists, else marks this task as complete.
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(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.
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(K, V) - Method in class java.util.HashMap
Associates the specified value with the specified key in this map.
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.
putAll(Map<? extends K, ? extends V>) - Method in class java.util.HashMap
Copies all of the mappings from the specified map to this map.
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, associates 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, associates 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, associates it with the given value.
putIfAbsent(K, V) - Method in class java.util.HashMap
 
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
 

Q

Queue<E> - Interface in java.util
A collection designed for holding elements prior to processing.
quietlyComplete() - Method in class java.util.concurrent.ForkJoinTask
Completes this task normally without setting a value.
quietlyCompleteRoot() - Method in class java.util.concurrent.CountedCompleter
Equivalent to getRoot().quietlyComplete().
quietlyInvoke() - Method in class java.util.concurrent.ForkJoinTask
Commences performing this task and awaits its completion if necessary, without returning its result or throwing its exception.
quietlyJoin() - Method in class java.util.concurrent.ForkJoinTask
Joins this task, without returning its result or throwing its exception.

R

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.
ReadLock(ReentrantReadWriteLock) - Constructor for class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
Constructor for use by subclasses.
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
A recursive resultless ForkJoinTask.
RecursiveAction() - Constructor for class java.util.concurrent.RecursiveAction
 
RecursiveTask<V> - Class in java.util.concurrent
A recursive result-bearing ForkJoinTask.
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.
reduceToDouble(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
An implementation of ReadWriteLock supporting similar semantics to ReentrantLock.
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
The lock returned by method ReentrantReadWriteLock.readLock().
ReentrantReadWriteLock.WriteLock - Class in java.util.concurrent.locks
The lock returned by method ReentrantReadWriteLock.writeLock().
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
Method that may be invoked by a ThreadPoolExecutor when execute cannot accept a task.
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
A handler for tasks that cannot be executed by a ThreadPoolExecutor.
release() - Method in class java.util.concurrent.Semaphore
Releases a permit, returning it to the semaphore.
release(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Releases in exclusive mode.
release(int) - Method in class java.util.concurrent.Semaphore
Releases the given number of permits, returning them to the semaphore.
release(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Releases in exclusive mode.
releaseShared(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Releases in shared mode.
releaseShared(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
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() - 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() - Method in class java.util.concurrent.ConcurrentLinkedDeque
 
remove() - Method in class java.util.concurrent.LinkedBlockingDeque
Retrieves and removes the head of the queue represented by this deque.
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() - Method in interface java.util.Queue
Retrieves and removes the head of this queue.
remove(int) - Method in class java.util.ArrayList
Removes the element at the specified position in this list.
remove(int) - Method in class java.util.concurrent.CopyOnWriteArrayList
Removes the element at the specified position in this list.
remove(int) - Method in class java.util.Vector
Removes the element at the specified position in this Vector.
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.ArrayList
Removes the first occurrence of the specified element from this list, if it is present.
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(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) - Method in class java.util.concurrent.ConcurrentLinkedDeque
Removes the first occurrence of the specified element from 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) - Method in class java.util.concurrent.ConcurrentSkipListMap
Removes the mapping for the specified key from this map if present.
remove(Object) - Method in class java.util.concurrent.ConcurrentSkipListSet
Removes the specified element from this set if it is present.
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(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(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.HashMap
Removes the mapping for the specified key from this map if present.
remove(Object) - Method in class java.util.PriorityQueue
Removes a single instance of the specified element from this queue, if it is present.
remove(Object) - Method in class java.util.Vector
Removes the first occurrence of the specified element in this Vector If the Vector does not contain the element, it is unchanged.
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(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, Object) - Method in class java.util.concurrent.ConcurrentSkipListMap
Removes the entry for a key only if currently mapped to a given value.
remove(Object, Object) - Method in class java.util.HashMap
 
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.
removeAll(Collection<?>) - Method in class java.util.ArrayDeque
 
removeAll(Collection<?>) - Method in class java.util.ArrayList
Removes from this list all of its elements that are contained in the specified collection.
removeAll(Collection<?>) - Method in class java.util.concurrent.ArrayBlockingQueue
 
removeAll(Collection<?>) - Method in class java.util.concurrent.ConcurrentLinkedDeque
 
removeAll(Collection<?>) - Method in class java.util.concurrent.ConcurrentLinkedQueue
 
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.LinkedBlockingDeque
 
removeAll(Collection<?>) - Method in class java.util.concurrent.LinkedBlockingQueue
 
removeAll(Collection<?>) - Method in class java.util.concurrent.LinkedTransferQueue
 
removeAll(Collection<?>) - Method in class java.util.concurrent.SynchronousQueue
Always returns false.
removeAll(Collection<?>) - Method in class java.util.Vector
Removes from this Vector all of its elements that are contained in the specified Collection.
removeAllElements() - Method in class java.util.Vector
Removes all components from this vector and sets its size to zero.
removeElement(Object) - Method in class java.util.Vector
Removes the first (lowest-indexed) occurrence of the argument from this vector.
removeElementAt(int) - Method in class java.util.Vector
Deletes the component at the specified index.
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 occurrence of the specified element from 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.ArrayDeque
 
removeIf(Predicate<? super E>) - Method in class java.util.ArrayList
 
removeIf(Predicate<? super E>) - Method in class java.util.concurrent.ArrayBlockingQueue
 
removeIf(Predicate<? super E>) - Method in class java.util.concurrent.ConcurrentLinkedDeque
 
removeIf(Predicate<? super E>) - Method in class java.util.concurrent.ConcurrentLinkedQueue
 
removeIf(Predicate<? super E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
 
removeIf(Predicate<? super E>) - Method in class java.util.concurrent.CopyOnWriteArraySet
 
removeIf(Predicate<? super E>) - Method in class java.util.concurrent.LinkedBlockingDeque
 
removeIf(Predicate<? super E>) - Method in class java.util.concurrent.LinkedBlockingQueue
 
removeIf(Predicate<? super E>) - Method in class java.util.concurrent.LinkedTransferQueue
 
removeIf(Predicate<? super E>) - Method in class java.util.Vector
 
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 occurrence of the specified element from 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.
removeRange(int, int) - Method in class java.util.ArrayList
Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
removeRange(int, int) - Method in class java.util.Vector
Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
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) - Method in interface java.util.concurrent.ConcurrentMap
Replaces the entry for a key only if currently mapped to some value.
replace(K, V) - Method in class java.util.concurrent.ConcurrentSkipListMap
Replaces the entry for a key only if currently mapped to some value.
replace(K, V) - Method in class java.util.HashMap
 
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, 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, 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, V) - Method in class java.util.HashMap
 
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 interface java.util.concurrent.ConcurrentMap
replaceAll(BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
replaceAll(BiFunction<? super K, ? super V, ? extends V>) - Method in class java.util.HashMap
 
replaceAll(UnaryOperator<E>) - Method in class java.util.ArrayList
 
replaceAll(UnaryOperator<E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
 
replaceAll(UnaryOperator<E>) - Method in class java.util.Vector
 
request(long) - Method in interface java.util.concurrent.Flow.Subscription
Adds the given number n of items to the current unfulfilled demand for this subscription.
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.ArrayDeque
 
retainAll(Collection<?>) - Method in class java.util.ArrayList
Retains only the elements in this list that are contained in the specified collection.
retainAll(Collection<?>) - Method in class java.util.concurrent.ArrayBlockingQueue
 
retainAll(Collection<?>) - Method in class java.util.concurrent.ConcurrentLinkedDeque
 
retainAll(Collection<?>) - Method in class java.util.concurrent.ConcurrentLinkedQueue
 
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.LinkedBlockingDeque
 
retainAll(Collection<?>) - Method in class java.util.concurrent.LinkedBlockingQueue
 
retainAll(Collection<?>) - Method in class java.util.concurrent.LinkedTransferQueue
 
retainAll(Collection<?>) - Method in class java.util.concurrent.SynchronousQueue
Always returns false.
retainAll(Collection<?>) - Method in class java.util.Vector
Retains only the elements in this Vector that are contained in the specified Collection.
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(CompletionStage<?>, Runnable) - Method in class java.util.concurrent.CompletableFuture
 
runAfterBoth(CompletionStage<?>, Runnable) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, executes the given action.
runAfterBothAsync(CompletionStage<?>, Runnable) - Method in class java.util.concurrent.CompletableFuture
 
runAfterBothAsync(CompletionStage<?>, Runnable) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, executes the given action using this stage's default asynchronous execution facility.
runAfterBothAsync(CompletionStage<?>, Runnable, Executor) - Method in class java.util.concurrent.CompletableFuture
 
runAfterBothAsync(CompletionStage<?>, Runnable, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, executes the given action using the supplied executor.
runAfterEither(CompletionStage<?>, Runnable) - Method in class java.util.concurrent.CompletableFuture
 
runAfterEither(CompletionStage<?>, Runnable) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, executes the given action.
runAfterEitherAsync(CompletionStage<?>, Runnable) - Method in class java.util.concurrent.CompletableFuture
 
runAfterEitherAsync(CompletionStage<?>, Runnable) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, executes the given action using this stage's default asynchronous execution facility.
runAfterEitherAsync(CompletionStage<?>, Runnable, Executor) - Method in class java.util.concurrent.CompletableFuture
 
runAfterEitherAsync(CompletionStage<?>, Runnable, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when either this or the other given stage complete normally, executes the given action using the supplied 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
A Future that is Runnable.
RunnableScheduledFuture<V> - Interface in java.util.concurrent

S

schedule(Runnable, long, TimeUnit) - Method in interface java.util.concurrent.ScheduledExecutorService
Submits a one-shot task 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 interface java.util.concurrent.ScheduledExecutorService
Submits a value-returning one-shot task that becomes enabled after the given delay.
schedule(Callable<V>, long, TimeUnit) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
 
scheduleAtFixedRate(Runnable, long, long, TimeUnit) - Method in interface java.util.concurrent.ScheduledExecutorService
Submits 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
Submits 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.
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, RejectedExecutionHandler) - Constructor for class java.util.concurrent.ScheduledThreadPoolExecutor
Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
ScheduledThreadPoolExecutor(int, ThreadFactory) - 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
Submits 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
Submits 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.
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.
SECONDS - java.util.concurrent.TimeUnit
Time unit representing one second.
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
Sets the value to newValue, with memory effects as specified by VarHandle.setVolatile(java.lang.Object...).
set(int) - Method in class java.util.concurrent.atomic.AtomicInteger
Sets the value to newValue, with memory effects as specified by VarHandle.setVolatile(java.lang.Object...).
set(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setVolatile(java.lang.Object...).
set(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setVolatile(java.lang.Object...).
set(int, E) - Method in class java.util.ArrayList
Replaces the element at the specified position in this list with the specified element.
set(int, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setVolatile(java.lang.Object...).
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(int, E) - Method in class java.util.Vector
Replaces the element at the specified position in this Vector with the specified element.
set(long) - Method in class java.util.concurrent.atomic.AtomicLong
Sets the value to newValue, with memory effects as specified by VarHandle.setVolatile(java.lang.Object...).
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(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(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) - Method in class java.util.concurrent.atomic.AtomicReference
Sets the value to newValue, with memory effects as specified by VarHandle.setVolatile(java.lang.Object...).
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.
set(V, boolean) - Method in class java.util.concurrent.atomic.AtomicMarkableReference
Unconditionally sets the value of both the reference and mark.
set(V, int) - Method in class java.util.concurrent.atomic.AtomicStampedReference
Unconditionally sets the value of both the reference and stamp.
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.
setElementAt(E, int) - Method in class java.util.Vector
Sets the component at the specified index of this vector to be the specified object.
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 and returns the old value.
setKeepAliveTime(long, TimeUnit) - Method in class java.util.concurrent.ThreadPoolExecutor
Sets the thread keep-alive time, which is the amount of time that threads may remain idle before being terminated.
setMaximumPoolSize(int) - Method in class java.util.concurrent.ThreadPoolExecutor
Sets the maximum allowed number of threads.
setOpaque(boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Sets the value to newValue, with memory effects as specified by VarHandle.setOpaque(java.lang.Object...).
setOpaque(int) - Method in class java.util.concurrent.atomic.AtomicInteger
Sets the value to newValue, with memory effects as specified by VarHandle.setOpaque(java.lang.Object...).
setOpaque(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setOpaque(java.lang.Object...).
setOpaque(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setOpaque(java.lang.Object...).
setOpaque(int, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setOpaque(java.lang.Object...).
setOpaque(long) - Method in class java.util.concurrent.atomic.AtomicLong
Sets the value to newValue, with memory effects as specified by VarHandle.setOpaque(java.lang.Object...).
setOpaque(V) - Method in class java.util.concurrent.atomic.AtomicReference
Sets the value to newValue, with memory effects as specified by VarHandle.setOpaque(java.lang.Object...).
setPendingCount(int) - Method in class java.util.concurrent.CountedCompleter
Sets the pending count to the given value.
setPlain(boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Sets the value to newValue, with memory semantics of setting as if the variable was declared non-volatile and non-final.
setPlain(int) - Method in class java.util.concurrent.atomic.AtomicInteger
Sets the value to newValue, with memory semantics of setting as if the variable was declared non-volatile and non-final.
setPlain(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Sets the element at index i to newValue, with memory semantics of setting as if the variable was declared non-volatile and non-final.
setPlain(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Sets the element at index i to newValue, with memory semantics of setting as if the variable was declared non-volatile and non-final.
setPlain(int, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Sets the element at index i to newValue, with memory semantics of setting as if the variable was declared non-volatile and non-final.
setPlain(long) - Method in class java.util.concurrent.atomic.AtomicLong
Sets the value to newValue, with memory semantics of setting as if the variable was declared non-volatile and non-final.
setPlain(V) - Method in class java.util.concurrent.atomic.AtomicReference
Sets the value to newValue, with memory semantics of setting as if the variable was declared non-volatile and non-final.
setRawResult(Void) - Method in class java.util.concurrent.RecursiveAction
Requires null completion 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(V) - Method in class java.util.concurrent.RecursiveTask
 
setRejectedExecutionHandler(RejectedExecutionHandler) - Method in class java.util.concurrent.ThreadPoolExecutor
Sets a new handler for unexecutable tasks.
setRelease(boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Sets the value to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
setRelease(int) - Method in class java.util.concurrent.atomic.AtomicInteger
Sets the value to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
setRelease(int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
setRelease(int, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
setRelease(int, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Sets the element at index i to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
setRelease(long) - Method in class java.util.concurrent.atomic.AtomicLong
Sets the value to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
setRelease(V) - Method in class java.util.concurrent.atomic.AtomicReference
Sets the value to newValue, with memory effects as specified by VarHandle.setRelease(java.lang.Object...).
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.
setSize(int) - Method in class java.util.Vector
Sets the size of this vector.
setState(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Sets the value of synchronization state.
setState(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
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.ArrayList
Returns the number of elements in this list.
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
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
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.HashMap
Returns the number of key-value mappings in this map.
size() - Method in class java.util.PriorityQueue
 
size() - Method in class java.util.Vector
Returns the number of components in this vector.
sleep(long) - Method in enum java.util.concurrent.TimeUnit
Performs a Thread.sleep using this time unit.
sort(Comparator<? super E>) - Method in class java.util.ArrayList
 
sort(Comparator<? super E>) - Method in class java.util.concurrent.CopyOnWriteArrayList
 
sort(Comparator<? super E>) - Method in class java.util.Vector
 
split() - Method in class java.util.SplittableRandom
Constructs and returns a new SplittableRandom instance that shares no mutable state with this instance.
spliterator() - Method in class java.util.ArrayDeque
Creates a late-binding and fail-fast Spliterator over the elements in this deque.
spliterator() - Method in class java.util.ArrayList
Creates a late-binding and fail-fast Spliterator over the elements in this list.
spliterator() - Method in class java.util.concurrent.ArrayBlockingQueue
Returns a Spliterator over the elements in this queue.
spliterator() - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView
 
spliterator() - Method in class java.util.concurrent.ConcurrentLinkedDeque
Returns a Spliterator over the elements in this deque.
spliterator() - Method in class java.util.concurrent.ConcurrentLinkedQueue
Returns a Spliterator over the elements in this queue.
spliterator() - Method in class java.util.concurrent.ConcurrentSkipListSet
Returns a Spliterator over the elements in this set.
spliterator() - Method in class java.util.concurrent.CopyOnWriteArrayList
Returns a Spliterator over the elements in this list.
spliterator() - Method in class java.util.concurrent.CopyOnWriteArraySet
Returns a Spliterator over the elements in this set in the order in which these elements were added.
spliterator() - Method in class java.util.concurrent.LinkedBlockingDeque
Returns a Spliterator over the elements in this deque.
spliterator() - Method in class java.util.concurrent.LinkedBlockingQueue
Returns a Spliterator over the elements in this queue.
spliterator() - Method in class java.util.concurrent.LinkedTransferQueue
Returns a Spliterator over the elements in this queue.
spliterator() - Method in class java.util.concurrent.PriorityBlockingQueue
Returns a Spliterator over the elements in this queue.
spliterator() - Method in class java.util.concurrent.SynchronousQueue
Returns an empty spliterator in which calls to trySplit always return null.
spliterator() - Method in class java.util.PriorityQueue
Creates a late-binding and fail-fast Spliterator over the elements in this queue.
spliterator() - Method in class java.util.Vector
Creates a late-binding and fail-fast Spliterator over the elements in this list.
SplittableRandom - Class in java.util
A generator of uniform pseudorandom values applicable for use in (among other contexts) isolated parallel computations that may generate subtasks.
SplittableRandom() - Constructor for class java.util.SplittableRandom
Creates a new SplittableRandom instance that is likely to generate sequences of values that are statistically independent of those of any other instances in the current program; and may, and typically does, vary across program invocations.
SplittableRandom(long) - Constructor for class java.util.SplittableRandom
Creates a new SplittableRandom instance using the specified initial seed.
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.ArrayList
Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.
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.
subList(int, int) - Method in class java.util.Vector
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, boolean, K, boolean) - 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.concurrent.ConcurrentNavigableMap
 
subMap(K, K) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
subMap(K, K) - Method in interface java.util.NavigableMap
SubmissionPublisher<T> - Class in java.util.concurrent
A Flow.Publisher that asynchronously issues submitted (non-null) items to current subscribers until it is closed.
SubmissionPublisher() - Constructor for class java.util.concurrent.SubmissionPublisher
Creates a new SubmissionPublisher using the ForkJoinPool.commonPool() for async delivery to subscribers (unless it does not support a parallelism level of at least two, in which case, a new Thread is created to run each task), with maximum buffer capacity of Flow.defaultBufferSize(), and no handler for Subscriber exceptions in method onNext.
SubmissionPublisher(Executor, int) - Constructor for class java.util.concurrent.SubmissionPublisher
Creates a new SubmissionPublisher using the given Executor for async delivery to subscribers, with the given maximum buffer size for each subscriber, and no handler for Subscriber exceptions in method onNext.
SubmissionPublisher(Executor, int, BiConsumer<? super Flow.Subscriber<? super T>, ? super Throwable>) - Constructor for class java.util.concurrent.SubmissionPublisher
Creates a new SubmissionPublisher using the given Executor for async delivery to subscribers, with the given maximum buffer size for each subscriber, and, if non-null, the given handler invoked when any Subscriber throws an exception in method onNext.
submit(Runnable) - Method in class java.util.concurrent.AbstractExecutorService
 
submit(Runnable) - Method in interface java.util.concurrent.ExecutorService
Submits a Runnable task for execution and returns a Future representing that task.
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.AbstractExecutorService
 
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, T) - Method in class java.util.concurrent.ForkJoinPool
 
submit(Runnable, T) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
 
submit(Runnable, V) - Method in interface java.util.concurrent.CompletionService
Submits a Runnable task for execution and returns a Future representing that task.
submit(Runnable, V) - Method in class java.util.concurrent.ExecutorCompletionService
 
submit(Callable<T>) - Method in class java.util.concurrent.AbstractExecutorService
 
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(Callable<T>) - Method in class java.util.concurrent.ForkJoinPool
 
submit(Callable<T>) - Method in class java.util.concurrent.ScheduledThreadPoolExecutor
 
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(Callable<V>) - Method in class java.util.concurrent.ExecutorCompletionService
 
submit(ForkJoinTask<T>) - Method in class java.util.concurrent.ForkJoinPool
Submits a ForkJoinTask for execution.
submit(T) - Method in class java.util.concurrent.SubmissionPublisher
Publishes the given item to each current subscriber by asynchronously invoking its onNext method, blocking uninterruptibly while resources for any subscriber are unavailable.
subscribe(Flow.Subscriber<? super T>) - Method in interface java.util.concurrent.Flow.Publisher
Adds the given Subscriber if possible.
subscribe(Flow.Subscriber<? super T>) - Method in class java.util.concurrent.SubmissionPublisher
Adds the given Subscriber unless already subscribed.
subSet(E, boolean, E, boolean) - 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 class java.util.concurrent.ConcurrentSkipListSet
 
subSet(E, E) - Method in interface java.util.NavigableSet
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
Equivalent in effect to DoubleAdder.sum() followed by DoubleAdder.reset().
sumThenReset() - Method in class java.util.concurrent.atomic.LongAdder
Equivalent in effect to LongAdder.sum() followed by LongAdder.reset().
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.

T

tailMap(K) - Method in interface java.util.concurrent.ConcurrentNavigableMap
 
tailMap(K) - Method in class java.util.concurrent.ConcurrentSkipListMap
 
tailMap(K) - Method in interface java.util.NavigableMap
tailMap(K, boolean) - Method in interface java.util.concurrent.ConcurrentNavigableMap
 
tailMap(K, boolean) - 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.
tailSet(E) - Method in class java.util.concurrent.ConcurrentSkipListSet
 
tailSet(E) - Method in interface java.util.NavigableSet
tailSet(E, boolean) - 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.
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
 
thenAccept(Consumer<? super T>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied action.
thenAcceptAsync(Consumer<? super T>) - Method in class java.util.concurrent.CompletableFuture
 
thenAcceptAsync(Consumer<? super T>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, is executed using this stage's default asynchronous execution facility, with this stage's result as the argument to the supplied action.
thenAcceptAsync(Consumer<? super T>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
thenAcceptAsync(Consumer<? super T>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, is executed using the supplied Executor, with this stage's result as the argument to the supplied action.
thenAcceptBoth(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>) - Method in class java.util.concurrent.CompletableFuture
 
thenAcceptBoth(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied action.
thenAcceptBothAsync(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>) - Method in class java.util.concurrent.CompletableFuture
 
thenAcceptBothAsync(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed using this stage's default asynchronous execution facility, with the two results as arguments to the supplied action.
thenAcceptBothAsync(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
thenAcceptBothAsync(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed using the supplied executor, with the two results as arguments to the supplied action.
thenApply(Function<? super T, ? extends U>) - Method in class java.util.concurrent.CompletableFuture
 
thenApply(Function<? super T, ? extends U>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied function.
thenApplyAsync(Function<? super T, ? extends U>) - Method in class java.util.concurrent.CompletableFuture
 
thenApplyAsync(Function<? super T, ? extends U>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, is executed using this stage's default asynchronous execution facility, with this stage's result as the argument to the supplied function.
thenApplyAsync(Function<? super T, ? extends U>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
thenApplyAsync(Function<? super T, ? extends U>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, is executed using the supplied Executor, with this stage's result as the argument to the supplied function.
thenCombine(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in class java.util.concurrent.CompletableFuture
 
thenCombine(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied function.
thenCombineAsync(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in class java.util.concurrent.CompletableFuture
 
thenCombineAsync(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed using this stage's default asynchronous execution facility, with the two results as arguments to the supplied function.
thenCombineAsync(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
thenCombineAsync(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed using the supplied executor, with the two results as arguments to the supplied function.
thenCompose(Function<? super T, ? extends CompletionStage<U>>) - Method in class java.util.concurrent.CompletableFuture
 
thenCompose(Function<? super T, ? extends CompletionStage<U>>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that is completed with the same value as the CompletionStage returned by the given function.
thenComposeAsync(Function<? super T, ? extends CompletionStage<U>>) - Method in class java.util.concurrent.CompletableFuture
 
thenComposeAsync(Function<? super T, ? extends CompletionStage<U>>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that is completed with the same value as the CompletionStage returned by the given function, executed using this stage's default asynchronous execution facility.
thenComposeAsync(Function<? super T, ? extends CompletionStage<U>>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
thenComposeAsync(Function<? super T, ? extends CompletionStage<U>>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that is completed with the same value as the CompletionStage returned by the given function, executed using the supplied Executor.
thenRun(Runnable) - Method in class java.util.concurrent.CompletableFuture
 
thenRun(Runnable) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, executes the given action.
thenRunAsync(Runnable) - Method in class java.util.concurrent.CompletableFuture
 
thenRunAsync(Runnable) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, executes the given action using this stage's default asynchronous execution facility.
thenRunAsync(Runnable, Executor) - Method in class java.util.concurrent.CompletableFuture
 
thenRunAsync(Runnable, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage that, when this stage completes normally, executes the given action using the supplied 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, the default thread factory and the 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) - 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>, 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.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.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.DiscardPolicy - Class in java.util.concurrent
A handler for rejected tasks that silently discards the rejected task.
timedJoin(Thread, long) - Method in enum java.util.concurrent.TimeUnit
Performs a timed Thread.join using this time unit.
timedWait(Object, long) - Method in enum java.util.concurrent.TimeUnit
Performs a timed Object.wait using this time unit.
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() - Method in class java.util.ArrayList
Returns an array containing all of the elements in this list in proper sequence (from first to last element).
toArray() - Method in class java.util.concurrent.ArrayBlockingQueue
Returns an array containing all of the elements in this queue, in proper sequence.
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() - Method in class java.util.concurrent.ConcurrentLinkedQueue
Returns an array containing all of the elements in this queue, in proper sequence.
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() - Method in class java.util.concurrent.CopyOnWriteArraySet
Returns an array containing all of the elements in this set.
toArray() - Method in class java.util.concurrent.DelayQueue
Returns an array containing all of the elements in this queue.
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() - Method in class java.util.concurrent.LinkedBlockingQueue
Returns an array containing all of the elements in this queue, in proper sequence.
toArray() - Method in class java.util.concurrent.LinkedTransferQueue
Returns an array containing all of the elements in this queue, in proper sequence.
toArray() - Method in class java.util.concurrent.PriorityBlockingQueue
Returns an array containing all of the elements in this queue.
toArray() - Method in class java.util.concurrent.SynchronousQueue
Returns a zero-length array.
toArray() - Method in class java.util.PriorityQueue
Returns an array containing all of the elements in this queue.
toArray() - Method in class java.util.Vector
Returns an array containing all of the elements in this Vector in the correct order.
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(T[]) - Method in class java.util.ArrayList
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(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(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(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(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(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(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(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(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(T[]) - Method in class java.util.concurrent.LinkedTransferQueue
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(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(T[]) - Method in class java.util.concurrent.SynchronousQueue
Sets the zeroth element of the specified array to null (if the array has non-zero length) and returns it.
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.
toArray(T[]) - Method in class java.util.Vector
Returns an array containing all of the elements in this Vector in the correct order; the runtime type of the returned array is that of the specified array.
toChronoUnit() - Method in enum java.util.concurrent.TimeUnit
Converts this TimeUnit to the equivalent ChronoUnit.
toCompletableFuture() - Method in class java.util.concurrent.CompletableFuture
Returns this CompletableFuture.
toCompletableFuture() - Method in interface java.util.concurrent.CompletionStage
Returns a CompletableFuture maintaining the same completion properties as this stage.
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
Returns the String representation of the DoubleAdder.sum().
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 LongAdder.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.ConcurrentLinkedDeque
 
toString() - Method in class java.util.concurrent.ConcurrentLinkedQueue
 
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.FutureTask
Returns a string representation of this FutureTask.
toString() - Method in class java.util.concurrent.LinkedBlockingDeque
 
toString() - Method in class java.util.concurrent.LinkedBlockingQueue
 
toString() - Method in class java.util.concurrent.LinkedTransferQueue
 
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.SynchronousQueue
Always returns "[]".
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.
toString() - Method in class java.util.Vector
Returns a string representation of this Vector, containing the String representation of each element.
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.
trimToSize() - Method in class java.util.ArrayList
Trims the capacity of this ArrayList instance to be the list's current size.
trimToSize() - Method in class java.util.Vector
Trims the capacity of this vector to be the vector's current size.
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(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Attempts to acquire in exclusive mode.
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.
tryAcquire(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Attempts to acquire in exclusive mode.
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.
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.
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.
tryAcquireShared(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Attempts to acquire in shared mode.
tryAcquireShared(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Attempts to acquire in shared mode.
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.
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.
tryComplete() - Method in class java.util.concurrent.CountedCompleter
If the pending count is nonzero, decrements the count; otherwise invokes CountedCompleter.onCompletion(CountedCompleter) and then similarly tries to complete this task's completer, if one exists, else marks this task as complete.
tryConvertToOptimisticRead(long) - Method in class java.util.concurrent.locks.StampedLock
If the lock state matches the given stamp then, atomically, 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, atomically performs one of the following actions.
tryConvertToWriteLock(long) - Method in class java.util.concurrent.locks.StampedLock
If the lock state matches the given stamp, atomically 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() - 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() - 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() - 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 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(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(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(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(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Attempts to set the state to reflect a release in exclusive mode.
tryRelease(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
Attempts to set the state to reflect a release in exclusive mode.
tryReleaseShared(int) - Method in class java.util.concurrent.locks.AbstractQueuedSynchronizer
Attempts to set the state to reflect a release in shared mode.
tryReleaseShared(long) - Method in class java.util.concurrent.locks.AbstractQueuedLongSynchronizer
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) - Method in interface java.util.concurrent.TransferQueue
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, 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.

U

unconfigurableExecutorService(ExecutorService) - Static method in class java.util.concurrent.Executors
Returns an object that delegates all defined ExecutorService methods to the given executor, but not any other methods that might otherwise be accessible using casts.
unconfigurableScheduledExecutorService(ScheduledExecutorService) - Static method in class java.util.concurrent.Executors
Returns an object that delegates all defined ScheduledExecutorService methods to the given executor, but not any other methods that might otherwise be accessible using casts.
unlock() - Method in interface java.util.concurrent.locks.Lock
Releases the lock.
unlock() - Method in class java.util.concurrent.locks.ReentrantLock
Attempts to release this lock.
unlock() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
Attempts to release this lock.
unlock() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
Attempts to release this lock.
unlock(long) - Method in class java.util.concurrent.locks.StampedLock
If the lock state matches the given stamp, releases the corresponding mode of the lock.
unlockRead(long) - Method in class java.util.concurrent.locks.StampedLock
If the lock state matches the given stamp, releases the non-exclusive lock.
unlockWrite(long) - Method in class java.util.concurrent.locks.StampedLock
If the lock state matches the given stamp, releases the exclusive lock.
unpark(Thread) - Static method in class java.util.concurrent.locks.LockSupport
Makes available the permit for the given thread, if it was not already available.
updateAndGet(int, IntUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i with the results of applying the given function, returning the updated value.
updateAndGet(int, LongUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongArray
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i with the results of applying the given function, returning the updated value.
updateAndGet(int, UnaryOperator<E>) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the element at index i with the results of applying the given function, returning the updated value.
updateAndGet(IntUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicInteger
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value with the results of applying the given function, returning the updated value.
updateAndGet(LongUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicLong
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value with the results of applying the given function, returning the updated value.
updateAndGet(UnaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReference
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the current value with the results of applying the given function, returning the updated value.
updateAndGet(T, IntUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicIntegerFieldUpdater
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the field of the given object managed by this updater with the results of applying the given function, returning the updated value.
updateAndGet(T, LongUnaryOperator) - Method in class java.util.concurrent.atomic.AtomicLongFieldUpdater
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the field of the given object managed by this updater with the results of applying the given function, returning the updated value.
updateAndGet(T, UnaryOperator<V>) - Method in class java.util.concurrent.atomic.AtomicReferenceFieldUpdater
Atomically updates (with memory effects as specified by VarHandle.compareAndSet(java.lang.Object...)) the field of the given object managed by this updater with the results of applying the given function, returning the updated value.

V

validate(long) - Method in class java.util.concurrent.locks.StampedLock
Returns true if the lock has not been exclusively acquired since issuance of the given stamp.
valueOf(String) - Static method in enum java.util.concurrent.TimeUnit
Returns the enum constant of this type with the specified name.
values() - Method in class java.util.concurrent.ConcurrentHashMap
Returns a Collection view of the values contained in this map.
values() - Method in class java.util.concurrent.ConcurrentSkipListMap
Returns a Collection view of the values contained in this map.
values() - Static method in enum java.util.concurrent.TimeUnit
Returns an array containing the constants of this enum type, in the order they are declared.
values() - Method in class java.util.HashMap
Returns a Collection view of the values contained in this map.
Vector<E> - Class in java.util
The Vector class implements a growable array of objects.
Vector() - Constructor for class java.util.Vector
Constructs an empty vector so that its internal data array has size 10 and its standard capacity increment is zero.
Vector(int) - Constructor for class java.util.Vector
Constructs an empty vector with the specified initial capacity and with its capacity increment equal to zero.
Vector(int, int) - Constructor for class java.util.Vector
Constructs an empty vector with the specified initial capacity and capacity increment.
Vector(Collection<? extends E>) - Constructor for class java.util.Vector
Constructs a vector containing the elements of the specified collection, in the order they are returned by the collection's iterator.

W

weakCompareAndSet(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Deprecated.
This method has plain memory effects but the method name implies volatile memory effects (see methods such as AtomicBoolean.compareAndExchange(boolean, boolean) and AtomicBoolean.compareAndSet(boolean, boolean)). To avoid confusion over plain or volatile memory effects it is recommended that the method AtomicBoolean.weakCompareAndSetPlain(boolean, boolean) be used instead.
weakCompareAndSet(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Deprecated.
This method has plain memory effects but the method name implies volatile memory effects (see methods such as AtomicInteger.compareAndExchange(int, int) and AtomicInteger.compareAndSet(int, int)). To avoid confusion over plain or volatile memory effects it is recommended that the method AtomicInteger.weakCompareAndSetPlain(int, int) be used instead.
weakCompareAndSet(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Deprecated.
This method has plain memory effects but the method name implies volatile memory effects (see methods such as AtomicIntegerArray.compareAndExchange(int, int, int) and AtomicIntegerArray.compareAndSet(int, int, int)). To avoid confusion over plain or volatile memory effects it is recommended that the method AtomicIntegerArray.weakCompareAndSetPlain(int, int, int) be used instead.
weakCompareAndSet(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Deprecated.
This method has plain memory effects but the method name implies volatile memory effects (see methods such as AtomicLongArray.compareAndExchange(int, long, long) and AtomicLongArray.compareAndSet(int, long, long)). To avoid confusion over plain or volatile memory effects it is recommended that the method AtomicLongArray.weakCompareAndSetPlain(int, long, long) be used instead.
weakCompareAndSet(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Deprecated.
This method has plain memory effects but the method name implies volatile memory effects (see methods such as AtomicReferenceArray.compareAndExchange(int, E, E) and AtomicReferenceArray.compareAndSet(int, E, E)). To avoid confusion over plain or volatile memory effects it is recommended that the method AtomicReferenceArray.weakCompareAndSetPlain(int, E, E) be used instead.
weakCompareAndSet(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Deprecated.
This method has plain memory effects but the method name implies volatile memory effects (see methods such as AtomicLong.compareAndExchange(long, long) and AtomicLong.compareAndSet(long, long)). To avoid confusion over plain or volatile memory effects it is recommended that the method AtomicLong.weakCompareAndSetPlain(long, long) be used instead.
weakCompareAndSet(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.
weakCompareAndSet(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.
weakCompareAndSet(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.
weakCompareAndSet(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
Deprecated.
This method has plain memory effects but the method name implies volatile memory effects (see methods such as AtomicReference.compareAndExchange(V, V) and AtomicReference.compareAndSet(V, V)). To avoid confusion over plain or volatile memory effects it is recommended that the method AtomicReference.weakCompareAndSetPlain(V, V) be used instead.
weakCompareAndSet(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.
weakCompareAndSet(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.
weakCompareAndSetAcquire(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetAcquire(java.lang.Object...).
weakCompareAndSetAcquire(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetAcquire(java.lang.Object...).
weakCompareAndSetAcquire(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetAcquire(java.lang.Object...).
weakCompareAndSetAcquire(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetAcquire(java.lang.Object...).
weakCompareAndSetAcquire(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetAcquire(java.lang.Object...).
weakCompareAndSetAcquire(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetAcquire(java.lang.Object...).
weakCompareAndSetAcquire(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetAcquire(java.lang.Object...).
weakCompareAndSetPlain(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetPlain(java.lang.Object...).
weakCompareAndSetPlain(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetPlain(java.lang.Object...).
weakCompareAndSetPlain(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetPlain(java.lang.Object...).
weakCompareAndSetPlain(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetPlain(java.lang.Object...).
weakCompareAndSetPlain(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetPlain(java.lang.Object...).
weakCompareAndSetPlain(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetPlain(java.lang.Object...).
weakCompareAndSetPlain(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetPlain(java.lang.Object...).
weakCompareAndSetRelease(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetRelease(java.lang.Object...).
weakCompareAndSetRelease(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetRelease(java.lang.Object...).
weakCompareAndSetRelease(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetRelease(java.lang.Object...).
weakCompareAndSetRelease(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetRelease(java.lang.Object...).
weakCompareAndSetRelease(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetRelease(java.lang.Object...).
weakCompareAndSetRelease(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetRelease(java.lang.Object...).
weakCompareAndSetRelease(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSetRelease(java.lang.Object...).
weakCompareAndSetVolatile(boolean, boolean) - Method in class java.util.concurrent.atomic.AtomicBoolean
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSet(java.lang.Object...).
weakCompareAndSetVolatile(int, int) - Method in class java.util.concurrent.atomic.AtomicInteger
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSet(java.lang.Object...).
weakCompareAndSetVolatile(int, int, int) - Method in class java.util.concurrent.atomic.AtomicIntegerArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSet(java.lang.Object...).
weakCompareAndSetVolatile(int, long, long) - Method in class java.util.concurrent.atomic.AtomicLongArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSet(java.lang.Object...).
weakCompareAndSetVolatile(int, E, E) - Method in class java.util.concurrent.atomic.AtomicReferenceArray
Possibly atomically sets the element at index i to newValue if the element's current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSet(java.lang.Object...).
weakCompareAndSetVolatile(long, long) - Method in class java.util.concurrent.atomic.AtomicLong
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSet(java.lang.Object...).
weakCompareAndSetVolatile(V, V) - Method in class java.util.concurrent.atomic.AtomicReference
Possibly atomically sets the value to newValue if the current value == expectedValue, with memory effects as specified by VarHandle.weakCompareAndSet(java.lang.Object...).
whenComplete(BiConsumer<? super T, ? super Throwable>) - Method in class java.util.concurrent.CompletableFuture
 
whenComplete(BiConsumer<? super T, ? super Throwable>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage with the same result or exception as this stage, that executes the given action when this stage completes.
whenCompleteAsync(BiConsumer<? super T, ? super Throwable>) - Method in class java.util.concurrent.CompletableFuture
 
whenCompleteAsync(BiConsumer<? super T, ? super Throwable>) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage with the same result or exception as this stage, that executes the given action using this stage's default asynchronous execution facility when this stage completes.
whenCompleteAsync(BiConsumer<? super T, ? super Throwable>, Executor) - Method in class java.util.concurrent.CompletableFuture
 
whenCompleteAsync(BiConsumer<? super T, ? super Throwable>, Executor) - Method in interface java.util.concurrent.CompletionStage
Returns a new CompletionStage with the same result or exception as this stage, that executes the given action using the supplied Executor when this stage completes.
writeLock() - Method in interface java.util.concurrent.locks.ReadWriteLock
Returns the lock used for writing.
writeLock() - Method in class java.util.concurrent.locks.ReentrantReadWriteLock
 
writeLock() - Method in class java.util.concurrent.locks.StampedLock
Exclusively acquires the lock, blocking if necessary until available.
WriteLock(ReentrantReadWriteLock) - Constructor for class java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock
Constructor for use by subclasses.
writeLockInterruptibly() - Method in class java.util.concurrent.locks.StampedLock
Exclusively acquires the lock, blocking if necessary until available or the current thread is interrupted.
A B C D E F G H I J K L M N O P Q R S T U V W