Class Summary |
BoundedBuffer |
Efficient array-based bounded buffer class. |
BoundedLinkedQueue |
A bounded variant of
LinkedQueue
class. |
BoundedPriorityQueue |
A heap-based priority queue, using semaphores for
concurrency control. |
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. |
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. |
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. |
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 |
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. |
PooledExecutor |
A tunable, extensible thread pool class. |
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. |
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. |
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.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. |
SyncCollection |
SyncCollections wrap Sync-based control around java.util.Collections. |
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. |
ThreadedExecutor |
An implementation of Executor that creates a new
Thread that invokes the run method of the supplied command. |
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. |
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. |