Class ConcurrentTaskExecutor

java.lang.Object
org.springframework.scheduling.concurrent.ConcurrentTaskExecutor
All Implemented Interfaces:
Executor, AsyncTaskExecutor, TaskExecutor, SchedulingTaskExecutor
Direct Known Subclasses:
ConcurrentTaskScheduler, DefaultManagedTaskExecutor
public class ConcurrentTaskExecutor extends Object implements AsyncTaskExecutor, SchedulingTaskExecutor
Adapter that takes a 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 Jakarta EE 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.

Since:
2.0
Author:
Juergen Hoeller
See Also:

  • Constructor Details

  • Method Details

    • setConcurrentExecutor

      public final void setConcurrentExecutor(Executor executor)
      Specify the Executor to delegate to.

      Autodetects a JSR-236 ManagedExecutorService in order to expose ManagedTask adapters for it.

    • getConcurrentExecutor

      public final Executor getConcurrentExecutor()
      Return the Executor that this adapter delegates to.

    • setTaskDecorator

      public final void setTaskDecorator(TaskDecorator taskDecorator)
      Specify a custom 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.

      Since:
      4.3

    • execute

      public void execute(Runnable task)
      Description copied from interface: TaskExecutor
      Execute the given task.

      The call might return immediately if the implementation uses an asynchronous execution strategy, or might block in the case of synchronous execution.

      Specified by:
      execute in interface Executor
      Specified by:
      execute in interface TaskExecutor
      Parameters:
      task - the Runnable to execute (never null)

    • execute

      @Deprecated public void execute(Runnable task, long startTimeout)
      Deprecated.
      Description copied from interface: AsyncTaskExecutor
      Execute the given task.

      As of 6.1, this method comes with a default implementation that simply delegates to TaskExecutor.execute(Runnable), ignoring the timeout completely.

      Specified by:
      execute in interface AsyncTaskExecutor
      Parameters:
      task - the Runnable to execute (never null)
      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_IMMEDIATE or AsyncTaskExecutor.TIMEOUT_INDEFINITE (the default as used by TaskExecutor.execute(Runnable)).
      See Also:

    • submit

      public Future<?> submit(Runnable task)
      Description copied from interface: AsyncTaskExecutor
      Submit a Runnable task for execution, receiving a Future representing that task. The Future will return a null result upon completion.

      As of 6.1, this method comes with a default implementation that delegates to TaskExecutor.execute(Runnable).

      Specified by:
      submit in interface AsyncTaskExecutor
      Parameters:
      task - the Runnable to execute (never null)
      Returns:
      a Future representing pending completion of the task

    • submit

      public <T> Future<T> submit(Callable<T> task)
      Description copied from interface: AsyncTaskExecutor
      Submit a Callable task for execution, receiving a Future representing that task. The Future will return the Callable's result upon completion.

      As of 6.1, this method comes with a default implementation that delegates to TaskExecutor.execute(Runnable).

      Specified by:
      submit in interface AsyncTaskExecutor
      Parameters:
      task - the Callable to execute (never null)
      Returns:
      a Future representing pending completion of the task