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