public abstract class ExecutorConfigurationSupport extends CustomizableThreadFactory implements BeanNameAware, InitializingBean, DisposableBean
ThreadPoolExecutor). Defines common configuration settings and common lifecycle handling.
ThreadPoolExecutor, Serialized Form
|Constructor and Description|
|Modifier and Type||Method and Description|
Set up the ExecutorService.
Create the target
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.
Set the name of the bean in the bean factory that created this bean.
Set the RejectedExecutionHandler to use for the ExecutorService.
Set the ThreadFactory to use for the ExecutorService's thread pool.
Specify the prefix to use for the names of newly created threads.
Set whether to wait for scheduled tasks to complete on shutdown, not interrupting running tasks and executing all tasks in the queue.
Perform a shutdown on the underlying ExecutorService.
createThread, getDefaultThreadNamePrefix, getThreadGroup, getThreadNamePrefix, getThreadPriority, isDaemon, nextThreadName, setDaemon, setThreadGroup, setThreadGroupName, setThreadPriority
protected final Log logger
public void setThreadFactory(java.util.concurrent.ThreadFactory threadFactory)
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
with its fallback to local threads in case of no managed thread factory found.
public void setThreadNamePrefix(java.lang.String threadNamePrefix)
public void setRejectedExecutionHandler(java.util.concurrent.RejectedExecutionHandler rejectedExecutionHandler)
public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)
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 -,
property instead of or in addition to this property.
public void setAwaitTerminationSeconds(int awaitTerminationSeconds)
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
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
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.
public void setBeanName(java.lang.String name)
Invoked after population of normal bean properties but before an
init callback such as
or a custom init-method.
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.
public void afterPropertiesSet()
initialize()after the container applied all property values.
public void initialize()
protected abstract java.util.concurrent.ExecutorService initializeExecutor(java.util.concurrent.ThreadFactory threadFactory, java.util.concurrent.RejectedExecutionHandler rejectedExecutionHandler)
ExecutorServiceinstance. Called by
threadFactory- the ThreadFactory to use
rejectedExecutionHandler- the RejectedExecutionHandler to use
public void destroy()
shutdownwhen the BeanFactory destroys the task executor instance.
public void shutdown()