|
||||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
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. |
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:
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 poolsExecutorUtils.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.
|
||||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |