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