public  void afterPropertiesSet() 
{
		initialize();
}

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

 protected BlockingQueue createQueue(int queueCapacity) 
{
		if (queueCapacity  > 0) {
			return new LinkedBlockingQueue(queueCapacity);
		}
		else {
			return new SynchronousQueue();
		}
}

Create the BlockingQueue to use for the ThreadPoolExecutor.

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

 public  void destroy() 
{
		shutdown();
}

Calls shutdown when the BeanFactory destroys the task executor instance.

 public  void execute(Runnable task) 
{
		Executor executor = getThreadPoolExecutor();
		try {
			executor.execute(task);
		}
		catch (RejectedExecutionException ex) {
			throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
		}
}

Implementation of both the JSR-166 backport Executor interface and the Spring TaskExecutor interface, delegating to the ThreadPoolExecutor instance.

 public int getActiveCount() 
{
		return getThreadPoolExecutor().getActiveCount();
}

Return the number of currently active threads.

 public int getCorePoolSize() 
{
		synchronized (this.poolSizeMonitor) {
			return this.corePoolSize;
		}
}

Return the ThreadPoolExecutor's core pool size.

 public int getKeepAliveSeconds() 
{
		synchronized (this.poolSizeMonitor) {
			return this.keepAliveSeconds;
		}
}

Return the ThreadPoolExecutor's keep-alive seconds.

 public int getMaxPoolSize() 
{
		synchronized (this.poolSizeMonitor) {
			return this.maxPoolSize;
		}
}

Return the ThreadPoolExecutor's maximum pool size.

 public int getPoolSize() 
{
		return getThreadPoolExecutor().getPoolSize();
}

Return the current pool size.

 public ThreadPoolExecutor getThreadPoolExecutor() throws IllegalStateException 
{
		Assert.state(this.threadPoolExecutor != null, "ThreadPoolTaskExecutor not initialized");
		return this.threadPoolExecutor;
}

Return the underlying ThreadPoolExecutor for native access.

 public  void initialize() 
{
		if (logger.isInfoEnabled()) {
			logger.info("Initializing ThreadPoolExecutor" + (this.beanName != null ? " '" + this.beanName + "'" : ""));
		}
		if (!this.threadNamePrefixSet && this.beanName != null) {
			setThreadNamePrefix(this.beanName + "-");
		}
		BlockingQueue queue = createQueue(this.queueCapacity);
		this.threadPoolExecutor = new ThreadPoolExecutor(
				this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
				queue, this.threadFactory, this.rejectedExecutionHandler);
		if (this.allowCoreThreadTimeOut) {
			this.threadPoolExecutor.allowCoreThreadTimeOut(true);
		}
}

Creates the BlockingQueue and the ThreadPoolExecutor.

 public boolean prefersShortLivedTasks() 
{
		return true;
}

This task executor prefers short-lived work units.

 public  void setAllowCoreThreadTimeOut(boolean allowCoreThreadTimeOut) 
{
		this.allowCoreThreadTimeOut = 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". Note that this feature is only available on backport-concurrent 3.0 or above (based on the code in Java 6).

 public  void setBeanName(String name) 
{
		this.beanName = name;
}

 public  void setCorePoolSize(int corePoolSize) 
{
	                    	 
		synchronized (this.poolSizeMonitor) {
			this.corePoolSize = corePoolSize;
			if (this.threadPoolExecutor != null) {
				this.threadPoolExecutor.setCorePoolSize(corePoolSize);
			}
		}
}

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

This setting can be modified at runtime, for example through JMX.

 public  void setKeepAliveSeconds(int keepAliveSeconds) 
{
		synchronized (this.poolSizeMonitor) {
			this.keepAliveSeconds = keepAliveSeconds;
			if (this.threadPoolExecutor != null) {
				this.threadPoolExecutor.setKeepAliveTime(keepAliveSeconds, TimeUnit.SECONDS);
			}
		}
}

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

This setting can be modified at runtime, for example through JMX.

 public  void setMaxPoolSize(int maxPoolSize) 
{
		synchronized (this.poolSizeMonitor) {
			this.maxPoolSize = maxPoolSize;
			if (this.threadPoolExecutor != null) {
				this.threadPoolExecutor.setMaximumPoolSize(maxPoolSize);
			}
		}
}

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

This setting can be modified at runtime, for example through JMX.

 public  void setQueueCapacity(int queueCapacity) 
{
		this.queueCapacity = 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.

 public  void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) 
{
		this.rejectedExecutionHandler =
				(rejectedExecutionHandler != null ? rejectedExecutionHandler : new ThreadPoolExecutor.AbortPolicy());
}

Set the RejectedExecutionHandler to use for the ThreadPoolExecutor. Default is the ThreadPoolExecutor's default abort policy.

 public  void setThreadFactory(ThreadFactory threadFactory) 
{
		this.threadFactory = (threadFactory != null ? threadFactory : this);
}

Set the ThreadFactory to use for the ThreadPoolExecutor's thread pool.

Default is this executor itself (i.e. the factory that this executor inherits from). See org.springframework.util.CustomizableThreadCreator 's javadoc for available bean properties.

 public  void setThreadNamePrefix(String threadNamePrefix) 
{
		super.setThreadNamePrefix(threadNamePrefix);
		this.threadNamePrefixSet = true;
}

 public  void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) 
{
		this.waitForTasksToCompleteOnShutdown = waitForJobsToCompleteOnShutdown;
}

Set whether to wait for scheduled tasks to complete on shutdown.

Default is "false". Switch this to "true" if you prefer fully completed tasks at the expense of a longer shutdown phase.

 public  void shutdown() 
{
		if (logger.isInfoEnabled()) {
			logger.info("Shutting down ThreadPoolExecutor" + (this.beanName != null ? " '" + this.beanName + "'" : ""));
		}
		if (this.waitForTasksToCompleteOnShutdown) {
			this.threadPoolExecutor.shutdown();
		}
		else {
			this.threadPoolExecutor.shutdownNow();
		}
}

Perform a shutdown on the ThreadPoolExecutor.