java.util.concurrent

Provides default implementations of ExecutorService execution methods.

A bounded BlockingQueue backed by an array.

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.

A hash table supporting full concurrency of retrievals and high expected concurrency for updates.

An unbounded concurrent Deque based on linked nodes.

An unbounded thread-safe Queue based on linked nodes.

A scalable concurrent ConcurrentNavigableMap implementation.

A scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap.

A thread-safe variant of java.util.ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.

A java.util.Set that uses an internal CopyOnWriteArrayList for all of its operations.

A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

A ForkJoinTask with a completion action performed when triggered and there are no remaining pending actions.

A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

An unbounded BlockingQueue of Delayed elements, in which an element can only be taken when its delay has expired.

A synchronization point at which threads can pair and swap elements within pairs.

A CompletionService that uses a supplied Executor to execute tasks.

Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package.

Interrelated interfaces and static methods for establishing flow-controlled components in which Publisher produce items consumed by one or more Subscriber, each managed by a Subscription.

An ExecutorService for running ForkJoinTasks.

Abstract base class for tasks that run within a ForkJoinPool.

A thread managed by a ForkJoinPool, which executes ForkJoinTasks.

A cancellable asynchronous computation.

An optionally-bounded BlockingDeque based on linked nodes.

An optionally-bounded BlockingQueue based on linked nodes.

An unbounded TransferQueue based on linked nodes.

A reusable synchronization barrier, similar in functionality to CyclicBarrier and CountDownLatch but supporting more flexible usage.

An unbounded BlockingQueue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations.

A recursive resultless ForkJoinTask.

A recursive result-bearing ForkJoinTask.

A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.

A counting semaphore.

A BlockingQueue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.

A random number generator isolated to the current thread.

An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured using Executors factory methods.

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.

Exception indicating that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task was cancelled.

Exception thrown when an error or other exception is encountered in the course of completing a result or task.

Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.

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

Exception thrown when a blocking operation times out.

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