京东T7架构师呕心沥血整理的Java线程池全解手册，希望能够帮到你

骆驼和他的java
212 阅读14分钟

Hello，今天给各位童鞋们分享Java线程池，赶紧拿出小本子记下来吧！

image.png

一、写在前面

1.1 线程池是什么

线程池（Thread Pool） 是一种池化思想管理线程的工具，经常出现在多线程服务器中，如MySQL。

线程过多会带来额外的开销，其中包括创建销毁线程的开销，操作系统调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务是创建销毁线程开销代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对操作系统内核的充分利用。

本文描述的线程池是JDK提供的ThreadPoolExecutor类

使用线程池带来的好处

降低资源消耗：通过赤化技术重复利用已创建的线程，降低想成创建和 销毁造成的消耗

提高响应速度：任务到达时，无需等待线程创建即可立即执行

提高线程的可管理性：线程是稀缺资源，如果无限制创建，不仅会消耗系统资源，还会因为线程的不合理分配导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控

提供更多更强大的功能：线程池具备可拓展性，允许开发人员向其中增加风多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行

1.2 线程池解决的问题是什么

线程池解决的问题就是资源管理的问题。在并发环境下，系统不能够确定在任意时刻有多少任务需要执行，有多少资源需要投入。

在这种不确定性下将会带来以下若干的问题

频繁申请/销毁资源和调度资源，将带来额外的开销，可能是非常巨大的

对资源无限申请缺少抑制手段，容易引发系统资源耗尽问题的风险

系统无法合理管理内部的资源分布，会减低系统的稳定性

为了解决资源分配的问题，线程池采用“池化”（Pooling）思想。池化，顾名思义，是为了做大化收益并最小化风险，而将资源统一在一起管理的一种思想。

在计算机领域池化技术表现为：统一管理IT资源，包括服务器资源、存储、网络资源等。通过共享资源，使用户在第投入中获益。

除去线程池其他比较典型的几种使用策略包括

内存池（Memory Pooling）：预先申请内存，提升申请内存的速度，减少内存碎片

连接池（Connection Pooling）：预先申请数据库连接，提升申请连接的速度，降低系统开销

实例池（Object Pooling）：循环使用对象，减资源在初始化和释放时昂贵的损耗

二、线程池和核心设计与实现

2.1 总体设计

Java中线程池核心实现类是ThreadPoolExecutor，本章基于JDK1.8的源码来分析Java线程池的核心设计与实现。首先看一下ThreadPoolExecutor的UML图，了解ThreadPoolExecutor的继承关系

image.png

ThreadPoolExecutor实现的顶层接口是Executor，顶层接口Executor提供了一种思想：将任务提交和任务执行进行解耦。用户无需关注如何创建线程，如何调度线程来执行任务，用户只需提供Runnable对象，将任务的运行逻辑提交到执行器Executor中，由Executor框架完成线程的调配和任务的执行部分。

ExecutorService

扩充执行任务的能力，补充可以为一个或者一批异步任务生成Future的方法

提供了管理线程池的方法，比如停止线程池的运行

AbstractExecutorService

串联任务流程，保证下层的实现只需要关注一个执行任务的方法

ThreadPoolExecutor

维护自身的生命周期

管理线程和任务，使两者良好的结合从而执行并行任务

ThreadPoolExecutor是如何运行，如何同时维护线程和执行任务的呢？其运行机制如下图所示

ThreadPoolExecutor运行流程

image.png 线程池在内部实际上构造了一个生产者消费者模型，将线程和任务两者解耦，并不直接关联，从而良好的管理缓冲任务，复用线程。线程池的运行主要分成两部分:：任务管理、线程管理。任务管理充当生产者角色，当任务提交后，线程池会判断该任务后续流转

任务申请线程执行该任务

缓冲到队列中等待线程执行

拒绝该任务

线程管理部分是消费者，它们被统一维护在线程池内，根据任务请求进行线程的分配，当线程执行完任务后会继续获取新的任务执行，最终获取不到任务的时候，线程会被回收。

接下来按照如下三个方面讲解线程池的运行机制：

线程池如何维护自身状态

线程池如何管理任务

线程池如何管理线程

2.2 生命周期管理

线程池运行的状态，并不是用户显式设置的，而是伴随着线程池的运行，由内部来维 护。线程池内部使用一个变量维护两个值：运行状态 (runState) 和线程数量 (workerCount)。在具体实现中，线程池将运行状态 (runState)、线程数量 (workerCount)

两个关键参数的维护放在了一起，如下代码所示：

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

ctl 这个 AtomicInteger 类型，是对线程池的运行状态和线程池中有效线程的数量 进行控制的一个字段，它同时包含两部分的信息：线程池的运行状态 (runState) 和 线程池内有效线程的数量 (workerCount)，高 3 位保存 runState，低 29 位保存 workerCount，两个变量之间互不干扰。用一个变量去存储两个值，可避免在做相关 决策时，出现不一致的情况，不必为了维护两者的一致，而占用锁资源。通过阅读线 程池源代码也可以发现，经常出现要同时判断线程池运行状态和线程数量的情况。线程池也提供了若干方法去供用户获得线程池当前的运行状态、线程个数。这里都使用的是位运算的方式，相比于基本运算，速度也会快很多。

关于内部封装的获取生命周期状态、获取线程池线程数量的计算方法如以下代码 所示：

// Packing and unpacking ctl

// 计算当前运行状态

private static int runStateOf(int c) { return c & ~CAPACITY; }

// 计算当前线程数据

private static int workerCountOf(int c) { return c & CAPACITY; }

// 通过状态和线程数生成ctl

private static int ctlOf(int rs, int wc) { return rs | wc; }

ThreadPoolExecutor 的运行状态有 5 种，分别为：

// runState is stored in the high-order bits

private static final int RUNNING = -1 << COUNT_BITS;

private static final int SHUTDOWN = 0 << COUNT_BITS;

private static final int STOP = 1 << COUNT_BITS;

private static final int TIDYING = 2 << COUNT_BITS;

private static final int TERMINATED = 3 << COUNT_BITS;

image.png 其生命周期转换如下图所示

线程池生命周期

image.png

2.3 任务调度机制

2.3.1 任务调度

任务调度是线程池的主要入口，当用户提交了一个任务，接下来这个任务将如何执行 都是由这个阶段决定的。了解这部分就相当于了解了线程池的核心运行机制。 首先，所有任务的调度都是由 execute 方法完成的，这部分完成的工作是：检查现在线程池的运行状态、运行线程数、运行策略，决定接下来执行的流程，是直接申请线程执行，或是缓冲到队列中执行，亦或是直接拒绝该任务。其执行过程如下：

首先检测线程池运行状态，如果不是 RUNNING，则直接拒绝，线程池要保证在 RUNNING 的状态下执行任务

如果 workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务

如果 workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中。

如 果 workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务。

如果 workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满 , 则根据拒绝策略来处理该任务 , 默认的处理方式是直接抛异常。

其执行流程如下

任务调度流程图

image.png

2.3.2 任务缓冲

任务缓冲模块是线程池能够管理任务的核心部分。线程池的本质是对任务和线程的管 理，而做到这一点最关键的思想就是将任务和线程两者解耦，不让两者直接关联，才 可以做后续的分配工作。线程池中是以生产者消费者模式，通过一个阻塞队列来实现 的。阻塞队列缓存任务，工作线程从阻塞队列中获取任务。

阻塞队列 (BlockingQueue) 是一个支持两个附加操作的队列。这两个附加的操作是： 在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程 会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元 素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

阻塞队列

image.png 使用不同的队列可以实现不一样的任务存取策略。在这里，我们可以再介绍下阻塞队列的成员：

image.png

image.png

2.3.3 任务申请

由上文的任务分配部分可知，任务的执行有两种可能：一种是任务直接由新创建的线 程执行。另一种是线程从任务队列中获取任务然后执行，执行完任务的空闲线程会再 次去从队列中申请任务再去执行。第一种情况仅出现在线程初始创建的时候，第二种 是线程获取任务绝大多数的情况。

线程需要从任务缓存模块中不断地取任务执行，帮助线程从阻塞队列中获取任务，实现线程管理模块和任务管理模块之间的通信。这部分策略由 getTask 方法实现，其 执行流程如下图所示：

线程获取任务的流程

image.png getTask 这部分进行了多次判断，为的是控制线程的数量，使其符合线程池的状 态。如果线程池现在不应该持有那么多线程，则会返回 null 值。工作线程 Worker 会不断接收新任务去执行，而当工作线程 Worker 接收不到任务的时候，就会开始 被回收。

源码分析

2.3.4 任务拒绝

任务拒绝模块是线程池的保护部分，线程池有一个最大的容量，当线程池的任务缓存 队列已满，并且线程池中的线程数目达到 maximumPoolSize 时，就需要拒绝掉该任务，采取任务拒绝策略，保护线程池。

拒绝策略是一个接口，其设计如下： image.png 用户可以通过实现这个接口去定制拒绝策略，也可以选择 JDK 提供的四种已有拒绝策略，其特点如下

image.png

image.png

image.png

image.png

2.4 Worker线程管理

2.4.1 Worker线程

线程池为了掌握线程的状态并维护线程的生命周期，设计了线程池内的工作线程Worker。

Java Worker源码部分

private final class Worker

    extends AbstractQueuedSynchronizer

    implements Runnable

{

    /** Thread this worker is running in.  Null if factory fails. */

    // worker持有的线程

    final Thread thread;

    /** Initial task to run.  Possibly null. */

    // 初始化的任务，可以为null

    Runnable firstTask;



    ...

}

Worker 这个工作线程，实现了 Runnable 接口，并持有一个线程 thread，一个初始化的任务 firstTask。thread 是在调用构造方法时通过 ThreadFactory 来创建的线程，可以用来执行任务；firstTask 用它来保存传入的第一个任务，这个任务可以有也可以为 null。如果这个值是非空的，那么线程就会在启动初期立即执行这个任务，也就对应核心线程创建时的情况；如果这个值是 null，那么就需要创建一个线程去执行任务列表（workQueue）中的任务，也就是非核心线程的创建

/**

 * The queue used for holding tasks and handing off to worker

 * threads.  We do not require that workQueue.poll() returning

 * null necessarily means that workQueue.isEmpty(), so rely

 * solely on isEmpty to see if the queue is empty (which we must

 * do for example when deciding whether to transition from

 * SHUTDOWN to TIDYING).  This accommodates special-purpose

 * queues such as DelayQueues for which poll() is allowed to

 * return null even if it may later return non-null when delays

 * expire.

 */

# workerQueue 源码定义

private final BlockingQueue workQueue;

worker执行任务 image.png 线程池需要管理线程的生命周期，需要在线程长时间不运行的时候进行回收。线程池 使用一张 Hash 表去持有线程的引用，这样可以通过添加引用、移除引用这样的操作 来控制线程的生命周期。这个时候重要的就是如何判断线程是否在运行。

/**

 * Set containing all worker threads in pool. Accessed only when

 * holding mainLock.

 */

private final HashSet workers = new HashSet();

Worker 是通过继承 AQS，使用 AQS 来实现独占锁这个功能。没有使用可重入锁ReentrantLock，而是使用 AQS，为的就是实现不可重入的特性去反应线程现在的执行状态。

private final class Worker

    extends AbstractQueuedSynchronizer

    implements Runnable

lock方法一旦获取了独占锁，表示当前线程正在执行任务中

如果正在执行任务，则不应该中断线程

如果该线程现在不是独占锁状态，也就是空闲状态，说明它没有正在处理任务，这时可以对该线程进行中断

线程池在执行shutdown方法或tryTeriminate方法是或调用interruptIdleWorkers方法来中断空闲线程，interruptIdleWorkers方法会使用tryLock方法来判断线程池中的线程是否是空闲状态，如果是空闲状态则可以安全回收

shutdown方法源码

public void shutdown() {

    final ReentrantLock mainLock = this.mainLock;

    mainLock.lock();

    try {

        checkShutdownAccess();

        advanceRunState(SHUTDOWN);

        // 执行interruptIdleWorkers方法

        interruptIdleWorkers();

        onShutdown(); // hook for ScheduledThreadPoolExecutor

    } finally {

        mainLock.unlock();

    }

    tryTerminate();

}

tryTerminate方法源码

image.png interruptIdleWorkers方法源码

image.png 在线程回收过程中就使用到了这种特性，回收过程如下图所示：

线程池回收过程

image.png

2.4.2 worker线程增加

增加线程是通过线程池中的 addWorker 方法，该方法的功能就是增加一个线程， 该方法不考虑线程池是在哪个阶段增加的该线程，这个分配线程的策略是在上个步 骤完成的，该步骤仅仅完成增加线程，并使它运行，最后返回是否成功这个结果。 addWorker 方法有两个参数：firstTask、core。firstTask 参数用于指定新增的线程执行的第一个任务，该参数可以为空；core 参数为 true 表示在新增线程时会判断当前活动线程数是否少于 corePoolSize，false 表示新增线程前需要判断当前活动线程数是否少于 maximumPoolSize，其执行流程如下图所示：

申请线程执行流程图

image.png 源码分析

image.png

image.png

2.4.3 worker线程回收

线程池中线程的销毁依赖 JVM 自动的回收，线程池做的工作是根据当前线程池的状态维护一定数量的线程引用，防止这部分线程被 JVM 回收，当线程池决定哪些线 程需要回收时，只需要将其引用消除即可。Worker 被创建出来后，就会不断地进行轮询，然后获取任务去执行，核心线程可以无限等待获取任务，非核心线程要限时获取任务。当 Worker 无法获取到任务，也就是获取的任务为空时，循环会结束，Worker 会主动消除自身在线程池内的引用。

image.png 事实上，在这个方法中，将线程引用移出线程池就已经结束了线程销毁的部分。但由于引起线程销毁的可能性有很多，线程池还要判断是什么引发了这次销毁，是否要改变线程池的现阶段状态，是否要根据新状态，重新分配线程。

线程销毁流程

image.png

2.4.4 worker线程执行任务

在 Worker 类中的 run 方法调用了 runWorker 方法来执行任务，runWorker 方法的执行过程如下：

while循环不断获取getTask()方法获取任务

getTask()方法从阻塞队列获取任务

如果线程池正在停止，那么保证当前线程是中断状态，否则要保证当前线程不是中断状态

执行任务

如果getTask结果为null则调出循环，执行processWorkerExit()，销毁线程

执行任务流程

image.png

2.4.5 worker如何保证核心线程不被回收

源码分析

我们通常都是通过执行execute(Runnable command)方法来向线程池提交一个不需要返回结果的任务的如果你需要返回结果那么就是  Future submit(Callable task)方法）

第一步：execute方法分析

image.png 第二步：addWorker()方法分析

image.png

image.png 第三步：查看worker中的run()

/** Delegates main run loop to outer runWorker */

public void run() {

runWorker(this);

}

第四步：查看runWorker()

image.png

我们可以看到beforeExecute(Thread t, Runnable r)方法和afterExecute(Runnable r, Throwable t)会在任务的执行前后执行，我们可以通过继承线程池的方式来重写这两个方法，这样就能够对任务的执行进行监控啦。

第五步：查看getTask()

image.png

好啦，今天的文章就到这里，希望能帮助到屏幕前迷茫的你们

avatar
文章
阅读
粉丝