public class ConcurrentTaskExecutor extends Object implements AsyncListenableTaskExecutor, SchedulingTaskExecutor
java.util.concurrent.Executorand exposes a Spring
TaskExecutorfor it. Also detects an extended
java.util.concurrent.ExecutorService, adapting the
Autodetects a JSR-236
in order to expose
ManagedTask adapters for it,
exposing a long-running hint based on
SchedulingAwareRunnable and an identity
name based on the given Runnable/Callable's
toString(). For JSR-236 style
lookup in a Java EE 7 environment, consider using
Note that there is a pre-built
ThreadPoolTaskExecutor that allows
for defining a
ThreadPoolExecutor in bean style,
exposing it as a Spring
This is a convenient alternative to a raw ThreadPoolExecutor definition with
a separate definition of the present adapter class.
|Modifier and Type||Class and Description|
Delegate that wraps a given Runnable/Callable with a JSR-236 ManagedTask, exposing a long-running hint based on
|Constructor and Description|
Create a new ConcurrentTaskExecutor, using a single thread executor as default.
Create a new ConcurrentTaskExecutor, using the given
|Modifier and Type||Method and Description|
Execute the given
Submit a Callable task for execution, receiving a Future representing that task.
Submit a Runnable task for execution, receiving a Future representing that task.
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
public final Executor getConcurrentExecutor()
Executorthat this adapter delegates to.
public final void setTaskDecorator(TaskDecorator taskDecorator)
TaskDecoratorto be applied to any
Runnableabout to be executed.
Note that such a decorator is not necessarily being applied to the
Callable but rather to the actual
execution callback (which may be a wrapper around the user-supplied task).
The primary use case is to set some execution context around the task's invocation, or to provide some monitoring/statistics for task execution.
NOTE: Exception handling in
is limited to plain
Runnable execution via
In case of
#submit calls, the exposed
Runnable will be a
FutureTask which does not propagate any exceptions; you might
have to cast it and call
Future#get to evaluate exceptions.
public void execute(Runnable task)
The call might return immediately if the implementation uses an asynchronous execution strategy, or might block in the case of synchronous execution.
@Deprecated public void execute(Runnable task, long startTimeout)
Runnableto execute (never
startTimeout- the time duration (milliseconds) within which the task is supposed to start. This is intended as a hint to the executor, allowing for preferred handling of immediate tasks. Typical values are
AsyncTaskExecutor.TIMEOUT_INDEFINITE(the default as used by
nullresult upon completion.
public ListenableFuture<?> submitListenable(Runnable task)
Runnabletask for execution, receiving a
ListenableFuturerepresenting that task. The Future will return a
nullresult upon completion.
public <T> ListenableFuture<T> submitListenable(Callable<T> task)
Callabletask for execution, receiving a
ListenableFuturerepresenting that task. The Future will return the Callable's result upon completion.