JDK线程池的使用

1. package cn.gaialine.threadpool;  
2.   
3. import java.util.concurrent.ArrayBlockingQueue;  
4. import java.util.concurrent.BlockingQueue;  
5. import java.util.concurrent.ThreadPoolExecutor;  
6. import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;  
7. import java.util.concurrent.TimeUnit;  
8.   
9. /** 
10.  * 线程池测试用例 
11.  * @author yangyong 
12.  * 
13.  */  
14. public class TestThreadPool {  
15.     //线程池维护线程的最少数量  
16.     private static final int COREPOOLSIZE = 2;  
17.     //线程池维护线程的最大数量  
18.     private static final int MAXINUMPOOLSIZE = 5;  
19.     //线程池维护线程所允许的空闲时间  
20.     private static final long KEEPALIVETIME = 4;  
21.     //线程池维护线程所允许的空闲时间的单位  
22.     private static final TimeUnit UNIT = TimeUnit.SECONDS;  
23.     //线程池所使用的缓冲队列,这里队列大小为3  
24.     private static final BlockingQueue<Runnable> WORKQUEUE = new ArrayBlockingQueue<Runnable>(3);  
25.     //线程池对拒绝任务的处理策略：AbortPolicy为抛出异常；CallerRunsPolicy为重试添加当前的任务，他会自动重复调用execute()方法；DiscardOldestPolicy为抛弃旧的任务，DiscardPolicy为抛弃当前的任务  
26.     private static final AbortPolicy HANDLER = new ThreadPoolExecutor.AbortPolicy();  
27.   
28.     public static void main(String[] args) {  
29.         // TODO 初始化线程池  
30.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(COREPOOLSIZE, MAXINUMPOOLSIZE, KEEPALIVETIME, UNIT, WORKQUEUE, HANDLER);  
31.         for (int i = 1; i < 11; i++) {  
32.             String task = "task@"+i;  
33.             System.out.println("put->"+task);  
34.       

    如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
    如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
    如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
    如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

    也就是：处理任务的优先级为：
    核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

    当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数
36.             threadPool.execute(new ThreadPoolTask(task));  
37.             try {  
38.                 Thread.sleep(1000);  
39.             } catch (InterruptedException e) {  
40.                 // TODO Auto-generated catch block  
41.                 e.printStackTrace();  
42.             }  
43.         }  
44.         threadPool.shutdown();//关闭主线程，但线程池会继续运行，直到所有任务执行完才会停止。若不调用该方法线程池会一直保持下去，以便随时添加新的任务  
45.     }  
46. }  

[java] view plain copy

1. package cn.gaialine.threadpool;  
2.   
3. import java.io.Serializable;  
4.   
5. /** 
6.  * 任务task 
7.  * @author yangyong 
8.  * 
9.  */  
10. public class ThreadPoolTask implements Runnable,Serializable{  
11.     private static final long serialVersionUID = -8568367025140842876L;  
12.   
13.     private Object threadPoolTaskData;  
14.     private static int produceTaskSleepTime = 10000;  
15.       
16.     public ThreadPoolTask(Object threadPoolTaskData) {  
17.         super();  
18.         this.threadPoolTaskData = threadPoolTaskData;  
19.     }  
20.   
21.     public void run() {  
22.         // TODO Auto-generated method stub  
23.         System.out.println("start..."+threadPoolTaskData);  
24.         try {  
25.             //模拟线程正在执行任务  
26.             Thread.sleep(produceTaskSleepTime);  
27.         } catch (InterruptedException e) {  
28.             // TODO Auto-generated catch block  
29.             e.printStackTrace();  
30.         }  
31.         System.out.println("stop..."+threadPoolTaskData);  
32.         threadPoolTaskData = null;  
33.     }  
34.       
35.     public Object getTask(){  
36.         return this.threadPoolTaskData;  
37.     }  
38. }  

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

[plain] view plain copy

1. put->task@1  
2. start...task@1  
3. put->task@2  
4. start...task@2  
5. put->task@3  
6. put->task@4  
7. put->task@5  
8. put->task@6  
9. start...task@6  
10. put->task@7  
11. start...task@7  
12. put->task@8  
13. start...task@8  
14. put->task@9  
15. Exception in thread "main" java.util.concurrent.RejectedExecutionException  
16.     at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)  
17.     at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)  
18.     at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)  
19.     at cn.gaialine.threadpool.TestThreadPool.main(TestThreadPool.java:42)  
20. stop...task@1  
21. start...task@3  
22. stop...task@2  
23. start...task@4  
24. stop...task@6  
25. start...task@5  
26. stop...task@7  
27. stop...task@8  
28. stop...task@3  
29. stop...task@4  
30. 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执行完毕，所有任务完成

JDK根据ThreadPoolExecutor配置好的线程池

[java] view plain copy

1. // 固定工作线程数量的线程池  
2. ExecutorService executorService1 = Executors.newFixedThreadPool(3);  
3.   
4. // 一个可缓存的线程池  
5. ExecutorService executorService2 = Executors.newCachedThreadPool();  
6.   
7. // 单线程化的Executor  
8. ExecutorService executorService3 = Executors.newSingleThreadExecutor();  
9.   
10. // 支持定时的以及周期性的任务执行  
11. ExecutorService executorService4 = Executors.newScheduledThreadPool(3);