org.springframework.scheduling.quartz

## Class SimpleThreadPoolTaskExecutor

- java.lang.Object
- - org.quartz.simpl.SimpleThreadPool
  - - org.springframework.scheduling.quartz.SimpleThreadPoolTaskExecutor

- All Implemented Interfaces:
    Executor, org.quartz.spi.ThreadPool, DisposableBean, InitializingBean, AsyncTaskExecutor, TaskExecutor, SchedulingTaskExecutor

      public class SimpleThreadPoolTaskExecutor
      extends SimpleThreadPool
      implements SchedulingTaskExecutor, InitializingBean, DisposableBean

  Subclass of Quartz's SimpleThreadPool that implements Spring's `TaskExecutor` interface and listens to Spring lifecycle callbacks.

  Can be shared between a Quartz Scheduler (specified as "taskExecutor") and other TaskExecutor users, or even used completely independent of a Quartz Scheduler (as plain TaskExecutor backend).

  Since:
    2.0
  Author:
    Juergen Hoeller
  See Also:
    `SimpleThreadPool`, `TaskExecutor`, `SchedulerFactoryBean.setTaskExecutor(java.util.concurrent.Executor)`

- - ### Field Summary

    - ### Fields inherited from interface org.springframework.core.task.AsyncTaskExecutor

      `TIMEOUT_IMMEDIATE, TIMEOUT_INDEFINITE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SimpleThreadPoolTaskExecutor()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterPropertiesSet()` Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
    `void` | `destroy()` Invoked by a BeanFactory on destruction of a singleton.
    `void` | `execute(Runnable task)` Execute the given `task`.
    `void` | `execute(Runnable task, long startTimeout)` Execute the given `task`.
    `boolean` | `prefersShortLivedTasks()` This task executor prefers short-lived work units.
    `void` | `setWaitForJobsToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)` Set whether to wait for running jobs to complete on shutdown.
    `<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 class org.quartz.simpl.SimpleThreadPool

      `blockForAvailableThreads, createWorkerThreads, getLog, getPoolSize, getThreadCount, getThreadNamePrefix, getThreadPriority, initialize, isMakeThreadsDaemons, isThreadsInheritContextClassLoaderOfInitializingThread, isThreadsInheritGroupOfInitializingThread, makeAvailable, runInThread, setMakeThreadsDaemons, setThreadCount, setThreadNamePrefix, setThreadPriority, setThreadsInheritContextClassLoaderOfInitializingThread, setThreadsInheritGroupOfInitializingThread, shutdown, shutdown`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### SimpleThreadPoolTaskExecutor

          public SimpleThreadPoolTaskExecutor()

  - ### Method Detail

    - #### setWaitForJobsToCompleteOnShutdown

          public void setWaitForJobsToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)

      Set whether to wait for running jobs to complete on shutdown. Default is "false".
      See Also:
        `SimpleThreadPool.shutdown(boolean)`

    - #### afterPropertiesSet

          public void afterPropertiesSet()
                                  throws SchedulerConfigException

      Description copied from interface: `InitializingBean`
      Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

      This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

      Specified by:
        `afterPropertiesSet` in interface `InitializingBean`
      Throws:
        `SchedulerConfigException`

    - #### 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

          public void execute(Runnable task,
                     long startTimeout)

      Description copied from interface: `AsyncTaskExecutor`
      Execute the given `task`.
      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)`).

    - #### 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.
      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.
      Specified by:
        `submit` in interface `AsyncTaskExecutor`
      Parameters:
        `task` - the `Callable` to execute (never `null`)
      Returns:
        a Future representing pending completion of the task

    - #### prefersShortLivedTasks

          public boolean prefersShortLivedTasks()

      This task executor prefers short-lived work units.
      Specified by:
        `prefersShortLivedTasks` in interface `SchedulingTaskExecutor`
      Returns:
        `true` if this `TaskExecutor` prefers short-lived tasks

    - #### destroy

          public void destroy()

      Description copied from interface: `DisposableBean`
      Invoked by a BeanFactory on destruction of a singleton.
      Specified by:
        `destroy` in interface `DisposableBean`