java.util.concurrent

Interfaces

BlockingDeque	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	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.
Callable	A task that returns a result and may throw an exception.
AsynchronousCompletionTask	A marker interface identifying asynchronous tasks produced by `async` methods.
CompletionService	A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
CompletionStage	A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.
ConcurrentMap	A `Map` providing thread safety and atomicity guarantees.
ConcurrentNavigableMap	A `ConcurrentMap` supporting `NavigableMap` operations, and recursively so for its navigable sub-maps.
Delayed	A mix-in style interface for marking objects that should be acted upon after a given delay.
Executor	An object that executes submitted `Runnable` tasks.
ExecutorService	An `Executor` that provides methods to manage termination and methods that can produce a `Future` for tracking progress of one or more asynchronous tasks.
Processor	A component that acts as both a Subscriber and Publisher.
Publisher	A producer of items (and related control messages) received by Subscribers.
Subscriber	A receiver of messages.
Subscription	Message control linking a `Publisher` and `Subscriber`.
ForkJoinWorkerThreadFactory	Factory for creating new `ForkJoinWorkerThread`s.
ManagedBlocker	Interface for extending managed parallelism for tasks running in `ForkJoinPool`s.
Future	A represents the result of an asynchronous computation.
RejectedExecutionHandler	A handler for tasks that cannot be executed by a `ThreadPoolExecutor`.
RunnableFuture	A `Future` that is `Runnable`.
RunnableScheduledFuture	A `ScheduledFuture` that is `Runnable`.
ScheduledExecutorService	An `ExecutorService` that can schedule commands to run after a given delay, or to execute periodically.
ScheduledFuture	A delayed result-bearing action that can be cancelled.
ThreadFactory	An object that creates new threads on demand.
TransferQueue	A `BlockingQueue` in which producers may wait for consumers to receive elements.

Classes

AbstractExecutorService	Provides default implementations of `ExecutorService` execution methods.
ArrayBlockingQueue	A bounded blocking queue backed by an array.
CompletableFuture	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.
ConcurrentHashMap	A hash table supporting full concurrency of retrievals and high expected concurrency for updates.
ConcurrentLinkedDeque	An unbounded concurrent deque based on linked nodes.
ConcurrentLinkedQueue	An unbounded thread-safe queue based on linked nodes.
ConcurrentSkipListMap	A scalable concurrent `ConcurrentNavigableMap` implementation.
ConcurrentSkipListSet	A scalable concurrent `NavigableSet` implementation based on a `ConcurrentSkipListMap`.
CopyOnWriteArrayList	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.
CopyOnWriteArraySet	A `Set` that uses an internal `CopyOnWriteArrayList` for all of its operations.
CountDownLatch	A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
CountedCompleter	A `ForkJoinTask` with a completion action performed when triggered and there are no remaining pending actions.
CyclicBarrier	A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
DelayQueue	An unbounded blocking queue of `Delayed` elements, in which an element generally becomes eligible for removal when its delay has expired.
Exchanger	A synchronization point at which threads can pair and swap elements within pairs.
ExecutorCompletionService	A `CompletionService` that uses a supplied `Executor` to execute tasks.
Executors	Factory and utility methods for `Executor`, `ExecutorService`, `ScheduledExecutorService`, `ThreadFactory`, and `Callable` classes defined in this package.
Flow	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`.
ForkJoinPool	An `ExecutorService` for running `ForkJoinTask`s.
ForkJoinTask	Abstract base class for tasks that run within a `ForkJoinPool`.
ForkJoinWorkerThread	A thread managed by a `ForkJoinPool`, which executes `ForkJoinTask`s.
FutureTask	A cancellable asynchronous computation.
LinkedBlockingDeque	An optionally-bounded blocking deque based on linked nodes.
LinkedBlockingQueue	An optionally-bounded blocking queue based on linked nodes.
LinkedTransferQueue	An unbounded `TransferQueue` based on linked nodes.
Phaser	A reusable synchronization barrier, similar in functionality to `CyclicBarrier` and `CountDownLatch` but supporting more flexible usage.
PriorityBlockingQueue	An unbounded blocking queue that uses the same ordering rules as class `PriorityQueue` and supplies blocking retrieval operations.
RecursiveAction	A recursive resultless `ForkJoinTask`.
RecursiveTask	A recursive result-bearing `ForkJoinTask`.
ScheduledThreadPoolExecutor	A `ThreadPoolExecutor` that can additionally schedule commands to run after a given delay, or to execute periodically.
Semaphore	A counting semaphore.
SubmissionPublisher	A `Flow.Publisher` that asynchronously issues submitted (non-null) items to current subscribers until it is closed.
SynchronousQueue	A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.
ThreadLocalRandom	A random number generator (with period 264) isolated to the current thread.
ThreadPoolExecutor	An `ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `Executors` factory methods.

Exceptions

BrokenBarrierException	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.
CancellationException	Exception indicating that the result of a value-producing task, such as a `FutureTask`, cannot be retrieved because the task was cancelled.
CompletionException	Exception thrown when an error or other exception is encountered in the course of completing a result or task.
ExecutionException	Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
RejectedExecutionException	Exception thrown by an `Executor` when a task cannot be accepted for execution.
TimeoutException	Exception thrown when a blocking operation times out.

Enums

TimeUnit

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.