org.springframework.core.task

## Interface AsyncTaskExecutor

- All Superinterfaces:
    Executor, TaskExecutor
  All Known Subinterfaces:
    AsyncListenableTaskExecutor, SchedulingTaskExecutor
  All Known Implementing Classes:
    ConcurrentTaskExecutor, ConcurrentTaskScheduler, DefaultManagedTaskExecutor, DefaultManagedTaskScheduler, SimpleAsyncTaskExecutor, SimpleThreadPoolTaskExecutor, TaskExecutorAdapter, ThreadPoolTaskExecutor, ThreadPoolTaskScheduler, WorkManagerTaskExecutor, WorkManagerTaskExecutor

      public interface AsyncTaskExecutor
      extends TaskExecutor

  Extended interface for asynchronous `TaskExecutor` implementations, offering support for `Callable`.

  Note: The `Executors` class includes a set of methods that can convert some other common closure-like objects, for example, `PrivilegedAction` to `Callable` before executing them.

  Implementing this interface also indicates that the `TaskExecutor.execute(Runnable)` method will not execute its Runnable in the caller's thread but rather asynchronously in some other thread.

  Since:
    2.0.3
  Author:
    Juergen Hoeller
  See Also:
    `SimpleAsyncTaskExecutor`, `SchedulingTaskExecutor`, `Callable`, `Executors`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static long` | `TIMEOUT_IMMEDIATE` Deprecated. as of 5.3.16 along with `execute(Runnable, long)`
    `static long` | `TIMEOUT_INDEFINITE` Deprecated. as of 5.3.16 along with `execute(Runnable, long)`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `execute(Runnable task, long startTimeout)` Deprecated. as of 5.3.16 since the common executors do not support start timeouts
    `<T> Future<T>` | `submit(Callable<T> task)` Submit a Callable task for execution, receiving a Future representing that task.
    `Future<?>` | `submit(Runnable task)` Submit a Runnable task for execution, receiving a Future representing that task.

    - ### Methods inherited from interface org.springframework.core.task.TaskExecutor

      `execute`

- - ### Field Detail

    - #### TIMEOUT_IMMEDIATE

          @Deprecated
          static final long TIMEOUT_IMMEDIATE

      Deprecated. as of 5.3.16 along with `execute(Runnable, long)`
      Constant that indicates immediate execution.
      See Also:
        Constant Field Values

    - #### TIMEOUT_INDEFINITE

          @Deprecated
          static final long TIMEOUT_INDEFINITE

      Deprecated. as of 5.3.16 along with `execute(Runnable, long)`
      Constant that indicates no time limit.
      See Also:
        Constant Field Values

  - ### Method Detail

    - #### execute

          @Deprecated
          void execute(Runnable task,
                                   long startTimeout)

      Deprecated. as of 5.3.16 since the common executors do not support start timeouts
      Execute the given `task`.
      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 `TIMEOUT_IMMEDIATE` or `TIMEOUT_INDEFINITE` (the default as used by `TaskExecutor.execute(Runnable)`).
      Throws:
        `TaskTimeoutException` - in case of the task being rejected because of the timeout (i.e. it cannot be started in time)
        `TaskRejectedException` - if the given task was not accepted
      See Also:
        `TaskExecutor.execute(Runnable)`

    - #### submit

          Future<?> submit(Runnable task)

      Submit a Runnable task for execution, receiving a Future representing that task. The Future will return a `null` result upon completion.
      Parameters:
        `task` - the `Runnable` to execute (never `null`)
      Returns:
        a Future representing pending completion of the task
      Throws:
        `TaskRejectedException` - if the given task was not accepted
      Since:
        3.0

    - #### submit

          <T> Future<T> submit(Callable<T> task)

      Submit a Callable task for execution, receiving a Future representing that task. The Future will return the Callable's result upon completion.
      Parameters:
        `task` - the `Callable` to execute (never `null`)
      Returns:
        a Future representing pending completion of the task
      Throws:
        `TaskRejectedException` - if the given task was not accepted
      Since:
        3.0