public abstract Class ExecutorConfigurationSupport

Implements org.springframework.beans.factory.InitializingBean.afterPropertiesSet.

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

Annotations

@Override

See Also

initialize()

Implements org.springframework.beans.factory.DisposableBean.destroy.

Calls shutdown when the BeanFactory destroys the executor instance.

Annotations

@Override

See Also

shutdown()

Overrides default org.springframework.context.SmartLifecycle.getPhase.

Return the lifecycle phase for pausing and resuming this executor.

Annotations

@Override

Since

6.1

See Also

setPhase

Set up the ExecutorService.

Initiate a shutdown on the underlying ExecutorService, rejecting further task submissions.

The executor will not accept further tasks and will prevent further scheduling of periodic tasks, letting existing tasks complete still. This step is non-blocking and can be applied as an early shutdown signal before following up with a full shutdown() call later on.

Automatically called for early shutdown signals on context close. Can be manually called as well, in particular outside a container.

Since

6.1

See Also

shutdown(), java.util.concurrent.ExecutorService#shutdown()

Implements org.springframework.context.Lifecycle.isRunning.

Check whether this executor is not paused and has not been shut down either.

Returns:boolean

Doc from org.springframework.context.Lifecycle.isRunning.

whether the component is currently running

Annotations

@Override

Since

6.1

See Also

start(), stop()

Implements org.springframework.context.ApplicationListener.onApplicationEvent.

ContextClosedEvent handler for initiating an early shutdown.

Parameters

event:ContextClosedEvent

Doc from org.springframework.context.ApplicationListener.onApplicationEvent.

the event to respond to

Annotations

@Override

Since

6.1

See Also

initiateShutdown()

Set whether to accept further tasks after the application context close phase has begun.

The default is false as of 6.1, triggering an early soft shutdown of the executor and therefore rejecting any further task submissions. Switch this to true in order to let other components submit tasks even during their own stop and destruction callbacks, at the expense of a longer shutdown phase. The executor will not go through a coordinated lifecycle stop phase then but rather only stop tasks on its own shutdown.

acceptTasksAfterContextClose=true like behavior also follows from "waitForTasksToCompleteOnShutdown" which effectively is a specific variant of this flag, replacing the early soft shutdown in the concurrent managed stop phase with a serial soft shutdown in the executor's destruction step, with individual awaiting according to the "awaitTerminationSeconds" property.

This flag will only have effect when the executor is running in a Spring application context and able to receive the ContextClosedEvent. Also, note that ThreadPoolTaskExecutor effectively accepts tasks after context close by default, in combination with a coordinated lifecycle stop, unless "strictEarlyShutdown" has been specified.

Since

6.1

See Also

org.springframework.context.ConfigurableApplicationContext#close(), DisposableBean#destroy(), shutdown(), setAwaitTerminationSeconds

Implements org.springframework.context.ApplicationContextAware.setApplicationContext.

Doc from org.springframework.context.ApplicationContextAware.setApplicationContext.

Set the ApplicationContext that this object runs in. Normally this call will be used to initialize the object.

Invoked after population of normal bean properties but before an init callback such as org.springframework.beans.factory.InitializingBean#afterPropertiesSet() or a custom init-method. Invoked after ResourceLoaderAware#setResourceLoader, ApplicationEventPublisherAware#setApplicationEventPublisher and MessageSourceAware, if applicable.

Parameters

applicationContext:ApplicationContext

the ApplicationContext object to be used by this object

Annotations

@Override

Variant of setAwaitTerminationSeconds with millisecond precision.

Since

5.2.4

See Also

setAwaitTerminationSeconds

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, java.util.concurrent.ExecutorService#shutdown(), java.util.concurrent.ExecutorService#awaitTermination

Implements org.springframework.beans.factory.BeanNameAware.setBeanName.

Doc from org.springframework.beans.factory.BeanNameAware.setBeanName.

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.

Parameters

name:String

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.

Annotations

@Override

Specify the lifecycle phase for pausing and resuming this executor. The default is DEFAULT_PHASE.

Since

6.1

See Also

SmartLifecycle#getPhase()

Set the RejectedExecutionHandler to use for the ExecutorService. The default is the ExecutorService's default abort policy.

See Also

java.util.concurrent.ThreadPoolExecutor.AbortPolicy

Set the ThreadFactory to use for the ExecutorService's thread pool. The default is the underlying ExecutorService's default thread factory.

In a Jakarta EE 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 org.springframework.jndi.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

java.util.concurrent.Executors#defaultThreadFactory(), jakarta.enterprise.concurrent.ManagedThreadFactory, DefaultManagedAwareThreadFactory

Overrides org.springframework.util.CustomizableThreadCreator.setThreadNamePrefix.

Doc from org.springframework.util.CustomizableThreadCreator.setThreadNamePrefix.

Specify the prefix to use for the names of newly created threads. Default is "SimpleAsyncTaskExecutor-".

Annotations

@Override

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

The default is false, with a coordinated lifecycle stop first (unless "acceptTasksAfterContextClose" has been set) and then an immediate shutdown 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. The executor will not go through a coordinated lifecycle stop phase then but rather only stop and wait for task completion on its own shutdown.

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

java.util.concurrent.ExecutorService#shutdown(), java.util.concurrent.ExecutorService#shutdownNow(), shutdown(), setAwaitTerminationSeconds

Perform a full shutdown on the underlying ExecutorService, according to the corresponding configuration settings.

This step potentially blocks for the configured termination period, waiting for remaining tasks to complete. For an early shutdown signal to not accept further tasks, call initiateShutdown() first.

See Also

setWaitForTasksToCompleteOnShutdown, setAwaitTerminationMillis, java.util.concurrent.ExecutorService#shutdown(), java.util.concurrent.ExecutorService#shutdownNow(), java.util.concurrent.ExecutorService#awaitTermination

Implements org.springframework.context.Lifecycle.start.

Resume this executor if paused before (otherwise a no-op).

Annotations

@Override

Since

6.1

Implements org.springframework.context.Lifecycle.stop.

Pause this executor, not waiting for tasks to complete.

Annotations

@Override

Since

6.1

Overrides default org.springframework.context.SmartLifecycle.stop.

Pause this executor, triggering the given callback once all currently executing tasks have completed.

Annotations

@Override

Since

6.1