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 setting up a ExecutorService (typically a ThreadPoolExecutor or ScheduledThreadPoolExecutor). Defines common configuration settings and common lifecycle handling.
Since:
3.0
Author:
Juergen Hoeller
See Also:
ExecutorService, Executors, ThreadPoolExecutor, ScheduledThreadPoolExecutor, Serialized Form

Field Summary
Fields
Modifier and Type Field Description
protected Log logger

Constructor Summary
Constructors
Constructor Description
ExecutorConfigurationSupport()

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`afterPropertiesSet()`	Calls `initialize()` after the container applied all property values.
`protected void`	`cancelRemainingTask(Runnable task)`	Cancel the given remaining task which never commended execution, as returned from `ExecutorService.shutdownNow()`.
`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`	`setAwaitTerminationMillis(long awaitTerminationMillis)`	Variant of `setAwaitTerminationSeconds(int)` with millisecond precision.
`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 ExecutorService.
`void`	`setThreadFactory(ThreadFactory threadFactory)`	Set the ThreadFactory to use for the ExecutorService'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 underlying ExecutorService.

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(@Nullable
                             ThreadFactory threadFactory)
```
    Set the ThreadFactory to use for the ExecutorService's thread pool. Default is the underlying ExecutorService's default thread factory.
    In a Java EE 7 or other managed environment with JSR-236 support, consider specifying a JNDI-located ManagedThreadFactory: by default, to be found at "java:comp/DefaultManagedThreadFactory". Use the "jee:jndi-lookup" namespace element in XML or the programmatic JndiLocatorDelegate for convenient lookup. Alternatively, consider using Spring's DefaultManagedAwareThreadFactory with its fallback to local threads in case of no managed thread factory found.
    See Also:
    Executors.defaultThreadFactory(), ManagedThreadFactory, DefaultManagedAwareThreadFactory
  - setThreadNamePrefix
```
public void setThreadNamePrefix(@Nullable
                                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(@Nullable
                                        RejectedExecutionHandler rejectedExecutionHandler)
```
    Set the RejectedExecutionHandler to use for the ExecutorService. Default is the ExecutorService'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:
    setAwaitTerminationMillis(long), ExecutorService.shutdown(), ExecutorService.awaitTermination(long, java.util.concurrent.TimeUnit)
  - setAwaitTerminationMillis
```
public void setAwaitTerminationMillis(long awaitTerminationMillis)
```
    Variant of setAwaitTerminationSeconds(int) with millisecond precision.
    Since:
    5.2.4
    See Also:
    setAwaitTerminationSeconds(int)
  - 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 underlying ExecutorService.
    See Also:
    ExecutorService.shutdown(), ExecutorService.shutdownNow()
  - cancelRemainingTask
```
protected void cancelRemainingTask(Runnable task)
```
    Cancel the given remaining task which never commended execution, as returned from ExecutorService.shutdownNow().
    Parameters:
    task - the task to cancel (typically a RunnableFuture)
    Since:
    5.0.5
    See Also:
    shutdown(), Future.cancel(boolean)

Class ExecutorConfigurationSupport

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class org.springframework.util.CustomizableThreadCreator

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

ExecutorConfigurationSupport

Method Detail

setThreadFactory

setThreadNamePrefix

setRejectedExecutionHandler

setWaitForTasksToCompleteOnShutdown

setAwaitTerminationSeconds

setAwaitTerminationMillis

setBeanName

afterPropertiesSet

initialize

initializeExecutor

destroy

shutdown

cancelRemainingTask