|
||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
Interface Summary | |
---|---|
Barrier | Barriers serve as synchronization points for groups of threads that must occasionally wait for each other. |
BoundedChannel | A channel that is known to have a capacity, signifying
that put operations may block when the
capacity is reached. |
Callable | Interface for runnable actions that bear results and/or throw Exceptions. |
Channel | Main interface for buffers, queues, pipes, conduits, etc. |
Executor | Interface for objects that execute Runnables, as well as various objects that can be wrapped as Runnables. |
ObservableSync.SyncObserver | Interface for objects that observe ObservableSyncs. |
PooledExecutor.BlockedExecutionHandler | Class for actions to take when execute() blocks. |
Puttable | This interface exists to enable stricter type checking for channels. |
ReadWriteLock | ReadWriteLocks maintain a pair of associated locks. |
Rendezvous.RendezvousFunction | Interface for functions run at rendezvous points |
Sync | Main interface for locks, gates, and conditions. |
Takable | This interface exists to enable stricter type checking for channels. |
ThreadFactory | Interface describing any class that can generate new Thread objects. |
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. |
Exception Summary | |
---|---|
BrokenBarrierException | Thrown by Barrier upon interruption of participant threads |
TimeoutException | Thrown by synchronization classes that report timeouts via exceptions. |
Note: Upon release of J2SE 1.5, this package enters maintenance mode: Only essential corrections will be released. JDK1.5 package java.util.concurrent includes improved, more efficient, standardized versions of the main components in this package. Please plan to convert your applications to use them. (A few niche classes here have no equivalents in java.util.concurrent. They will become part of a follow-up add-on package that will also include other unstandardized classes.)
This package provides standardized, efficient versions of utility classes commonly encountered in concurrent Java programming. This code consists of implementations of ideas that have been around for ages, and is merely intended to save you the trouble of coding them. Discussions of the rationale and applications of several of these classes can be found in the second edition of Concurrent Programming in Java. There are also pdf slides providing an overview of the package.
The package mainly consists of implementations of a few interfaces:
Sync
-- locks, conditions Channel
-- queues, buffers Barrier
-- multi-party synchronization SynchronizedVariable
-- atomic ints, refs etc java.util.Collection
-- collections Executor
-- replacements for direct use of Thread
If you arrived at page
http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html
following links from your local documentation, please check the
version number and get an update if you are running an outdated
version.
EDU.oswego.cs.dl.util.concurrent
is available in (tar.gz
format) or (zip
format).
It is currently distributed in source form only. To build it, use a Java 1.2+ compiler to:
javac -d [SOMEWHERE IN YOUR CLASSPATH] *.javaOr use this ant build file donated by Travell Perkins.
The classes in the misc
directory can be built the
same way.
To use it, add to java files:
import EDU.oswego.cs.dl.util.concurrent.*
You can also create a jar or zip file of the compiled classes and add them to your classpath.
All documentation except for this file was produced by javadoc, which places some index and summary files outside the current directory. This can cause some broken links on unpacked versions. You can avoid this, and integrate with your local javadoc-produced documentation by running:
javadoc -public -d [BASE OF SOME JAVADOC PATH] *.java
acquire
, attempt(msecs)
, and
release
.
Implementations
The following implementation classes do not themselves perform any synchronization, but serve as adaptors, glue, and extensibility hooks for those that do. They may also be helpful when using Syncs in generic before/after constructions:
Related Classes
Implementations
Implementations
Related Classes
put
and take
, as well as
timeout-based offer
and poll
. To assist
efforts to use channels with somewhat greater type safety, Channel
is defined as a subinterface of Puttable and Takable, each defining only one side of
the channel. Also, the BoundedChannel subinterface is used
for channels with finite capacities.
Implementations
Related Classes
execute
Runnable commands.
Implementations
Related classes
misc
directory
that might be of interest but aren't really part of this
package. They include:
package EDU.oswego.cs.dl.util.concurrent ; class Random extends java.util.Random { public Random() {super() ;} public Random(long l) {super(l) ;} public int nextInt(int i) { int ii = (int)(i * nextDouble()) ; if (ii >= i) {ii = i-1 ;} // should (almost?) never happen... return ii ; } }
Konstantin Läufer has generously placed a version compiled for JDK1.1 at http://www.cs.luc.edu/~laufer/courses/337/handouts/concurrent11.zip
Thread.currentThread().interrupt()
to propagate
status.
If you need to invoke such methods even when the thread is in an interrupted state (for example, during recovery actions) you can do:
void quietlyAcquire(Sync sync) { boolean wasInterrupted = Thread.interrupted(); // record and clear for (;;) { try { sync.acquire(); // or any other method throwing InterruptedException break; } catch (InterruptedException ex) { // re-interrupted; try again wasInterrupted = true; } } if (wasInterrupted) { // re-establish interrupted state Thread.currentThread().interrupt(); } }
The heavy use of InterruptedException makes it possible to write very responsive and robust code, at the expense of forcing class and method authors to contemplate possible exception handling actions at each interruption (and time-out) point. See the CPJ supplement page on cancellation for more discussion of some associated design issues.
You will almost surely trade off some cost in efficiency for the
flexibility of using Syncs and classes built out of them rather
than built-in synchronized
method/block locks. On
some JVMs the cost is very low. (You can check approximate impact
using SynchronizationTimer.)
But, while Java VMs are getting much faster about
synchronized
locks, most of the classes in this
package rely heavily on wait/notify and interruption mechanics,
which are not currently as heavily optimized. (Also, they seem to
be subject to more variation in behavior than other Java
constructs.) Class implementations generally ignore the fact
that the JVM overhead for these operations might be slower than
you'd wish they were on some JVMs.
protected
?
Serializable
?
x
via synchronized(x) {
... }
?
synchronized(x)
and so probably ought never
use it.
EDU
..., not edu
?
|
||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |