概述
之前我写了一篇博客,系统的介绍了线程池相关知识。感兴趣的读者可以点击这里查看之前的博客。
最近我打算实现一个简单的线程池,在实现过程遇到很多问题,从中发现很多之前没有搞懂的知识点。为了查缺补漏,我打算整理一遍线程池核心功能的完整源码。
线程池如何执行任务
本篇主要介绍线程池执行一个任务的全过程。为了便于理解,我打算按照源码执行顺序展开,其中每个方法尽可能通过流程图的方式展示。
在阅读本篇博客前,需要你对线程池有一个大概的了解,本篇不会具体解释某个属性的作用,如果对线程池本身还不太熟悉的话,建议先点击概述中的链接初步了解一下。
1、execute(Runnable command)
进入正题,线程池无论通过哪种方式执行任务,最终都会调用 execute() 方法。下面我们直接给出 execute() 方法的源码:
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
关于该方法的逻辑,我们直接通过以下流程图介绍:
首先就流程图中,几个我认为比较迷惑的点先列出来并给出我的理解:
-
为什么在任务入队后,还需要判断线程池状态是否停止,并尝试删除任务呢?
答:这里实际上是做了一个 复检 的操作,为的是防止在任务入队期间线程池停止。
-
为什么要分两种线程?一种以被执行任务为参数,一种以null为参数?
答:这里的任务参数表示 第一个执行的任务。也就是说,该线程启动后有一个初始任务。如果任务入队的话,就不需要创建线程默认执行,因为它迟早会从队列中取出并执行。
-
核心线程和非核心的区别有哪些?
答:我认为两者本身没有区别,只是在创建线程过程中,核心线程和非核心线程进行不同的逻辑判断,核心线程根据核心线程数判断,非核心线程根据所有线程数判断。
总结:就我个人理解,execute() 方法主要判断 是否需要创建 Worker对象 。而在线程池中,Worker类也就是线程工作类,也就是说该方法主要判断当前任务是否需要创建新线程来执行。
根据阅读上述代码,我们会发现,只有以下三种情况才会创建新的线程:
- 线程池中工作线程数量小于 核心线程数量 时,创建 核心线程。
- 线程池中阻塞队列不为空,工作线程数量等于0时,创建 非核心线程。
- 创建核心线程失败,任务入队失败时,创建 非核心线程。
而这三种情况对应的实际场景依次分别是:
- 核心线程数量不够,补充新的核心线程执行当前任务
- 线程池中没有线程,并且阻塞队列中存在未执行的任务,将任务入队,按照队列顺序依次执行
- 核心线程已满,阻塞队列已满,创建非核心线程执行当前任务
当然上述只是线程执行的第一步,下面我们来阅读具体创建工作线程的代码:
2、addWorker(Runnable firstTask, boolean core)
线程池执行 execute() 方法后,最终都要通过 addWorker() 方法创建的线程执行。下面我们直接给出 addWork() 方法的源代码:
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
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;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive())
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
关于该方法的逻辑,我们也通过流程图的方式展开:
首先我们解释流程图中的 特殊情况 :线程池处于 ShutDown状态,当前任务为空,并且阻塞队列不为空时。这也就对应上述 execute() 方法的第二种情况,唯一区别是,execute() 方法执行时线程池还处于 Running 状态,而这里线程池已经处于ShutDown状态。
通过这里也可以反映出线程池策略:线程池停止后不会处理新方法,但缓存队列中的方法还会执行。
关于上述流程图,我也列举出部分疑问我和理解:
-
上述代码中,为什么要加解锁?
答:加解锁期间,主要是为了处理部分线程不安全的变量。如:workers 采用 HashSet 数据结构,largestPoolSize 是 int 类型的,这两个全局变量都是线程不安全的。
-
上述代码中,创建线程后,为什么要判断线程是否启动?
答:关于这个问题我也不能理解:新创建的线程在没有启动时,isAlive() 方法一定会返回 false,也就是说该判断一定不同通过。我怀疑该方法是为了确定创建对象期间是否出错,也就是初始化thread属性期间没有出现异常。
总结:addWorker() 方法主要完成 创建工作线程,并启动该工作线程。有且仅当工作线程创建成功并启动时返回 True。该方法在 execute() 方法的基础上,增加了判断线程数量的操作,其余都是一些维护线程池属性的操作。除此之外,它还实现了非Running状态,拒绝执行任务的逻辑。
execute()方法 和 addWorker() 方法都是在主线程层面调用线程池执行任务,下面我们具体看一下工作线程是如何执行任务,也就是Worker类的源码。
3、Worker 类
Worker类是线程池中用来封装工作线程的核心类,我们直接看它的源码:
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread;
Runnable firstTask;
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1);
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
// 略
}
首先该类继承 AbstractQueuedSynchronizer 类,简化部分同步操作。其实也很容易猜到,这里简化的是每个任务执行所获取和释放的锁定。
其次该类实现了 Runnable 接口,也就是说可以将该类对象作为参数创建线程,启动线程来执行该类的run() 方法。
最后该类有两个重要的属性:thread 和 firstTask。thread 表示工作线程本身,firstTask 表示该工作线程的首任务。在构造方法中,通过Worker对象本身作为参数创建线程 thread,而该 thread 又是 Worker 对象的属性。我们在启动该Worker对象的thread属性时,实际上就是执行Worker对象的run()方法,也就是线程体。
关于这样做的好处我是这样理解的:
- 线程池可以从外部维护 Worker对象,而不是 Thread 对象,易于管理
- 可以通过Worker对象实现部分方法,通过调用这些方法操作线程,而不是通过thread对象
- 可以在Worker对象中维护属性记录线程的状态,不用每次调用Thread方法判断
下面我们来看 runWorker() 方法的源码,熟悉线程体都做了什么
4、runWorker(Worker w)
所有工作线程最终都会走到 runWorker() 方法来执行任务,这里我直接贴出源码:
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock();
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
上述代码我们依旧通过流程图的形式展开,如下所示(流程图中部分非关键逻辑可能存在错误,例如线程调用interrupt()方法并不会立即停止):
这个方法的核心功能就是告诉我们,工作线程通过直接执行Runnable对象方法的run方法执行任务。
其中 执行前期操作 和 执行后期操作 都可能产生异常,方法体内可以做异常抛出等操作。
需要注意的一点是:有且仅当getTask()方法抛出异常时,才会导致停止标志以true的形式执行 processWorkerExit() 方法。关于该方法的逻辑本篇暂时不做结束,后续再其他博客中展开。
通过该方法,我们可以看出线程池中,工作线程能够复用的主要原理是:通过单线程执行多个任务的 run() 方法。其中在处理完某个任务后,通过 getTask() 方法获取新的任务执行。
最后,我们来看一下 getTask() 方法的实现原理。
5、getTask()
在线程池中,工作线程循环调用 getTask() 方法获取任务进行执行,这也是线程池单线程执行多任务的原理。我们直接看源码:
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
其中该方法逻辑有点绕,我先通过流程图的方式给出大体逻辑,下面通过文字对比较绕的模块单独介绍:
判断线程池是否停止:可以理解为线程池是否不工作了,主要表示以下两种场景:
- 线程池状态为STOP及以后
- 线程池状态为SHUTDOWN,并且阻塞队列已经为空
这里主要为了区分线程池处于SHUTDOWN,但是队列不为空的情况。我们知道,线程池处于SHUTDOWN状态时,还是会处理阻塞队列中的任务的,也就是还在工作的。
判断是否超时回收:当存在以下两种情况时,超时线程才会被回收:
- 配置 allowCoreThreadTimeOut 为 True,也就是所有线程空闲都会回收
- 线程数超过最大核心线程数,也就可以理解为非核心线程空闲都会被回收
判断线程是否可回收:判断一个线程是否可回收主要集中在以下两种情况,其中无论哪种情况至少得满足下述两种情况中的一种:
- 线程数大于1,也就是说有线程可回收
- 阻塞队列为空,也就是说当前没有任务需要执行
判断可回收的情况如下:
- 线程数大于最大线程数
- 线程已超时,并且该线程超时会被回收
流程图中比较模糊的几个判断及解释已经给出,现在我们再来看 getTask()方法。
我理解 getTask() 方法的核心作用是 控制工作线程的周期。可以总结为:
- 如果当前线程是可回收的,超过最长空闲时返回null,线程执行 processWorkerExit() 方法被回收
- 如果线程是不可回收的,就阻塞线程,直到有任务时返回任务,交给工作线程处理
最后我们再来聊聊线程回收,通过总结上述代码,我认为只有三种情况才会回收线程:
- 线程池不工作了
- 超时可回收线程超时了
- 线程数超过最大线程,并且当前没有任务
**那么线程池是如何做到阻塞工作线程不让它被回收的呢?又是如何做到回收线程?
答:阻塞队列的 take() 方法在队列为空时会阻塞,因此线程也会阻塞,此时线程就会一直等待任务,不被回收。阻塞队列的 poll() 方法不会阻塞,如果线程池为空,直接返回null。回到 runWorker() 方法,如果任务为空,就会跳出循环执行 processWorkerExit() 方法,该方法会通过 tryTerminate() 方法停止线程并回收。