Package pt.ua.concurrent

A concurrent library based on Design-by-Contract.

See: Description

Interface Summary

Interface	Description
InterruptibleAwaitingThreads	Java's interface to extend support for Interruptible Awaiting Threads.
Signal	A simple signal abstraction module.
Sync	Java's interface for locks.
SyncCV	Java's interface for condition variables.

Class Summary

Class	Description
Actor	An actor module (object-oriented approach for message passing concurrent programming).
AtomicLockingMutexSet	Atomic locking operation on an unordered set of mutexes.
Barrier	A thread barrier abstract class.
BinarySemaphore	Binary semaphore class.
BoundedSemaphore	Bounded semaphore class (a semaphore that cannot exceed a given value).
Channel<T>	A simple module support a (generic) communication channel between two threads.
CObject	A replacement for Object to ease and augment the usage of concurrent related methods.
Console	System output related static utilities (supporting colors).
CRunnable	A replacement for Runnable to handle exceptions (and other details).
CThread	Thread related static utilities.
DynamicBarrier	A dynamically sized thread barrier class.
Event	A simple module supporting two valued events.
Exchanger<T>	A simple module support a (generic) exchanger (bidirectional) communication channel between two threads.
ExternalBarrier	An externally triggered thread barrier abstract class. In this type of barrier, the barrier is released by an externally usable (public) method (release).
FixedBarrier	A fixed sized thread barrier class.
Future<T>	Actor's Futures class.
GroupMutex	Group mutex.
GroupMutexComposedCV	A composed condition variable for an exterior GroupMutex with a list of alternative internal Sync objects (used, for example, to integrate internal, external and conditional synchronization of shared objects).
GroupMutexCV	Group exclusion condition variable class.
InternalBarrier	An internally triggered thread barrier abstract class. In this type of barrier, the participating threads are the ones that release the barrier (when the number of waiting threads reach the barrier defined size).
Metronome	This class implements an active (thread) metronome class, able to periodically synchronize any * number of threads.
Mutex	Mutual exclusion lock.
MutexCV	Mutex condition variable class.
MutexSetCV	Mutex set condition variable class.
PersistentSignal	A persistent signal module (signals are kept until a successful delivery).
RWEx	Readers-writer exclusion class.
RWExCV	Readers-writer exclusion condition variable class.
Semaphore	A standard counting semaphore class.
SyncState
TransientSignal	A transient signal module (signals thrown away if no one is waiting).
TriggeredBarrier	An externally triggered thread barrier class. In this type of barrier, the barrier is released by an externally usable (public) method (release).
WrapRunnable	Runnable wrap class.

Enum Summary

Enum	Description
CThread.TerminationPolicy	Termination policy for thread created through current CThread's object.
GroupMutex.Priority	Locking priority choices: CURRENT_ACTIVE_GROUP: active group is always preferred; GROUP_NUMBER_INCREASING: the higher the group number the higher its priority; GROUP_NUMBER_DECREASING: the lower the group number the higher its priority; TIME_OF_ARRIVAL: priority ordered by decreasing waiting time (not yet implemented!).
Mutex.Priority	Locking priority choices: UNDEFINED: undefined priority (default); TIME_OF_ARRIVAL: priority ordered by decreasing waiting time (not yet implemented!).
RWEx.Priority	Locking priority choices: WRITER: priority to writers (a waiting writer prevents new readers from getting the lock); READERS: priority to readers (a waiting reader prevents new writers from getting the lock); TIME_OF_ARRIVAL: priority ordered by decreasing waiting time (not yet implemented!).

Exception Summary

Exception	Description
ThreadInterruptedException	InterruptedException unchecked exception replacement.

Package pt.ua.concurrent Description

A concurrent library based on Design-by-Contract.

This package implements a Design-by-Contract based concurrency library for programming language Java. One of its mains features is its simplification of the usage of native Java concurrency constructs (wait, notify, notifyAll, join, etc.) by replacing the annoying InterruptedException checked exception with an equivalent ThreadInterruptedException unchecked exception (easing the development of concurrent Java code, and preventing a serious source of Java bugs due to the erroneous algorithm of ignoring exceptions).

This library is also the base of a new approach for object-oriented concurrent programming in which both models of thread communication -- shared object and message passing -- are supported. In the shared object model it is possible to fully synchronize a shared object with all the three aspects required -- internal, conditional and external -- without forcing the internal synchronization of the object to a monitor (mutual exclusion). In fact, one may safely use an internal synchronization scheme based on CoW (copy-on-write) or transactions, and still be able to externally synchronize the shared object.

This package contains the following groups of modules:

Base library modules:

InterruptibleAwaitingThreads: Java's interface to extend support for Interruptible Awaiting Threads
CThread: a replacement of Thread
CRunnable: a replacement of Runnable (to correctly handle exceptions and to register start time)
ThreadInterruptedException: InterruptedException unchecked exception replacement
CObject: a replacement of Object for Sync and/or SynCV purposes
WrapRunnable: transforms a Runnable into a CRunnable

Utility modules:

Console: output to a console supporting colors
Metronome: implementation of an active (thread) metronome class, able to periodically synchronize any number of threads

Elementary synchronization modules:

Signal: a simple signal abstraction module
TransientSignal: a transient signal module
PersistentSignal: a persistent signal module
Event: a simple module supporting two valued events
Semaphore: a standard general semaphore
BoundedSemaphore: a semaphore bounded by a maximum value
BinarySemaphore: a binary semaphore
Channel: a simple module support a (generic) communication channel between two threads
Exchanger: a simple module support a (generic) exchanger (bidirectional) communication channel between two threads

Locking modules:

Sync: Java's interface for locks
SyncCV: Java's interface for condition variables
Mutex: a POSIX-threads alike mutual exclusion synchronization class
MutexCV: a POSIX-threads alike mutex condition variable class
RWEx: a readers-writer exclusion synchronization class
RWExCV: a readers-writer exclusion condition variable class
GroupMutex: a group exclusion synchronization class
GroupMutexCV: a group exclusion condition variable class
SyncState: an internal module (to ease the implementaion of getStateAndUnlock/recoverState services)
GroupMutexComposedCV: composed group mutex CV to allow a CV applicable to a GroupMutex and one of any element of an array of Sync objects
MutexSetCV: a Mutex set condition variable class
AtomicLockingMutexSet: atomic locking operation on an unordered set of mutexes

Barrier modules:

Barrier: a thread barrier interface
InternalBarrier: an internally triggered thread barrier abstract class
ExternalBarrier: an externally triggered thread barrier abstract class
FixedBarrier: a fixed sized thread barrier class
DynamicBarrier: a dynamically sized thread barrier class
TriggeredBarrier: an externally triggered thread barrier class

Message passing modules:

Actor: an actor communication class
Future: actor's future results class

Version:

0.9

Author:

Miguel Oliveira e Silva (mos@ua.pt)