Class Summary | |
---|---|
AbstractCollection | Overrides toArray() and toArray(Object[]) in AbstractCollection to provide implementations valid for concurrent collections. |
AbstractExecutorService | Provides default implementations of ExecutorService execution methods. |
AbstractList | Overrides toArray() and toArray(Object[]) in AbstractCollection to provide implementations valid for concurrent lists. |
AbstractMap | Convenience base class for map implementations that provides helper classes representing simple map entries, both mutable and immutable. |
AbstractMap.SimpleEntry | An Entry maintaining a key and a value. |
AbstractMap.SimpleImmutableEntry | An Entry maintaining an immutable key and value, This class does not support method setValue. |
AbstractQueue | This class provides skeletal implementations of some Queue operations. |
AbstractSequentialList | Overrides toArray() and toArray(Object[]) in AbstractCollection to provide implementations valid for concurrent lists. |
AbstractSet | Overrides toArray() and toArray(Object[]) in AbstractCollection to provide implementations valid for concurrent sets. |
ArrayBlockingQueue | A bounded blocking queue backed by an array. |
ArrayDeque | Resizable-array implementation of the Deque interface. |
Arrays | |
AtomicBoolean | A {@code boolean} value that may be updated atomically. |
AtomicInteger | An {@code int} value that may be updated atomically. |
AtomicIntegerArray | An {@code int} array in which elements may be updated atomically. |
AtomicLong | A {@code long} value that may be updated atomically. |
AtomicLongArray | A {@code long} array in which elements may be updated atomically. |
AtomicMarkableReference | An {@code AtomicMarkableReference} maintains an object reference along with a mark bit, that can be updated atomically. |
AtomicReference | An object reference that may be updated atomically. |
AtomicReferenceArray | An array of object references in which elements may be updated atomically. |
AtomicStampedReference | An {@code AtomicStampedReference} maintains an object reference along with an integer "stamp", that can be updated atomically. |
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. |
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. |
Callable | A task that returns a result and may throw an exception. |
CancellationException | Exception indicating that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task was cancelled. |
Collections | Augments java.util.Collections with methods added in Java 5.0 and higher. |
CompletionService | A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks. |
ConcurrentHashMap | A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates. |
ConcurrentLinkedQueue | An unbounded thread-safe queue based on linked nodes. |
ConcurrentMap | A java.util.Map providing additional atomic putIfAbsent, remove, and replace methods. |
ConcurrentNavigableMap | A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps. |
ConcurrentSkipListMap | A scalable concurrent ConcurrentNavigableMap implementation. |
ConcurrentSkipListSet | A scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap. |
Condition |
{@code Condition} factors out the {@code Object} monitor
methods (Object#wait() wait , Object#notify notify
and Object#notifyAll notifyAll ) into distinct objects to
give the effect of having multiple wait-sets per object, by
combining them with the use of arbitrary Lock implementations.
|
CopyOnWriteArrayList | |
CopyOnWriteArraySet | A java.util.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. |
Delayed | A mix-in style interface for marking objects that should be acted upon after a given delay. |
DelayQueue | An unbounded blocking queue of Delayed elements, in which an element can only be taken when its delay has expired. |
Deque | A linear collection that supports element insertion and removal at both ends. |
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. |
Executor | An object that executes submitted Runnable tasks. |
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. |
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. |
FIFOWaitQueue | Simple linked list queue used in FIFOSemaphore. |
Future | A Future represents the result of an asynchronous computation. |
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. |
LinkedList | |
Lock | {@code Lock} implementations provide more extensive locking operations than can be obtained using {@code synchronized} methods and statements. |
NanoTimer | Interface to specify custom implementation of precise timer. |
NavigableMap | A java.util.SortedMap extended with navigation methods returning the closest matches for given search targets. |
NavigableSet | A java.util.SortedSet extended with navigation methods reporting closest matches for given search targets. |
PriorityBlockingQueue | An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations. |
PriorityQueue | An unbounded queue that supports element retrieval in the order of relative priority. |
Queue | A collection designed for holding elements prior to processing. |
ReadWriteLock |
A ReadWriteLock maintains a pair of associated locks , one for read-only operations and one for writing.
|
ReentrantLock | A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using {@code synchronized} methods and statements, but with extended capabilities. |
ReentrantReadWriteLock | An implementation of ReadWriteLock supporting similar semantics to ReentrantLock. |
ReentrantReadWriteLock.ReadLock | The lock returned by method ReentrantReadWriteLock. |
ReentrantReadWriteLock.WriteLock | The lock returned by method ReentrantReadWriteLock. |
RejectedExecutionException | Exception thrown by an Executor when a task cannot be accepted for execution. |
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. |
ScheduledThreadPoolExecutor | A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically. |
Semaphore | A counting semaphore. |
SynchronousQueue | A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa. |
ThreadFactory | An object that creates new threads on demand. |
ThreadHelpers | Emulation of some new functionality present in java.lang.Thread in J2SE 5.0. |
ThreadHelpers.UncaughtExceptionHandler | Abstraction of the exception handler which receives notifications of exceptions occurred possibly in various parts of the system. |
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 {@code RejectedExecutionException}. |
ThreadPoolExecutor.CallerRunsPolicy | A handler for rejected tasks that runs the rejected task directly in the calling thread of the {@code 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 {@code 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. |
TreeMap | Sorted map implementation based on a red-black tree and implementing all the methods from the NavigableMap interface. |
TreeMap.Entry | |
TreeSet | |
Utils |
This class groups together the functionality of java.util.concurrent that cannot be fully and reliably implemented in backport, but for which some form of emulation is possible. |
WaitQueue | Base class for internal queue classes for semaphores, etc. |
WaitQueue.QueuedSync | |
WaitQueue.WaitNode |