死磕JDK源码ThreadPoolExecutor源码保姆级详解
Posted JavaEdge.
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了死磕JDK源码ThreadPoolExecutor源码保姆级详解相关的知识，希望对你有一定的参考价值。
位运算表示线程池状态，因为位运算是改变当前值的一种高效手段。
属性
线程池状态
Integer 有32位：
- 最左边3位表示线程池状态，可表示从0至7的8个不同数值
- 最右边29位表工作线程数
private static final int COUNT_BITS = Integer.SIZE - 3;
线程池的状态用高3位表示，其中包括了符号位。五种状态的十进制值按从小到大依次排序为：
RUNNING < SHUTDOWN < STOP < TIDYING <TERMINATED
这就能通过比较值的大小来确定线程池的状态。
源码中经常出现通过isRunning判断
000-1111111111111111111111111;
类似于子网掩码，用于与运算。得到左3位 or 右29位
-
111 - 0000000000000000000000000000(十进制: -536, 870, 912);
该状态表示：线程池能接受新任务
-
000 - 0000000000000000000000000(十进制: 0);
不再接受新任务，但可继续执行队列中的任务
-
001 - 00000000000000000000000000(十进制: 536,870， 912);
全面拒绝，并中断正在处理的任务
-
010 - 00000000000000000000000000.(十进制值: 1, 073, 741, 824);
所有任务已经被终止
-
101 - 000000000000000000000000000(十进制值: 1, 610,612, 736)
已清理完现场
与运算
000 - 11111111111111111111 位掩码，用于后续的掩码参与计算。
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
比如：001 - 000000000000000000000100011 表 35 个工作线程。
掩码取反：111 - 00000000000000000000000，即得到左边3位001;
表示线程池当前处于STOP状态
private static int runStateOf(int c) { return c & ~CAPACITY; }
同理掩码 000 - 11111111111111111111，得到右29位，即工作线程数：
private static int workerCountOf(int c) { return c & CAPACITY; }
把左3位与右29位或运算,合并成一个值
private static int ctlOf(int rs, int wc) { return rs | wc; }
线程池状态控制器，保存了线程池的状态、工作线程数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
我们都知道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(c) < corePoolSize) {
if (addWorker(command, true))
return;
// 若创建失败,为防止外部已经在线程池中加入新任务,在此重新获取一下
c = ctl.get();
}
execute方法在不同的阶段有三次addWorker的尝试动作。
// 若 工作线程数 >=核心线程数 或线程创建失败,则将当前任务放到工作队列中
// 只有线程池处于 RUNNING 态,才执行后半句 : 置入队列
if (isRunning(c) && 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的可能原因：
- 线程池没有处
RUNNING态 - 线程工厂创建新的任务线程失败
参数
- firstTask
外部启动线程池时需要构造的第一个线程，它是线程的母体 - core
新增工作线程时的判断指标- true
需要判断当前RUNNING态的线程是否少于corePoolsize - false
需要判断当前RUNNING态的线程是否少于maximumPoolsize
- true
JDK8源码
private boolean addWorker(Runnable firstTask, boolean core) {
// 1. 不需要任务预定义的语法标签，响应下文的continue retry
// 快速退出多层嵌套循环
retry:
// 外自旋,判断线程池的运行状态
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 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(c);
// 若超过最大允许线程数，则不能再添加新线程
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 3. 将当前活动线程数+1
if (compareAndIncrementWorkerCount(c))
break retry;
// 线程池状态和工作线程数是可变化的，需经常读取最新值
c = ctl.get(); // Re-read ctl
// 若已关闭，则再次从retry 标签处进入，在第2处再做判断(第4处)
if (runStateOf(c) != 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(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 如果成功，那么就是所有创建线程前的条件校验都满足了，准备创建线程执行任务
// 这里失败的话，说明有其他线程也在尝试往线程池中创建线程
if (compareAndIncrementWorkerCount(c))
break retry;
// 由于有并发，重新再读取一下 ctl
c = ctl.get(); // Re-read ctl
// 正常如果是 CAS 失败的话，进到下一个里层的for循环就可以了
// 可如果是因为其他线程的操作，导致线程池的状态发生了变更，如有其他线程关闭了这个线程池
// 那么需要回到外层的for循环
if (runStateOf(c) != 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)死磕 java线程系列之线程池深入解析——构造方法