jdk1.5新特性之ThreadPoolExecutor线程池

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

/*
		 public ThreadPoolExecutor( int corePoolSize,
		
		 int maximumPoolSize,
		
		 long keepAliveTime,
		
		 TimeUnit unit,
		
		 BlockingQueue<Runnable> workQueue,
		
		 RejectedExecutionHandler handler) {
		
		 this (corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
		
		 Executors. defaultThreadFactory (), handler);
		
		 }
		
		 corePoolSize ：线程池维护线程的最少数量，哪怕是空闲的。
		
		 maximumPoolSize ：线程池维护线程的最大数量。
		
		 keepAliveTime ：线程池维护线程所允许的空闲时间。
		
		 unit ：线程池维护线程所允许的空闲时间的单位。
		
		 workQueue ：线程池所使用的缓冲队列，改缓冲队列的长度决定了能够缓冲的最大数量。就是等待进入线程池的队列。
		
		 拒绝任务：拒绝任务是指当线程池里面的线程数量达到 maximumPoolSize 且 workQueue 队列已满的情况下被尝试添加进来的任务。
		
		 handler ：线程池对拒绝任务的处理策略。在 ThreadPoolExecutor 里面定义了 4 种 handler 策略，分别是
		
		 1. CallerRunsPolicy ：这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功。2,3,4则分别是对超过缓冲队列的请求要么抛弃要么报错，所以一般使用第一个，这样不会对请求有任何丢失的问题。
		
		 2. AbortPolicy ：对拒绝任务抛弃处理，并且抛出异常。
		
		 3. DiscardPolicy ：对拒绝任务直接无声抛弃，没有异常信息。
		
		 4. DiscardOldestPolicy ：对拒绝任务不抛弃，而是抛弃队列里面等待最久的一个线程，然后把拒绝任务加到队列。 
 
 */


public class TestThreadPool {

	private static int produceTaskSleepTime = 2;

	private static int consumeTaskSleepTime = 2000;

	private static int produceTaskMaxNumber = 9;

	public static void main(String[] args) {

		// 构造一个线程池
		ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 3, 3,
				TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2),
				new ThreadPoolExecutor.CallerRunsPolicy());
		for (int i = 1; i <= produceTaskMaxNumber; i++) {
			try {
				// 产生一个任务，并将其加入到线程池
				String task = "task@ " + i;
				System.out.println("put " + task);
				threadPool.execute(new ThreadPoolTask(task));

				// 便于观察，等待一段时间
				Thread.sleep(produceTaskSleepTime);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public static class ThreadPoolTask implements Runnable, Serializable {
		private static final long serialVersionUID = 0;

		// 保存任务所需要的数据
		private Object threadPoolTaskData;

		ThreadPoolTask(Object tasks) {
			this.threadPoolTaskData = tasks;
		}

		public void run() {
			// 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句
			System.out.println("start .." + threadPoolTaskData);
			try {
				// // 便于观察，等待一段时间
				Thread.sleep(consumeTaskSleepTime);
			} catch (Exception e) {
				e.printStackTrace();
			}
			System.out.println("end .." + threadPoolTaskData);
			threadPoolTaskData = null;
		}

		public Object getTask() {
			return this.threadPoolTaskData;
		}
	}
}
//下面说明一下 本test实际上是针对最大3个线程的池加入9个请求，队列数量是2个，那么最大处理请求是5个，超
//过了4个，然而使用第一种handler则会重新尝试请求这超过的4个请求直到全部成功为止。如果选择其他3种
//handler那么就会处理不完全。
//另外，如果这次请求没有超过最大请求数的话，线程会继续挂起等待后续请求，直到请求数到最大请求或者超过最大
//请求数后才结束一次线程池维护。然后根据设置线程池维护的等待时间，继续下一次的线程池维护。