All Classes

Class	Description
Barrier	Barriers serve as synchronization points for groups of threads that must occasionally wait for each other.
BoundedBuffer	Efficient array-based bounded buffer class.
BoundedChannel	A channel that is known to have a capacity, signifying that put operations may block when the capacity is reached.
BoundedLinkedQueue	A bounded variant of LinkedQueue class.
BoundedPriorityQueue	A heap-based priority queue, using semaphores for concurrency control.
BrokenBarrierException	Thrown by Barrier upon interruption of participant threads
Callable	Interface for runnable actions that bear results and/or throw Exceptions.
Channel	Main interface for buffers, queues, pipes, conduits, etc.
ClockDaemon	A general-purpose time-based daemon, vaguely similar in functionality to common system-level utilities such as at (and the associated crond) in Unix.
ClockDaemon.TaskNode
ConcurrentHashMap	A version of Hashtable supporting concurrency for both retrievals and updates: Retrievals Retrievals may overlap updates.
ConcurrentHashMap.Entry	ConcurrentHashMap collision list entry.
ConcurrentHashMap.Segment	Bookkeeping for each concurrency control segment.
ConcurrentReaderHashMap	A version of Hashtable that supports mostly-concurrent reading, but exclusive writing.
ConcurrentReaderHashMap.BarrierLock	A Serializable class for barrier lock
ConcurrentReaderHashMap.Entry	ConcurrentReaderHashMap collision list entry.
CondVar	This class is designed for fans of POSIX pthreads programming.
CopyOnWriteArrayList	This class implements a variant of java.util.ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.
CopyOnWriteArrayList.COWIterator
CopyOnWriteArrayList.COWSubList
CopyOnWriteArraySet	This class implements a java.util.Set that uses a CopyOnWriteArrayList for all of its operations.
CountDown	A CountDown can serve as a simple one-shot barrier.
CVBuffer
CyclicBarrier	A cyclic barrier is a reasonable choice for a barrier in contexts involving a fixed sized group of threads that must occasionally wait for each other.
DefaultChannelCapacity	A utility class to set the default capacity of BoundedChannel implementations that otherwise require a capacity argument
DirectExecutor	An implementation of Executor that invokes the run method of the supplied command and then returns.
Executor	Interface for objects that execute Runnables, as well as various objects that can be wrapped as Runnables.
FIFOReadWriteLock	This class implements a policy for reader/writer locks in which threads contend in a First-in/First-out manner for access (modulo the limitations of FIFOSemaphore, which is used for queuing).
FIFOSemaphore	A First-in/First-out implementation of a Semaphore.
FIFOSemaphore.FIFOWaitQueue	Simple linked list queue used in FIFOSemaphore.
FIFOSlot
FJTask	Abstract base class for Fork/Join Tasks.
FJTask.Par	A new Par, when executed, runs the tasks provided in the constructor in parallel using coInvoke(tasks).
FJTask.Par2	A new Par(task1, task2), when executed, runs task1 and task2 in parallel using coInvoke(task1, task2).
FJTask.Seq	A new Seq, when executed, invokes each task provided in the constructor, in order.
FJTask.Seq2	A new Seq2(task1, task2), when executed, invokes task1 and then task2, in order.
FJTask.Wrap	A FJTask that holds a Runnable r, and calls r.run when executed.
FJTaskRunner	Specialized Thread subclass for running FJTasks.
FJTaskRunner.VolatileTaskRef	An object holding a single volatile reference to a FJTask.
FJTaskRunnerGroup	A stripped down analog of a ThreadGroup used for establishing and managing FJTaskRunner threads.
FJTaskRunnerGroup.InvokableFJTask	Wrap wait/notify mechanics around a task so that invoke() can wait it out
Fraction	An immutable class representing fractions as pairs of longs.
FutureResult	A class maintaining a single reference variable serving as the result of an operation.
Heap	A heap-based priority queue, without any concurrency control (i.e., no blocking on empty/full states).
Latch	A latch is a boolean condition that is set at most once, ever.
LayeredSync	A class that can be used to compose Syncs.
LinkedNode	A standard linked list node used in various queue classes
LinkedQueue	A linked list based channel implementation.
LockedExecutor	An implementation of Executor that invokes the run method of the supplied command within a synchronization lock and then returns.
Mutex	A simple non-reentrant mutual exclusion lock.
NullSync	A No-Op implementation of Sync.
ObservableSync	The ObservableSync class performs no synchronization itself, but invokes event-style messages to other observer objects upon invocation of Sync methods.
ObservableSync.SyncObserver	Interface for objects that observe ObservableSyncs.
PipedChannel	A channel based on a java.io.PipedInputStream and java.io.PipedOutputStream.
PooledExecutor	A tunable, extensible thread pool class.
PooledExecutor.BlockedExecutionHandler	Class for actions to take when execute() blocks.
PrioritySemaphore	A Semaphore that grants requests to threads with higher Thread priority rather than lower priority when there is contention.
PrioritySemaphore.PriorityWaitQueue
PropertyChangeMulticaster	This class is interoperable with java.beans.PropertyChangeSupport, but relies on a streamlined copy-on-write scheme similar to that used in CopyOnWriteArrayList.
Puttable	This interface exists to enable stricter type checking for channels.
QueuedExecutor	An implementation of Executor that queues incoming requests until they can be processed by a single background thread.
QueuedSemaphore	Abstract base class for semaphores relying on queued wait nodes.
QueuedSemaphore.WaitQueue	Base class for internal queue classes for semaphores, etc.
QueuedSemaphore.WaitQueue.WaitNode
ReaderPreferenceReadWriteLock	A ReadWriteLock that prefers waiting readers over waiting writers when there is contention.
ReadWriteLock	ReadWriteLocks maintain a pair of associated locks.
ReentrantLock	A lock with the same semantics as builtin Java synchronized locks: Once a thread has a lock, it can re-obtain it any number of times without blocking.
ReentrantWriterPreferenceReadWriteLock	A writer-preference ReadWriteLock that allows both readers and writers to reacquire read or write locks in the style of a ReentrantLock.
Rendezvous	A rendezvous is a barrier that: Unlike a CyclicBarrier, is not restricted to use with fixed-sized groups of threads.
Rendezvous.RendezvousFunction	Interface for functions run at rendezvous points
Rendezvous.Rotator	The default rendezvous function.
Semaphore	Base class for counting semaphores.
SemaphoreControlledChannel	Abstract class for channels that use Semaphores to control puts and takes.
Slot	A one-slot buffer, using semaphores to control access.
SwingWorker	An abstract class that you subclass to perform GUI-related work in a dedicated thread.
Sync	Main interface for locks, gates, and conditions.
SyncCollection	SyncCollections wrap Sync-based control around java.util.Collections.
SynchronizationTimer	This program records times for various fine-grained synchronization schemes, and provides some ways of measuring them over different context parameters.
SynchronizedBoolean	A class useful for offloading synch for boolean instance variables.
SynchronizedByte	A class useful for offloading synch for byte instance variables.
SynchronizedChar	A class useful for offloading synch for char instance variables.
SynchronizedDouble	A class useful for offloading synch for double instance variables.
SynchronizedFloat	A class useful for offloading synch for float instance variables.
SynchronizedInt	A class useful for offloading synch for int instance variables.
SynchronizedLong	A class useful for offloading synch for long instance variables.
SynchronizedRef	A simple class maintaining a single reference variable that is always accessed and updated under synchronization.
SynchronizedShort	A class useful for offloading synch for short instance variables.
SynchronizedVariable	Base class for simple, small classes maintaining single values that are always accessed and updated under synchronization.
SynchronousChannel	A rendezvous channel, similar to those used in CSP and Ada.
SynchronousChannel.Queue	Simple FIFO queue class to hold waiting puts/takes.
SyncList	SyncLists wrap Sync-based control around java.util.Lists.
SyncMap	SyncMaps wrap Sync-based control around java.util.Maps.
SyncSet	SyncSets wrap Sync-based control around java.util.Sets.
SyncSortedMap	SyncSortedMaps wrap Sync-based control around java.util.SortedMaps.
SyncSortedSet	SyncSortedSets wrap Sync-based control around java.util.SortedSets.
Takable	This interface exists to enable stricter type checking for channels.
ThreadedExecutor	An implementation of Executor that creates a new Thread that invokes the run method of the supplied command.
ThreadFactory	Interface describing any class that can generate new Thread objects.
ThreadFactoryUser	Base class for Executors and related classes that rely on thread factories.
ThreadFactoryUser.DefaultThreadFactory
TimedCallable	TimedCallable runs a Callable function for a given length of time.
TimeoutException	Thrown by synchronization classes that report timeouts via exceptions.
TimeoutSync	A TimeoutSync is an adaptor class that transforms all calls to acquire to instead invoke attempt with a predetermined timeout value.
VetoableChangeMulticaster	This class is interoperable with java.beans.VetoableChangeSupport, but relies on a streamlined copy-on-write scheme similar to that used in CopyOnWriteArrayList.
WaitableBoolean	A class useful for offloading synch for boolean instance variables.
WaitableByte	A class useful for offloading waiting and signalling operations on single byte variables.
WaitableChar	A class useful for offloading waiting and signalling operations on single char variables.
WaitableDouble	A class useful for offloading waiting and signalling operations on single double variables.
WaitableFloat	A class useful for offloading waiting and signalling operations on single float variables.
WaitableInt	A class useful for offloading waiting and signalling operations on single int variables.
WaitableLong	A class useful for offloading waiting and signalling operations on single long variables.
WaitableRef	A class useful for offloading synch for Object reference instance variables.
WaitableShort	A class useful for offloading waiting and signalling operations on single short variables.
WaiterPreferenceSemaphore	An implementation of counting Semaphores that enforces enough fairness for applications that need to avoid indefinite overtaking without necessarily requiring FIFO ordered access.
WaitFreeQueue	A wait-free linked list based queue implementation.
WaitFreeQueue.Node	List nodes for Queue
WriterPreferenceReadWriteLock	A ReadWriteLock that prefers waiting writers over waiting readers when there is contention.