Package edu.emory.mathcs.util.concurrent

Concurrency utilities, in most part adapted or taken literally from dl.util.concurrent library by Doug Lea and partially modified to match the incoming JDK 1.5 java.util.concurrent package.

See:
          Description

Interface Summary
AsyncTask.Cancellable  
Callback Abstraction of a callback, to be invoked by a middleware upon completion of some asynchronously scheduled action.
 

Class Summary
AlarmClock This class provide some value-added over java.util.Timer: that is, it enables rescheduling of previously scheduled tasks.
AsyncTask A class maintaining a single reference variable serving as the result of an operation.
DelegatableThreadLocal Version of a InheritableThreadLocal that can be propagated to worker threads by means of ThreadContext.
DynamicArrayBlockingQueue This class represents queue of objects.
ExecutorUtils  
ExecutorUtils.SafeThreadFactory Thread factory implementation that attempts to ensure that created threads are equivalent regardless of threads that request creation.
ReentrantNamedLock Implements a reentrant named lock that can be shared between different parts of the application without sharing the lock object, by using a common name.
SecureAsyncTask Variant of AsyncTask that overrides method createPerformer so that it always runs with a fixed access control context and thread context inherited from the caller of createPerformer method.
SecureThreadPoolExecutor Version of ThreadPoolExecutor that ensures propagation of access control context and thread context from call initiator to the thread executing the call.
ThreadContext Represents an immutable snapshot of a thread state.
ThreadSerializingExecutor The executor that delegates to other executor (usually pooling executor) but ensures that tasks scheduled from a single thread are executed sequentially.
ThreadUtils Low-level thread access utilities.
 

Package edu.emory.mathcs.util.concurrent Description

Concurrency utilities, in most part adapted or taken literally from dl.util.concurrent library by Doug Lea and partially modified to match the incoming JDK 1.5 java.util.concurrent package. This package contains a subset of java.util.concurrent functionality; however, it adds several extensions, mostly security related:

The most prominent use of these extensions is in the middleware systems, where it is not uncommon for separate executable actions to run with different access permissions, depending on the identity of a subject that requested them.