ThreadPoolExecutor运转机制及BlockingQueue详解

本文详细解析了ThreadPoolExecutor的工作原理,包括其构建参数的具体含义、内部运作机制以及如何正确使用。并通过实例演示了不同类型的阻塞队列在实际场景中的应用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

文章来源:http://blog.youkuaiyun.com/zmx729618/article/details/51453792


1、ThreadPoolExecutor的构建参数

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

[java]  view plain copy
  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 plain copy
  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 plain copy
  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类的构造方法说起:

  1. ThreadPoolExecutor public ThreadPoolExecutor(int corePoolSize,    // 核心线程数  
  2.                           int maximumPoolSize, // 最大线程数  
  3.                           long keepAliveTime,  // 生存时间  
  4.                           TimeUnit unit,       // keepAliveTime值的度量单位  
  5.                           BlockingQueue<Runnable> workQueue)   // 阻塞队列  

 

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

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

  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)。

代码示例:

  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 from java.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)。

代码示例:

  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 from java.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,先进先出。

代码示例:

  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: Task
zmx.jdkthreadpool.test.PoolForArrayBlockingQueueTest$1@6c3b0b1e rejected from java.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大小 ,线程数多,队列容量少,资源浪费。线程数少,队列容量多,性能低,还可能导致内存溢出。

<think>好的,我现在需要回答用户关于ThreadPoolExecutorBlockingQueue作用的问题。首先,我得确保自己正确理解这两个概念,以及它们在Java并发编程中的角色和相互关系。 首先,ThreadPoolExecutorJava中用于管理线程池的核心类。线程池的主要作用是复用线程,减少线程创建和销毁的开销,提高系统性能。而BlockingQueue,顾名思义,是一种支持阻塞操作的队列,常用于生产者和消费者模式,协调多个线程之间的任务处理。 用户的问题是关于它们的作用,特别是ThreadPoolExecutor如何使用BlockingQueue。我需要分步骤理清楚两者的关系。首先,ThreadPoolExecutor内部的工作机制是怎样的?当有任务提交时,线程池会根据配置的参数来决定如何处理这些任务。核心线程数、最大线程数、队列容量这些参数是关键。 接下来,BlockingQueueThreadPoolExecutor中具体承担什么角色?当核心线程都在忙时,新任务会被放入队列中等待。如果队列满了,才会创建新线程直到达到最大线程数。如果队列未满,任务会被暂存,直到有线程空闲出来处理它们。这里需要解释不同类型的BlockingQueue,比如LinkedBlockingQueue、ArrayBlockingQueue、SynchronousQueue等,它们的不同特性如何影响线程池的行为。 然后,可能需要举例说明不同的队列类型如何导致不同的线程池行为。例如,使用无界队列(如LinkedBlockingQueue不设置容量)可能会导致任务堆积,内存耗尽。而使用有界队列可以防止资源耗尽,但需要合理设置队列大小和最大线程数。还有同步移交队列(如SynchronousQueue),它不存储元素,每个插入操作必须等待另一个线程的移除操作,这样线程池会直接创建新线程直到达到最大线程数,之后则执行拒绝策略。 此外,需要提到当队列已满且线程数达到最大值时,ThreadPoolExecutor的拒绝策略会起作用,比如抛出异常、丢弃任务等。这也是BlockingQueue在其中的关键作用,因为它控制了任务的排队策略。 在整理这些信息时,要确保结构清晰,逐步引导用户理解两者的作用。可能需要先分别介绍ThreadPoolExecutorBlockingQueue,再说明它们的协同工作方式,最后举例不同配置下的行为差异,这样用户能够更好地理解其应用场景和配置选择的重要性。 同时,要注意用户可能对某些术语不太熟悉,需要用简洁明了的中文解释,避免过于技术化的表述。比如,解释“阻塞队列”时,可以说明它如何让生产者线程在队列满时阻塞,消费者线程在队列空时等待,从而协调两者的速度差异。 最后,检查是否有遗漏的重要点,比如线程池的工作流程、队列类型的选择对性能的影响,以及如何根据应用场景合理配置参数。确保回答不仅准确,还能帮助用户实际应用这些知识解决问题。</think>ThreadPoolExecutorBlockingQueueJava线程编程中是紧密配合的组件,以下是它们的核心作用及协作关系: --- ### 一、ThreadPoolExecutor的作用 这是Java标准库中的**线程池实现**,核心功能包括: 1. **线程复用**:避免频繁创建/销毁线程的开销 2. **资源管控**:通过参数限制最大并发数 3. **任务调度**:决定何时执行任务、何时拒绝任务 4. **生命周期管理**:提供关闭线程池的方法 关键参数: - `corePoolSize`:核心线程数(常驻线程) - `maximumPoolSize`:最大线程数(临时线程上限) - `keepAliveTime`:空闲线程存活时间 - `workQueue`:任务队列(需使用BlockingQueue) --- ### 二、BlockingQueue的作用 这是**线程安全的阻塞队列**,在ThreadPoolExecutor中承担任务缓冲区的角色: 1. **暂存待处理任务**:当所有核心线程忙碌时,新任务进入队列等待 2. **流量控制**:通过队列容量限制任务堆积量 3. **协调生产-消费速度**:队列满时阻塞提交者,队列空时阻塞工作者线程 常见实现类: | 队列类型 | 特性 | 适用场景 | |---------|-----|---------| | `LinkedBlockingQueue` | 无界/有界链表队列 | 默认选择,适合多数场景 | | `ArrayBlockingQueue` | 有界数组队列 | 需要固定容量限制 | | `SynchronousQueue` | 无缓冲同步队列 | 直接传递任务,需快速响应 | | `PriorityBlockingQueue` | 带优先级的队列 | 需要任务优先级排序 | --- ### 三、协作流程 当提交新任务时,ThreadPoolExecutor按以下顺序处理: ``` 1. 如果当前线程数 < corePoolSize ➔ 立即创建新线程执行任务 2. 否则,尝试将任务放入BlockingQueue - 如果队列未满 ➔ 任务进入队列等待 - 如果队列已满 ➔ 创建新临时线程(直到达到maximumPoolSize) 3. 当线程数已达max且队列已满 ➔ 触发拒绝策略 ``` --- ### 四、配置示例 ```java // 创建有界队列(容量=10) BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10); // 初始化线程ThreadPoolExecutor executor = new ThreadPoolExecutor( 5, // corePoolSize 10, // maximumPoolSize 60, // keepAliveTime(秒) TimeUnit.SECONDS, queue ); // 设置拒绝策略(队列满时抛出异常) executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy()); ``` --- ### 五、典型应用场景 1. **Web服务器请求处理**:队列缓冲突发流量 2. **批量数据处理**:控制并发处理的任务数量 3. **异步任务调度**:避免主线程阻塞 4. **资源敏感型应用**:防止系统过载 --- ### 六、注意事项 1. **队列容量规划**:需平衡内存占用与吞吐量 2. **拒绝策略选择**:根据业务需求选择丢弃策略或补偿机制 3. **监控队列深度**:通过`executor.getQueue().size()`观察任务堆积情况 4. **避免无界队列**:可能导致内存溢出(OOM) 理解两者的协作机制,能帮助开发者更好地进行并发程序设计和性能调优。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值