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
||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.
Map providing additional atomic
putIfAbsent, remove, and replace methods.
||A mix-in style interface for marking objects that should be
acted upon after a given delay.
||An object that executes submitted
Executor that provides methods to manage termination and
methods that can produce a
Future for tracking progress of
one or more asynchronous tasks.
||A Future represents the result of an asynchronous
||A handler for tasks that cannot be executed by a
ExecutorService 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.
||Provides default implementation of
||A bounded blocking queue backed by an
||A hash table supporting full concurrency of retrievals and
adjustable expected concurrency for updates.
||An unbounded thread-safe queue based on linked nodes.
||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.
Set that uses
CopyOnWriteArrayList for all of its
||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.
|DelayQueue<E extends Delayed>
||An unbounded blocking queue of
Delayed elements, in which an element can only be taken
when its delay has expired.
||A synchronization point at which two threads can exchange objects.
CompletionService that uses a supplied
to execute tasks.
||Factory and utility methods for
ThreadFactory , and
Callable classes defined in this
||A cancellable asynchronous computation.
||An optionally-bounded blocking queue based on
||An unbounded blocking queue that uses
the same ordering rules as class
PriorityQueue and supplies
blocking retrieval operations.
ThreadPoolExecutor that can additionally schedule
commands to run after a given delay, or to execute
||A counting semaphore.
||A blocking queue in which each
put must wait for a take, and vice versa.
ExecutorService that executes each submitted task using
one of possibly several pooled threads, normally configured
Executors factory methods.
||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 execute method,
unless the executor has been shut down, in which case the task
||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.
||A handler for rejected tasks that silently discards the