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 |
|
CondVar |
This class is designed for fans of POSIX pthreads programming.
|
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.
|
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 |
|
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.
|
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.
|