public class ConcurrentTaskExecutor extends Object implements org.springframework.core.task.AsyncListenableTaskExecutor, SchedulingTaskExecutor
java.util.concurrent.Executor and exposes
 a Spring TaskExecutor for it.
 Also detects an extended java.util.concurrent.ExecutorService, adapting
 the AsyncTaskExecutor interface accordingly.
 Autodetects a JSR-236 ManagedExecutorService
 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 DefaultManagedTaskExecutor.
 
Note that there is a pre-built ThreadPoolTaskExecutor that allows
 for defining a ThreadPoolExecutor in bean style,
 exposing it as a Spring TaskExecutor directly.
 This is a convenient alternative to a raw ThreadPoolExecutor definition with
 a separate definition of the present adapter class.
Executor, 
ExecutorService, 
ThreadPoolExecutor, 
Executors, 
DefaultManagedTaskExecutor, 
ThreadPoolTaskExecutor| Modifier and Type | Class and Description | 
|---|---|
| protected static class  | ConcurrentTaskExecutor.ManagedTaskBuilderDelegate that wraps a given Runnable/Callable  with a JSR-236 ManagedTask,
 exposing a long-running hint based on  SchedulingAwareRunnableand a given identity name. | 
| Constructor and Description | 
|---|
| ConcurrentTaskExecutor()Create a new ConcurrentTaskExecutor, using a single thread executor as default. | 
| ConcurrentTaskExecutor(Executor executor)Create a new ConcurrentTaskExecutor, using the given  Executor. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | execute(Runnable task) | 
| void | execute(Runnable task,
       long startTimeout) | 
| Executor | getConcurrentExecutor()Return the  Executorthat this adapter delegates to. | 
| void | setConcurrentExecutor(Executor executor)Specify the  Executorto delegate to. | 
| void | setTaskDecorator(org.springframework.core.task.TaskDecorator taskDecorator)Specify a custom  TaskDecoratorto be applied to anyRunnableabout to be executed. | 
| <T> Future<T> | submit(Callable<T> task) | 
| Future<?> | submit(Runnable task) | 
| <T> org.springframework.util.concurrent.ListenableFuture<T> | submitListenable(Callable<T> task) | 
| org.springframework.util.concurrent.ListenableFuture<?> | submitListenable(Runnable task) | 
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitprefersShortLivedTaskspublic ConcurrentTaskExecutor()
Executors.newSingleThreadExecutor()public ConcurrentTaskExecutor(@Nullable
                              Executor executor)
Executor.
 Autodetects a JSR-236 ManagedExecutorService
 in order to expose ManagedTask adapters for it.
executor - the Executor to delegate topublic final void setConcurrentExecutor(@Nullable
                                        Executor executor)
Executor to delegate to.
 Autodetects a JSR-236 ManagedExecutorService
 in order to expose ManagedTask adapters for it.
public final Executor getConcurrentExecutor()
Executor that this adapter delegates to.public final void setTaskDecorator(org.springframework.core.task.TaskDecorator taskDecorator)
TaskDecorator to be applied to any Runnable
 about to be executed.
 Note that such a decorator is not necessarily being applied to the
 user-supplied Runnable/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.
public void execute(Runnable task)
public void execute(Runnable task, long startTimeout)
execute in interface org.springframework.core.task.AsyncTaskExecutorpublic Future<?> submit(Runnable task)
submit in interface org.springframework.core.task.AsyncTaskExecutorpublic <T> Future<T> submit(Callable<T> task)
submit in interface org.springframework.core.task.AsyncTaskExecutorpublic org.springframework.util.concurrent.ListenableFuture<?> submitListenable(Runnable task)
submitListenable in interface org.springframework.core.task.AsyncListenableTaskExecutorpublic <T> org.springframework.util.concurrent.ListenableFuture<T> submitListenable(Callable<T> task)
submitListenable in interface org.springframework.core.task.AsyncListenableTaskExecutor