ThreadPoolExecutor

什么是线程池

 

    多线程开发中，由于线程数量多，并且每个线程执行一段时间就结束，所以要频繁的创建线程，但是这样频繁的创建线程会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。在这种情况下，人们就想要一种可以线程执行完后不用销毁，同时该线程还可以去执行其他任务，在这样的情况下线程池就出现了。

 

    线程池就是线程的池子，任务提交到线程池后，就从线程池中取出一个空闲的线程为之服务，服务完后不销毁该线程，而是将该线程还回到线程池中。

 

    在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，再把任务交给内部某个空闲的线程，如果没有空闲的进程，任务就处于等待状态，这就是封装。

 

    使用了线程池后减少了创建和销毁线程的次数，每个线程都可以被重复利用，可执行多个任务；同时可以根据系统的承受能力，调整线程池中线程的数目，避免出现将系统内存消耗完毕这样的情况出现。

 

 

ThreadPoolExecuto例子

 

    我们先通过一个简单的线程池的例子先来对ThreadPoolExecuto进行一个整体的认识，我们构造了一个正常线程数量为5，最大线程池数量为10，任务缓存队列5的线程池，让这个线程池来执行15个任务的demo。

 

    先来看下MyRunnable类，用来记录当前正在执行的任务数：

[java]  view plain copy

1. package com.tgb.threadpool;  
2.   
3. /** 
4.  * 线程执行 
5.  * @author kang 
6.  * 
7.  */  
8. public class MyRunnable implements Runnable {  
9.   
10.     // 正在执行的任务数  
11.     private int num;  
12.   
13.     public MyRunnable(int num) {  
14.         this.num = num;  
15.     }  
16.   
17.     @Override  
18.     public void run() {  
19.         System.out.println("正在执行的MyRunnable " + num);  
20.         try {  
21.             Thread.currentThread().sleep(4000);  
22.         } catch (InterruptedException e) {  
23.             e.printStackTrace();  
24.         }  
25.         System.out.println("MyRunnable " + num + "执行完毕");  
26.   
27.     }  
28.   
29. }  

 

    线程池客户端：

[java]  view plain copy

1. package com.tgb.threadpool;  
2.   
3. import java.util.concurrent.ArrayBlockingQueue;  
4. import java.util.concurrent.ThreadPoolExecutor;  
5. import java.util.concurrent.TimeUnit;  
6.   
7. /** 
8.  * 线程池调用客户端 
9.  * @author kang 
10.  * 
11.  */  
12. public class ThreadPoolExecutorTest {  
13.   
14.     //池中所保存的线程数，包括空闲线程。  
15.     final static int corePoolSize = 5;  
16.     //池中允许的最大线程数。  
17.     final static int maximumPoolSize = 10;  
18.     //当线程数大于核心线程时，此为终止前多余的空闲线程等待新任务的最长时间  
19.     final static long keepAliveTime = 200;  
20.     //执行前用于保持任务的队列5，即任务缓存队列  
21.     final static ArrayBlockingQueue<Runnable> workQueue =new ArrayBlockingQueue<Runnable>(5);  
22.       
23.     public static void main(String[] args) {  
24.         //构建一个线程池，正常线程数量为5，最大线程数据为10，等待时间200  
25.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(  
26.                 corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MINUTES, workQueue);  
27.           
28.         //线程池去执行15个任务  
29.         for (int i = 0; i < 15; i++) {  
30.             MyRunnable myRunnable = new MyRunnable(i);  
31.             threadPoolExecutor.execute(myRunnable);  
32.             System.out.println("线程池中现在的线程数目是："+threadPoolExecutor.getPoolSize()+",  队列中正在等待执行的任务数量为："+  
33.                     threadPoolExecutor.getQueue().size());  
34.         }  
35.         //关掉线程池  
36.         threadPoolExecutor.shutdown();  
37.           
38.     }  
39.       
40. }  

    执行结果：

[cpp]  view plain copy

1. 正在执行的MyRunnable 0  
2. 线程池中现在的线程数目是：1,  队列中正在等待执行的任务数量为：0  
3. 线程池中现在的线程数目是：2,  队列中正在等待执行的任务数量为：0  
4. 正在执行的MyRunnable 1  
5. 线程池中现在的线程数目是：3,  队列中正在等待执行的任务数量为：0  
6. 正在执行的MyRunnable 2  
7. 线程池中现在的线程数目是：4,  队列中正在等待执行的任务数量为：0  
8. 正在执行的MyRunnable 3  
9. 线程池中现在的线程数目是：5,  队列中正在等待执行的任务数量为：0  
10. 正在执行的MyRunnable 4  
11. 线程池中现在的线程数目是：5,  队列中正在等待执行的任务数量为：1  
12. 线程池中现在的线程数目是：5,  队列中正在等待执行的任务数量为：2  
13. 线程池中现在的线程数目是：5,  队列中正在等待执行的任务数量为：3  
14. 线程池中现在的线程数目是：5,  队列中正在等待执行的任务数量为：4  
15. 线程池中现在的线程数目是：5,  队列中正在等待执行的任务数量为：5  
16. 线程池中现在的线程数目是：6,  队列中正在等待执行的任务数量为：5  
17. 正在执行的MyRunnable 10  
18. 线程池中现在的线程数目是：7,  队列中正在等待执行的任务数量为：5  
19. 正在执行的MyRunnable 11  
20. 线程池中现在的线程数目是：8,  队列中正在等待执行的任务数量为：5  
21. 正在执行的MyRunnable 12  
22. 线程池中现在的线程数目是：9,  队列中正在等待执行的任务数量为：5  
23. 正在执行的MyRunnable 13  
24. 线程池中现在的线程数目是：10,  队列中正在等待执行的任务数量为：5  
25. 正在执行的MyRunnable 14  
26. MyRunnable 0执行完毕  
27. 正在执行的MyRunnable 5  
28. MyRunnable 3执行完毕  
29. MyRunnable 4执行完毕  
30. MyRunnable 2执行完毕  
31. 正在执行的MyRunnable 7  
32. 正在执行的MyRunnable 6  
33. 正在执行的MyRunnable 8  
34. MyRunnable 1执行完毕  
35. 正在执行的MyRunnable 9  
36. MyRunnable 12执行完毕  
37. MyRunnable 11执行完毕  
38. MyRunnable 10执行完毕  
39. MyRunnable 14执行完毕  
40. MyRunnable 13执行完毕  
41. MyRunnable 5执行完毕  
42. MyRunnable 9执行完毕  
43. MyRunnable 8执行完毕  
44. MyRunnable 6执行完毕  
45. MyRunnable 7执行完毕  

    从执行结果来看，当线程池中线程的数量大于 5 时，便将任务放入任务缓存队列里面，任务缓存队列满了以后，变创建新的线程，来执行，如果让任务数量大于 15 ，程序就会报错，抛出任务拒绝异常，这时可以增大任务缓存队列，有兴趣的同学可以去试试。

 

    通过这个demo应该可以对线程池有了一个宏观的理解了吧，下面我们就继续深入的来学习ThreadPoolExecutor 对象。