ThreadPoolExecutor运转机制详解

最新推荐文章于 2024-07-30 07:46:59 发布
最新推荐文章于 2024-07-30 07:46:59 发布
阅读量860 收藏 1
点赞数
分类专栏： 专业知识 文章标签： ThreadPoolExecutor 多线程 并发 原理 拒绝策略

一、原理：

最近，在工作中接触到ThreadPoolExecutor,在这里记录一下相关的知识点，以便今后使用。

先看一下新建一个ThreadPoolExecutor的构建参数:

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          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是如何构建的。

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

newFixedThreadPool就是一个固定大小的ThreadPool 

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

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

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

二、排队

排队有三种通用策略：

  1. 直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
  2. 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
  3. 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。
三、被拒绝的任务

当 Executor 已经关闭，并且 Executor 将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法 execute(java.lang.Runnable) 中提交的新任务将被拒绝。在以上两种情况下，execute 方法都将调用其RejectedExecutionHandler 的RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：

  1. 在默认的 ThreadPoolExecutor.AbortPolicy 中，处理程序遭到拒绝将抛出运行时RejectedExecutionException。
  2. 在 ThreadPoolExecutor.CallerRunsPolicy 中，线程调用运行该任务的execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
  3. 在 ThreadPoolExecutor.DiscardPolicy 中，不能执行的任务将被删除。
  4. 在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

定义和使用其他种类的 RejectedExecutionHandler 类也是可能的，但这样做需要非常小心，尤其是当策略仅用于特定容量或排队策略时。 

公用的类ThreadPoolTask

public class ThreadPoolTask implements Runnable { 
  // 保存任务所需要的数据 
  private Object threadPoolTaskData; 
  private static int consumerTaskSleepTime = 2000; 

  ThreadPoolTask(Object tasks) { 
    this.threadPoolTaskData = tasks; 
  } 

  public void run() { 
    // 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句 
    System.out.println("start .." + threadPoolTaskData); 
    try { 
      //便于观察，等待一段时间 
      Thread.sleep(consumerTaskSleepTime); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    System.out.println("finish " + threadPoolTaskData); 
    threadPoolTaskData = null; 
  } 

}

ThreadPoolExecutor.AbortPolicy 

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
}

运行结果 

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
put task@ 4
start ..task@ 2
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 7
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
put task@ 9
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
put task@ 10
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
finish task@ 2
finish task@ 6
finish task@ 7
start ..task@ 4
start ..task@ 3
finish task@ 1
start ..task@ 5
finish task@ 4
finish task@ 3
finish task@ 5

ThreadPoolExecutor.CallerRunsPolicy 

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
}

运行结果 

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 8
start ..task@ 7
finish task@ 2
finish task@ 1
start ..task@ 3
start ..task@ 4
finish task@ 6
start ..task@ 5
finish task@ 7
finish task@ 8
put task@ 9
put task@ 10
start ..task@ 9
finish task@ 4
finish task@ 3
start ..task@ 10
finish task@ 9
finish task@ 5
finish task@ 10

ThreadPoolExecutor.DiscardPolicy 
import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
}

运行结果 

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
put task@ 9
start ..task@ 7
put task@ 10
finish task@ 2
finish task@ 1
start ..task@ 3
start ..task@ 4
finish task@ 7
finish task@ 6
start ..task@ 5
finish task@ 3
finish task@ 4
finish task@ 5

ThreadPoolExecutor.DiscardOldestPolicy 
import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察，等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
}

运行结果 

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 7
put task@ 9
put task@ 10
finish task@ 6
finish task@ 7
start ..task@ 8
finish task@ 1
start ..task@ 9
finish task@ 2
start ..task@ 10
finish task@ 8
finish task@ 9
finish task@ 10


keepAliveTime

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

有点拗口，其实这个不难理解，在使用了“池”的应用中，大多都有类似的参数需要配置。比如数据库连接池，DBCP中的maxIdle，minIdle参数。

什么意思？接着上面的解释，后来向老板派来的工人始终是“借来的”，俗话说“ 有借就有还”，但这里的问题就是 什么时候还了，如果借来的工人刚完成一个任务就还回去，后来发现任务还有，那岂不是又要去借？这一来一往，老板肯定头也大死了。

合理的策略：既然借了，那就多借一会儿。直到“ 某一段”时间后，发现再也用不到这些工人时，便可以还回去了。这里的某一段时间便是keepAliveTime的含义，TimeUnit为keepAliveTime值的度量。


备注：

既然最终任务都是由execute(Runnable)方法执行，就直接来看该方法实现的所在类。首当其冲肯定是类ThreadPoolExecutor了，相信他是java concurrent包中用的最多的一个

线程池执行器，包括spring中ThreadPoolTaskExecutor也是利用它来执行任务的。从类的“家谱”来看，ThreadPoolExecutor直接继承自AbstractExecutorService，因此必须实现的方法只有public void execute(Runnable command)，查看之发现和想象不一样(原以为他会直接以此runnable创建一个thread然后直接start, ^_^)，他内部还会其他的执行逻辑，那是因为ThreadPoolExecutor内部会维护一个线程池，所以有很多额外的操作。



thjnemo
关注
专栏目录
ThreadPoolExecutor参数及执行流程
qq_43357821的博客
02-06 224
任务提交给线程池 如果线程池中线程数小于核心线程数，则创建一个新的线程来执行该任务。否则进入步骤3 提交任务时，线程池中的空闲的线程数为0并且线程数等于核心线程数，则观察线程池中的任务队列是否已满，如果未满则将任务添加到任务队列，否则进入步骤4 如果最大线程数大于核心线程数，并且总线程数小于最大线程数，则创建一个新的线程来执行该任务。否则进入步骤5 当任务队列已满时，就执行拒绝策略(后续详解拒绝策略 ThreadPoolExecutor public ThreadPoolExecutor(in..
ThreadPoolExecutor里面4种拒绝策略--CallerRunsPolicy
chikoucha6215的博客
08-19 7493
首先介绍一下ThreadPoolExecutor构造方法： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, ...
（十四）线程池
qq_32076957的博客
01-19 2942
线程池
【HBZ分享】ThreadPoolExecutor核心的运作流程
最新发布
a645293829的博客
07-30 801
ThreadPoolExectutor的核心API原理及运行流程
ThreadPoolExecutor执行过程分析
weixin_34174422的博客
06-23 112
ThreadPoolExecutor public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, ...
说说ThreadPoolExecutor饱和策略CallerRunsPolicy
懂幸福，爱生活
06-21 1万+
之前在文章深入线程池ThreadPoolExecutor中聊到了线程池
java threadpoolexecutor api_ThreadPoolExecutor.CallerRunsPolicy
weixin_36197669的博客
02-27 502
ThreadPoolExecutor.CallerRunsPolicy ClassDefinitionAssembly:Mono.Android.dllA handler for rejected tasks that runs the rejected taskdirectly in the calling thread of the execute method,unless the exec...
ThreadPoolExecutor运转机制介绍
12-19
### ThreadPoolExecutor 运转机制详解 #### 一、ThreadPoolExecutor 的基本概念与构造函数解析 在Java并发编程中，`ThreadPoolExecutor` 是一种强大的工具，它可以帮助开发者有效地管理和执行线程。`...
Android 消息机制详解（源码分析ThreadLocal、Looper、Handler、AsyncTask）
lly-Rachel的博客
09-01 386
Android 消息机制 1 概述 Android 的消息机制主要是指 Handler 的运行机制以及 Handler 所附带的 MessageQueue 和 Looper 的工作过程。 Android 应用是事件驱动的，每个事件都会转化为一个系统消息，即 Message 。消息中包含了事件相关的信息以及这个消息的处理人——Handler。每个进程中都有一个默认的消息队列（Message Queue，采用单链表的形式来存储消息列表），这个消息队列维护了一个待处理的消息列表，消息循环不断地从这个队列中取出消息
详解Spark Streaming的Graceful Shutdown
茅庐
01-06 1万+
本文主要探讨Spark Streaming的Graceful Shutdown，重点为三个问题：为什么需要Graceful Shutdown？如何触发Graceful Shutdown？Graceful Shutdown过程是怎样的？
Java开发常见面试题详解（并发，JVM）
热门推荐
KISS
03-12 8万+
预览 并发 问题 详解 请谈谈你对volatile的理解 link CAS你知道吗？ link 原子类Atomiclntegerl的ABA问题谈谈?原子更新引用知道吗？ link 我们知道ArrayList是线程不安全，请编码写一个不安全的案例并给出解决方案 link 公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁 link CountDownLatch/CyclicBarrier/Semaphore使用过吗？ link 阻塞队列知道吗？ l
2022金三银四必问储备知识：Java线程池详解
duan18888的博客
05-17 333
线程池概念 说得简单明了一点，就是管理线程的一个池子，是一种基于池化思想管理线程的工具。 为解决资源分配的问题，线程池采用了“池化”（Pooling）思想。池化，顾名思义，是为了最大化收益并最小化风险，而将资源统一在一起管理的一种思想。 Pooling is the grouping together of resources (assets, equipment, personnel, effort, etc.) for the purposes of maximizing advantage o
Java 线程池ThreadPoolExecutor
abing37的专栏
09-01 2万+
 Java线程池ThreadPoolExecutor. JDK1.5开始关于多线程加了很多特性。如：ConcurrentHashMap:放弃使用公用锁同步每一个方法，使用了更细化的锁机制，分离锁。对于大数据量的HashMap同步操作效率有了较大提升。CopyOnWriteArrayList:是同步Lis
一种关于ThreadPoolExecutor拒绝策略之CallerRunsPolicy（调用者运行策略）的实验研究
m0_58639137的博客
11-09 2085
线程池 CallerRunsPolicy 拒绝策略
Java ThreadPoolExecutor的拒绝策略CallerRunsPolicy
weixin_43600910的博客
01-24 1541
CallerRunsPolicy execute 去执行新任务，也就是main线程去执行，这种策略会降低新任务提交速度，影响整体性能。 main方法 public static void main(String[] args) { ExecutorService es = new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnab
ThreadPoolExecutor.CallerRunsPolicy 可伸缩队列
weixin_35757531的博客
02-14 1676
ThreadPoolExecutor.CallerRunsPolicy 是一种可伸缩队列策略。这种策略是当线程池中的线程数达到最大值，并且已提交的任务数大于线程池中的线程数时，任务将在调用者线程中执行，而不是在线程池中的线程中执行。这个策略可以控制任务的执行速度，防止线程池中的任务过多导致的资源耗尽。 ...
Java ThreadPoolExecutor的拒绝策略CallerRunsPolicy的一个潜在的大坑
明明如月的技术博客
05-07 2万+
一、背景 前面一篇文章转载了ThreadPoolExecutor的几种拒绝策略：https://blog.csdn.net/w605283073/article/details/89930154，讲得很不错。 但是网上介绍使用拒绝策略遇到的大坑的文章不多。 本文介绍其中一个真是故障的场景。 二、问题描述 ThreadPoolExecutor的拒绝策略常用的是DiscardPolicy...
ThreadPoolExecutor执行过程
干饭人的食堂
09-24 616
前言 最近写代码的时候用到了多线程线程池的地方
ThreadPoolExecutor执行流程
weixin_53946630的博客
05-21 680
ThreadPoolExecutor执行流程：核心线程数、最大线程数、任务队列 1.当任务量小于核心线程数的时候，它会创建一个线程来执行此任务 2.当任务量大于核心线程数，并且没有空闲线程的时候，且线程池的线程数小于最大线程数，此时会将任务存到任务队列里面。 注意：因为把多出来的任务存储在任务队列的成本最小，所以此时线程池会将新任务存在任务队列当中，而非新创建线程来执行任务。 3.当前任务量比较大的时候，此时没有空闲的线程，并且任务队列已经满了，此时会判断当前线程池的任务数量是否大于等于最大线程数。 如果当
Python ThreadPoolExecutor异常捕获详解
为了解决这个问题，我们需要理解`ThreadPoolExecutor`的工作机制，并学习如何正确地捕获和处理线程池中的异常。 首先，让我们来看一个简单的问题示例。在下面的代码片段中，我们创建了一个工作线程`thread_executor...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值