public abstract class ExecutorConfigurationSupport extends CustomizableThreadFactory implements org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean, org.springframework.beans.factory.DisposableBean
ExecutorService
(typically a ThreadPoolExecutor
or
ScheduledThreadPoolExecutor
).
Defines common configuration settings and common lifecycle handling,
inheriting thread customization options (name, priority, etc) from
CustomizableThreadCreator
.
ExecutorService
,
Executors
,
ThreadPoolExecutor
,
ScheduledThreadPoolExecutor
,
Serialized FormConstructor and Description |
---|
ExecutorConfigurationSupport() |
Modifier and Type | Method and 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 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) |
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) |
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 full shutdown on the underlying ExecutorService,
according to the corresponding configuration settings.
|
newThread
protected final Log logger
public void setThreadFactory(@Nullable 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 DefaultManagedAwareThreadFactory
with its fallback to local threads in case of no managed thread factory found.
public void setThreadNamePrefix(@Nullable String threadNamePrefix)
setThreadNamePrefix
in class org.springframework.util.CustomizableThreadCreator
public void setRejectedExecutionHandler(@Nullable RejectedExecutionHandler rejectedExecutionHandler)
ThreadPoolExecutor.AbortPolicy
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 -,
set the "awaitTerminationSeconds"
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
"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.
public void setAwaitTerminationMillis(long awaitTerminationMillis)
setAwaitTerminationSeconds(int)
with millisecond precision.setAwaitTerminationSeconds(int)
public void setBeanName(String name)
setBeanName
in interface org.springframework.beans.factory.BeanNameAware
public void afterPropertiesSet()
initialize()
after the container applied all property values.afterPropertiesSet
in interface org.springframework.beans.factory.InitializingBean
initialize()
public void initialize()
protected abstract ExecutorService initializeExecutor(ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler)
ExecutorService
instance.
Called by afterPropertiesSet
.threadFactory
- the ThreadFactory to userejectedExecutionHandler
- the RejectedExecutionHandler to useafterPropertiesSet()
public void destroy()
shutdown
when the BeanFactory destroys the executor instance.destroy
in interface org.springframework.beans.factory.DisposableBean
shutdown()
public void shutdown()
protected void cancelRemainingTask(Runnable task)
ExecutorService.shutdownNow()
.task
- the task to cancel (typically a RunnableFuture
)shutdown()
,
Future.cancel(boolean)