Java.Util.Concurrent Namespace

Implementations.

Classes ThreadPoolExecutor and ScheduledThreadPoolExecutor provide tunable, flexible thread pools.

Classes

AbstractExecutorService

Provides default implementations of IExecutorService execution methods.

ArrayBlockingQueue

A bounded IBlockingQueue backed by an array.

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.

CompletableFuture
CompletionException
ConcurrentHashMap

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

ConcurrentLinkedDeque

An unbounded concurrent IDeque based on linked nodes.

ConcurrentLinkedQueue

An unbounded thread-safe IQueue based on linked nodes.

ConcurrentSkipListMap

ConcurrentNavigableMap

CopyOnWriteArrayList

A thread-safe random-access list.

CopyOnWriteArraySet

A ISet 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
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 IBlockingQueue of Delayed elements, in which an element can only be taken when its delay has expired.

Exchanger

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

ExecutionException

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

ExecutorCompletionService

A ICompletionService that uses a supplied IExecutor to execute tasks.

Executors

Factory and utility methods for IExecutor, IExecutorService, IScheduledExecutorService, IThreadFactory, and ICallable classes defined in this package.

ForkJoinPool

An IExecutorService for running ForkJoinTasks.

ForkJoinTask

Abstract base class for tasks that run within a ForkJoinPool.

ForkJoinWorkerThread

A thread managed by a ForkJoinPool, which executes ForkJoinTasks.

FutureTask

A cancellable asynchronous computation.

IBlockingDequeExtensions
IBlockingQueueExtensions
IExecutorServiceExtensions
IFutureExtensions
LinkedBlockingDeque

An optionally-bounded IBlockingDeque based on linked nodes.

LinkedBlockingQueue

An optionally-bounded IBlockingQueue based on linked nodes.

LinkedTransferQueue

An unbounded ITransferQueue based on linked nodes.

Phaser

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

PriorityBlockingQueue

An unbounded IBlockingQueue 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.

RejectedExecutionException

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

ScheduledThreadPoolExecutor

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

Semaphore

A counting semaphore.

SynchronousQueue

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

ThreadLocalRandom

A random number generator isolated to the current thread.

ThreadPoolExecutor

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

TimeoutException

Exception thrown when a blocking operation times out.

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.

Interfaces

CompletableFuture.IAsynchronousCompletionTask
ForkJoinPool.IForkJoinWorkerThreadFactory
ForkJoinPool.IManagedBlocker
IBlockingDeque

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

IBlockingQueue

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

ICallable

A task that returns a result and may throw an exception.

ICompletionService

A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.

ICompletionStage
IConcurrentMap

A IMap providing additional atomic putIfAbsent, remove, and replace methods.

IDelayed

A mix-in style interface for marking objects that should be acted upon after a given delay.

IExecutor

An object that executes submitted IRunnable tasks.

IExecutorService

An IExecutor that provides methods to manage termination and methods that can produce a IFuture for tracking progress of one or more asynchronous tasks.

IFuture

A Future represents the result of an asynchronous computation.

IRejectedExecutionHandler

A handler for tasks that cannot be executed by a ThreadPoolExecutor.

IRunnableFuture

A IFuture that is IRunnable.

IRunnableScheduledFuture

A IScheduledFuture that is IRunnable.

IScheduledExecutorService

An IExecutorService that can schedule commands to run after a given delay, or to execute periodically.

IScheduledFuture

A delayed result-bearing action that can be cancelled.

IThreadFactory

An object that creates new threads on demand.

ITransferQueue

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