Index

A B C D E F G H I J K L M N O P Q R S T U V W
All Classes and Interfaces|All Packages|Serialized Form|System Properties

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

Constructor for subclasses to call.

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.

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

Constructor for subclasses to call.

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.

adaptInterruptible(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.concurrent.CopyOnWriteArrayList

Inserts the specified element at the specified position in this list.

add(long) - Method in class java.util.concurrent.atomic.LongAdder

Adds the given value.

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(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.concurrent.CopyOnWriteArrayList

Inserts all of the elements in the specified collection into this list, starting at the specified position.

addAll(Collection<? extends E>) - Method in class java.util.concurrent.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 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.

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

addIfAbsent(E) - Method in class java.util.concurrent.CopyOnWriteArrayList

Appends the element, if not present.

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

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.

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 StampedLock.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 StampedLock.asReadLock(), and ReadWriteLock.writeLock() to StampedLock.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 StampedLock.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 Class 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 class java.util.concurrent.BrokenBarrierException

Constructs a BrokenBarrierException with no specified detail message.

BrokenBarrierException(String) - Constructor for exception class 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 Class 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 class java.util.concurrent.CancellationException

Constructs a CancellationException with no detail message.

CancellationException(String) - Constructor for exception class java.util.concurrent.CancellationException

Constructs a CancellationException with the specified detail message.

CANCELLED - Enum constant in enum class java.util.concurrent.Future.State

The task was cancelled.

ceiling(E) - Method in class java.util.concurrent.ConcurrentSkipListSet

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.

ceilingKey(K) - Method in class java.util.concurrent.ConcurrentSkipListMap

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.ConcurrentHashMap.KeySetView

Removes all of the elements from this view, by removing all the mappings from the map backing this view.

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.

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.

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.

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 Class 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 class java.util.concurrent.CompletionException

Constructs a CompletionException with no detail message.

CompletionException(String) - Constructor for exception class java.util.concurrent.CompletionException

Constructs a CompletionException with the specified detail message.

CompletionException(String, Throwable) - Constructor for exception class java.util.concurrent.CompletionException

Constructs a CompletionException with the specified detail message and cause.

CompletionException(Throwable) - Constructor for exception class 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).

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.

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.

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), initial 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.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.

containsAll(Collection<?>) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView

containsAll(Collection<?>) - Method in class java.util.concurrent.CopyOnWriteArrayList

Returns true if this list contains all of the elements of the specified collection.

containsAll(Collection<?>) - Method in class java.util.concurrent.CopyOnWriteArraySet

Returns true if this set contains all of the elements of the specified collection.

containsAll(Collection<?>) - Method in class java.util.concurrent.SynchronousQueue

Returns false unless the given collection is empty.

containsKey(Object) - Method in class java.util.concurrent.ConcurrentHashMap

Tests if the specified object is a key in this table.

containsKey(Object) - Method in class java.util.concurrent.ConcurrentSkipListMap

Returns true if this map contains a mapping for the specified key.

containsValue(Object) - Method in class java.util.concurrent.ConcurrentHashMap

Returns true if this map maps one or more keys to the specified value.

containsValue(Object) - Method in class java.util.concurrent.ConcurrentSkipListMap

Returns true if this map maps one or more keys to the specified value.

convert(long, TimeUnit) - Method in enum class java.util.concurrent.TimeUnit

Converts the given time duration in the given unit to this unit.

convert(Duration) - Method in enum class java.util.concurrent.TimeUnit

Converts the given time duration 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.

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 object.

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 - Enum constant in enum class 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.

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.

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

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

descendingSet() - Method in class java.util.concurrent.ConcurrentSkipListSet

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

doubles(double, double) - Method in class java.util.concurrent.ThreadLocalRandom

doubles(long) - Method in class java.util.concurrent.ThreadLocalRandom

doubles(long, double, double) - Method in class java.util.concurrent.ThreadLocalRandom

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

Equivalent to DoubleAccumulator.get().

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 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.

elements() - Method in class java.util.concurrent.ConcurrentHashMap

Returns an enumeration of the values in this table.

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.

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.

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

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.

exceptionallyAsync(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, using this stage's default asynchronous execution facility.

exceptionallyAsync(Function<Throwable, ? extends T>, Executor) - 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, using the supplied Executor.

exceptionallyCompose(Function<Throwable, ? extends CompletionStage<T>>) - Method in interface java.util.concurrent.CompletionStage

Returns a new CompletionStage that, when this stage completes exceptionally, is composed using the results of the supplied function applied to this stage's exception.

exceptionallyComposeAsync(Function<Throwable, ? extends CompletionStage<T>>) - Method in interface java.util.concurrent.CompletionStage

Returns a new CompletionStage that, when this stage completes exceptionally, is composed using the results of the supplied function applied to this stage's exception, using this stage's default asynchronous execution facility.

exceptionallyComposeAsync(Function<Throwable, ? extends CompletionStage<T>>, Executor) - Method in interface java.util.concurrent.CompletionStage

Returns a new CompletionStage that, when this stage completes exceptionally, is composed using the results of the supplied function applied to this stage's exception, using the supplied Executor.

exceptionNow() - Method in interface java.util.concurrent.Future

Returns the exception thrown by the task, without waiting.

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.

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 Class 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 class java.util.concurrent.ExecutionException

Constructs an ExecutionException with no detail message.

ExecutionException(String) - Constructor for exception class java.util.concurrent.ExecutionException

Constructs an ExecutionException with the specified detail message.

ExecutionException(String, Throwable) - Constructor for exception class java.util.concurrent.ExecutionException

Constructs an ExecutionException with the specified detail message and cause.

ExecutionException(Throwable) - Constructor for exception class 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

FAILED - Enum constant in enum class java.util.concurrent.Future.State

The task completed with an exception.

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.

finalize() - Method in class java.util.concurrent.ThreadPoolExecutor

Deprecated, for removal: This API element is subject to removal in a future version.

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.

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.

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

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.

floorKey(K) - Method in class java.util.concurrent.ConcurrentSkipListMap

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 interface java.util.concurrent.ConcurrentMap

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.concurrent.PriorityBlockingQueue

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

Creates a ForkJoinPool with parallelism equal to Runtime.availableProcessors(), using defaults for all other parameters (see ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).

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

Constructor for subclasses to call.

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.

Future.State - Enum Class in java.util.concurrent

Represents the computation state.

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.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.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(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.concurrent.ConcurrentLinkedDeque

getFirst() - Method in class java.util.concurrent.LinkedBlockingDeque

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.concurrent.ConcurrentLinkedDeque

getLast() - Method in class java.util.concurrent.LinkedBlockingDeque

getMap() - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView

Returns the map backing this view.

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.

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 completed tasks that were executed by a thread other than their submitter.

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.

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, boolean) - Method in interface java.util.concurrent.ConcurrentNavigableMap

headMap(K, boolean) - Method in class java.util.concurrent.ConcurrentSkipListMap

headSet(E) - Method in class java.util.concurrent.ConcurrentSkipListSet

headSet(E, boolean) - Method in class java.util.concurrent.ConcurrentSkipListSet

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

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.

higherKey(K) - Method in class java.util.concurrent.ConcurrentSkipListMap

HOURS - Enum constant in enum class 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.concurrent.CopyOnWriteArrayList

inForkJoinPool() - Static method in class java.util.concurrent.ForkJoinTask

Returns true if the current thread is a ForkJoinWorkerThread executing as a ForkJoinPool computation.

ints() - Method in class java.util.concurrent.ThreadLocalRandom

ints(int, int) - Method in class java.util.concurrent.ThreadLocalRandom

ints(long) - Method in class java.util.concurrent.ThreadLocalRandom

ints(long, int, int) - Method in class java.util.concurrent.ThreadLocalRandom

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.concurrent.ConcurrentHashMap.KeySetView

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.

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.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.

J

java.base - module java.base

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.ForkJoinPool.common.exceptionHandler - Search tag in class java.util.concurrent.ForkJoinPool

System Property

java.util.concurrent.ForkJoinPool.common.maximumSpares - Search tag in class java.util.concurrent.ForkJoinPool

System Property

java.util.concurrent.ForkJoinPool.common.parallelism - Search tag in class java.util.concurrent.ForkJoinPool

System Property

java.util.concurrent.ForkJoinPool.common.parallelism - Search tag in java.util.concurrent.ForkJoinPool.setParallelism(int)

System Property

java.util.concurrent.ForkJoinPool.common.threadFactory - Search tag in class java.util.concurrent.ForkJoinPool

System Property

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(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

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.

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.concurrent.CopyOnWriteArrayList

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...).

lazySubmit(ForkJoinTask<T>) - Method in class java.util.concurrent.ForkJoinPool

Submits the given task without guaranteeing that it will eventually execute in the absence of available active threads.

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.concurrent.CopyOnWriteArrayList

listIterator(int) - Method in class java.util.concurrent.CopyOnWriteArrayList

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

longs(long) - Method in class java.util.concurrent.ThreadLocalRandom

longs(long, long) - Method in class java.util.concurrent.ThreadLocalRandom

longs(long, long, long) - Method in class java.util.concurrent.ThreadLocalRandom

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

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.

lowerKey(K) - Method in class java.util.concurrent.ConcurrentSkipListMap

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.

MICROSECONDS - Enum constant in enum class java.util.concurrent.TimeUnit

Time unit representing one thousandth of a millisecond.

MILLISECONDS - Enum constant in enum class 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 - Enum constant in enum class java.util.concurrent.TimeUnit

Time unit representing sixty seconds.

N

NANOSECONDS - Enum constant in enum class 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

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(Callable<T>) - Method in class java.util.concurrent.AbstractExecutorService

Returns a RunnableFuture for the given callable task.

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.

nextComplete() - Method in class java.util.concurrent.CountedCompleter

If this task does not have a completer, invokes ForkJoinTask.quietlyComplete() and returns null.

nextDouble(double) - Method in class java.util.concurrent.ThreadLocalRandom

nextDouble(double, double) - Method in class java.util.concurrent.ThreadLocalRandom

nextFloat(float) - Method in class java.util.concurrent.ThreadLocalRandom

nextFloat(float, float) - Method in class java.util.concurrent.ThreadLocalRandom

nextInt(int) - Method in class java.util.concurrent.ThreadLocalRandom

nextInt(int, int) - Method in class java.util.concurrent.ThreadLocalRandom

nextLong(long) - Method in class java.util.concurrent.ThreadLocalRandom

nextLong(long, long) - Method in class java.util.concurrent.ThreadLocalRandom

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 class java.util.concurrent.TimeUnit

Converts a ChronoUnit to the equivalent TimeUnit.

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, 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 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, 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 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, 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.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.

peekFirst() - Method in class java.util.concurrent.ConcurrentLinkedDeque

peekFirst() - Method in class java.util.concurrent.LinkedBlockingDeque

peekLast() - Method in class java.util.concurrent.ConcurrentLinkedDeque

peekLast() - Method in class java.util.concurrent.LinkedBlockingDeque

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.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(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.concurrent.ConcurrentLinkedDeque

pollFirst() - Method in class java.util.concurrent.ConcurrentSkipListSet

pollFirst() - Method in class java.util.concurrent.LinkedBlockingDeque

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.

pollLast() - Method in class java.util.concurrent.ConcurrentLinkedDeque

pollLast() - Method in class java.util.concurrent.ConcurrentSkipListSet

pollLast() - Method in class java.util.concurrent.LinkedBlockingDeque

pollLast(long, TimeUnit) - Method in 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.

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.concurrent.ConcurrentLinkedDeque

pop() - Method in class java.util.concurrent.LinkedBlockingDeque

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.

privilegedCallable(Callable<T>) - Static method in class java.util.concurrent.Executors

Deprecated, for removal: This API element is subject to removal in a future version.

This method is only useful in conjunction with the Security Manager, which is deprecated and subject to removal in a future release. Consequently, this method is also deprecated and subject to removal. There is no replacement for the Security Manager or this method.

privilegedCallableUsingCurrentClassLoader(Callable<T>) - Static method in class java.util.concurrent.Executors

Deprecated, for removal: This API element is subject to removal in a future version.

This method is only useful in conjunction with the Security Manager, which is deprecated and subject to removal in a future release. Consequently, this method is also deprecated and subject to removal. There is no replacement for the Security Manager or this method.

privilegedThreadFactory() - Static method in class java.util.concurrent.Executors

Deprecated, for removal: This API element is subject to removal in a future version.

This method is only useful in conjunction with the Security Manager, which is deprecated and subject to removal in a future release. Consequently, this method is also deprecated and subject to removal. There is no replacement for the Security Manager or this method.

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 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

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.

putAll(Map<? extends K, ? extends V>) - Method in class java.util.concurrent.ConcurrentHashMap

Copies all of the mappings from the specified map to this one.

putFirst(E) - Method in interface java.util.concurrent.BlockingDeque

Inserts the specified element at the front of this deque, waiting if necessary for space to become available.

putFirst(E) - Method in class java.util.concurrent.LinkedBlockingDeque

putIfAbsent(K, V) - Method in class java.util.concurrent.ConcurrentHashMap

If the specified key is not already associated with a value, 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.

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

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.

quietlyJoin(long, TimeUnit) - Method in class java.util.concurrent.ForkJoinTask

Tries to join this task, returning true if it completed (possibly exceptionally) before the given timeout and/or the the current thread has been interrupted, else false.

quietlyJoinUninterruptibly(long, TimeUnit) - Method in class java.util.concurrent.ForkJoinTask

Tries to join this task, returning true if it completed (possibly exceptionally) before the given timeout.

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

Constructor for subclasses to call.

RecursiveTask<V> - Class in java.util.concurrent

A recursive result-bearing ForkJoinTask.

RecursiveTask() - Constructor for class java.util.concurrent.RecursiveTask

Constructor for subclasses to call.

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 Class in java.util.concurrent

Exception thrown by an Executor when a task cannot be accepted for execution.

RejectedExecutionException() - Constructor for exception class java.util.concurrent.RejectedExecutionException

Constructs a RejectedExecutionException with no detail message.

RejectedExecutionException(String) - Constructor for exception class java.util.concurrent.RejectedExecutionException

Constructs a RejectedExecutionException with the specified detail message.

RejectedExecutionException(String, Throwable) - Constructor for exception class java.util.concurrent.RejectedExecutionException

Constructs a RejectedExecutionException with the specified detail message and cause.

RejectedExecutionException(Throwable) - Constructor for exception class 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 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(int) - Method in class java.util.concurrent.CopyOnWriteArrayList

Removes the element at the specified position in this list.

remove(Object) - Method in class java.util.concurrent.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, 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(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.concurrent.ArrayBlockingQueue

removeAll(Collection<?>) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView

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.PriorityBlockingQueue

removeAll(Collection<?>) - Method in class java.util.concurrent.SynchronousQueue

Always returns false.

removeFirst() - Method in class java.util.concurrent.ConcurrentLinkedDeque

removeFirst() - Method in class java.util.concurrent.LinkedBlockingDeque

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

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.concurrent.PriorityBlockingQueue

removeLast() - Method in class java.util.concurrent.ConcurrentLinkedDeque

removeLast() - Method in class java.util.concurrent.LinkedBlockingDeque

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

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, 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.

replaceAll(BiFunction<? super K, ? super V, ? extends V>) - Method in interface java.util.concurrent.ConcurrentMap

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.

resultNow() - Method in interface java.util.concurrent.Future

Returns the computed result, without waiting.

retainAll(Collection<?>) - Method in class java.util.concurrent.ArrayBlockingQueue

retainAll(Collection<?>) - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView

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.PriorityBlockingQueue

retainAll(Collection<?>) - Method in class java.util.concurrent.SynchronousQueue

Always returns false.

run() - Method in class java.util.concurrent.ForkJoinWorkerThread

This method is required to be public, but should never be called explicitly.

run() - Method in class java.util.concurrent.FutureTask

run() - Method in interface java.util.concurrent.RunnableFuture

Sets this Future to the result of its computation unless it has been cancelled.

runAfterBoth(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

A ScheduledFuture that is Runnable.

RUNNING - Enum constant in enum class java.util.concurrent.Future.State

The task has not completed.

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 - Enum constant in enum class 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.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(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.

setCurrentBlocker(Object) - Static method in class java.util.concurrent.locks.LockSupport

Sets the object to be returned by invocations of getBlocker for the current thread.

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...).

setParallelism(int) - Method in class java.util.concurrent.ForkJoinPool

Changes the target parallelism of this pool, controlling the future creation, use, and termination of worker threads.

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.

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.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.KeySetView

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.

sleep(long) - Method in enum class java.util.concurrent.TimeUnit

Performs a Thread.sleep using this time unit.

spliterator() - Method in class java.util.concurrent.ArrayBlockingQueue

Returns a Spliterator over the elements in this queue.

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.

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.

state() - Method in interface java.util.concurrent.Future

Returns the computation state.

subList(int, int) - Method in class java.util.concurrent.CopyOnWriteArrayList

Returns a view of the portion of this list between fromIndex, inclusive, and toIndex, exclusive.

subMap(K, boolean, K, boolean) - Method in interface java.util.concurrent.ConcurrentNavigableMap

subMap(K, boolean, K, boolean) - Method in class java.util.concurrent.ConcurrentSkipListMap

subMap(K, K) - Method in interface java.util.concurrent.ConcurrentNavigableMap

subMap(K, K) - Method in class java.util.concurrent.ConcurrentSkipListMap

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, E) - Method in class java.util.concurrent.ConcurrentSkipListSet

SUCCESS - Enum constant in enum class java.util.concurrent.Future.State

The task completed with a result.

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, boolean) - Method in interface java.util.concurrent.ConcurrentNavigableMap

tailMap(K, boolean) - Method in class java.util.concurrent.ConcurrentSkipListMap

tailSet(E) - Method in class java.util.concurrent.ConcurrentSkipListSet

tailSet(E, boolean) - Method in class java.util.concurrent.ConcurrentSkipListSet

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 (with period 2⁶⁴) 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 the 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 the 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 class java.util.concurrent.TimeUnit

Performs a timed Thread.join using this time unit.

timedWait(Object, long) - Method in enum class java.util.concurrent.TimeUnit

Performs a timed Object.wait using this time unit.

TimeoutException - Exception Class in java.util.concurrent

Exception thrown when a blocking operation times out.

TimeoutException() - Constructor for exception class java.util.concurrent.TimeoutException

Constructs a TimeoutException with no specified detail message.

TimeoutException(String) - Constructor for exception class java.util.concurrent.TimeoutException

Constructs a TimeoutException with the specified detail message.

TimeUnit - Enum Class 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.concurrent.ArrayBlockingQueue

Returns an array containing all of the elements in this queue, in proper sequence.

toArray() - Method in class java.util.concurrent.ConcurrentHashMap.KeySetView

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(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.ConcurrentHashMap.KeySetView

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.

toChronoUnit() - Method in enum class 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 class java.util.concurrent.TimeUnit

Equivalent to DAYS.convert(duration, this).

toHours(long) - Method in enum class java.util.concurrent.TimeUnit

Equivalent to HOURS.convert(duration, this).

toMicros(long) - Method in enum class java.util.concurrent.TimeUnit

Equivalent to MICROSECONDS.convert(duration, this).

toMillis(long) - Method in enum class java.util.concurrent.TimeUnit

Equivalent to MILLISECONDS.convert(duration, this).

toMinutes(long) - Method in enum class java.util.concurrent.TimeUnit

Equivalent to MINUTES.convert(duration, this).

toNanos(long) - Method in enum class java.util.concurrent.TimeUnit

Equivalent to NANOSECONDS.convert(duration, this).

toSeconds(long) - Method in enum class java.util.concurrent.TimeUnit

Equivalent to SECONDS.convert(duration, this).

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.KeySetView

Returns a string representation of this collection.

toString() - Method in class java.util.concurrent.ConcurrentHashMap

Returns a string representation of this map.

toString() - Method in class java.util.concurrent.CopyOnWriteArrayList

Returns a string representation of this list.

toString() - Method in class java.util.concurrent.CountDownLatch

Returns a string identifying this latch, as well as its state.

toString() - Method in class java.util.concurrent.ForkJoinPool

Returns a string identifying this pool, as well as its state, including indications of run state, parallelism level, and worker and task counts.

toString() - Method in class java.util.concurrent.FutureTask

Returns a string representation of this FutureTask.

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.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.

transfer(E) - Method in class java.util.concurrent.LinkedTransferQueue

Transfers the element to a consumer, waiting if necessary to do so.

transfer(E) - Method in interface java.util.concurrent.TransferQueue

Transfers the element to a consumer, waiting if necessary to do so.

TransferQueue<E> - Interface in java.util.concurrent

A BlockingQueue in which producers may wait for consumers to receive elements.

tryAcquire() - 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 class java.util.concurrent.Future.State

Returns the enum constant of this class with the specified name.

valueOf(String) - Static method in enum class java.util.concurrent.TimeUnit

Returns the enum constant of this class 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 class java.util.concurrent.Future.State

Returns an array containing the constants of this enum class, in the order they are declared.

values() - Static method in enum class java.util.concurrent.TimeUnit

Returns an array containing the constants of this enum class, in the order they are declared.

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
All Classes and Interfaces|All Packages|Serialized Form|System Properties