了解字段ctl
先介绍一下这段代码的意义，变量 ctl 的注释说明如下：
线程池状态量ctl是一个原子整数，封装了两个概念字段
- workerCount，表示有效线程数；
- runState，表示线程池的运行状态；
// 线程池状态量，默认为-1
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 位移常量，29位
private static final int COUNT_BITS = Integer.SIZE - 3;
// 根据位移常量得到的用来计算rs和wc的基数，同时也是最大线程数，原码为000111..111 （29个1）
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
为了打包成一个int，int类型为32位，我们用int类型的后29位来表示有效线程数，所以最大线程数为
(2^29 )-1。用前3位表示线程池的运行状态，其中首位为符号位，所以只能表示-3到+3之间。
然后我们再去看代码，这里的常量-1到3表示的就是线程池状态rs的所有取值
// 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;
这里提供了如何通过ctl得到rs和wc的方法，以及通过rs和wc计算ctl的方法，位运算逻辑不在此赘述
// Packing and unpacking ctl
private static int runStateOf(int c) { return c & ~CAPACITY; }
private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
还有一些进一步说明如下：
workerCount 是允许启动和不允许停止的线程数量。 该值可能会暂时不同于活动线程的实际数量，例如，当 ThreadFactory 在被询问时未能创建线程时，以及退出线程在终止前仍在执行簿记时。 用户可见的池大小报告为工作人员集的当前大小。
runState 提供主要的生命周期控制，取值：
RUNNING：接受新任务并处理排队任务
SHUTDOWN：不接受新任务，但处理排队任务
STOP：不接受新任务，不处理排队任务，并中断正在进行的任务
TIDYING：所有任务都已终止，wc 为零，转换到此状态的线程将运行 terminate() 钩子方法
TERMINATED： terminate() 已完成
这些值之间的数字顺序很重要，以允许有序比较。runState 随时间单调增加，但不需要命中每个状态。可能的转换是：
RUNNING -> SHUTDOWN 在调用 shutdown() 时，可能隐含在 finalize() 中
RUNNING 或 SHUTDOWN-> STOP 在调用 shutdownNow() 时
SHUTDOWN -> TIDYING 当队列和池都为空时
STOP -> TIDYING当池为空时
TIDYING -> TERMINATED 当 terminate() 钩子方法完成时
流程转换图（盗图）如下：
再看核心构造方法：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> 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;
}
构造函数的参数含义如下：
- corePoolSize：指定了线程池中的线程数量，它的数量决定了添加的任务是开辟新的线程去执行，还是放到workQueue任务队列中去；
- maximumPoolSize：指定了线程池中的最大线程数量，这个参数会根据你使用的workQueue任务队列的类型，决定线程池会开辟的最大线程数量；
- keepAliveTime：当线程池中空闲线程数量超过corePoolSize时，多余的线程会在多长时间内被销毁；设置为0L，表示空闲的线程会立刻终止
- unit：keepAliveTime的单位
- workQueue：任务队列，被添加到线程池中，但尚未被执行的任务；它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种；
- threadFactory：线程工厂，用于创建线程，一般用默认即可；
- handler：拒绝策略；当任务太多来不及处理时，如何拒绝任务；
其中用的较多的是这个构造：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
// 默认的拒绝执行策略，ThreadPoolExecutor提供了3种拒绝策略，对应3个静态内部类，
// 有兴趣的可以了解一下，十分简单
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
所以着重了解一下corePoolSize，maximumPoolSize，workQueue这三个参数的作用。我们略过一些细节，通过源码分析执行过程来了解。
通过设置corePoolSize和maximumPoolSize相同，可以创建一个固定大小的线程池。 通过将maximumPoolSize设置为基本上无界的值，例如Integer.MAX_VALUE，可以允许池容纳任意数量的并发任务。 通过设置队列为无界队列，那么maximumPoolSize将不起作用，但仍要保证maximumPoolSize>=corePoolSize。通常，核心和最大池大小仅在构建时设置，但也可以使用setCorePoolSize和setMaximumPoolSize进行动态更改。
看源码了解执行过程
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 1、工作线程 < 配置的核心线程数
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);
}
当线程池中的线程数量等于corePoolSize 时，如果继续提交任务，该任务会被添加到阻塞队列workQueue中，当阻塞队列也满了之后，则线程池会新建线程执行任务直到maximumPoolSize。
线程通常在任务执行完毕后会自动退出销毁，那么线程池是如何复用线程的呢？答案就是让任务不要结束。
/**
* 检查是否可以根据当前池状态和给定界限（核心或最大值）添加新的工作线程
* 返回true，则表示创建成功且已启动，false通常表示创建失败
* 失败可能是不符合corePoolSize，maximumPoolSize限制，也可能是线程池关闭，或者是线程工厂创建线程失败
*/
private boolean addWorker(Runnable firstTask, boolean core) {
// 第一部分：自旋、CAS、重读ctl 等结合，直到确定是否可以创建worker，
// 可以则跳出循环继续操作，否则返回false
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
/**
* rs >= SHUTDOWN 说明线程池已关闭或即将完全关闭
* rs == SHUTDOWN 说明线程池刚好处于关闭状态，但是已经入队的任务需要继续执行
* firstTask == null 说明并没有需要立刻执行的任务，联系上面execute方法
* ! workQueue.isEmpty() 队列不为空
* 这后三个条件组合在一起，说明本次是为了添加一个没有任务的线程然后再从非空的队列中获取任务的，
* 比如正好处于线程池关闭，队列中有任务需要执行，但是核心线程挂掉，需要补充非核心线程的情况，属于特例
*/
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)) // CAS增长workerCount，成功则跳出循环
break retry;
c = ctl.get(); // Re-read ctl 重新获取ctl
if (runStateOf(c) != rs) // 状态改变则继续外层循环，否则在内层循环
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// 第二部分：创建worker，这部分使用ReentrantLock锁
boolean workerStarted = false; // 线程启动标志位
boolean workerAdded = false; // 线程是否加入workers 标志位
Worker w = null;
try {
w = new Worker(firstTask); //创建worker
final Thread t = w.thread;
// 这里只可能是线程工厂创建线程失败才为null，视线程工厂生成策略而定
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 获取到锁以后仍需检查ctl，可能在上一个获取到锁处理的线程可能会改变runState
// 如 ThreadFactory 创建失败 或线程池被 shutdown等
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;
}
看到这里还是不太清晰，这时候就到主角出场了
/**
* 扩展了aqs，实现了一个不可重入的锁，关于锁的细节，这里不再分析
*/
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/** 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); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** 将实际的run方法逻辑委派给外部（即ThreadPoolExecutor）的runWorker方法 */
public void run() {
runWorker(this);
}
// ...
核心逻辑如下：
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
/**
* 这里实现了一个循环，执行完初始任务firstTask 之后，会去队列中取任务
* getTask方法涉及到队列，可能会阻塞
*/
while (task != null || (task = getTask()) != null) {
w.lock();
// 确保只有当线程是stoping时，才会被设置为中断，否则清楚中断标示
// 如果线程池状态 >= STOP ,且当前线程没有设置中断状态，则wt.interrupt()
// 如果线程池状态 < STOP，但是线程已经中断了，再次判断线程池是否 >= STOP，如果是 wt.interrupt()
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();
// 任务执行过程中假设出现异常，也会进入processWorkerExit，退出循环，当前线程执行完退出
} 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);
}
}
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
//线程池中状态>= STOP，或者状态为SHUTDOWN且阻塞队列为空，则worker - 1，return null
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// 减少工作线程数量wc
decrementWorkerCount();
// 返回null，追溯到runWorker，也会从循环中退出，线程完成任务，退出run方法，线程销毁
return null;
}
int wc = workerCountOf(c);
// 判断工人是否应该淘汰，allowCoreThreadTimeOut 表示是否允许核心线程超时退出
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 从阻塞队列中获取task，如果需要超时控制，则调用poll()，否则调用take()
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
线程池中多余的线程是如何回收的？
https://zhuanlan.zhihu.com/p/269145872
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
