All Classes and Interfaces
Class
Description
Barriers serve
as synchronization points for groups of threads that
must occasionally wait for each other.
Efficient array-based bounded buffer class.
A channel that is known to have a capacity, signifying
that
put operations may block when the
capacity is reached.A bounded variant of
LinkedQueue
class.
A heap-based priority queue, using semaphores for
concurrency control.
Thrown by Barrier upon interruption of participant threads
Interface for runnable actions that bear results and/or throw Exceptions.
Main interface for buffers, queues, pipes, conduits, etc.
A general-purpose time-based daemon, vaguely similar in functionality
to common system-level utilities such as
at
(and the associated crond) in Unix.A version of Hashtable supporting
concurrency for both retrievals and updates:
Retrievals
Retrievals may overlap updates.
ConcurrentHashMap collision list entry.
Bookkeeping for each concurrency control segment.
A version of Hashtable that supports mostly-concurrent reading, but
exclusive writing.
A Serializable class for barrier lock
ConcurrentReaderHashMap collision list entry.
This class is designed for fans of POSIX pthreads programming.
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.
This class implements a java.util.Set that uses a
CopyOnWriteArrayList for all of its operations.
A CountDown can serve as a simple one-shot barrier.
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.
A utility class to set the default capacity of
BoundedChannel
implementations that otherwise require a capacity argument
An implementation of Executor that
invokes the run method of the supplied command and then returns.
Interface for objects that execute Runnables,
as well as various objects that can be wrapped
as Runnables.
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).
A First-in/First-out implementation of a Semaphore.
Simple linked list queue used in FIFOSemaphore.
Abstract base class for Fork/Join Tasks.
A
new Par, when executed,
runs the tasks provided in the constructor in parallel using
coInvoke(tasks).A
new Par(task1, task2), when executed,
runs task1 and task2 in parallel using coInvoke(task1, task2).A
new Seq, when executed,
invokes each task provided in the constructor, in order.A
new Seq2(task1, task2), when executed,
invokes task1 and then task2, in order.A FJTask that holds a Runnable r, and calls r.run when executed.
Specialized Thread subclass for running FJTasks.
An object holding a single volatile reference to a FJTask.
A stripped down analog of a ThreadGroup used for
establishing and managing FJTaskRunner threads.
Wrap wait/notify mechanics around a task so that
invoke() can wait it out
An immutable class representing fractions as pairs of longs.
A class maintaining a single reference variable serving as the result
of an operation.
A heap-based priority queue, without any concurrency control
(i.e., no blocking on empty/full states).
A latch is a boolean condition that is set at most once, ever.
A class that can be used to compose Syncs.
A standard linked list node used in various queue classes
A linked list based channel implementation.
An implementation of Executor that
invokes the run method of the supplied command within
a synchronization lock and then returns.
A simple non-reentrant mutual exclusion lock.
A No-Op implementation of Sync.
The ObservableSync class performs no synchronization
itself, but invokes event-style messages to other
observer objects upon invocation of Sync methods.
Interface for objects that observe ObservableSyncs.
A channel based on a java.io.PipedInputStream and
java.io.PipedOutputStream.
A tunable, extensible thread pool class.
Class for actions to take when execute() blocks.
A Semaphore that grants requests to threads with higher
Thread priority rather than lower priority when there is
contention.
This class is interoperable with java.beans.PropertyChangeSupport,
but relies on a streamlined copy-on-write scheme similar to
that used in CopyOnWriteArrayList.
This interface exists to enable stricter type checking
for channels.
An implementation of Executor that queues incoming
requests until they can be processed by a single background
thread.
Abstract base class for semaphores relying on queued wait nodes.
Base class for internal queue classes for semaphores, etc.
A ReadWriteLock that prefers waiting readers over
waiting writers when there is contention.
ReadWriteLocks maintain a pair of associated locks.
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.
A writer-preference ReadWriteLock that allows both readers and
writers to reacquire
read or write locks in the style of a ReentrantLock.
A rendezvous is a barrier that:
Unlike a CyclicBarrier, is not restricted to use
with fixed-sized groups of threads.
Interface for functions run at rendezvous points
The default rendezvous function.
Base class for counting semaphores.
Abstract class for channels that use Semaphores to
control puts and takes.
A one-slot buffer, using semaphores to control access.
An abstract class that you subclass to perform GUI-related work
in a dedicated thread.
Main interface for locks, gates, and conditions.
SyncCollections wrap Sync-based control around java.util.Collections.
This program records times for various fine-grained synchronization
schemes, and provides some ways of measuring them over different
context parameters.
A class useful for offloading synch for boolean instance variables.
A class useful for offloading synch for byte instance variables.
A class useful for offloading synch for char instance variables.
A class useful for offloading synch for double instance variables.
A class useful for offloading synch for float instance variables.
A class useful for offloading synch for int instance variables.
A class useful for offloading synch for long instance variables.
A simple class maintaining a single reference variable that
is always accessed and updated under synchronization.
A class useful for offloading synch for short instance variables.
Base class for simple, small classes
maintaining single values that are always accessed
and updated under synchronization.
A rendezvous channel, similar to those used in CSP and Ada.
Simple FIFO queue class to hold waiting puts/takes.
SyncLists wrap Sync-based control around java.util.Lists.
SyncMaps wrap Sync-based control around java.util.Maps.
SyncSets wrap Sync-based control around java.util.Sets.
SyncSortedMaps wrap Sync-based control around java.util.SortedMaps.
SyncSortedSets wrap Sync-based control around java.util.SortedSets.
This interface exists to enable stricter type checking
for channels.
An implementation of Executor that creates a new
Thread that invokes the run method of the supplied command.
Interface describing any class that can generate
new Thread objects.
Base class for Executors and related classes that rely on thread factories.
TimedCallable runs a Callable function for a given length of time.
Thrown by synchronization classes that report
timeouts via exceptions.
A TimeoutSync is an adaptor class that transforms all
calls to acquire to instead invoke attempt with a predetermined
timeout value.
This class is interoperable with java.beans.VetoableChangeSupport,
but relies on a streamlined copy-on-write scheme similar to
that used in CopyOnWriteArrayList.
A class useful for offloading synch for boolean instance variables.
A class useful for offloading waiting and signalling operations
on single byte variables.
A class useful for offloading waiting and signalling operations
on single char variables.
A class useful for offloading waiting and signalling operations
on single double variables.
A class useful for offloading waiting and signalling operations
on single float variables.
A class useful for offloading waiting and signalling operations
on single int variables.
A class useful for offloading waiting and signalling operations
on single long variables.
A class useful for offloading synch for Object reference instance variables.
A class useful for offloading waiting and signalling operations
on single short variables.
An implementation of counting Semaphores that
enforces enough fairness for applications that
need to avoid indefinite overtaking without
necessarily requiring FIFO ordered access.
A wait-free linked list based queue implementation.
List nodes for Queue
A ReadWriteLock that prefers waiting writers over
waiting readers when there is contention.