【死磕JDK源码】ThreadPoolExecutor源码保姆级详解

我们都知道Executor接口有且只有一个方法execute()，通过参数传入待执行线程的对象。

execute

---

线程池执行任务

public void execute(Runnable command) {

if (command == null)

throw new NullPointerException();

/**

• 分 3 步：

• 2. 如果一个任务可以成功排队，那么仍需double-check我们是否应该添加一个线程（因为自上次检查以来现有线程已死亡）或池在进入此方法后关闭.所以我们重新检查状态，并在必要时回滚.如果停止，或者如果没有，则启动一个新线程
• 3. 如果我们无法将任务排队，则尝试添加一个新线程。如果失败，我们知道我们已经关闭或饱和，因此拒绝该任务

*/

int c = ctl.get();

// 1. 若工作线程数 < 核心线程数,则创建新线程并执行当前任务

if (workerCountOf© < corePoolSize) {

if (addWorker(command, true))

return;

// 若创建失败,为防止外部已经在线程池中加入新任务,在此重新获取一下

c = ctl.get();

}

execute方法在不同的阶段有三次addWorker的尝试动作。

// 若 工作线程数 >=核心线程数 或线程创建失败,则将当前任务放到工作队列中

// 只有线程池处于 RUNNING 态,才执行后半句 : 置入队列

if (isRunning© && workQueue.offer(command)) {

int recheck = ctl.get();

// 只有线程池处于 RUNNING 态,才执行后半句 : 置入队列

if (! isRunning(recheck) && remove(command))

reject(command);

// 若之前的线程已被消费完,新建一个线程

else if (workerCountOf(recheck) == 0)

addWorker(null, false);

// 核心线程和队列都已满,尝试创建一个新线程

}

else if (!addWorker(command, false))

// 抛出RejectedExecutionException异常

// 若 addWorker 返回是 false,即创建失败,则唤醒拒绝策略.

reject(command);

}

发生拒绝的理由有两个

( 1 )线程池状态为非RUNNING状态

(2)等待队列已满。

下面继续分析addWorker

addWorker 源码解析

---

原子性地检查 runState 和 workerCount，通过返回 false 来防止在不应该添加线程时出现误报。

根据当前线程池状态，检查是否可以添加新的线程：

• 若可

则创建并启动任务;若一切正常则返回true;

• 返回false的可能原因：

1. 线程池没有处RUNNING态

2. 线程工厂创建新的任务线程失败

参数

• firstTask

外部启动线程池时需要构造的第一个线程，它是线程的母体

• core

新增工作线程时的判断指标

• true

需要判断当前RUNNING态的线程是否少于corePoolsize

• false

需要判断当前RUNNING态的线程是否少于maximumPoolsize

JDK8源码

private boolean addWorker(Runnable firstTask, boolean core) {

// 1. 不需要任务预定义的语法标签，响应下文的continue retry

// 快速退出多层嵌套循环

retry:

// 外自旋,判断线程池的运行状态

for (;😉 {

int c = ctl.get();

int rs = runStateOf©;

// 2. 若RUNNING态,则条件为false,不执行后面判断

// 若STOP及以上状态,或firstTask初始线程非空,或队列为空

// 都会直接返回创建失败

// Check if queue empty only if necessary.

if (rs >= SHUTDOWN &&

! (rs == SHUTDOWN &&

firstTask == null &&

! workQueue.isEmpty()))

return false;

for (;😉 {

int wc = workerCountOf©;

// 若超过最大允许线程数，则不能再添加新线程

if (wc >= CAPACITY ||

wc >= (core ? corePoolSize : maximumPoolSize))

return false;

// 3. 将当前活动线程数+1

if (compareAndIncrementWorkerCount©)

break retry;

// 线程池状态和工作线程数是可变化的，需经常读取最新值

c = ctl.get(); // Re-read ctl

// 若已关闭，则再次从retry 标签处进入，在第2处再做判断(第4处)

if (runStateOf© != rs)

continue retry;

//如果线程池还是RUNNING态,说明仅仅是第3处失败

//继续循环执行(第5外)

// else CAS failed due to workerCount change; retry inner loop

}

}

// 开始创建工作线程

boolean workerStarted = false;

boolean workerAdded = false;

Worker w = null;

try {

// 利用Worker 构造方法中的线程池工厂创建线程,并封装成工作线程Worker对象

// 和 AQS 有关！！！

w = new Worker(firstTask);

// 6. 注意这是Worker中的属性对象thread

final Thread t = w.thread;

if (t != null) {

// 在进行ThreadpoolExecutor的敏感操作时

// 都需要持有主锁，避免在添加和启动线程时被干扰

final ReentrantLock mainLock = this.mainLock;

mainLock.lock();

try {

// Recheck while holding lock.

// Back out on ThreadFactory failure or if

// shut down before lock acquired.

int rs = runStateOf(ctl.get());

// 当线程池状态为RUNNING 或SHUTDOWN

// 且firstTask 初始线程为空时

if (rs < SHUTDOWN ||

(rs == SHUTDOWN && firstTask == null)) {

if (t.isAlive()) // precheck that t is startable

throw new IllegalThreadStateException();

workers.add(w);

int s = workers.size();

// 整个线程池在运行期间的最大并发任务个数

if (s > largestPoolSize)

// 更新为工作线程的个数

largestPoolSize = s;

// 新增工作线程成功

workerAdded = true;

}

} finally {

mainLock.unlock();

}

if (workerAdded) {

// 看到亲切迷人的start方法了!

// 这并非线程池的execute 的command 参数指向的线程

t.start();

workerStarted = true;

}

}

} finally {

// 线程启动失败，把刚才第3处加，上的工作线程计数再减-回去

if (! workerStarted)

addWorkerFailed(w);

}

return workerStarted;

}

第1处

配合循环语句出现的标签，类似于goto语法作用。label 定义时，必须把标签和冒号的组合语句紧紧相邻定义在循环体之前，否则编译报错。目的是在实现多重循环时能够快速退出到任何一层。出发点似乎非常贴心，但在大型软件项目中，滥用标签行跳转的后果将是无法维护的！

在 workerCount 加1成功后，直接退出两层循环。

第2处,这样的表达式不利于阅读,应如是

第3处

与第1处的标签呼应,AtomicInteger对象的加1操作是原子性的。break retry表 直接跳出与retry 相邻的这个循环体

第4处

此continue跳转至标签处,继续执行循环.

如果条件为false,则说明线程池还处于运行状态,即继续在for(;)循环内执行.

第5处

compareAndIncrementWorkerCount方法执行失败的概率非常低.

即使失败,再次执行时成功的概率也是极高的,类似于自旋原理.

这里是先加1,创建失败再减1,这是轻量处理并发创建线程的方式;

如果先创建线程,成功再加1,当发现超出限制后再销毁线程,那么这样的处理方式明显比前者代价要大.

第6处

Worker对象是工作线程的核心类实现。它实现了Runnable接口,并把本对象作为参数输入给run()中的runWorker (this)。所以内部属性线程thread在start的时候，即会调用runWorker。

private final class Worker

extends AbstractQueuedSynchronizer

implements Runnable

{

/**

• This class will never be serialized, but we provide a

• serialVersionUID to suppress a javac warning.

*/

private static final long serialVersionUID = 6138294804551838833L;

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

final Thread thread;

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

Runnable firstTask;

/** Per-thread task counter */

volatile long completedTasks;

/**

• Creates with given first task and thread from ThreadFactory.

• @param firstTask the first task (null if none)

*/

Worker(Runnable firstTask) {

setState(-1); // 直到调用runWorker前，禁止被中断

this.firstTask = firstTask;

this.thread = getThreadFactory().newThread(this);

}

/** 将主线程的 run 循环委托给外部的 runWorker 执行 */

public void run() {

runWorker(this);

}

// Lock methods

//

// The value 0 represents the unlocked state.

// The value 1 represents the locked state.

protected boolean isHeldExclusively() {

return getState() != 0;

}

protected boolean tryAcquire(int unused) {

if (compareAndSetState(0, 1)) {

setExclusiveOwnerThread(Thread.currentThread());

return true;

}

return false;

}

protected boolean tryRelease(int unused) {

setExclusiveOwnerThread(null);

setState(0);

return true;

}

public void lock() { acquire(1); }

public boolean tryLock() { return tryAcquire(1); }

public void unlock() { release(1); }

public boolean isLocked() { return isHeldExclusively(); }

void interruptIfStarted() {

Thread t;

if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {

try {

t.interrupt();

} catch (SecurityException ignore) {

}

}

}

}

setState(-1)是为何

设置个简单的状态，检查状态以防止中断。在调用停止线程池时会判断state 字段，决定是否中断之。

t 到底是谁？

源码分析

===================================================================

/**

• 检查是否可以根据当前池状态和给定的边界（核心或最大)

• 添加新工作线程。如果是这样,工作线程数量会相应调整，如果可能的话,一个新的工作线程创建并启动

• 将firstTask作为其运行的第一项任务。

• 如果池已停止此方法返回false

• 如果线程工厂在被访问时未能创建线程,也返回false

• 如果线程创建失败，或者是由于线程工厂返回null，或者由于异常（通常是在调用Thread.start（）后的OOM）），我们干净地回滚。

*/

private boolean addWorker(Runnable firstTask, boolean core) {

/**

• Check if queue empty only if necessary.

• 如果线程池已关闭，并满足以下条件之一，那么不创建新的 worker：

•  1. 线程池状态大于 SHUTDOWN，也就是 STOP, TIDYING, 或 TERMINATED
  

•  2. firstTask != null
  

•  3. workQueue.isEmpty()
  

• 简单分析下：

•  状态控制的问题，当线程池处于 SHUTDOWN ，不允许提交任务，但是已有任务继续执行
  

•  当状态大于 SHUTDOWN ，不允许提交任务，且中断正在执行任务
  

•  多说一句：若线程池处于 SHUTDOWN，但 firstTask 为 null，且 workQueue 非空，是允许创建 worker 的
  

*/

if (rs >= SHUTDOWN &&

! (rs == SHUTDOWN &&

firstTask == null &&

! workQueue.isEmpty()))

return false;

for (;😉 {

int wc = workerCountOf©;

if (wc >= CAPACITY ||

wc >= (core ? corePoolSize : maximumPoolSize))

return false;

// 如果成功，那么就是所有创建线程前的条件校验都满足了，准备创建线程执行任务

// 这里失败的话，说明有其他线程也在尝试往线程池中创建线程

if (compareAndIncrementWorkerCount©)

break retry;

// 由于有并发，重新再读取一下 ctl

c = ctl.get(); // Re-read ctl

// 正常如果是 CAS 失败的话，进到下一个里层的for循环就可以了

// 可如果是因为其他线程的操作，导致线程池的状态发生了变更，如有其他线程关闭了这个线程池

// 那么需要回到外层的for循环

if (runStateOf© != rs)

continue retry;

// else CAS failed due to workerCount change; retry inner loop

}

}

/* *

• 到这里，我们认为在当前这个时刻，可以开始创建线程来执行任务

*/

// worker 是否已经启动

boolean workerStarted = false;

// 是否已将这个 worker 添加到 workers 这个 HashSet 中

boolean workerAdded = false;

Worker w = null;

try {

// 把 firstTask 传给 worker 的构造方法

w = new Worker(firstTask);

// 取 worker 中的线程对象，Worker的构造方法会调用 ThreadFactory 来创建一个新的线程

final Thread t = w.thread;

if (t != null) {

//先加锁

final ReentrantLock mainLock = this.mainLock;

// 这个是整个类的全局锁，持有这个锁才能让下面的操作“顺理成章”，

// 因为关闭一个线程池需要这个锁，至少我持有锁的期间，线程池不会被关闭

mainLock.lock();

try {

// Recheck while holding lock.

// Back out on ThreadFactory failure or if

// shut down before lock acquired.

int rs = runStateOf(ctl.get());

// 小于 SHUTTDOWN 即 RUNNING

// 如果等于 SHUTDOWN，不接受新的任务，但是会继续执行等待队列中的任务

if (rs < SHUTDOWN ||

(rs == SHUTDOWN && firstTask == null)) {

// worker 里面的 thread 不能是已启动的

if (t.isAlive()) // precheck that t is startable

throw new IllegalThreadStateException();

// 加到 workers 这个 HashSet 中

workers.add(w);

int s = workers.size();

if (s > largestPoolSize)

largestPoolSize = s;

workerAdded = true;

}

} finally {

mainLock.unlock();

}

// 若添加成功

if (workerAdded) {

// 启动线程

t.start();

workerStarted = true;

}

}

} finally {

// 若线程没有启动，做一些清理工作，若前面 workCount 加了 1，将其减掉

if (! workerStarted)

addWorkerFailed(w);

}

// 返回线程是否启动成功

return workerStarted;

}

看下 addWorkFailed

记录 workers 中的个数的最大值，因为 workers 是不断增加减少的，通过该值可知线程池的大小的历史峰值。只有拿到主锁才能访问。

private int largestPoolSize;

runWorker

// worker 线程启动后调用

// worker 初始化时，可指定 firstTask，那么第一个任务也就可以不需要从队列中获取

final void runWorker(Worker w) {

Thread wt = Thread.currentThread();

// 该线程的第一个任务(若有)

Runnable task = w.firstTask;

w.firstTask = null;

// 允许中断

w.unlock();

boolean completedAbruptly = true;

try {

// 自旋，不断从等待队列获取任务，执行之

// 循环调用 getTask 获取任务

while (task != null || (task = getTask()) != null) {

w.lock();

// 若线程池状态大于等于 STOP，那么意味着该线程也要中断

/**

• 若线程池STOP，请确保线程 已被中断

• 如果没有，请确保线程未被中断

• 这需要在第二种情况下进行重新检查，以便在关中断时处理shutdownNow竞争

*/

if ((runStateAtLeast(ctl.get(), STOP) ||

(Thread.interrupted() &&

runStateAtLeast(ctl.get(), STOP))) &&

!wt.isInterrupted())

wt.interrupt();

try {

// 这是一个钩子方法，留给需要的子类实现

beforeExecute(wt, task);

Throwable thrown = null;

try {

// 到这里终于可以执行任务了

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。

很多人担心学了容易忘，这里教你一个方法，那就是重复学习。

打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。

从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。

人的本性就是容易遗忘，只有不断加深印象、重复学习才能真正掌握，所以很多书我都是推荐大家多看几遍。哪有那么多天才，他只是比你多看了几遍书。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
-e0oGhRfk-1712731425688)]

[外链图片转存中…(img-7iVqooR1-1712731425689)]

[外链图片转存中…(img-XCzzVDCR-1712731425689)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。

很多人担心学了容易忘，这里教你一个方法，那就是重复学习。

打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。

从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。

[外链图片转存中…(img-O1aYISsk-1712731425689)]

人的本性就是容易遗忘，只有不断加深印象、重复学习才能真正掌握，所以很多书我都是推荐大家多看几遍。哪有那么多天才，他只是比你多看了几遍书。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！