ThreadPoolExecutor的工作机制

最新推荐文章于 2024-07-31 21:58:42 发布
最新推荐文章于 2024-07-31 21:58:42 发布
阅读量450 收藏
点赞数

来自：http://www.iteye.com/topic/1118660


背景

前段时间一个项目中因为涉及大量的线程开发，把jdk cocurrent的代码重新再过了一遍。这篇文章中主要是记录一下学习ThreadPoolExecutor过程中容易被人忽略的点，Doug Lea的整个类设计还是非常nice的

 

正文

先看一副图，描述了ThreadPoolExecutor的工作机制: 

 

整个ThreadPoolExecutor的任务处理有4步操作：

 

  • 第一步，初始的poolSize < corePoolSize，提交的runnable任务，会直接做为new一个Thread的参数，立马执行
  • 第二步，当提交的任务数超过了corePoolSize，就进入了第二步操作。会将当前的runable提交到一个block queue中
  • 第三步，如果block queue是个有界队列，当队列满了之后就进入了第三步。如果poolSize < maximumPoolsize时，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务
  • 第四步，如果第三步救急方案也无法处理了，就会走到第四步执行reject操作。
几点说明：(相信这些网上一搜一大把，我这里简单介绍下，为后面做一下铺垫)
  • block queue有以下几种实现：
    1. ArrayBlockingQueue :  有界的数组队列
    2. LinkedBlockingQueue : 可支持有界/无界的队列，使用链表实现
    3. PriorityBlockingQueue : 优先队列，可以针对任务排序
    4. SynchronousQueue : 队列长度为1的队列，和Array有点区别就是：client thread提交到block queue会是一个阻塞过程，直到有一个worker thread连接上来poll task。
  • RejectExecutionHandler是针对任务无法处理时的一些自保护处理：
    1. Reject 直接抛出Reject exception
    2. Discard 直接忽略该runnable，不可取
    3. DiscardOldest 丢弃最早入队列的的任务
    4. CallsRun 直接让原先的client thread做为worker线程，进行执行

容易被人忽略的点：
1.  pool threads启动后，以后的任务获取都会通过block queue中，获取堆积的runnable task.

所以建议：  block size >= corePoolSize ，不然线程池就没任何意义
2.  corePoolSize 和 maximumPoolSize的区别， 和大家正常理解的数据库连接池不太一样。
  *  据dbcp pool为例，会有minIdle , maxActive配置。minIdle代表是常驻内存中的threads数量，maxActive代表是工作的最大线程数。
  *  这里的corePoolSize就是连接池的maxActive的概念，它没有minIdle的概念(每个线程可以设置keepAliveTime，超过多少时间多有任务后销毁线程，但不会固定保持一定数量的threads)。 
  * 这里的maximumPoolSize，是一种救急措施的第一层。当threadPoolExecutor的工作threads存在满负荷，并且block queue队列也满了，这时代表接近崩溃边缘。这时允许临时起一批threads，用来处理runnable，处理完后立马退出。

所以建议：   maximumPoolSize >= corePoolSize =期望的最大线程数。 (我曾经配置了corePoolSize=1, maximumPoolSize=20, blockqueue为无界队列，最后就成了单线程工作的pool。典型的配置错误)

3. 善用blockqueue和reject组合. 这里要重点推荐下CallsRun的Rejected Handler，从字面意思就是让调用者自己来运行。
我们经常会在线上使用一些线程池做异步处理，比如我前面做的 (业务层)异步并行加载技术分析和设计, 将原本串行的请求都变为了并行操作，但过多的并行会增加系统的负载(比如软中断，上下文切换)。所以肯定需要对线程池做一个size限制。但是为了引入异步操作后，避免因在block queue的等待时间过长，所以需要在队列满的时，执行一个callsRun的策略，并行的操作又转为一个串行处理，这样就可以保证尽量少的延迟影响。

所以建议：   RejectExecutionHandler = CallsRun ,  blockqueue size = 2 * poolSize (为啥是2倍poolSize，主要一个考虑就是瞬间高峰处理，允许一个thread等待一个runnable任务)

Btrace容量规划

再提供一个btrace脚本，分析线上的thread pool容量规划是否合理，可以运行时输出poolSize等一些数据。

 

 

Java代码   收藏代码
  1. import static com.sun.btrace.BTraceUtils.addToAggregation;  
  2. import static com.sun.btrace.BTraceUtils.field;  
  3. import static com.sun.btrace.BTraceUtils.get;  
  4. import static com.sun.btrace.BTraceUtils.newAggregation;  
  5. import static com.sun.btrace.BTraceUtils.newAggregationKey;  
  6. import static com.sun.btrace.BTraceUtils.printAggregation;  
  7. import static com.sun.btrace.BTraceUtils.println;  
  8. import static com.sun.btrace.BTraceUtils.str;  
  9. import static com.sun.btrace.BTraceUtils.strcat;  
  10.   
  11. import java.lang.reflect.Field;  
  12. import java.util.concurrent.atomic.AtomicInteger;  
  13.   
  14. import com.sun.btrace.BTraceUtils;  
  15. import com.sun.btrace.aggregation.Aggregation;  
  16. import com.sun.btrace.aggregation.AggregationFunction;  
  17. import com.sun.btrace.aggregation.AggregationKey;  
  18. import com.sun.btrace.annotations.BTrace;  
  19. import com.sun.btrace.annotations.Kind;  
  20. import com.sun.btrace.annotations.Location;  
  21. import com.sun.btrace.annotations.OnEvent;  
  22. import com.sun.btrace.annotations.OnMethod;  
  23. import com.sun.btrace.annotations.OnTimer;  
  24. import com.sun.btrace.annotations.Self;  
  25.   
  26. /** 
  27.  * 并行加载监控 
  28.  *  
  29.  * @author jianghang 2011-4-7 下午10:59:53 
  30.  */  
  31. @BTrace  
  32. public class AsyncLoadTracer {  
  33.   
  34.     private static AtomicInteger rejecctCount = BTraceUtils.newAtomicInteger(0);  
  35.     private static Aggregation   histogram    = newAggregation(AggregationFunction.QUANTIZE);  
  36.     private static Aggregation   average      = newAggregation(AggregationFunction.AVERAGE);  
  37.     private static Aggregation   max          = newAggregation(AggregationFunction.MAXIMUM);  
  38.     private static Aggregation   min          = newAggregation(AggregationFunction.MINIMUM);  
  39.     private static Aggregation   sum          = newAggregation(AggregationFunction.SUM);  
  40.     private static Aggregation   count        = newAggregation(AggregationFunction.COUNT);  
  41.   
  42.     @OnMethod(clazz = "java.util.concurrent.ThreadPoolExecutor", method = "execute", location = @Location(value = Kind.ENTRY))  
  43.     public static void executeMonitor(@Self Object self) {  
  44.         Field poolSizeField = field("java.util.concurrent.ThreadPoolExecutor", "poolSize");  
  45.         Field largestPoolSizeField = field("java.util.concurrent.ThreadPoolExecutor", "largestPoolSize");  
  46.         Field workQueueField = field("java.util.concurrent.ThreadPoolExecutor", "workQueue");  
  47.   
  48.         Field countField = field("java.util.concurrent.ArrayBlockingQueue", "count");  
  49.         int poolSize = (Integer) get(poolSizeField, self);  
  50.         int largestPoolSize = (Integer) get(largestPoolSizeField, self);  
  51.         int queueSize = (Integer) get(countField, get(workQueueField, self));  
  52.   
  53.         println(strcat(strcat(strcat(strcat(strcat("poolSize : ", str(poolSize)), " largestPoolSize : "),  
  54.                                      str(largestPoolSize)), " queueSize : "), str(queueSize)));  
  55.     }  
  56.   
  57.     @OnMethod(clazz = "java.util.concurrent.ThreadPoolExecutor", method = "reject", location = @Location(value = Kind.ENTRY))  
  58.     public static void rejectMonitor(@Self Object self) {  
  59.         String name = str(self);  
  60.         if (BTraceUtils.startsWith(name, "com.alibaba.pivot.common.asyncload.impl.pool.AsyncLoadThreadPool")) {  
  61.             BTraceUtils.incrementAndGet(rejecctCount);  
  62.         }  
  63.     }  
  64.   
  65.     @OnTimer(1000)  
  66.     public static void rejectPrintln() {  
  67.         int reject = BTraceUtils.getAndSet(rejecctCount, 0);  
  68.         println(strcat("reject count in 1000 msec: ", str(reject)));  
  69.         AggregationKey key = newAggregationKey("rejectCount");  
  70.         addToAggregation(histogram, key, reject);  
  71.         addToAggregation(average, key, reject);  
  72.         addToAggregation(max, key, reject);  
  73.         addToAggregation(min, key, reject);  
  74.         addToAggregation(sum, key, reject);  
  75.         addToAggregation(count, key, reject);  
  76.     }  
  77.   
  78.     @OnEvent  
  79.     public static void onEvent() {  
  80.         BTraceUtils.truncateAggregation(histogram, 10);  
  81.         println("---------------------------------------------");  
  82.         printAggregation("Count", count);  
  83.         printAggregation("Min", min);  
  84.         printAggregation("Max", max);  
  85.         printAggregation("Average", average);  
  86.         printAggregation("Sum", sum);  
  87.         printAggregation("Histogram", histogram);  
  88.         println("---------------------------------------------");  
  89.     }  
  90. }  
 

运行结果：

 

Java代码   收藏代码
  1. poolSize : 1 , largestPoolSize = 10 , queueSize = 10  
  2. reject count in 1000 msec: 0  

 

说明：

1. poolSize 代表为当前的线程数

2. largestPoolSize 代表为历史最大的线程数

3. queueSize 代表blockqueue的当前堆积的size

4. reject count 代表在1000ms内的被reject的数量

 

 

最后

  这是我对ThreadPoolExecutor使用过程中的一些经验总结，希望能对大家有所帮助，如有描述不对的地方欢迎拍砖。


wszxl492719760
关注
ThreadPoolExecutor介绍
hahazz233的博客
06-15 495
首先我们要思考一下为什么要使用线程池。Java提供了多线程机制让我们能够同时运行多个任务，就像多个任务由多个人同时执行，而不是一个人依次执行这些任务。但是如果我们每次执行任务都创建一个线程，导致的问题有因此Java提供了默认的线程池，帮助大家解决这些问题，通过ThreadPoolExecutor，我们可以实现多种线程创建回收策略，以适应不同的需求场景。线程池可以使用的场景有要正确使用线程池，我们需要理解其中的几个重要参数，通过ThreadPoolExecutor的构造函数可以看到参数如下 coreP
ThreadPoolExecutor几点使用建议
agapple
12-06 304
背景 前段时间一个项目中因为涉及大量的线程开发，把jdk cocurrent的代码重新再过了一遍。这篇文章中主要是记录一下学习ThreadPoolExecutor过程中容易被人忽略的点，Doug Lea的整个类设计还是非常nice的   正文 先看一副图，描述了ThreadPoolExecutor的工作机制:    整个ThreadPoolExecutor的任务处理...
ThreadPoolExecutor运转机制详解
weixin_34062469的博客
07-26 73
  ThreadPoolExecutor机制 一、概述 1、ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务； 2、Executors方法提供的线程服务，都是通过参数设置来实现不同的线程池机制。 3、先来了解其线程池管理的机制，有助于正确使用，避免错误使用导致严重故障。同时可以根...
ThreadPoolExecutor机制及各参数讲…
u013036068的博客
10-19 3323
本文系转载，原文地址：http://825635381.iteye.com/blog/2184680 ThreadPoolExecutor机制  一、概述  1、ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务；  2、Executors方法提供的线程服务，都是通过参
ThreadPoolExecutor机制
Very_red的博客
01-05 849
一、概述1、ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务； 2、Executors方法提供的线程服务，都是通过参数设置来实现不同的线程池机制。 3、先来了解其线程池管理的机制，有助于正确使用，避免错误使用导致严重故障。同时可以根据自己的需求实现自己的线程池二、核心构造方法讲解下面是ThreadPoolExecutor最核心的构造方法构造方法参数讲解 参数名 作用 ...
ThreadPoolExecutor的实现机制
朱玉强的博客
05-28 298
原文地址：《ThreadPoolExecutor的实现机制》 1、什么是ThreadPoolExecutor ThreadPoolExecutor是一个 ExecutorService一个具体实现，在实际项目中，主要使用ThreadPoolExecutor维护的线程队列中的任意一个空闲线程去执行每个提交任务。说的直白点就是在实际项目中，没有办法为每个提交的任务立马分配一个线程，所以在程序中维护一个...
ThreadPoolExecutor线程池的使用方法
08-25
ThreadPoolExecutor线程池提供了灵活的线程管理机制，可以根据需要选择合适的任务队列和拒绝策略，并且可以自定义线程工厂和线程工具类，从而满足不同应用场景的需求。 ThreadPoolExecutor的使用方法可以分为以下几...
ThreadPoolExecutor运转机制介绍
12-19
### ThreadPoolExecutor 运转机制详解 #### 一、ThreadPoolExecutor 的基本概念与构造函数解析 在Java并发编程中，`ThreadPoolExecutor` 是一种强大的工具，它可以帮助开发者有效地管理和执行线程。`...
java ThreadPoolExecutor 并发调用实例详解
08-30
在这些机制中，ThreadPoolExecutor 是一个非常重要的概念，它提供了一个线程池，允许开发者将任务提交到线程池中，并行地执行这些任务。 ThreadPoolExecutor 的主要作用是管理一个线程池，线程池中包含多个线程，每...
线程池之ThreadPoolExecutor.docx
06-27
线程池的工作机制在于控制线程数量，它会将任务放入队列，然后根据线程池的设定创建并启动线程执行这些任务。如果线程数量超过最大限制，额外的任务会被排队等待，直到有线程完成任务释放资源。线程池的使用有三个...
ThreadPoolExecutor
cowbin2012的专栏
07-28 1万+
什么是线程池       多线程开发中，由于线程数量多，并且每个线程执行一段时间就结束，所以要频繁的创建线程，但是这样频繁的创建线程会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。在这种情况下，人们就想要一种可以线程执行完后不用销毁，同时该线程还可以去执行其他任务，在这样的情况下线程池就出现了。       线程池就是线程的池子，任务提交到线程池后，就从线程池中取
ThreadPoolExecutor 运作机制再次理解 ----- 一次小坑记
u011385186的专栏
10-25 1049
private static final ExecutorService executorService = new ThreadPoolExecutor(20, 25, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(1), new ThreadPoolExecutor.CallerRunsPolicy()); 这里核心线程数20 ...
ThreadPoolExecutor工作原理及源码详解
最新发布
weixin_44991038的博客
07-31 776
ThreadPoolExecutor线程池原理以及源码解析
Java的ThreadPoolExecutor使用几点建议（转载）
lovemedsz的专栏
12-26 536
整个ThreadPoolExecutor的任务处理有4步操作：   第一步，初始的poolSize 第二步，当提交的任务数超过了corePoolSize，就进入了第二步操作。会将当前的runable提交到一个block queue中 第三步，如果block queue是个有界队列，当队列满了之后就进入了第三步。如果poolSize 第四步，如果第三步救急方案也无法处理了，就会走到第四步执
线程池中各个参数如何合理设置
riemann_的博客
03-06 3万+
一、前言 在开发过程中，好多场景要用到线程池。每次都是自己根据业务场景来设置线程池中的各个参数。这两天又有需求碰到了，索性总结一下方便以后再遇到可以直接看着用。虽说根据业务场景来设置各个参数的值，但有些万变不离其宗，掌握它的原理对如何用好线程池起了至关重要的作用。那我们接下来就来进行线程池的分析。 二、ThreadPoolExecutor的重要参数 我们先来看下ThreadPoolExecutor...
线程池参数设置原则
weixin_45560850的博客
05-24 4234
一：线程池参数简介 corePoolSize:核心线程数 queueCapacity:阻塞队列 参数合理设置 为了说明合理设置的条件，我们首先确定有以下几个相关参数： 1、tasks:系统每秒需要处理的最大任务数量（假设每秒任务数为100-1000）； 2、tasktime：单线程处理一个任务所需要的时间，0.1s； 3、responsetime：系统允许任务最大的响应时间（每个响应时间不超过2s）； corePoolSize：核心线程数 每个任务需要tasktime
用了这么久线程池，你真的知道如何合理配置线程数吗？
这个时代，作为程序员可能要学习小程序
07-02 2248
点击上方关注 “终端研发部”设为“星标”，和你一起掌握更多数据库知识一、线程池如何配置合理线程数（1）CPU密集型：定义：CPU密集型的意思就是该任务需要大量运算，而没有阻塞，CPU一直全速运行。CPU密集型任务只有在真正的多核CPU上才可能得到加速（通过多线程）。CPU密集型任务配置尽可能少的线程数。“CPU密集型线程数配置公式：(CPU核数+1)个线程的线程池（2）I...
ThreadPoolExecutor详解
热门推荐
赶路人儿
08-15 11万+
一、ThreadPoolExecutor类讲解 1、线程池状态： 五种状态： 线程池的状态 说明 RUNNING 允许提交并处理任务 SHUTDOWN 不允许提交新的任务，但是会处理完已提交的任务 STOP 不允许提交新的任务，也不会处理阻塞队列中未执行的任务， 并设置正在执行的线程的中断标志位 TIDYING .
Java线程池的使用(合理设置线程池的大小)
weixin_42169734的博客
01-20 1019
线程池工具类 import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.Callable; import java.util.concurrent.Future; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUn
Java ThreadPoolExecutor详解与工作原理
线程池"ThreadPoolExecutor是Java并发编程中用于管理线程的一种机制，它可以高效地执行并发任务，避免频繁创建和销毁线程带来的开销。本文将深入探讨ThreadPoolExecutor的构造函数、工作原理以及其核心参数的设置与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值