剖析流程思路:
- 简要查看类体系图,同时阅读类上源码注释,大致了解该类作用。
- 了解该类关键属性,以及构造方法。
- 查看类的内部类。简要了解重点的内部类
- 剖析类的常用方法。知道线程池是如何处理提交过来的任务,以及知道它是如何达到线程资源重复利用。
- 总结
可以看到ThreadPoolExecutor是Executor接口下的落地实现。
关于Executor接口是干嘛的,总的来说就一句话:想要达到提交任务和执行任务相分离。比如以前代码是new Thread(runnable). thread.start().耦合度太高,所以制定Executor接口体系来分离。
类描述:
ThreadPoolExecutor就是线程池,也叫做线程执行器。在线程池中有5个生命周期,分别为RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED。知道线程的生命周期有利于后续看方法实现,因为在方法实现中会大量判断线程中的状态来做不同的处理手段。
**RUNNING**:表示线程处于运行状态。可接收新任务,并且可以处理任务 **SHUTDOWN**:表示线程进入关闭状态,不允许外部提交任务到线程池,但是会把当前待处理的任务处理完毕,在关闭,俗称优雅的关闭。 **STOP**:表示线程立刻进入关闭状态,既不允许外部提交任务到线程池,同时也不会执行待处理的任务,并且如果当前线程已经有在执行的任务,会中断。 **TIDYING**:表示线程进入终止状态中。当任务全部中断,并且线程数全部停止,也就是为0,线程转换成tidying状态。 **TERMINATED**:表示线程进入终止状态。当terminated() 方法执行的时候,线程进入这个状态,换句话说terminated() 方法相当于遗言。
线程池状态变化顺序如下: RUNNING -> SHUTDOWN:当调用shutdown()时,running切换到shutdown状态。 RUNNING -> STOP:当调用shutdownNow()时,running切换到STOP状态。 SHUTDOWN -> TIDYING:当阻塞队列为空,并且线程全部停止销毁,转变成tidying STOP -> TIDYING:当池为空时。 TIDYING -> TERMINATED:当钩子terminated()方法执行的时候。
其实源码上的类注释非常的多,我这只是摘出来一个点,目的是帮助后续看方法。其他有兴趣可以去看看。我可以总结一下类上面的注释主要说了啥:
- 池化技术的作用
- 如何创建线程池(Exectors或者手动指定参数创建)
- 池中核心线程的使用和池大小的关系
- 池中队列的选择与使用
- 池中的拒绝策略的选择
- 等等。
有了前面的线程声明周期状态的了解,我们来看看线程池中的字段以及常量,从而大致可以猜出线程池的想要怎么工作。
// 阻塞队列,用于存放待执行的任务。 private final BlockingQueue类的构造器:workQueue; // 用于存放当前线程池中所有的工作线程 worker对象 private final HashSet workers = new HashSet (); // 创建线程的工厂 private volatile ThreadFactory threadFactory; // 支持 awaitTermination 的等待条件 private final Condition termination = mainLock.newCondition(); // 最大线程数 private volatile int maximumPoolSize; // 核心线程数 private volatile int corePoolSize; // 锁对象 private final ReentrantLock mainLock = new ReentrantLock(); // 记录同时在池中的最大线程数 private int largestPoolSize; // 非核心线程的最大空闲时间 private volatile long keepAliveTime; // 拒绝策略 private volatile RejectedExecutionHandler handler; // 默认的拒绝策略 private static final RejectedExecutionHandler defaultHandler = new AbortPolicy(); // 完成任务的计数 private long completedTaskCount; // 是否允许核心线程超时,如果true,则核心线程空闲的时候也会进入等待时间,超过就销毁。 private volatile boolean allowCoreThreadTimeOut; // ctl 主池控制状态。 如果通过wockerCount()方法计算它,则表示:计算当前工作线程的数量 // 如果通过runState()方法计算它,则表示:获取当前线程池的运行状态。 // 线程池的运行状态如下5个变量所示: private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static final int COUNT_BITS = Integer.SIZE - 3; private static final int CAPACITY = (1 << COUNT_BITS) - 1; // 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; private static final RuntimePermission shutdownPerm = new RuntimePermission("modifyThread"); private static final boolean ONLY_ONE = true;
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
通过上面字段的认识,现在看它的构造器一点都不陌生,就是对一些字段的初始化。比如初始化核心线程,最大线程,以及线程的空闲等待时间,池采用哪种组设队列来存储任务,以及采取那种拒绝策略等。
在往下我们就简要看看内部类,从而过渡到它的整个工作原理。
类中内部类:4个拒绝策略和一个工作线程Worker。
拒绝策略:public interface RejectedExecutionHandler {
void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
这是拒绝策略的接口定义,四个拒绝策略都是实现了这个接口,重写了拒绝方式。所以如果默认的4个拒绝策略不满足你的需求,你可以自定义实现这个接口,编写自己的拒绝策略。
-
AbortPolicy:拒绝本次任务,并且抛出一个异常
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
-
DiscardPolicy:拒绝本次任务,但是不抛出异常
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {}
-
DiscardOldestPolicy:丢弃最老的任务,并且重试execute,即将任务重试提交。
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
-
CallerRunsPolicy:直接让调用者线程执行该任务。
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
Woker:线程池中的工作者线程
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); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
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) {
}
}
}
}
可以看到worker其实就是一个Runnable,重写了run方法,最终运行任务,走的是runworker(this).同时类里面还extends AQS,有一些AQS相关的,但是无关紧要,它不在本文章中。我们可以忽略,只要记住worker是一个runnable类型,任务提交到线程池,会被包装成worker去运行即可。
看到此处,我们都有一些印象线程池内部都有哪些字段,以及它的工作者线程worker了。现在我们就可以去看方法实现原理了。
类常用方法解析:
此刻,我们就从代码角度走一下线程池的工作流程:
1.当执行execute(runnable) 即 提交任务到线程。execute执行3步骤:
1.如果核心线程数没满,则在创建一个核心线程跑这个任务,---》程序结束。
2.核心满了,则将任务入队,入队后需要再次检测线程池状态,因为有可能池关闭了,如果关闭则从任务队列中回滚这个任务。如果池没关闭,则进一步检测是否有工作线程(因为有可能现有的线程自上次检测后就死了),如果没有,开启一个。 ---》程序结束
3.如果不能入队,再次尝试启动一个非核心线程,如果失败,说明线程池达到饱和状态,采取拒绝策略。---》程序结束。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
// 1. 检测线程池状态核心线程状态数 & 可否再次开启一个核心线程
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 2. 判断线程池状态 & 尝试入队
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);
}
// 3. 入队失败,继续尝试一次开启非核心线程,如果失败,采取拒绝
else if (!addWorker(command, false))
reject(command);
}
execute方法执行的这3步骤就是面试时常常问的线程池的工作原理或者叫工作流程,总结起来就是上面的步骤:
当任务提交到线程池的时候,首先会判断核心线程数是否达到上限,如果没有,则新开启一个核心线程提供本次的任务。
如果核心线程数已经达到上限,那么会尝试将任务加入到阻塞队列中,入队成功会再次判断线程池的状态,如果关闭了,就执行队列回滚,并且采用拒绝策略拒绝本次的任务。或者如果入队成功,但是线程池没有工作线程,就会开启一个非核心线程。
如果入队都失败了,那么就说明阻塞队列是满的,直接开启一个非核心线程提供服务。
如果非核心线程也开启失败了,我们就知道线程池线程数量已经达到饱和状态,就采取拒绝策略拒绝本次任务。
最后非核心线程处理完毕任务后,会进入一个最大等待时间,超过这个时间没有接收到任务,就会进入销毁阶段。(这个知识点后面才会看到)
2.addWorker(Runnable firstTask, boolean core):给线程池增加一个工作线程。(core来判断是否核心)检测是否可以根据线程池的状态和边界 给线程池添加一个新的工作线程,如果可以,线程数量会得到更新,并且firstTask会作为新工作线程的首个任务。如果池已经停止或者无法创建新线程则return false。创建线程失败无非两种情况:1、线程工厂return null,2.由于异常(通常是thread.start() 抛出oom)我们就干净利落的回滚。
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 1. 检测线程池状态
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
// 1. 检测线程池的线程数量的边界
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 程序能执行到此处,说明可以添加一个新线程就利用cas操作将wokerCount值+1
if (compareAndIncrementWorkerCount(c))
break retry;
// cas失败,自旋重试
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 2.创建一个新woker者,将firstTask作为它的首个任务。
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()) // precheck that t is startable
throw new IllegalThreadStateException();
// 添加工作者到wokers集合中,并且维护当前所有工作者个数。
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;
}
worker一旦添加,那么最终cpu调度的时候执行的肯定是worker中的run方法。来看下。
worker工作者者的run方法直接调用runWoker。目标来到runWorker,看工作者线程如何工作。
public void run() {
runWorker(this);
}
3. runWorker(Worker w):运行工作者线程
看代码之前先阅读该方法的说明。
工作线程主要任务,反复从队列中获取任务并且执行,同时处理一些问题:
- 运行首个任务,运行完毕,通过getTask再次获取一个任务运行。如果getTask返回null,则worker根据池状态或配置参数而退出。
- 运行任何一个任务之前,尝试获取锁,以防止在任务执行时其他池中断。然后我们确保除非池正在停止,否者线程没有中断集。
- 每个任务在运行之前都会执行beforeExecute,这可能会导致异常,这种情况下,我们会让线程死亡而不处理任务。
- 假设beforeExecute正常执行,没有抛出异常,那么我们将执行任务,在执行任务中收集它抛出的任何异常以发送到afterExecute。我们分别处理 RuntimeException、Error和任意 Throwables。因为我们不能在 Runnable.run 中重新抛出 Throwable,所以我们在出路时将它们包装在 Errors 中(到线程的 * UncaughtExceptionHandler)。任何抛出的异常也保守的导致线程死亡。
- 任务执行完毕后,执行afterExecute,afterExecute也可能引发异常,同样也会导致线程死亡。
- 异常机制的最终效果是 afterExecute和线程的 UncaughtExceptionHandler 具有尽可能准确的信息,因为我们可以提供有关用户代码遇到的任何问题的信息。
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 循环获取任务,并且执行,通过getTask().直到getTask() 返回null
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
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,并且传递收集到的异常
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// worker退出while,为垂死的工人进行清理和记账
processWorkerExit(w, completedAbruptly);
}
}
那么通过以上注释以及代码,我们清晰的知道,原来线程池中的worker工作者,会先将当前首任务跑完,然后循环去阻塞队列中获取任务在执行,直到获取返回null,才死亡!那么重点就来到getTask()方法呗,看worker是如何去阻塞队列中获取新任务的。
getTask(): 从阻塞队列中获取一个任务,获取不到return nullwoker工作者在从阻塞队列中获取任务,获取不到执行阻塞 或者 定时等待任务,具体取决于配置设置,或者如果此woker工作者由于以下任何原因必须退出,则return null:
-
线程池超过maximumPoolSize 个工人
-
线程池进入stop状态
-
线程池进入shutdown状态 并且 阻塞队列为空
-
当前worker超时等待任务
通过上一个runWorker方法,我们知道一旦return null该worker 就会进入销毁阶段。
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 线程池进入shutdown状态 并且 阻塞队列为空 则 将 worketCount-1. 同时return null
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 {
// 通过timed来区分核心还是非核心
// 如果非核心,则调用阻塞队列的poll并且带上超时时间
// 如果核心,则调用组设队列的take方法,而take组设式等待,每获取到任务,就阻塞调用者线程。
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
通过此getTask方法,可以看到其实就是通过wc(当前线程池的工作线程数) 是否大于corePoolSize,如果大于,则说明当前worker是一个非核心,那么就调用阻塞队列的poll()并且携带上超时时间,否者调用take()。而poll方法超过时间每获取到任务,则reutn null,一旦return null,那么当前worker就会进入销毁。而take方法是阻塞式等待,获取不到任务,则阻塞当前worker。从而保证线程池中始终有那么几个核心线程数没有销毁。
总结:ThreadPoolExecutor这个类重要的就是构造方法上的7大参数,整个线程池的运行原理都是围绕着7大参数来执行。 另外读完ThreadPoolExecutor类要知道线程池的整个工作流程,以及核心线程数是如何不被销毁的。这两个知识点在面试时命中率非常高。
最后还有一些知识点可以去扩展学习,就是线程池该如何正确配置7大参数,以及阻塞队列的实现原理(重点剖析一个一般就差不多了),还有一开始看到的AQS,后续也可以看看。看完AQS,才可以去理解后续的JUC包下的锁等。
补充:如果文章中哪些错误!欢迎大神指出!本人刚毕业入行,希望能够得到前辈的指点与批评!



