org.springframework.scheduling.concurrent

## Class ExecutorConfigurationSupport

- java.lang.Object
- - org.springframework.util.CustomizableThreadCreator
  - - org.springframework.scheduling.concurrent.CustomizableThreadFactory
    - - org.springframework.scheduling.concurrent.ExecutorConfigurationSupport

All Implemented Interfaces:
  Serializable, ThreadFactory, Aware, BeanNameAware, DisposableBean, InitializingBean

Direct Known Subclasses:
  ScheduledExecutorFactoryBean, ThreadPoolExecutorFactoryBean, ThreadPoolTaskExecutor, ThreadPoolTaskScheduler

    public abstract class ExecutorConfigurationSupport
    extends CustomizableThreadFactory
    implements BeanNameAware, InitializingBean, DisposableBean

Base class for classes that are setting up a `java.util.concurrent.ExecutorService` (typically a `ThreadPoolExecutor`). Defines common configuration settings and common lifecycle handling.

Since:
  3.0
Author:
  Juergen Hoeller
See Also:
  `ExecutorService`, `Executors`, `ThreadPoolExecutor`, Serialized Form

### Field Summary

Fields
`protected Log` `logger`

### Constructor Summary

Constructors
Constructor and Description
`ExecutorConfigurationSupport()`

### Method Summary

Methods
`void` `afterPropertiesSet()` Calls `initialize()` after the container applied all property values.
`void` `destroy()` Calls `shutdown` when the BeanFactory destroys the task executor instance.
`void` `initialize()` Set up the ExecutorService.
`protected abstract ExecutorService` `initializeExecutor(ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler)` Create the target `ExecutorService` instance.
`void` `setAwaitTerminationSeconds(int awaitTerminationSeconds)` Set the maximum number of seconds that this executor is supposed to block on shutdown in order to wait for remaining tasks to complete their execution before the rest of the container continues to shut down.
`void` `setBeanName(String name)` Set the name of the bean in the bean factory that created this bean.
`void` `setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler)` Set the RejectedExecutionHandler to use for the ThreadPoolExecutor.
`void` `setThreadFactory(ThreadFactory threadFactory)` Set the ThreadFactory to use for the ThreadPoolExecutor's thread pool.
`void` `setThreadNamePrefix(String threadNamePrefix)` Specify the prefix to use for the names of newly created threads.
`void` `setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)` Set whether to wait for scheduled tasks to complete on shutdown, not interrupting running tasks and executing all tasks in the queue.
`void` `shutdown()` Perform a shutdown on the ThreadPoolExecutor.

### Methods inherited from class org.springframework.scheduling.concurrent.CustomizableThreadFactory

`newThread`

### Methods inherited from class org.springframework.util.CustomizableThreadCreator

`createThread, getDefaultThreadNamePrefix, getThreadGroup, getThreadNamePrefix, getThreadPriority, isDaemon, nextThreadName, setDaemon, setThreadGroup, setThreadGroupName, setThreadPriority`

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

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

### Field Detail

#### logger

    protected final Log logger

### Constructor Detail

#### ExecutorConfigurationSupport

    public ExecutorConfigurationSupport()

### Method Detail

#### setThreadFactory

    public void setThreadFactory(ThreadFactory threadFactory)

Set the ThreadFactory to use for the ThreadPoolExecutor's thread pool. Default is the ThreadPoolExecutor's default thread factory.

See Also:
  `Executors.defaultThreadFactory()`

#### setThreadNamePrefix

    public void setThreadNamePrefix(String threadNamePrefix)

Description copied from class: `CustomizableThreadCreator`
Specify the prefix to use for the names of newly created threads. Default is "SimpleAsyncTaskExecutor-".

Overrides:
  `setThreadNamePrefix` in class `CustomizableThreadCreator`

#### setRejectedExecutionHandler

    public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler)

Set the RejectedExecutionHandler to use for the ThreadPoolExecutor. Default is the ThreadPoolExecutor's default abort policy.

See Also:
  `ThreadPoolExecutor.AbortPolicy`

#### setWaitForTasksToCompleteOnShutdown

    public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)

Set whether to wait for scheduled tasks to complete on shutdown, not interrupting running tasks and executing all tasks in the queue.

Default is "false", shutting down immediately through interrupting ongoing tasks and clearing the queue. Switch this flag to "true" if you prefer fully completed tasks at the expense of a longer shutdown phase.

Note that Spring's container shutdown continues while ongoing tasks are being completed. If you want this executor to block and wait for the termination of tasks before the rest of the container continues to shut down - e.g. in order to keep up other resources that your tasks may need -, set the `"awaitTerminationSeconds"` property instead of or in addition to this property.

See Also:
  `ExecutorService.shutdown()`, `ExecutorService.shutdownNow()`

#### setAwaitTerminationSeconds

    public void setAwaitTerminationSeconds(int awaitTerminationSeconds)

Set the maximum number of seconds that this executor is supposed to block on shutdown in order to wait for remaining tasks to complete their execution before the rest of the container continues to shut down. This is particularly useful if your remaining tasks are likely to need access to other resources that are also managed by the container.

By default, this executor won't wait for the termination of tasks at all. It will either shut down immediately, interrupting ongoing tasks and clearing the remaining task queue - or, if the `"waitForTasksToCompleteOnShutdown"` flag has been set to `true`, it will continue to fully execute all ongoing tasks as well as all remaining tasks in the queue, in parallel to the rest of the container shutting down.

In either case, if you specify an await-termination period using this property, this executor will wait for the given time (max) for the termination of tasks. As a rule of thumb, specify a significantly higher timeout here if you set "waitForTasksToCompleteOnShutdown" to `true` at the same time, since all remaining tasks in the queue will still get executed - in contrast to the default shutdown behavior where it's just about waiting for currently executing tasks that aren't reacting to thread interruption.

See Also:
  `ExecutorService.shutdown()`, `ExecutorService.awaitTermination(long, java.util.concurrent.TimeUnit)`

#### setBeanName

    public void setBeanName(String name)

Description copied from interface: `BeanNameAware`
Set the name of the bean in the bean factory that created this bean.

Invoked after population of normal bean properties but before an init callback such as `InitializingBean.afterPropertiesSet()` or a custom init-method.

Specified by:
  `setBeanName` in interface `BeanNameAware`
Parameters:
  `name` - the name of the bean in the factory. Note that this name is the actual bean name used in the factory, which may differ from the originally specified name: in particular for inner bean names, the actual bean name might have been made unique through appending "#..." suffixes. Use the `BeanFactoryUtils.originalBeanName(String)` method to extract the original bean name (without suffix), if desired.

#### afterPropertiesSet

    public void afterPropertiesSet()

Calls `initialize()` after the container applied all property values.

Specified by:
  `afterPropertiesSet` in interface `InitializingBean`
See Also:
  `initialize()`

#### initialize

    public void initialize()

Set up the ExecutorService.

#### initializeExecutor

    protected abstract ExecutorService initializeExecutor(ThreadFactory threadFactory,
                                     RejectedExecutionHandler rejectedExecutionHandler)

Create the target `ExecutorService` instance. Called by `afterPropertiesSet`.

Parameters:
  `threadFactory` - the ThreadFactory to use
  `rejectedExecutionHandler` - the RejectedExecutionHandler to use
Returns:
  a new ExecutorService instance
See Also:
  `afterPropertiesSet()`

#### destroy

    public void destroy()

Calls `shutdown` when the BeanFactory destroys the task executor instance.

Specified by:
  `destroy` in interface `DisposableBean`
See Also:
  `shutdown()`

#### shutdown

    public void shutdown()

Perform a shutdown on the ThreadPoolExecutor.

See Also:
  `ExecutorService.shutdown()`, `ExecutorService.shutdownNow()`, `awaitTerminationIfNecessary()`