spirng的ThreadPoolExecutor

模仿一般数据库连接池的配置，看了BoneCP的源代码实现，里面关于BoneCPConfig类的实现，采用了ThreadPoolExecutor的实现方式，然后就想到采用spring的注入方式，ThreadPoolExecutor在异步处理方面做得相当好。

那么接下来看下实现方式！

stpe1: spirng.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<!-- Beans Declaration -->
	<bean id="TestTask" class="org.ibyoung.task.TestTask"></bean>
	<bean id="ThreadPoolMonitorService" class="org.ibyoung.monitor.srv.ThreadPoolMonitorService">
		<property name="monitoringPeriod"  value="5" />
	</bean>
    <bean id="TestRejectedExecutionHandler" class="org.ibyoung.handler.TestRejectedExecutionHandler"></bean>
    <bean id="TestThreadPoolExecutorService" class="org.ibyoung.srv.TestThreadPoolExecutorService">
		<property name="corePoolSize"  value="1" />
		<property name="maxPoolSize"   value="3" />
		<property name="keepAliveTime" value="1" />
		<property name="queueCapacity" value="3" />
		<property name="testRejectedExecutionHandler" ref="TestRejectedExecutionHandler" />
	</bean>
	<bean id="Starter" class="org.ibyoung.start.Starter">
		<property name="threadPoolMonitorService" ref="ThreadPoolMonitorService" />
		<property name="testThreadPoolExecutorService" ref="TestThreadPoolExecutorService" />
	</bean>
</beans>

 step2: 声明配置文件

import java.util.concurrent.ThreadPoolExecutor;

import com.otv.handler.TestRejectedExecutionHandler;

/**
 * 
 * @author chenyang
 * 
 */
public interface ITestThreadPoolExecutorService {

	public ThreadPoolExecutor createNewThreadPool();

	public int getCorePoolSize();

	public void setCorePoolSize(int corePoolSize);

	public int getMaxPoolSize();

	public void setMaxPoolSize(int maximumPoolSize);

	public long getKeepAliveTime();

	public void setKeepAliveTime(long keepAliveTime);

	public int getQueueCapacity();

	public void setQueueCapacity(int queueCapacity);

	public TestRejectedExecutionHandler getTestRejectedExecutionHandler();

	public void setTestRejectedExecutionHandler(TestRejectedExecutionHandler testRejectedExecutionHandler);

}

 step3: 实现

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.otv.handler.TestRejectedExecutionHandler;

/**
 * 
 * @author chenyang
 * 
 */
public class TestThreadPoolExecutorService implements ITestThreadPoolExecutorService {

	private int  corePoolSize;
	private int  maxPoolSize; 
	private long keepAliveTime;
	private int  queueCapacity;
	TestRejectedExecutionHandler testRejectedExecutionHandler;
	
	public ThreadPoolExecutor createNewThreadPool() {
		ThreadPoolExecutor executor = new ThreadPoolExecutor(getCorePoolSize(), 
																getMaxPoolSize(), 
																getKeepAliveTime(), 
																TimeUnit.SECONDS, 
																new ArrayBlockingQueue<Runnable>(getQueueCapacity()), 
																getTestRejectedExecutionHandler());
		return executor;
	}
	
	public int getCorePoolSize() {
		return corePoolSize;
	}
	
	public void setCorePoolSize(int corePoolSize) {
		this.corePoolSize = corePoolSize;
	}
	
	public int getMaxPoolSize() {
		return maxPoolSize;
	}
	
	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}
	
	public long getKeepAliveTime() {
		return keepAliveTime;
	}
	
	public void setKeepAliveTime(long keepAliveTime) {
		this.keepAliveTime = keepAliveTime;
	}
	
	public int getQueueCapacity() {
		return queueCapacity;
	}

	public void setQueueCapacity(int queueCapacity) {
		this.queueCapacity = queueCapacity;
	}
	
	public TestRejectedExecutionHandler getTestRejectedExecutionHandler() {
		return testRejectedExecutionHandler;
	}

	public void setTestRejectedExecutionHandler(TestRejectedExecutionHandler testRejectedExecutionHandler) {
		this.testRejectedExecutionHandler = testRejectedExecutionHandler;
	}

}

 step4: 监听类

import java.util.concurrent.ThreadPoolExecutor;

public interface IThreadPoolMonitorService extends Runnable {

	public void monitorThreadPool();
	
	public ThreadPoolExecutor getExecutor();
	
	public void setExecutor(ThreadPoolExecutor executor);
	
}

 step5: 服务启动类

import java.util.concurrent.ThreadPoolExecutor;

/**
 * 
 * @author chenyang
 * 
 */
public class Starter {
	
	private static Logger log = Logger.getLogger(TestRejectedExecutionHandler.class);
	
	IThreadPoolMonitorService threadPoolMonitorService;
	ITestThreadPoolExecutorService testThreadPoolExecutorService;
	
	public void start() {
		
		ThreadPoolExecutor executor = testThreadPoolExecutorService.createNewThreadPool();
		executor.allowCoreThreadTimeOut(true);
		
		threadPoolMonitorService.setExecutor(executor);
		
		Thread monitor = new Thread(threadPoolMonitorService);
		monitor.start();

		for(int i=1;i<10;i++) {
			executor.execute(new TestTask("Task"+i));
		}
		
		try	{
		    Thread.sleep(40000);
		} catch (Exception e)	{
		    log.error(e.getMessage());
		}
		System.out.println("-------------------------------------------");
		for(int i=10;i<19;i++) {
			executor.execute(new TestTask("Task"+i));
		}
		
		executor.shutdown();
	}	

	public IThreadPoolMonitorService getThreadPoolMonitorService() {
		return threadPoolMonitorService;
	}

	public void setThreadPoolMonitorService(IThreadPoolMonitorService threadPoolMonitorService) {
		this.threadPoolMonitorService = threadPoolMonitorService;
	}

	public ITestThreadPoolExecutorService getTestThreadPoolExecutorService() {
		return testThreadPoolExecutorService;
	}

	public void setTestThreadPoolExecutorService(ITestThreadPoolExecutorService testThreadPoolExecutorService) {
		this.testThreadPoolExecutorService = testThreadPoolExecutorService;
	}
}