Overview | Package | Class | Tree | Deprecated | Index | Help
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES

## 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:

- Implementation of unbounded blocking queue using arrays: `DynamicArrayBlockingQueue`
- `ThreadContext` and `DelegatableThreadLocal`s which together allow to store/restore and temporarily delegate thread state, including thread locals and context class loaders, to worker threads in thread pools
- `ExecutorUtils.delegatedRunnable(java.lang.Runnable)`, encapsulating Runnable together with the creator's access control context and thread context, allows to create and execute asynchronous tasks with retained security context and thread state. That is, it ensures that the runnable will be executed within exactly the same security context and thread state as when it was created, even though by a different thread.
- `ExecutorUtils.safeThreadFactory()`: In comparison to the factories from the original dl.u.c, and the factories used in JDK 1.5, this one ensures a security consistency: threads are created within the thread context and access control context of the pool creator rather than that of the (rather random) thread pool client. It ensures that all threads within the pool have identical security properties and state.
- `SecureThreadPoolExecutor` enforces even stricter context propagation, ensuring that tasks are running within the context of the client that submitted them.

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.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES