ThreadPoolExecutor可扩展性

编写一个ThreadPoolExecutorExtention类继承ThreadPoolExecutorchong并且重写beforeExecute()、afterExecute()、terminated()

package Thread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorExtention extends ThreadPoolExecutor{

	//默认一个构造方法
	public ThreadPoolExecutorExtention(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
			BlockingQueue<Runnable> workQueue,  RejectedExecutionHandler handler) {
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
		// TODO Auto-generated constructor stub
	}

	/**
	 * 在每个任务执行之前调用
	 */
	@Override
	protected void beforeExecute(Thread t, Runnable r) {
		 System.out.println("===beforeExecute==="); 
		super.beforeExecute(t, r);
	}

	/**
	 * 在每个任务执行之后调用
	 */
	@Override
	protected void afterExecute(Runnable r, Throwable t) {
		System.out.println("===afterExecute==="); 
		super.afterExecute(r, t);
	}
	/**
	 * 任务执行完成后最后调用
	 */
	@Override
	protected void terminated() {
		System.out.println("===terminated==="); 
		super.terminated();
	}
}
/**
 * 创建一个任务类
 * @date: 2017年5月8日 下午2:06:17
 */
class MyTask implements Runnable {
	private int taskNum;

	public MyTask(int num) {
		this.taskNum = num;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("正在执行task " + taskNum);
		try {
			Thread.currentThread().sleep(4);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("task " + taskNum + "执行完毕");
	}
}

编写一个测试类测试：

package Thread;

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

public class ThreadPoolExecutorExtentioTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ThreadPoolExecutorExtention executor = new ThreadPoolExecutorExtention(5, 10, 200, TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<Runnable>(5), new ThreadPoolExecutor.CallerRunsPolicy());
		for (int i = 0; i < 15; i++) {
			MyTask myTask = new MyTask(i);
			executor.allowCoreThreadTimeOut(true);
			executor.execute(myTask);
			System.out.println("线程池中线程数目：" + executor.getPoolSize() + "，队列中等待执行的任务数目：" + executor.getQueue().size()
					+ "，已执行完别的任务数目：" + executor.getCompletedTaskCount());
		}
		executor.shutdown();
	}
}

最终的执行结果：

===beforeExecute===
正在执行task 0
线程池中线程数目：1，队列中等待执行的任务数目：0，已执行完别的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行完别的任务数目：0
===beforeExecute===
正在执行task 1
线程池中线程数目：3，队列中等待执行的任务数目：0，已执行完别的任务数目：0
===beforeExecute===
正在执行task 2
线程池中线程数目：4，队列中等待执行的任务数目：0，已执行完别的任务数目：0
===beforeExecute===
正在执行task 3
线程池中线程数目：5，队列中等待执行的任务数目：0，已执行完别的任务数目：0
===beforeExecute===
正在执行task 4
线程池中线程数目：5，队列中等待执行的任务数目：1，已执行完别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：2，已执行完别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：3，已执行完别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：4，已执行完别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：5，已执行完别的任务数目：0
线程池中线程数目：6，队列中等待执行的任务数目：5，已执行完别的任务数目：0
===beforeExecute===
正在执行task 10
===beforeExecute===
正在执行task 11
线程池中线程数目：7，队列中等待执行的任务数目：5，已执行完别的任务数目：0
线程池中线程数目：8，队列中等待执行的任务数目：5，已执行完别的任务数目：0
线程池中线程数目：9，队列中等待执行的任务数目：5，已执行完别的任务数目：0
===beforeExecute===
正在执行task 13
线程池中线程数目：10，队列中等待执行的任务数目：5，已执行完别的任务数目：0
===beforeExecute===
正在执行task 14
===beforeExecute===
正在执行task 12
task 0执行完毕
===afterExecute===
===beforeExecute===
正在执行task 5
task 1执行完毕
===afterExecute===
task 4执行完毕
===afterExecute===
===beforeExecute===
task 3执行完毕
===afterExecute===
task 2执行完毕
===afterExecute===
===beforeExecute===
正在执行task 8
正在执行task 7
===beforeExecute===
正在执行task 6
===beforeExecute===
正在执行task 9
task 11执行完毕
===afterExecute===
task 13执行完毕
===afterExecute===
task 12执行完毕
===afterExecute===
task 14执行完毕
===afterExecute===
task 10执行完毕
===afterExecute===
task 5执行完毕
===afterExecute===
task 8执行完毕
===afterExecute===
task 6执行完毕
===afterExecute===
task 9执行完毕
===afterExecute===
task 7执行完毕
===afterExecute===
===terminated===