package

java.util.concurrent

Classes | Description

Utility classes commonly useful in concurrent programming.

Interfaces

BlockingQueue<E>	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<V>	A task that returns a result and may throw an exception.
CompletionService<V>	A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
ConcurrentMap<K, V>	A `Map` providing additional atomic `putIfAbsent`, `remove`, and `replace` methods.
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.
Future<V>	A `Future` represents the result of an asynchronous computation.
RejectedExecutionHandler	A handler for tasks that cannot be executed by a `ThreadPoolExecutor`.
ScheduledExecutorService	An `ExecutorService` that can schedule commands to run after a given delay, or to execute periodically.
ScheduledFuture<V>	A delayed result-bearing action that can be cancelled.
ThreadFactory	An object that creates new threads on demand.

Classes

AbstractExecutorService	Provides default implementations of `ExecutorService` execution methods.
ArrayBlockingQueue<E>	A bounded `blocking queue` backed by an array.
ConcurrentHashMap<K, V>	A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates.
ConcurrentLinkedQueue<E>	An unbounded thread-safe `queue` based on linked nodes.
CopyOnWriteArrayList<E>	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.
CopyOnWriteArraySet<E>	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.
CyclicBarrier	A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
DelayQueue<E extends Delayed>	An unbounded `blocking queue` of `Delayed` elements, in which an element can only be taken when its delay has expired.
Exchanger<V>	A synchronization point at which threads can pair and swap elements within pairs.
ExecutorCompletionService<V>	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.
FutureTask<V>	A cancellable asynchronous computation.
LinkedBlockingQueue<E>	An optionally-bounded `blocking queue` based on linked nodes.
PriorityBlockingQueue<E>	An unbounded `blocking queue` that uses the same ordering rules as class `PriorityQueue` and supplies blocking retrieval operations.
ScheduledThreadPoolExecutor	A `ThreadPoolExecutor` that can additionally schedule commands to run after a given delay, or to execute periodically.
Semaphore	A counting semaphore.
SynchronousQueue<E>	A `blocking queue` in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.
ThreadPoolExecutor	An `ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `Executors` factory methods.
ThreadPoolExecutor.AbortPolicy	A handler for rejected tasks that throws a `RejectedExecutionException`.
ThreadPoolExecutor.CallerRunsPolicy	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	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	A handler for rejected tasks that silently discards the rejected task.

Enums

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

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