jdk1.5线程池

一、API研究

线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为：

ThreadPoolExecutor(int corePoolSize,   
                   int maximumPoolSize,   
                   long keepAliveTime, TimeUnit unit,   
                   BlockingQueue<Runnable> workQueue,   
                   RejectedExecutionHandler handler)  

•corePoolSize
线程池维护线程的最少数量
•maximumPoolSiz
线程池维护线程的最大数量
•keepAliveTime
线程池维护线程所允许的空闲时间
•unit
线程池维护线程所允许的空闲时间的单位
•workQueue
线程池所使用的缓冲队列
•handler
线程池对拒绝任务的处理策略

一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。

看这个参数很容易让人以为是线程池里保持corePoolSize个线程，如果不够用，就加线程入池直至maximumPoolSize大小，如果还不够就往workQueue里加，如果workQueue也不够就用RejectedExecutionHandler来做拒绝处理。

但实际情况不是这样，具体流程如下：

1）当池子大小小于corePoolSize就新建线程，并处理请求

2）当池子大小等于corePoolSize，把请求放入workQueue中，池子里的空闲线程就去从workQueue中取任务并处理

3）当workQueue放不下新入的任务时，新建线程入池，并处理请求，如果池子大小撑到了maximumPoolSize就用RejectedExecutionHandler来做拒绝处理

4）另外，当池子的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁

当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue

handler有四个选择： •ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
•ThreadPoolExecutor.CallerRunsPolicy()
由调用者执行这个任务
•ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
•ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务

java.util.concurrent.Executors工具类还提供了以下几个连接池：

a.       static ExecutorService newCachedThreadPool()

产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用
比较适合没有固定大小并且比较快速就能完成的小任务。

b.       static ExecutorService newFixedThreadPool(int poolSize)

产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个queue里顺序执行

c.       static ExecutorService newSingleThreadExecutor()

产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。
d. static ScheduledExecutorServicenewSingleThreadScheduledExecutor()
创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
e. static ScheduledExecutorServicenewSingleThreadScheduledExecutor()：创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
f.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) :用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。

二，示例解析

package cn.gaialine.threadpool;

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

/**
 * 线程池测试用例
 * @author yangyong
 *
 */
public class TestThreadPool {
	//线程池维护线程的最少数量
	private static final int COREPOOLSIZE = 2;
	//线程池维护线程的最大数量
	private static final int MAXINUMPOOLSIZE = 5;
	//线程池维护线程所允许的空闲时间
	private static final long KEEPALIVETIME = 4;
	//线程池维护线程所允许的空闲时间的单位
	private static final TimeUnit UNIT = TimeUnit.SECONDS;
	//线程池所使用的缓冲队列,这里队列大小为3
	private static final BlockingQueue<Runnable> WORKQUEUE = new ArrayBlockingQueue<Runnable>(3);
	//线程池对拒绝任务的处理策略：AbortPolicy为抛出异常；CallerRunsPolicy为重试添加当前的任务，他会自动重复调用execute()方法；DiscardOldestPolicy为抛弃旧的任务，DiscardPolicy为抛弃当前的任务
	private static final AbortPolicy HANDLER = new ThreadPoolExecutor.AbortPolicy();

	public static void main(String[] args) {
		// TODO 初始化线程池
		ThreadPoolExecutor threadPool = new ThreadPoolExecutor(COREPOOLSIZE, MAXINUMPOOLSIZE, KEEPALIVETIME, UNIT, WORKQUEUE, HANDLER);
		for (int i = 1; i < 11; i++) {
			String task = "task@"+i;
			System.out.println("put->"+task);
			//一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法
			
			threadPool.execute(new ThreadPoolTask(task));
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		threadPool.shutdown();//关闭主线程，但线程池会继续运行，直到所有任务执行完才会停止。若不调用该方法线程池会一直保持下去，以便随时添加新的任务
	}
}

package cn.gaialine.threadpool;

import java.io.Serializable;

/**
 * 任务task
 * @author yangyong
 *
 */
public class ThreadPoolTask implements Runnable,Serializable{
	private static final long serialVersionUID = -8568367025140842876L;

	private Object threadPoolTaskData;
	private static int produceTaskSleepTime = 10000;
	
	public ThreadPoolTask(Object threadPoolTaskData) {
		super();
		this.threadPoolTaskData = threadPoolTaskData;
	}

	public void run() {
		// TODO Auto-generated method stub
		System.out.println("start..."+threadPoolTaskData);
		try {
			//模拟线程正在执行任务
			Thread.sleep(produceTaskSleepTime);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("stop..."+threadPoolTaskData);
		threadPoolTaskData = null;
	}
	
	public Object getTask(){
		return this.threadPoolTaskData;
	}
}

执行测试，每1秒添加一个任务，每个任务执行10秒，查看打印数据

put->task@1
start...task@1
put->task@2
start...task@2
put->task@3
put->task@4
put->task@5
put->task@6
start...task@6
put->task@7
start...task@7
put->task@8
start...task@8
put->task@9
Exception in thread "main" java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1760)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:767)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:658)
	at base.TestThreadPool.main(TestThreadPool.java:42)
stop...task@1
start...task@3
stop...task@2
start...task@4
stop...task@6
start...task@5
stop...task@7
stop...task@8
stop...task@3
stop...task@4
stop...task@5

从中可以看出task1和task2依次最先执行，这时候currentPoolSize=2达到了corePoolSize，task3、task4、task5被送入缓冲队列，达到了workQueue最大值3，task6、task7、task8开启新的线程开始执行，此时currentPoolSize=5达到了maximumPoolSize，task9、task10根据AbortPolicy策略抛出异常，不再执行task9和task10。10秒钟后task1、task2....依次执行完毕释放线程，开始执行队列里的task3、task4、task5，最后task3、4、5执行完毕，所有任务完成