这是我参与8月更文挑战的第14天，活动详情查看：8月更文挑战
前言
上篇介绍了线程池的基本原理和使用的场景，本文主要从源码角度去分析线程池
1. 源码分析
在HotSpot VM的线程模型中，Java线程（java.lang.Thread）被一对一映射为本地操作系统线程。Java线程启动时会创建一个本地操作系统线程；当该Java线程终止时，这个操作系统线程也会被回收。操作系统会调度所有线程并将它们分配给可用的CPU。
Java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（Executor框架）将这些任务映射为固定数量的线程.
1.1 整体的框架
顶层的接口Executor void execute(Runnable command);
ExecutorService 对Executor功能扩展. 线程池提交任务的两种方式execute和submit, 两个最大的区别是submit可以通过FutureTask获取到线程执行的结果.
AbstractExecutorService 实现了ExecutorService很多的接口.
Executor框架主要由3大部分
- 任务, 被执行任务需要实现的接口：Runnable接口或Callable接口。
- 任务的执行, 核心接口Executor，以及继承自Executor的ExecutorService接口. Executor框架有两个关键类实现了ExecutorService接口(ThreadPoolExecutor和ScheduledThreadPoolExecutor)
- 异步计算的结果, 包括接口Future和实现Future接口的FutureTask类。
1.2 ThreadPoolExecutor详解
上一篇已经介绍了ThreadPoolExecutor的构造函数, 线程池的生命周期状态转换, 核心的成员变量方法. 那么我从源码的入口ThreadPoolExecutor.execute() 开始分析
1.2.1 execute 方法
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
// ctl表示线程池状态和线程数的
int c = ctl.get();
// 1. 判断线程数是否小于核心线程数
if (workerCountOf(c) < corePoolSize) {
// 添加任务
if (addWorker(command, true))
return;
// 如果提交任务失败，再次获取ctl的值
c = ctl.get();
}
// 2. 判断线程池是否处于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);
}
// 3. 添加非核心线程, 这里面就会判断当前的线程数,是否大于最大线程数
else if (!addWorker(command, false))
reject(command);
}
主流程可以对照前面的图, 业务流程很清晰, 下面我们在看看addWorker 方法
1.2.2 addWorker 方法
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
// 线程池状态
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// 1. 线程池状态, STOP, TIDYING, 或者TERMINATED
// 2. 状态是 SHUTDOWN, SHUTDOWN状态下，是不接收新的任务的。
// 3. 状态是SHUTDOWN,且firstTask == null,但是队列是空的,当前入队的任务还是需要执行的.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
// code 表示是否是核心线程, 判断当前线程数是否超过限制
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// CAS, 失败重试
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// worker是否已经启动的标志位
boolean workerStarted = false;
// 当前worker是否已经存放到HashSet中了
boolean workerAdded = false;
Worker w = null;
try {
// 构造一个Worker
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());
//如果rs<SHUTDOWN，说明线程池处于RUNNING状态或者线程池处于SHUTDOWN状态并且没有新的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 将线程的worker加入到workers这个HashSet中
workers.add(w);
int s = workers.size();
// largestPoolSize记录的是线程池中线程数曾经到达的最大值
if (s > largestPoolSize)
largestPoolSize = s;
// 标识添加成功
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 如果worker添加成功，启动线程执行任务
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
// 失败处理
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
1.2.3 addWorkerFailed 方法
我们在看看失败处理addWorkerFailed方法
主要做3件事情:
- 将worker从workers中移除
- worker的数量-1
- 检查termination
1.2.4 Worker 内部类
ThreadPoolExecutor中一个内部类:Worker。java线程池中的线程被包装成了一个个的Worker，代表线程池中的工作线程。
看下woker的类图,我们可以看到worker继承了AQS, 实现了线程Runable接口
worker主要方法, 下面的方法我们其实很熟悉了, AQS 实现类和线程run方法, 我们看下runWorker方法
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
// 释放独占锁, AQS中state设置为0
w.unlock(); // allow interrupts
//这个标志位代表当前Worker是否因为执行任务出现异常而停止的
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
// Worker加锁的意义在于，在线程池的其他方法中可能会中断Worker
// 为了保证Worker安全的完成任务，必须要在获取到锁的情况下才能中断Worker
// 如tryTerminate()，shutdown()等都会关闭worker。
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，准备接受下一个任务
task = null;
// 这个worker已完成任务数+1
w.completedTasks++;
// 释放独占锁
w.unlock();
}
}
completedAbruptly = false;
} finally {
//执行到这里说明：要么队列中已经没有任务了，要么执行任务出现了异常
processWorkerExit(w, completedAbruptly);
}
}
1.2.5 getTask 方法
如何从任务队列中取任务?
这个方法就是从队列中获取任务，返回null代表线程需要被关闭。一共有以下三种可能:
- 阻塞获取任务直到获取成功
- 获取任务超时了，也就说线程空闲了keepAliveTime这么久了，还是没有获取到任务，这个时候线程需要被关闭(这里有个前提就是线程数要大于corePoolSize)
- 如果出现下面几种情况返回null，返回null说明线程需要被关闭
- 线程池中worker的数量大于maximumPoolSize(由于调用setMaximumPoolSize进行了设置)
- 线程池处于STOP状态，这个时候不能执行任务队列中的任务
- 线程池处于SHUTDOWN状态，但是任务队列是空的
- 线程池中worker的数量大于maximumPoolSize(由于调用setMaximumPoolSize进行了设置)
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// CAS workerCount -1
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
// 前置校验通过了, 取任务
try {
// 如果timed为true，调用带超时的poll方法，否则执行take方法阻塞获取任务。
// 这边主要判断核心线程是否需要回收
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
1.2.6 processWorkerExit 方法
Worker.runWorker() 中清理worker的方法
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 线程池已完成的线程数+1
completedTaskCount += w.completedTasks;
// 将worker从线程池中移除
workers.remove(w);
} finally {
mainLock.unlock();
}
// 处理TERMINATED状态
tryTerminate();
int c = ctl.get();
// 如果线程池状态是RUNNING或者SHUTDOWN
if (runStateLessThan(c, STOP)) {
// 并且不是因为执行任务出现异常而进入到这个方法
if (!completedAbruptly) {
// 是否允许回收核心线程
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// 如果这个worker是由于执行任务异常而结束，或者是线程池中还有任务要执行
// 但却没有线程了。这个时候调用addWorker创建新的线程
addWorker(null, false);
}
}
1.2.7 tryTerminate 方法
这个方法其实就是用来处理线程池TERMINATED状态的. 执行完terminated()之后，就会由 TIDYING -> TERMINATED。
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
// 如果这个时候worker的数量不为0, 线程池不能停止
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// CAS尝试将线程状态转换成TIDYING
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
// 个钩子方法
terminated();
} finally {
// 执行完terminated()之后，最终将线程池状态置为TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
1.2.8 interruptIdleWorkers 方法
1.2.9 shutdown 方法
关闭线程池，这个方法会中断没有执行任务的线程
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// shutdown状态->shutdown
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
1.2.10 shutdownnow 方法
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 线程池状态->STOP
advanceRunState(STOP);
// 直接中断所有的workers线程
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
代码中shutdown和shutdowNow最关键的不同处在于中断线程的操作
参考文档
JAVA线程池源码深度解析
Java线程池架构(一)原理和源码解析
《并发编程艺术》
