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