Top Description Fields Constructors Methods
org.springframework.scheduling.concurrent

public Class ThreadPoolExecutorFactoryBean

extends ExecutorConfigurationSupport
implements FactoryBean<ExecutorService>
Class Inheritance
All Implemented Interfaces
org.springframework.beans.factory.FactoryBean
Annotations
@SuppressWarnings:serial
Imports
java.util.concurrent.BlockingQueue, .ExecutorService, .Executors, .LinkedBlockingQueue, .RejectedExecutionHandler, .SynchronousQueue, .ThreadFactory, .ThreadPoolExecutor, .TimeUnit, org.springframework.beans.factory.FactoryBean, org.springframework.lang.Nullable
JavaBean that allows for configuring a java.util.concurrent.ThreadPoolExecutor in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its native java.util.concurrent.ExecutorService type.

The default configuration is a core pool size of 1, with unlimited max pool size and unlimited queue capacity. This is roughly equivalent to java.util.concurrent.Executors#newSingleThreadExecutor(), sharing a single thread for all tasks. Setting "queueCapacity" to 0 mimics java.util.concurrent.Executors#newCachedThreadPool(), with immediate scaling of threads in the pool to a potentially very high number. Consider also setting a "maxPoolSize" at that point, as well as possibly a higher "corePoolSize" (see also the "allowCoreThreadTimeOut" mode of scaling).

For an alternative, you may set up a ThreadPoolExecutor instance directly using constructor injection, or use a factory method definition that points to the java.util.concurrent.Executors class. This is strongly recommended in particular for common @Bean methods in configuration classes, where this FactoryBean variant would force you to return the FactoryBean type instead of the actual Executor type.

If you need a timing-based java.util.concurrent.ScheduledExecutorService instead, consider ScheduledExecutorFactoryBean.

Author
Juergen Hoeller
Since
3.0
See Also
java.util.concurrent.ExecutorService, java.util.concurrent.Executors, java.util.concurrent.ThreadPoolExecutor

Field Summary

Modifier and TypeField and Description
private boolean
allowCoreThreadTimeOut

private int
corePoolSize

private ExecutorService
exposedExecutor

private boolean
exposeUnconfigurableExecutor

private int
keepAliveSeconds

private int
maxPoolSize

private boolean
prestartAllCoreThreads

private int
queueCapacity

private boolean
strictEarlyShutdown

Inherited from org.springframework.scheduling.concurrent.ExecutorConfigurationSupport:
logger

Constructor Summary

AccessConstructor and Description
public
ThreadPoolExecutorFactoryBean()

Method Summary

Modifier and TypeMethod and Description
protected ThreadPoolExecutor

Returns:

a new ThreadPoolExecutor instance
createExecutor(int
the specified core pool size
corePoolSize, int
the specified maximum pool size
maxPoolSize, int
the specified keep-alive time in seconds
keepAliveSeconds, BlockingQueue<Runnable>
the BlockingQueue to use
queue, ThreadFactory
the ThreadFactory to use
threadFactory, RejectedExecutionHandler
the RejectedExecutionHandler to use
rejectedExecutionHandler)

Create a new instance of ThreadPoolExecutor or a subclass thereof.

protected BlockingQueue<Runnable>

Returns:

the BlockingQueue instance
createQueue(int
the specified queue capacity
queueCapacity)

Create the BlockingQueue to use for the ThreadPoolExecutor.

public ExecutorService
getObject()

Implements org.springframework.beans.factory.FactoryBean.getObject.

Return an instance (possibly shared or independent) of the object managed by this factory.
public Class<? extends ExecutorService>
getObjectType()

Implements org.springframework.beans.factory.FactoryBean.getObjectType.

Return the type of object that this FactoryBean creates, or null if not known in advance.
protected ExecutorService
initializeExecutor(ThreadFactory
the ThreadFactory to use
threadFactory, RejectedExecutionHandler
the RejectedExecutionHandler to use
rejectedExecutionHandler)

Implements abstract org.springframework.scheduling.concurrent.ExecutorConfigurationSupport.initializeExecutor.

Create the target java.util.concurrent.ExecutorService instance.
protected void
initiateEarlyShutdown()

Overrides org.springframework.scheduling.concurrent.ExecutorConfigurationSupport.initiateEarlyShutdown.

Early shutdown signal: do not trigger further tasks, let existing tasks complete before hitting the actual destruction step in the shutdown() method.
public boolean
isSingleton()

Overrides default org.springframework.beans.factory.FactoryBean.isSingleton.

Is the object managed by this factory a singleton?
public void
setAllowCoreThreadTimeOut(boolean allowCoreThreadTimeOut)

Specify whether to allow core threads to time out.

public void
setCorePoolSize(int corePoolSize)

Set the ThreadPoolExecutor's core pool size.

public void
setExposeUnconfigurableExecutor(boolean exposeUnconfigurableExecutor)

Specify whether this FactoryBean should expose an unconfigurable decorator for the created executor.

public void
setKeepAliveSeconds(int keepAliveSeconds)

Set the ThreadPoolExecutor's keep-alive seconds.

public void
setMaxPoolSize(int maxPoolSize)

Set the ThreadPoolExecutor's maximum pool size.

public void
setPrestartAllCoreThreads(boolean prestartAllCoreThreads)

Specify whether to start all core threads, causing them to idly wait for work.

public void
setQueueCapacity(int queueCapacity)

Set the capacity for the ThreadPoolExecutor's BlockingQueue.

public void
setStrictEarlyShutdown(boolean defaultEarlyShutdown)

Specify whether to initiate an early shutdown signal on context close, disposing all idle threads and rejecting further task submissions.

Inherited from org.springframework.scheduling.concurrent.ExecutorConfigurationSupport:
afterExecuteafterPropertiesSetbeforeExecutecancelRemainingTaskdestroygetPhaseinitializeinitiateShutdownisRunningonApplicationEventsetAcceptTasksAfterContextClosesetApplicationContextsetAwaitTerminationMillissetAwaitTerminationSecondssetBeanNamesetPhasesetRejectedExecutionHandlersetThreadFactorysetThreadNamePrefixsetWaitForTasksToCompleteOnShutdownshutdownstartstopstop

Field Detail

allowCoreThreadTimeOutback to summary
private boolean allowCoreThreadTimeOut
corePoolSizeback to summary
private int corePoolSize
exposedExecutorback to summary
private ExecutorService exposedExecutor
Annotations
@Nullable
exposeUnconfigurableExecutorback to summary
private boolean exposeUnconfigurableExecutor
keepAliveSecondsback to summary
private int keepAliveSeconds
maxPoolSizeback to summary
private int maxPoolSize
prestartAllCoreThreadsback to summary
private boolean prestartAllCoreThreads
queueCapacityback to summary
private int queueCapacity
strictEarlyShutdownback to summary
private boolean strictEarlyShutdown

Constructor Detail

ThreadPoolExecutorFactoryBeanback to summary
public ThreadPoolExecutorFactoryBean()

Method Detail

createExecutorback to summary
protected ThreadPoolExecutor createExecutor(int corePoolSize, int maxPoolSize, int keepAliveSeconds, BlockingQueue<Runnable> queue, ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler)

Create a new instance of ThreadPoolExecutor or a subclass thereof.

The default implementation creates a standard ThreadPoolExecutor. Can be overridden to provide custom ThreadPoolExecutor subclasses.

Parameters
corePoolSize:int

the specified core pool size

maxPoolSize:int

the specified maximum pool size

keepAliveSeconds:int

the specified keep-alive time in seconds

queue:BlockingQueue<Runnable>

the BlockingQueue to use

threadFactory:ThreadFactory

the ThreadFactory to use

rejectedExecutionHandler:RejectedExecutionHandler

the RejectedExecutionHandler to use

Returns:ThreadPoolExecutor

a new ThreadPoolExecutor instance

See Also
afterPropertiesSet()
createQueueback to summary
protected BlockingQueue<Runnable> createQueue(int queueCapacity)

Create the BlockingQueue to use for the ThreadPoolExecutor.

A LinkedBlockingQueue instance will be created for a positive capacity value; a SynchronousQueue else.

Parameters
queueCapacity:int

the specified queue capacity

Returns:BlockingQueue<Runnable>

the BlockingQueue instance

See Also
java.util.concurrent.LinkedBlockingQueue, java.util.concurrent.SynchronousQueue
getObjectback to summary
public ExecutorService getObject()

Implements org.springframework.beans.factory.FactoryBean.getObject.

Doc from org.springframework.beans.factory.FactoryBean.getObject.

Return an instance (possibly shared or independent) of the object managed by this factory.

As with a BeanFactory, this allows support for both the Singleton and Prototype design pattern.

If this FactoryBean is not fully initialized yet at the time of the call (for example because it is involved in a circular reference), throw a corresponding FactoryBeanNotInitializedException.

As of Spring 2.0, FactoryBeans are allowed to return null objects. The factory will consider this as normal value to be used; it will not throw a FactoryBeanNotInitializedException in this case anymore. FactoryBean implementations are encouraged to throw FactoryBeanNotInitializedException themselves now, as appropriate.

Returns:ExecutorService

an instance of the bean (can be null)

Annotations
@Override
@Nullable
getObjectTypeback to summary
public Class<? extends ExecutorService> getObjectType()

Implements org.springframework.beans.factory.FactoryBean.getObjectType.

Doc from org.springframework.beans.factory.FactoryBean.getObjectType.

Return the type of object that this FactoryBean creates, or null if not known in advance.

This allows one to check for specific types of beans without instantiating objects, for example on autowiring.

In the case of implementations that are creating a singleton object, this method should try to avoid singleton creation as far as possible; it should rather estimate the type in advance. For prototypes, returning a meaningful type here is advisable too.

This method can be called before this FactoryBean has been fully initialized. It must not rely on state created during initialization; of course, it can still use such state if available.

Note

Autowiring will simply ignore FactoryBeans that return null here. Therefore, it is highly recommended to implement this method properly, using the current state of the FactoryBean.

Returns:Class<? extends ExecutorService>

the type of object that this FactoryBean creates, or null if not known at the time of the call

Annotations
@Override
initializeExecutorback to summary
protected ExecutorService initializeExecutor(ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler)

Implements abstract org.springframework.scheduling.concurrent.ExecutorConfigurationSupport.initializeExecutor.

Doc from org.springframework.scheduling.concurrent.ExecutorConfigurationSupport.initializeExecutor.

Create the target java.util.concurrent.ExecutorService instance. Called by afterPropertiesSet.

Parameters
threadFactory:ThreadFactory

the ThreadFactory to use

rejectedExecutionHandler:RejectedExecutionHandler

the RejectedExecutionHandler to use

Returns:ExecutorService

a new ExecutorService instance

Annotations
@Override
initiateEarlyShutdownback to summary
protected void initiateEarlyShutdown()

Overrides org.springframework.scheduling.concurrent.ExecutorConfigurationSupport.initiateEarlyShutdown.

Doc from org.springframework.scheduling.concurrent.ExecutorConfigurationSupport.initiateEarlyShutdown.

Early shutdown signal: do not trigger further tasks, let existing tasks complete before hitting the actual destruction step in the shutdown() method. This goes along with a coordinated lifecycle stop phase.

Called from onApplicationEvent(ContextClosedEvent) if no indications for a late shutdown have been determined, that is, if the "acceptTasksAfterContextClose and "waitForTasksToCompleteOnShutdown" flags have not been set.

The default implementation calls initiateShutdown().

Annotations
@Override
isSingletonback to summary
public boolean isSingleton()

Overrides default org.springframework.beans.factory.FactoryBean.isSingleton.

Doc from org.springframework.beans.factory.FactoryBean.isSingleton.

Is the object managed by this factory a singleton? That is, will getObject() always return the same object (a reference that can be cached)?

Note

If a FactoryBean indicates to hold a singleton object, the object returned from getObject() might get cached by the owning BeanFactory. Hence, do not return true unless the FactoryBean always exposes the same reference.

The singleton status of the FactoryBean itself will generally be provided by the owning BeanFactory; usually, it has to be defined as singleton there.

Note

This method returning false does not necessarily indicate that returned objects are independent instances. An implementation of the extended SmartFactoryBean interface may explicitly indicate independent instances through its SmartFactoryBean#isPrototype() method. Plain FactoryBean implementations which do not implement this extended interface are simply assumed to always return independent instances if the isSingleton() implementation returns false.

The default implementation returns true, since a FactoryBean typically manages a singleton instance.

Returns:boolean

whether the exposed object is a singleton

Annotations
@Override
setAllowCoreThreadTimeOutback to summary
public void setAllowCoreThreadTimeOut(boolean allowCoreThreadTimeOut)

Specify whether to allow core threads to time out. This enables dynamic growing and shrinking even in combination with a non-zero queue (since the max pool size will only grow once the queue is full).

Default is "false".

See Also
java.util.concurrent.ThreadPoolExecutor#allowCoreThreadTimeOut(boolean)
setCorePoolSizeback to summary
public void setCorePoolSize(int corePoolSize)

Set the ThreadPoolExecutor's core pool size. Default is 1.

setExposeUnconfigurableExecutorback to summary
public void setExposeUnconfigurableExecutor(boolean exposeUnconfigurableExecutor)

Specify whether this FactoryBean should expose an unconfigurable decorator for the created executor.

Default is "false", exposing the raw executor as bean reference. Switch this flag to "true" to strictly prevent clients from modifying the executor's configuration.

See Also
java.util.concurrent.Executors#unconfigurableExecutorService
setKeepAliveSecondsback to summary
public void setKeepAliveSeconds(int keepAliveSeconds)

Set the ThreadPoolExecutor's keep-alive seconds. Default is 60.

setMaxPoolSizeback to summary
public void setMaxPoolSize(int maxPoolSize)

Set the ThreadPoolExecutor's maximum pool size. Default is Integer.MAX_VALUE.

setPrestartAllCoreThreadsback to summary
public void setPrestartAllCoreThreads(boolean prestartAllCoreThreads)

Specify whether to start all core threads, causing them to idly wait for work.

Default is "false".

Since
5.3.14
See Also
java.util.concurrent.ThreadPoolExecutor#prestartAllCoreThreads
setQueueCapacityback to summary
public void setQueueCapacity(int queueCapacity)

Set the capacity for the ThreadPoolExecutor's BlockingQueue. Default is Integer.MAX_VALUE.

Any positive value will lead to a LinkedBlockingQueue instance; any other value will lead to a SynchronousQueue instance.

See Also
java.util.concurrent.LinkedBlockingQueue, java.util.concurrent.SynchronousQueue
setStrictEarlyShutdownback to summary
public void setStrictEarlyShutdown(boolean defaultEarlyShutdown)

Specify whether to initiate an early shutdown signal on context close, disposing all idle threads and rejecting further task submissions.

Default is "false". See ThreadPoolTaskExecutor#setStrictEarlyShutdown for details.

Since
6.1.4
See Also
initiateShutdown()