Provides default implementations of IExecutorService execution methods.
A bounded IBlockingQueue backed by an array.
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.
A hash table supporting full concurrency of retrievals and high expected concurrency for updates.
An unbounded concurrent IDeque based on linked nodes.
An unbounded thread-safe IQueue based on linked nodes.
A thread-safe random-access list.
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
An unbounded IBlockingQueue of
A synchronization point at which threads can pair and swap elements within pairs.
Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
Abstract base class for tasks that run within a ForkJoinPool.
A cancellable asynchronous computation.
An optionally-bounded IBlockingDeque based on linked nodes.
An optionally-bounded IBlockingQueue based on linked nodes.
An unbounded ITransferQueue based on linked nodes.
A recursive resultless ForkJoinTask.
A recursive result-bearing ForkJoinTask.
Exception thrown by an IExecutor when a task cannot be accepted for execution.
A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.
A counting semaphore.
A IBlockingQueue 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.
A handler for rejected tasks that throws a
A handler for rejected tasks that runs the rejected task
directly in the calling thread of the
A handler for rejected tasks that discards the oldest unhandled
request and then retries
A handler for rejected tasks that silently discards the rejected task.
Exception thrown when a blocking operation times out.
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.
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.
A task that returns a result and may throw an exception.
A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
A IMap providing additional atomic
A mix-in style interface for marking objects that should be acted upon after a given delay.
An object that executes submitted IRunnable tasks.
A handler for tasks that cannot be executed by a ThreadPoolExecutor.
An IExecutorService that can schedule commands to run after a given delay, or to execute periodically.
A delayed result-bearing action that can be cancelled.
An object that creates new threads on demand.
A IBlockingQueue in which producers may wait for consumers to receive elements.