程序博客网 > 数据整合系统sci

ThreadPoolExecutor中BlockingQueue的三种实现及排队策略

来源：互联网 发布：数据整合系统sci 编辑：程序博客网 时间：2024/05/16 15:33

1、ThreadPoolExecutor的构建参数

       最近发现几起对ThreadPoolExecutor的误用，其中包括自己，发现都是因为没有仔细看注释和内部运转机制，想当然的揣测参数导致，先看一下新建一个ThreadPoolExecutor的构建参数：

[java] view plaincopy
  1. public ThreadPoolExecutor(int corePoolSize,  
  2.                           int maximumPoolSize,  
  3.                           long keepAliveTime,  
  4.                           TimeUnit unit,  
  5.                           BlockingQueue<Runnable> workQueue,  
  6.                           ThreadFactory threadFactory,  
  7.                           RejectedExecutionHandler handler)  

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

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

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

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

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

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

内部结构如下所示：

        从中可以发现ThreadPoolExecutor就是依靠BlockingQueue的阻塞机制来维持线程池，当池子里的线程无事可干的时候就通过workQueue.take()阻塞住。

其实可以通过Executes来学学几种特殊的ThreadPoolExecutor是如何构建的。

[java] view plaincopy
  1. public static ExecutorService newFixedThreadPool(int nThreads) {  
  2.     return new ThreadPoolExecutor(nThreads, nThreads,  
  3.                                   0L, TimeUnit.MILLISECONDS,  
  4.                                   new LinkedBlockingQueue<Runnable>());  
  5. }  

            newFixedThreadPool就是一个固定大小的ThreadPool

[java] view plaincopy
  1. public static ExecutorService newCachedThreadPool() {  
  2.     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  
  3.                                   60L, TimeUnit.SECONDS,  
  4.                                   new SynchronousQueue<Runnable>());  
  5. }  

        newCachedThreadPool比较适合没有固定大小并且比较快速就能完成的小任务，没必要维持一个Pool，这比直接new Thread来处理的好处是能在60秒内重用已创建的线程。

       其他类型的ThreadPool看看构建参数再结合上面所说的特性就大致知道它的特性。

       线程池的作用就是用尽可能少的线程来执行尽可能多的Runnable，以实现对线程的充分利用。先从ThreadPoolExecutor类的构造方法说起：

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. ThreadPoolExecutor public ThreadPoolExecutor(int corePoolSize,    // 核心线程数  
  2.                           int maximumPoolSize, // 最大线程数  
  3.                           long keepAliveTime,  // 生存时间  
  4.                           TimeUnit unit,       // keepAliveTime值的度量单位  
  5.                           BlockingQueue<Runnable> workQueue)   // 阻塞队列  

 

           我们通过ThreadPoolExecutor类的execute()方法添加我们要执行的任务。下面通过实例讲解ThreadPoolExecutor类的使用。

           首先，定义任务类Task：将会被线程池执行的任务类。

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class Task {  
  2.     public void fun() {  
  3.         for (int i = 0; i < 10; i++) {  
  4.             System.out.println(Thread.currentThread().getName() + " 执行 - " + i);  
  5.         }  
  6.     }  
  7. }  

 

        在创建线程池之前，我们先了解一下BlockingQueue，在构造线程池的时候，需要为其指定一个BlockingQueue，可用于传输和保持提交的任务。可以使用此队列与池大小进行交互。

2、BlockingQueue(阻塞队列):

如果运行的线程少于 corePoolSize，则 Executor始终首选添加新的线程，而不进行排队(不添加进阻塞队列)。

如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。

如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。

3、队列的三种通用策略详解：

3.1 直接提交 SynchronousQueue

       它将任务直接提交给线程而不保存它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。  SynchronousQueue线程安全的Queue，可以存放若干任务（但当前只允许有且只有一个任务在等待），其中每个插入操作必须等待另一个线程的对应移除操作，也就是说A任务进入队列，B任务必须等A任务被移除之后才能进入队列，否则执行异常策略。你来一个我扔一个，所以说SynchronousQueue没有任何内部容量。

       比如：核心线程数为2，最大线程数为3；使用SynchronousQueue。

       当前有2个核心线程在运行，又来了个A任务，两个核心线程没有执行完当前任务，根据如果运行的线程等于或多于 corePoolSize，

      则 Executor 始终首选将请求加入队列，而不添加新的线程。所以A任务被添加到队列，此时的队列是SynchronousQueue，

      当前不存在可用于立即运行任务的线程，因此会构造一个新的线程，此时又来了个B任务，两个核心线程还没有执行完。

       新创建的线程正在执行A任务，所以B任务进入Queue后，最大线程数为3，发现没地方仍了。就只能执行异常策略(RejectedExecutionException)。

代码示例：

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package zmx.jdkthreadpool.test;  
  2.   
  3. import java.util.concurrent.SynchronousQueue;  
  4. import java.util.concurrent.ThreadPoolExecutor;  
  5. import java.util.concurrent.TimeUnit;  
  6.   
  7. public class PoolForSynchronousQueueTest {  
  8.       
  9.     public static void main(String[] args) {  
  10.             
  11.             ThreadPoolExecutor pool =  new ThreadPoolExecutor(2, 3, 3L,   
  12.                             TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), new ThreadPoolExecutor.AbortPolicy());  
  13.             for (int i = 0; i < 4; i++) {  
  14.                 pool.execute(new Runnable() {  
  15.                     @Override  
  16.                     public void run() {  
  17.                             for (int i = 0; i < 10; i++) {  
  18.                                 System.out.println(Thread.currentThread().getName() + " 执行 - " + i);  
  19.                             }  
  20.                             System.out.println("run");  
  21.                         }  
  22.                     });  
  23.             }  
  24.             pool.shutdown();  
  25.    }  
  26.   
  27.   
  28. }  
  29. // 在添加第4个任务的时候，程序抛出 java.util.concurrent.RejectedExecutionException</span>  


 运行结果：

pool-1-thread-2 执行 - 0

run
pool-1-thread-1 执行 - 0
run
pool-1-thread-3 执行 - 0
run

Exception in thread "main" Java.util.concurrent.RejectedExecutionException: Taskzmx.jdkthreadpool.test.PoolForSynchronousQueueTest$1@bda96b rejected fromjava.util.concurrent.ThreadPoolExecutor@4e4b9101[Running, pool size = 3, active threads = 3, queued tasks = 0, completed tasks = 0]
 at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2048)
 at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:821)
 at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1372)
 at zmx.jdkthreadpool.test.PoolForSynchronousQueueTest.main(PoolForSynchronousQueueTest.java:14)

3.2 无界队列 如LinkedBlockingQueue

        使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有核心线程都在忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就没意义了。）也就不会有新线程被创建，都在那等着排队呢。如果未指定容量，则它等于 Integer.MAX_VALUE。如果设置了Queue预定义容量，则当核心线程忙碌时，新任务会在队列中等待，直到超过预定义容量(新任务没地方放了)，才会执行异常策略。你来一个我接一个，直到我容不下你了。FIFO，先进先出。

        比如：核心线程数为2，最大线程数为3；使用LinkedBlockingQueue(1)，设置容量为1。

        当前有2个核心线程在运行，又来了个A任务，两个核心线程没有执行完当前任务，根据如果运行的线程等于或多于 corePoolSize，

        则 Executor 始终首选将请求加入队列，而不添加新的线程。所以A任务被添加到队列，此时的队列是LinkedBlockingQueue，

        此时又来了个B任务，两个核心线程没有执行完当前任务，A任务在队列中等待，队列已满。所以根据如果无法将请求加入队列，则创建新的线程，

         B任务被新创建的线程所执行，此时又来个C任务，此时maximumPoolSize已满，队列已满，只能执行异常策略(RejectedExecutionException)。

代码示例：

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package zmx.jdkthreadpool.test;  
  2.   
  3. import java.util.concurrent.LinkedBlockingQueue;  
  4. import java.util.concurrent.ThreadPoolExecutor;  
  5. import java.util.concurrent.TimeUnit;  
  6.   
  7. public class PoolForLinkedBlockingQueueTest {  
  8.       
  9.       
  10.     public static void main(String[] args) {  
  11.             
  12.         ThreadPoolExecutor pool =  new ThreadPoolExecutor(2, 3, 3L,   
  13.                                 TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(1),    
  14.                                 new ThreadPoolExecutor.AbortPolicy());  
  15.         for (int i = 0; i < 5; i++) {  
  16.             pool.execute(new Runnable() {  
  17.                 @Override  
  18.                 public void run() {  
  19.                         for (int i = 0; i < 10; i++) {  
  20.                             System.out.println(Thread.currentThread().getName() + " 执行 - " + i);  
  21.                         }  
  22.                         System.out.println("run");  
  23.                     }  
  24.                 });  
  25.         }  
  26.         pool.shutdown();  
  27.     }  
  28.   
  29. }  
  30. // 在添加第5个任务的时候，程序抛出 java.util.concurrent.RejectedExecutionException</span>  


 运行结果：

pool-1-thread-1 执行 - 0
pool-1-thread-2 执行 - 0
run
run
pool-1-thread-2 执行 - 0
run
pool-1-thread-3 执行 - 0
run

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Taskzmx.jdkthreadpool.test.PoolForLinkedBlockingQueueTest$1@7d557ee8 rejected fromjava.util.concurrent.ThreadPoolExecutor@2a97cec[Running, pool size = 3, active threads = 3, queued tasks = 1, completed tasks = 0]
 at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2048)
 at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:821)
 at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1372)
 at zmx.jdkthreadpool.test.PoolForLinkedBlockingQueueTest.main(PoolForLinkedBlockingQueueTest.java:16)

 

      无界的话要防止任务增长的速度远远超过处理任务的速度。

 

3.3 有界队列 如ArrayBlockingQueue

       操作模式跟LinkedBlockingQueue查不多，只不过必须为其设置容量。所以叫有界队列。new ArrayBlockingQueue<Runnable>(Integer.MAX_VALUE) 跟 new LinkedBlockingQueue(Integer.MAX_VALUE)效果一样。LinkedBlockingQueue 底层是链表结构，ArrayBlockingQueue  底层是数组结构。你来一个我接一个，直到我容不下你了。FIFO，先进先出。

代码示例：

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package zmx.jdkthreadpool.test;  
  2.   
  3. import java.util.concurrent.ArrayBlockingQueue;  
  4. import java.util.concurrent.ThreadPoolExecutor;  
  5. import java.util.concurrent.TimeUnit;  
  6.   
  7. public class PoolForArrayBlockingQueueTest {  
  8.       
  9.     public static void main(String[] args) {  
  10.             
  11.         ThreadPoolExecutor pool =  new ThreadPoolExecutor(2, 3, 3L,   
  12.                                 TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1),    
  13.                                 new ThreadPoolExecutor.AbortPolicy());  
  14.         for (int i = 0; i < 5; i++) {  
  15.             pool.execute(new Runnable() {  
  16.                 @Override  
  17.                 public void run() {  
  18.                         for (int i = 0; i < 10; i++) {  
  19.                             System.out.println(Thread.currentThread().getName() + " 执行 - " + i);  
  20.                         }  
  21.                         System.out.println("run");  
  22.                     }  
  23.                 });  
  24.         }  
  25.         pool.shutdown();  
  26.     }  
  27.   
  28. }  
  29. // 在添加第5个任务的时候，程序抛出 java.util.concurrent.RejectedExecutionException</span>  


 运行结果：

pool-1-thread-1 执行 - 0
run
pool-1-thread-1 执行 - 0
run
pool-1-thread-3 执行 - 0
run
pool-1-thread-2 执行 - 0

run
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Taskzmx.jdkthreadpool.test.PoolForArrayBlockingQueueTest$1@6c3b0b1e rejected fromjava.util.concurrent.ThreadPoolExecutor@7d6ac92e[Running, pool size = 3, active threads = 3, queued tasks = 1, completed tasks = 0]
 at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2048)
 at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:821)
 at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1372)
 at zmx.jdkthreadpool.test.PoolForArrayBlockingQueueTest.main(PoolForArrayBlockingQueueTest.java:15)

4、关于keepAliveTime

        JDK解释：当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。

       也就是说啊，线程池中当前的空闲线程服务完某任务后的存活时间。如果时间足够长，那么可能会服务其它任务。

       这里的空闲线程包不包括后来新创建的服务线程呢？我的理解是包括的。

5、关于handler有四个选择

        ThreadPoolExecutor.AbortPolicy()  抛出java.util.concurrent.RejectedExecutionException异常。 

        ThreadPoolExecutor.CallerRunsPolicy()  重试添加当前的任务，他会自动重复调用execute()方法。 

        ThreadPoolExecutor.DiscardOldestPolicy()  抛弃旧的任务   ThreadPoolExecutor.DiscardPolicy()  抛弃当前的任务。 

6、结论及分析：

        使用无界队列，要防止任务增长的速度远远超过处理任务的速度，控制不好可能导致的结果就是内存溢出。

        使用有界队列，关键在于调节线程数和Queue大小 ，线程数多，队列容量少，资源浪费。线程数少，队列容量多，性能低，还可能导致内存溢出。

0 0
数据整合系统sci 数据整合系统sci
原创粉丝点击
热门IT博客
最优化理论与算法pdf最优化理论与算法pdf
电脑机器码修改软件电脑机器码修改软件
淘宝宝贝设置货到付款
佛教与现代科学 知乎
新浪唱聊mac版
2015中国服务贸易数据
初级程序员证书查询
python黑客编程
淘宝网新店怎么推广
mahout聚类算法实现
模拟植物生长算法 pdf
海王星写频软件
windows 串口工具
青牛软件手机卡
上海话剧艺术中心淘宝
萨克斯校音器软件
淘宝外包费用
周易掐指算法
泰伦斯琼斯数据
sqlserver数据库创建表
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 青岛崂山国际花园 崂山一日游线路 崂山桶装水价格 崂山绿茶的功效与作用 青岛崂山景区住宿 崂山矿泉水有限公司 青岛市崂山区 青岛好玩的地方 青岛有什么好玩的 青岛有什么好玩的地方 青岛游玩攻略 青岛哪里好玩 青岛三天旅游攻略 青岛自驾游攻略 青岛攻略 青岛旅游景点 中国海洋大学崂山校区 青岛大学附属医院崂山院区 从青岛火车站到崂山 崆 崆山白云洞 崆山白云洞旅游 崆山白云洞门票 石崆寨 崆山白云洞门票多少 寻乌石崆寨门票多少钱 西游之气血长河 崆崆无 崆山白云洞票价 崆山白云洞旅游攻略 崇义县 崇义 崇义黄泽兰获刑 抚州崇仁 崇仁 崇仁县 崇仁古镇 崇仁蛋糕店 崇仁电视台 崇仁吧 江西崇仁 三笠宫崇仁亲王

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里