线程池 ThreadPoolExecutor 源码详细分析
作者：互联网
1、线程池的作用
一方面当执行大量一步任务的时候线程池能够提供较好的性能，在不使用线程池的时候，每当需要执行异步的时候都是直接 new 一线程进行运行，而线程的创建和销毁都是需要开销的。使用线程池的时候，线程池里面的线程是可复用的，不会每次执行异步任务的时候都重新创建和销毁线程。
另一方面线程池提供了一种资源限制和管理的手段，比如可以限制线程的个数，动态新增线程等，每个 ThreadPoolExecutor 也保留了一些基本的统计数据，比如当前线程池完成的任务数目等。
2、ThreadPoolExecutor 继承体系
- Executor：只定义了一个方法
execute()，用于执行提交的任务 - ExecutorService：定义了一些线程池管理、任务提交、线程检测的方法
- AbstractExecutorService：提供了
ExecutorService接口执行方法的默认实现，用于同一处理Callable任务和Runnable任务。
下面介绍一下线程池的拒绝策略
当线程池的任务缓存队列已经满了并且线程池中的线程数目达到 maximumPoolSize 的时候，如果还有任务到来就会采取任务拒绝策略，通常有以下四种拒绝策略：
- AbortPolicy：直接抛出一个
RejectedExecutionException的异常，让你感知到任务被拒绝了，下面你可以根据业务逻辑选择重试或者放弃提交。 - DisCardPolicy：当新任务被提交后直接被丢弃，也不会给你任何的通知，可能造成数据丢失的现象。
- DisCardOldestPolicy：如果线程池没有关闭且没有能力执行，则会丢弃任务队列中的头结点，然后重新提交被拒绝的任务。通常是存活时间最长的任务，这种策略与第二种不同之处在于它丢弃的任务不是最新提交的，而是队列中存活时间最长的，这样就可以腾出资源给新提交的任务，但是同理也存在一定的数据丢失风险。
- CallerRunsPolicy：当有新任务提交的时候，如果线程池没被关闭且没有能力执行，则把这个任务交于提交任务的线程执行，也就是谁提交任务，谁就负责执行任务。这样做主要有两点好处：
- 提交的新任务不会被丢弃，这样也就不会造成业务损失。
- 由于谁提交任务谁就要负责执行，这样提交任务的线程就得负责执行任务，而执行任务又是比较耗时得，在这段期间，提交任务得线程被占用，也就不会提交新的任务，减缓了任务提交得速度，相当于是一个负反馈。在此期间，线程池中的线程也可以充分利用这段时间来执行掉一部分任务，腾出一定的空间，相当于是给了线程池一定的缓冲期。
阻塞队列
BlockingQueue
BlockingQueue 在 java.util.concurrent 包下，其他阻塞类都实现自 BlockingQueue 接口，BlockingQueue 提供了线程安全的队列访问方式，当向队列中插入数据的时候，如果队列已经满了，线程则会阻塞等待队列中的元素被取出后再插入；当从队列中取数据的时候，如果队列为空，则线程会阻塞等待队列中有新元素再获取。
LinkedBlockingQueue
LinkedBlockingQueue 是一个由链表实现的线程安全的有界阻塞队列，容量默认值为 Integer.MAX_VALUE，也可以自定义容量，建议指定容量大小，默认大小在添加速度大于删除速度的情况下有造成内存溢出的风险，LinkedBlockingQueue 是先进先出的方式存储元素。
ArrayBlockingQueue
ArrayBlockingQueue 是一个有边界的阻塞队列，它的内部实现是一个数组。它的容量是有限的，我们在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。ArrayBlockingQueue 也是先进先出的方式存储数据，ArrayBlockingQueue 内部的阻塞队列通过 ReenterLock 和 Condition 条件队列实现的，因此 ArrayBlockingQueue 中的元素存在公平访问和非公平访问的区别，对于公平访问队列，被阻塞的线程可以按照阻塞的先后顺序访问队列，即先阻塞的线程先访问队列。而非公平队列，当队列可用的时候，阻塞的线程将进入争夺访问资源的竞争中，也就是说谁先抢到谁就执行，没有固定的先后顺序。
DelayQueue
DelayQueue 是一个支持延时获取元素的无界阻塞队列，队列中的元素必须实现 Delayed 接口，在创建元素的时候可以指定延迟时间，只有到达了延迟的时间之后，才能获取到该元素。实现了 Delayed 接口必须重写两个方法，getDelay(TimeUnit) 和 compareTo(Delayed)。
PriorityQueue
PriorityQueue 是一个基于优先级堆的无界优先级队列。优先级队列的元素按照其自然顺序进行排序，或者根据构造队列的时候提供的 Comparator 进行排序，具体取决于所使用的构造方法。优先级队列不允许使用 null 元素。
PriorityQueue 需要注意的点：
- PriorityQueue 是非线程安全的，在多线程情况下可使用
PriorityBlockingQueue类替代。 - PriorityQueue 不允许插入 null 元素。
LinkedTransferQueue
LinkedTransferQueue 是一个由链表结构组成的无界阻塞队列，相对于其他阻塞队列，LinkedTransferQueue 采用一种预占模式。意思就是消费者线程取元素的时候，如果队列不为空，则直接取走数据，若是队列为空，那就生成一个节点（节点元素为 null）入队，然后消费者线程被等待在这个节点上，后面生产者线程入队的时候发现有一个元素为 null 的节点，生产者线程就不入队了，直接就将元素填充到该节点，并唤醒该节点等待的线程，被唤醒的消费者线程取走元素，从调用的方法返回。我们称这种节点操作为 匹配 方式。
总结
| 队列 | 有界性 | 锁 | 数据结构 |
|---|---|---|---|
| ArrayBlockingQueue | bounded | 加锁 | arraylist |
| LinkedBlockingQueue | optionally-bounded | 加锁 | linkedlist |
| ConcurrentLinkedQueue | unbounded | 无锁 | linkedlist |
| LinkedTransferQueue | unbounded | 无锁 | linkedlist |
| PriorityBlockingQueue | unbounded | 加锁 | heap |
| DelayQueue | unbounded | 加锁 | heap |
五种常用线程池
- newCachedThreadPool：可缓存的线程池
- newCachedThreadPool 用于创建一个可缓存的线程池，之所以叫可缓存线程池，是因为它在创建新线程的时候如果有可重用的线程，则重用它们，否则创建一个新线程并将其添加到线程池中。
- 在线程池的 keepAliveTime 时间超过默认的 60秒后，该线程会被终止并从缓存中移除，因此在没有线程任务运行的时候，newCachedThreadPool 将不会占用系统的线程资源
- newFixedThreadPool：固定大小的线程池
- newFixedThreadPool 可用于创建一个固定的线程数量的线程池
- 如果任务数量大于等于指定线程池中线程的数量，则新提交的任务将在阻塞队列中排队，直到有可用的线程资源。
- newScheduledThreadPool：可做任务调度的线程池
- newScheduledThreadPool 用于创建可定时调度的线程池，可设置在给定延迟时间后执行或者定期执行某个线程任务。
- newSingleThreadPool ：单个线程的线程池
- newSingleThreadPool：创建的线程池会确保池中永远有且只有一个可用的线程
- 在该线程停止或者发生异常的时候，newSingleThreadPool 线程池会启动一个新的线程代替该线程继续执行任务
- newWorkStealingPool：足够大小的线程池
- newWorkStealingPool 用于创建持有足够多线程的线程池来达到快速运算的目的。
- 在内部通过使用多个队列来减少各个线程调度产生的竞争
- 足够的线程指的是 JDK 根据当前线程的运行需求向操作系统中申请足够多的线程，以保障线程的快速执行
3、ThreadPoolExecutor 源码分析
3.1、成员属性
// 高三位：表示当前线程池运行状态，除去高三位的低位29位：表示当前线程池中所拥有的线程数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 表示在ctl 中，低 COUNT_BITS 位是用于存放当前线程数量的位数
// 这里为什么不直接使用29，而是使用 Integer.SIZE - 3 表示?
// 小概率情况，防止 Integer在JDK版本变更中所占的字节位数不是4个字节了
private static final int COUNT_BITS = Integer.SIZE - 3; // 29
// 低 COUNT_BITS 位 所能表达的最大数值
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits 在ctl中的高三位所代表的运行状态
// -1 负数在计算机中以补码的形式存在 1110 0000 0000 0000 0000 0000 0000 0000 转换成整数是一个负数
private static final int RUNNING = -1 << COUNT_BITS;
// 0000 0000 0000 0000 0000 0000 0000 000
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 0010 0000 0000 0000 0000 0000 0000 0000
private static final int STOP = 1 << COUNT_BITS;
// 0100 0000 0000 0000 0000 0000 0000 0000
private static final int TIDYING = 2 << COUNT_BITS;
// 0110 0000 0000 0000 0000 0000 0000 0000
private static final int TERMINATED = 3 << COUNT_BITS;
// 任务队列，当线程池中的线程达到核心线程数的时候，再提交的时候就会直接提交到 workQueue
// workQueue instanceof ArrayBrokingQueue LinkedBrokingQueue 同步队列
private final BlockingQueue<Runnable> workQueue;
// 线程池的全局锁，增加worker，减少worker 的时候需要持有mainLock，修改线程池运行状态的时候也需要
private final ReentrantLock mainLock = new ReentrantLock();
// 线程池真正存放worker -> thread的地方
private final HashSet<Worker> workers = new HashSet<Worker>();
// 当外部线程调用 awaitTermination() 方法的时候，外部线程会等待当前线程池状态为 Terminated 为止
// 等待是如何实现的？就是将外部线程封装成waitNode放入到 Condition 队列中了，waitNode.thread 就是外部线程，会被park掉（处于WAITING 状态）
// 当线程池状态变为 Termination的时候，会去唤醒这些线程，通过 termination.signAll() ，唤醒之后这些线程会进入到阻塞队列，头结点会去抢占mainLock
// 抢到锁的线程会继续执行 awaitTermin() 后面的程序，这些线程最后都会正常执行
// 简单理解，termination.await() 会将线程阻塞在这里
// termination.signAll() 会将阻塞在这里的线程依次唤醒
private final Condition termination = mainLock.newCondition();
// 记录线程池生命周期内线程数最大值
private int largestPoolSize;
// 记录线程池所完成的任务总数，当worker 退出的时候会将 worker 完成的任务累计到completedTaskCount
private long completedTaskCount;
// 创建线程的时候会使用线程工厂，当我们使用 Executors.newFix.. newCache.. 创建线程池的时候使用的是 DefaultThreadFactory
// 一般不建议使用 DefaultThreadFactory，推荐自己实现 ThreadFactory，为什么不推荐使用DefaultThreadFactory？
// 因为DefaultThreadFactory创建线程的时候给赋值给线程的名字是 namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"
// 当线程池中的某个线程出现问题的时候，并不能通过该线程名字去定位到哪个地方出现了问题，这是很浪费时间的
private volatile ThreadFactory threadFactory;
// 拒绝策略：juc包中默认提供了四种方式，默认采用 AbortPolicy，直接抛出异常的方式
private volatile RejectedExecutionHandler handler;
// 空闲线程存活时间，当allowCoreThreadTimeOut == false的时候，会维护核心线程数内的线程存活，超出时间的线程会超时
// allowCoreThreadTimeOut == true的时候，核心线程数量内的线程空闲的时候，也会被回收
private volatile long keepAliveTime;
// 控制核心线程数量内的线程是否可以被回收 true，可以，false 不可以
private volatile boolean allowCoreThreadTimeOut;
// 核心线程数量限制
private volatile int corePoolSize;
// 线程池最大线程数量限制
private volatile int maximumPoolSize;
// 缺省的拒绝策略：采用的是 AbortPolicy 直接抛出异常的方式
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
构造方法
// 构造方法
public ThreadPoolExecutor(int corePoolSize, // 核心线程数量限制
int maximumPoolSize, // 最大线程数限制
// 空闲线程存活时间，当allowCoreThreadTimeOut == false的时候，会维护核心线程数内的线程存活，超出时间的线程会超时
// allowCoreThreadTimeOut == true的时候，核心线程数量内的线程空闲的时候，也会被回收
long keepAliveTime,
TimeUnit unit, // 时间单位 seconds nano..
// 任务队列，当线程池中的线程达到核心线程数的时候，再提交的时候就会直接提交到 workQueue
// workQueue instanceof ArrayBrokingQueue LinkedBrokingQueue 同步队列
BlockingQueue<Runnable> workQueue,
// 创建线程的时候会使用线程工厂，当我们使用 Executors.newFix.. newCache.. 创建线程池的时候使用的是 DefaultThreadFactory
// 一般不建议使用 DefaultThreadFactory，推荐自己实现 ThreadFactory，为什么不推荐使用DefaultThreadFactory？
// 因为DefaultThreadFactory创建线程的时候给赋值给线程的名字是 namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"
// 当线程池中的某个线程出现问题的时候，并不能通过该线程名字去定位到哪个地方出现了问题，这是很浪费时间的
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;
}
3.2、成员预热方法
// Packing and unpacking ctl
// 获取当前线程池运行状态
// ~CAPACITY & c = ctl => ~0001 1111 1111 1111 1111 1111 1111 1111 & 1110 0000 0000 0000 0000 0000 0000 0011（假设是RUNNING状态）
// ~CAPACITY => 1110 0000 0000 0000 0000 0000 0000 0011
// ctl => 1110 0000 0000 0000 0000 0000 0000 0000
// ~CAPACITY & c => 1110 0000 0000 0000 0000 0000 0000 0000
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 获取当前线程池线程数量
// c == ctl => 1110 0000 0000 0000 0000 0000 0000 0111
// CAPACITY => 0001 1111 1111 1111 1111 1111 1111 1111
// c & CAPACITY => 0000 0000 0000 0000 0000 0000 0000 0111
private static int workerCountOf(int c) { return c & CAPACITY; }
// 用在重置当前线程池 ctl 值的时候会用到
// rs：代表线程池状态 wc：代表当前线程池 worker（线程）数量
// rs： 1110 0000 0000 0000 0000 0000 0000 0000 (假设位RUNNING状态)
// wc： 0000 0000 0000 0000 0000 0000 0000 0111
// rs | wc：1110 0000 0000 0000 0000 0000 0000 0111 == 重置为ctl的值
private static int ctlOf(int rs, int wc) { return rs | wc; }
// 比较当前线程池ctl所表示的状态，是否小于某个状态s
// c = 1110 0000 0000 0000 0000 0000 0000 0111 < 0000 0000 0000 0000 0000 0000 0000 0000 == true
// 所有情况下，RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
// 比较当前线程池 ctl 所表示的状态，是否大于等于某个状态
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
// 小于SHUTDOWN 一定是 RUNNING 状态 SGUTDOWN == 0
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
// 使用 CAS 的方式让 ctl 的值 + 1，成功返回true，失败返回false
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
// 使用 CAS 的方式让 ctl 的值 -1，成功返回true，失败返回false
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
// 将ctl 的值减-1，这个方法一定成功
private void decrementWorkerCount() {
// 这里会一直进行重试，直到成功为止
do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}
3.3、Worker 内部类分析
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
// Worker 采用了AQS 的独占模式
// 独占模式：两个重要属性 state 和 ExclusiveOwnerThread
// state：0的时候，表示未被占用，>0 的时候表示被占用，<0 的时候，表示初始状态，这种情况下不能被抢锁
// ExclusiveOwnerThread：表示独占锁线程
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
// Worker 内部封装的工作线程
final Thread thread;
/** Initial task to run. Possibly null. */
// 假设 firstTask 不为空，那么当 worker 启动后（内部的线程启动）会优先执行 firstTask，当执行完firstTask后，会当workQueue中去获取下一个任务
// 初始化任务，只在worker 第一次执行任务的时候执行，之后都是从workqueue中获取任务执行
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)
*/
// firstTask 可以为 null，为null启动后会到 queue中获取
Worker(Runnable firstTask) {
// 设置 AQS 独占模式为初始化状态，不能被抢占锁
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
// 使用线程工厂创建了一个线程，并且将当前 worker 指定为 Runnable，也就是说当 thread启动的时候，会以worker.run()为入口
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
// 当worker 启动的时候，会执行run()方法
public void run() {
// ThreadPoolExector -> runWork(Worker w) 这个是核心方法，等后面分析worker启动后逻辑的时候会以这里为切入点
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
// 判断当前worker的独占锁是否被独占
// 0 表示未被占用
// 1 表示已经占用
protected boolean isHeldExclusively() {
return getState() != 0;
}
// 尝试去占用当前 worker 的独占锁
//
protected boolean tryAcquire(int unused) {
// 使用 CAS 修改 AQS 中的state，期望值为0（0的时候表示未被占用），修改成功表示当前线程修改成功
// 那么设置 ExclusiveOwnerThread 为当前线程
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// 尝试释放当前 worker 的独占锁
// 外部不会直接调用该方法，这个方法是 AQS的，外部调用 unlock的时候，unlock -> AQS.release -> tryRelease
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// 加锁，加锁失败的时候，会阻塞当前线程，直到获取到锁位置
public void lock() { acquire(1); }
// 尝试去加锁，如果当前锁是未被持有状态，加锁成功后会返回true，否则不会阻塞当前线程，直接返回false
public boolean tryLock() { return tryAcquire(1); }
// 一般情况下，咱们调用unlock 要保证当前线程是持有锁的
// 特殊情况，当 worker 的 state == -1的时候，调用 unlock 表示初始化state，设置 state == 0
// 启动worker 之前会先调用 unlock() 这个方法，会强制刷新ExclusiveOwnerThread == null 和 state == 0
public void unlock() { release(1); }
// 就是返回当前 worker 的lock 是否被占用
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
3.4、execute(Runnable command) 方法分析
// 线程池提交方法
// Runnable command：可以是普通的 Runnable 实现类，也可以是 FutureTask
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
// 获取ctl 最新值 ctl：高三位 表示线程池状态，低位表示当前线程池线程数量
int c = ctl.get();
// workerCountOf(c)：获取当前线程池数量
// 条件成立：表示当前线程数量小于核心线程数量，此次提交任务，直接创建一个新的worker，对应线程池中多了一个新线程
if (workerCountOf(c) < corePoolSize) {
// addWorker 即为创建线程的过程，会创建worker对象，并且将command作为fistTask
// core == true：表示采用核心线程数量限制，false：表示采用 maximumPoolSize
if (addWorker(command, true))
// 创建成功后直接返回，addWorker 方法里面会启动新创建的worker，将firstTask执行
return;
// 执行到这条语句，说明addWorker 一定是失败了
// 有几种可能？
// 1.存在并发现象，execute 方法是有可能有多个线程同时调用的，当workerCountOf(c)<corePoolSize成立后
// 其他线程可能也成立了，并且向线程池中创建了worker，这个时候线程池中线程数量已经达到了核心线程数，所以当前线程失败了
// 2.当前线程池状态发生改变了，RUNNING SHUTDOWN STOP TIDYING TERMINATION
// 当线程池状态是非 RUNNING 状态的时候，addWorker(firstWorker != null,true | false) 一定会失败
// SHUTDOWN 状态下，也有可能创建成功，前提 firstTask == null 而且当前queue不为空，特殊情况，在addWorker方法中有说明
c = ctl.get();
}
// 执行到这里有几种情况？
// 1.当前线程数量已经达到了 corePoolSize
// 2.addWorker 失败，并发导致
// 条件成立：说明当前线程池处于RUNNING 状态，则尝试将 task 放入到workqueue中
if (isRunning(c) && workQueue.offer(command)) {
// 进入到内部的前提条件：当前线程池中的线程数量大于等于corePoolSize，并且当前线程池处于RUNNING状态，而且当前线程将command放入到workqueue成功
// 再次获取ctl的值
int recheck = ctl.get();
// 条件一：! isRunning(recheck) 成立：说明你提交到队列之后，线程池状态被外部线程给修改了,比如：shutdown() shutdownNow()
// 这种情况成立的话，说明线程池状态被外部线程给修改了，需要把刚刚提交的任务给删除掉
// 条件二：remove(command) ：有可能成功，也有可能失败
// 成功：提交之后，线程池中的线程还未消费（处理）
// 失败：提交之后，在shutdown() shutdownNow() 之前，就被线程池中的线程给处理了
if (! isRunning(recheck) && remove(command))
// 提交之后，线程状态为非RUNNING了且移除任务队列成功，走个拒绝策略
reject(command);
// 有几种情况会走到这里？
// 1.当前线程池是RUNNING 状态
// 2.线程池状态是非 RUNNING 状态，但是 remove 提交的任务失败
// 担心当前线程池是 RUNNING 状态，但是线程池中的存活数量是0，这个时候，会很尴尬，任务没线程去跑了
// 这里其实是一个担保机制，保证线程池在RUNNING 状态下，最起码得有一个线程在工作
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 执行到这里，有几种情况？
// 1.workqueue.offer(command)失败，说明当前队列满了
// 2.当前线程是非RUNNING 状态
// 1.offer失败，需要做什么？说明当前queue满了，这个时候，如果当前线程数量尚未达到maximumPoolSize得话，尝试创建新得worker，直接执行command
// 假设线程数量达到 maximumPoolSize 得话，这里会也会失败，也会走拒绝策略
// 2.线程池状态为非RUNNING 状态，这个时候因为 command != null addWorker 一定是返回false
else if (!addWorker(command, false))
reject(command);
}
3.4、addWorker(Runnable firstTask, boolean core) 方法分析（重点）
// 返回值总结：
// true：表示worker 创建成功，且线程启动成功
// false：表示创建失败
// 1.线程池状态 rs > SHUTDOWN (STOP TIDYING TERMINATION)
// 2.rs == shutdown 但是队列中已经没有任务了 或者 当前状态是SHUTDOWN 且队列未空，但是当前任务的firstTask不为null
// 3. 当前线程池已经达到指定指标（corePoolSize / maximumPoolSize）
// 4.threadFactory 实现类创建的线程为null
// Runnable firstTask：可以为null，表示启动worker之后，worker 自动到queue中去获取任务，如果不是null，则worker优先执行 firstTask
// boolean core：表示采用的线程池的线程数限制，true：采用核心线程数限制，false：采用maximumPoolSize线程数限制
private boolean addWorker(Runnable firstTask, boolean core) {
// 自旋操作：判断当前线程池状态是否允许创建线程
retry:
for (;;) {
// 获取当前ctl值保存到c中
int c = ctl.get();
// 获取当前线程池运行状态保存到rs中
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// 条件一：rs >= SHUTDOWN 成立：说明当前线程池状态不是RUNNING 状态
// 条件二：前置条件：当前线程池状态不是RUNNING 状态 ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())
// rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()
// 表示：当前线程池状态是SHUTDOWN状态 && 当前提交的任务是null addWorker这个方法可能不是execute去调用的 && 当前任务队列不是空
// 排除掉这种情况，当前线程池状态是SHUTDOWN状态，但是队列里面还有任务尚未处理，这个时候是允许添加worker的，但是不允许再次提交task
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
// 什么情况下会返回false？
// 线程池状态 rs >= SHUTDOWN
// rs == SHUTDOWN 但是队列中已经没有任务了 或者 rs == SHUTDOWN 且 firstTask != null
return false;
// 上面这些代码，就是判断当前线程池状态是否允许添加worker
// 内部自旋操作:获取创建线程令牌的过程
for (;;) {
// 获取当前线程池中的线程数量，保存到wc中
int wc = workerCountOf(c);
// 条件一：wc >= CAPACITY 永远不成立，因为CAPACITY是一个5亿多的数字
// 条件二：wc >= (core ? corePoolSize : maximumPoolSize)
// core == true，判断当前线程数量是否 >= corePoolSize，会拿核心线程数量做限制
// core == false，判断当前线程数量是否 >= maximumPoolSize，会拿最大线程数量做限制
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
// 执行到这里，说明当前已经无法添加线程了，已经达到指定限制了
return false;
// 条件成立：说明记录线程数量已经加1成功，相当于申请到了一块令牌
// 条件失败：说明可能有其他线程，修改过ctl这个值了，CAS 发生了冲突
// 可能发生过什么冲突？
// 1.其他线程execute() 申请过令牌了，在这之前，改变了ctl的值，期望值c与内存中的ctl的值不符合，导致CAS 失败
// 2.外部线程可能调用过 shutdown() 或者 shutdownNow() 导致线程池状态发生了变化了，ctl高三位表示线程池状态
// 线程池状态改变后，CAS 操作也会失败
if (compareAndIncrementWorkerCount(c))
// 进入到这里，一定是CAS 失败，申请到令牌了，跳出外部自旋操作
break retry;
// CAS 失败，没有成功的申请到令牌
// 获取最新的 ctl 值
c = ctl.get(); // Re-read ctl
// 判断当前线程池状态是否发生过变化，如果外部在这之前调用过shutdown 或者shurdownNow会导致线程池状态发生变化
if (runStateOf(c) != rs)
// 线程池状态发生变化后，直接返回到外层循环，外层循环负责判断当前线程池状态，是否允许创建线程
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// CAS 成功，跳出外部自旋操作来到了这里
// workerStarted：表示当前创建的worker是否已经启动 false：未启动 true：已经启动
boolean workerStarted = false;
// workerAdded：表示创建的worker是否添加到线程池中 false：未添加 true：已经添加
boolean workerAdded = false;
// w：表示后面创建worker 的一个引用
Worker w = null;
try {
// 创建worker
w = new Worker(firstTask);
// 将新创建的worker 节点的线程赋值给t
final Thread t = w.thread;
// 为什么这里还要做 t != null 这个判断？
// 为了防止ThreadFactory 实现类有bug，因为ThreadFactory 是一个接口，谁都可以实现
// 防止程序员自己实现的ThreadFactory 实现类有bug，导致创建出来的Thread为null
if (t != null) {
// 将全局锁的引用保存到mainLock变量中
final ReentrantLock mainLock = this.mainLock;
// 持有全局锁，可能会阻塞，直到获取成功为止，同一时刻操作线程池内部相关的操作都必须持有锁
mainLock.lock();
// 从这里加锁之后，其他线程是无法修改线程池状态的
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
// 获取最新的线程池运行状态保存到rs中
int rs = runStateOf(ctl.get());
// 条件一：rs < SHUTDOWN 成立：当前线程池处于RUNNING 状态，最正常的状态
// 条件二： 前置条件：当前线程池状态不是RUNNING 状态
// (rs == SHUTDOWN && firstTask == null)：当前状态为SHUTDOWN 状态且firstTask为null
// 其实判断的就是SHUTDOWN 状态下的特殊情况，只不过这里不再判断队列是否为空了
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// t.isAlive() 当前线程start 后，线程isAlive 会返回true
// 防止程序员在ThreadFactory实现类创建线程返回给外部之前，将线程给start了
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 将咱们创建的worker 添加到线程池中
workers.add(w);
// 获取最新当前线程池的线程数量
int s = workers.size();
// 条件成立：说明当前线程数量是一个新高，更新lagestPoolSize线程池中的线程最大数量
if (s > largestPoolSize)
largestPoolSize = s;
// 表示线程已经加入到线程池中了
workerAdded = true;
}
} finally {
// 释放线程池全局锁
mainLock.unlock();
}
// 条件成立：说明当前添加worker成功
// 条件失败：说明线程池在lock之前，线程池状态发生了变化导致添加失败
if (workerAdded) {
// 成功后则将创建的worker启动
t.start();
// 启动标记设置为true
workerStarted = true;
}
}
} finally {
// 条件成立：说明添加当前线程到线程池失败或者启动线程失败，需要做清理工作
// 1.释放令牌
// 2.将当前worker 清理出workers集合
if (! workerStarted)
addWorkerFailed(w);
}
// 返回新创建的线程是否启动
return workerStarted;
}
addWorkerFailed(Worker w) 方法
// addWorker添加线程到线程池中失败或者线程启动失败的后续工作，两个操作
// 1.释放令牌
// 2.将当前worker 清理出workers集合
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
// 持有线程池全局锁，因为操作的是线程池相关的东西
mainLock.lock();
try {
// 条件成立：需要将worker 在workers 中清理除去
if (w != null)
workers.remove(w);
// 线程池计数恢复-1，前面+1获取令牌了，这里因为失败，所以要-1，相当于归还令牌
decrementWorkerCount();
// 回头讲，shutdown shutdownNow再说
tryTerminate();
} finally {
// 释放线程池全局锁
mainLock.unlock();
}
}
3.5、runWorker(Worker w) 方法分析
// w：就是启动worker
final void runWorker(Worker w) {
// wt == w.thread
Thread wt = Thread.currentThread();
// 将初始执行的task赋值给task
Runnable task = w.firstTask;
// 清空当前w.firstTask的引用
w.firstTask = null;
// 这里为什么先调用unlock? 就是为了初始化worker state = 0 和 ExclusiveOwnerThread = null
// 启动worker 之前会先调用 unlock() 这个方法，会强制刷新ExclusiveOwnerThread == null 和 state == 0
w.unlock(); // allow interrupts
// 是否是突然退出？如果为true，表示发生异常了，当前线程突然退出的，回头需要做一些处理 false：表示正常退出的
boolean completedAbruptly = true;
try {
// 条件一：task != null 指的就是firstTask 是否为null 如果是null，直接执行循环体里面
// 条件二：(task = getTask()) != null 条件成立：说明当前线程在queue中获取任务成功，getTask是会阻塞线程的方法
// getTask()如果返回null，说明当前线程需要执行退出逻辑
while (task != null || (task = getTask()) != null) {
// worker 设置独占锁为当前线程
// 为什么要设置独占锁呢？就是怕shutdown()的时候会判断当前worker状态，根据独占锁是否空闲来判断当前worker是否正在工作
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
// 条件一：runStateAtLeast(ctl.get(), STOP) 说明线程池状态大于等于STOP，线程池目前处于STOP/TIDYING/TERMINATION，此时线程一定要给它一个中断信号
// 条件一成立：(runStateAtLeast(ctl.get(), STOP) && !wt.isInterrupted()
// 上面条件如果成立，说明当前线程池状态是大于等于STOP且当前线程是未设置中断状态的，此时需要进入到if里面，给当前线程一个中断
// 假设：(runStateAtLeast(ctl.get(), STOP) == false
// (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))
// Thread.interrupted() 获取当前中断状态，且设置中断位为false，连续调用两次interrupted()方法，第二次一定是返回false
// runStateAtLeast(ctl.get(), STOP)：大概率这里还是false
// 其实它在强制刷新当前线程的中断标记为false，因为有可能上一次执行task的时候，业务代码里面将线程的中断标记位设置为了true且没有做处理
// 所以这里一定要强制刷新一下，不会再影响到后面的task了
// 假如：Thread.interrupted() == true && runStateAtLeast(ctl.get(), STOP) == true
// 这种情况有可能发生嘛？
// 有可能，因为外部线程再当前线程第一次(runStateAtLeast(ctl.get(), STOP) == false后，有机会调用shutdown shutdownNow方法将线程池状态修改
// 这个时候也会将当前线程的中断标记位再次设置为中断状态
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// 钩子方法，留给子类实现的
beforeExecute(wt, task);
// 表示异常情况，如果thrown不为空，表示task运行过程中发生了异常，向上层抛出了异常
Throwable thrown = null;
try {
// task可能是firstTask，也可能是普通的runnable接口实现类
// 如果前面是通过submit()提交的runnable/callable会被封装成FutureTask对象
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完成任务数量
w.completedTasks++;
// worker 处理完一个任务后会释放独占锁，然后再次到queue中获取任务
// 1.正常情况下会再次回到getTask()那里获取任务 while(getTask())
// 2.task.run()内部抛出异常了
w.unlock();
}
} // while
// 什么情况下会来到这里?
// getTask()返回null的时候，说明当前线程应该执行退出逻辑了
completedAbruptly = false;
} finally {
// task.run() 内部抛出异常的时候，当上面的finally执行完以后跳到这里
// 正常提出 completedAbruptly = false 异常退出：completedAbruptly = true
// 这个方法以后再说
processWorkerExit(w, completedAbruptly);
}
}
3.6、getTask() 方法分析（重点）
// 什么情况下会返回null?
// 1.rs >= STOP成立说明：当前线程池的状态最低也是STOP状态，一定要返回null了
// 2.说明当前线程池状态为SHUTDOWN状态且任务队列已经为null，此时一定要返回null
// 3.线程池中的线程数量超过最大限制的时候，会有一部分线程返回为null
// 4.线程池中的线程数超过corePoolSize的时候，会有一部分线程超时后返回null
// 到当前的任务队列queue中去获取任务
private Runnable getTask() {
// 表示当前线程获取任务是否超时 默认false true表示已经超时
boolean timedOut = false; // Did the last poll() time out?
// 自旋
for (;;) {
// 获取最新ctl的值保存到c中
int c = ctl.get();
// 获取当前线程池的运行状态
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// 条件一：rs >= SHUTDOWN 条件成立：说明当前线程池是非RUNNING 状态，可能是SHUTDOWN/STOP/TIDYING/TERMINATION//
// 条件二：rs >= STOP || workQueue.isEmpty()
// 2.1：rs >= STOP成立说明：当前线程池的状态最低也是STOP状态，一定要返回null了
// 2.2：前置条件：状态是SHUTDOWN，workqueue.isEmpty() 条件成立：说明当前线程池状态为SHUTDOWN状态且任务队列已经为null，此时一定要返回null
// 返回null，runworker()方法就会将返回null的线程执行退出线程池的逻辑
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// 使用CAS + 死循环的方式将ctl的值-1
decrementWorkerCount();
return null;
}
// 执行到这里，有几种情况：
// 1.线程池是RUNNING 状态
// 2.线程池是SHUTDOWN 状态，但是队列queue还未为空，此时可以创建线程（添加worker）
// 获取线程池中的线程数量
int wc = workerCountOf(c);
// timed == true：表示当前这个线程获取task的时候是支持超时机制的，使用queue.poll(时间单位，数量)
// 当获取task超时的情况下，下一次自旋就可能返回null了
// timed == false：表示当前这个线程获取task的时候是不支持超时机制的，当前线程会使用 queue.take()
// 情况一：allowCoreThreadTimeOut == true 表示核心线程数量内的空闲线程可以被回收，所有线程都是使用queue.poll()超时机制这种方式获取task
// 情况二：allowCoreThreadTimeOut == false 表示当前线程池会维护核心数量内的线程
// wc > corePoolSize：条件成立：当前线程池中的线程数量是大于核心线程数的，此时让所有路过这里的线程都使用poll，超时的方式去获取任务
// 这样就可能会有一部分线程获取不到任务，返回null，然后runworker会执行线程退出逻辑
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 条件一：(wc > maximumPoolSize || (timed && timedOut)
// 1.1：wc > maximumPoolSize 为什么会成立？setMaximumPoolSize() 方法，可能外部线程将线程池最大线程数设置为比初始化时的要小
// 1.2：timed && timedOut 条件成立：前置条件，当前线程使用poll()的方式从队列queue中获取worker执行，上一次循环的时候，使用poll的方式获取任务的时候，超时了
// 条件一为true：表示线程可以被回收，达到回收的标准，当确实需要回收的时候再回收
// 条件二：wc > 1 || workQueue.isEmpty()
// 2.1：wc > 1：条件成立，说明当前线程池中还有其他线程，当前线程不需要从队列中获取任务可以直接回收
// 2.2：workQueue.isEmpty()：前置条件，条件成立：wc == 1 ，说明当前任务队列已经空了，最后一个线程，也可以放心的退出
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
// 使用 CAS 机制，将ctl的值减去1，减一成功的线程返回null
// CAS 失败？为什么会CAS 失败？
// 1.其他线程先你一步推出了
// 2.线程池状态发生变化了
if (compareAndDecrementWorkerCount(c))
return null;
// 再次自旋的时候，timed有可能就是false了，因为当前线程CAS失败，很有可能是因为其他线程成功退出导致的，再次查询的时候
// 检查发现，当前线程就可能属于不需要回收范围内了
continue;
}
// 获取任务的逻辑
try {
// poll(long timeout, TimeUnit unit)：从BlockingQueue取出一个队首的对象，如果在指定时间内，
// 队列一旦有数据可取，则立即返回队列中的数据。否则直到时间超时还没有数据可取，返回失败。
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
// take 方法：获取队列中的第一个元素，如果被阻塞，则等待
workQueue.take();
// 条件成立：返回任务
if (r != null)
return r;
// 说明当前线程超时了
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
3.7、processWorkerExit(Worker w, boolean completedAbruptly) 方法分析
// 线程退出的逻辑
// w：线程执行的worker要获取任务
// completedAbruptly：线程是否发生异常 true：表示线程发生了异常 false：表示线程没有发生异常
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 条件成立：代表当前w这个worker 是发生异常退出的 task任务执行过程中向上抛出了异常
// 异常退出的时候，ctl的线程数量并没有-1
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
// 获取线程池的全局锁引用
final ReentrantLock mainLock = this.mainLock;
// 加锁
mainLock.lock();
try {
// 将当前worker完成的task数量，汇总到线程池的completedTaskCount
completedTaskCount += w.completedTasks;
// 将worker 从任务中移除
workers.remove(w);
} finally {
mainLock.unlock();
}
// 回头再说
tryTerminate();
// 获取最新的ctl值
int c = ctl.get();
// 条件成立：说明当前线程池状态为RUNNING 或者 SHUTDOWN 状态
if (runStateLessThan(c, STOP)) {
// 条件成立：说明当前线程是正常退出的
if (!completedAbruptly) {
// min：表示线程池最低持有的线程数量
// allowCoreThreadTimeOut == true：说明核心线程数内的线程，也会超时被回收 min = 0
// allowCoreThreadTimeOut == false：说明核心线程数内的线程，不会超时被回收 min = corePoolSize
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
// 前提状态：线程池状态为RUNNING SHUTDOWN
// 条件一： min == 0成立
// 条件二：! workQueue.isEmpty() 说明任务队列中还有任务，最起码留一个线程
if (min == 0 && ! workQueue.isEmpty())
min = 1;
// 条件成立：线程池中还拥有足够的线程
// 考虑一个问题：workerCountOf(c) >= min => (0 >= 0)
// 有可能!
// 什么情况下，当线程池中的核心线程数是可以被回收的，会出现这种情况，这种情况下，当前线程池中的线程数会变为0
// 下次再提交任务的时候，会再次创建线程
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// 1.当前线程再执行task的时候发生异常，这里一定要创建一个新的worker顶上去
// 2.! workQueue.isEmpty() 说明任务队列中还有任务，最起码要留一个线程，当前状态为 RUNNING | SHUTDOWN
// 3.线程数量小于corePoolSize值，此时会创建线程，维护线程池中的线程数量在corePollSize左右
addWorker(null, false);
}
}
3.8、shutdown() 方法分析
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
// 获取线程池的全局锁
mainLock.lock();
try {
// 判断是否有权限
checkShutdownAccess();
// 设置线程池的状态为 SHUTDOWN
advanceRunState(SHUTDOWN);
// 中断空闲线程
interruptIdleWorkers();
// 空方法，子类可以扩展
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
// 释放线程池全局锁
mainLock.unlock();
}
// 后面再说
tryTerminate();
}
// 中断空闲线程
private void interruptIdleWorkers() {
interruptIdleWorkers(false);
}
// 通过自旋操作设置线程池的状态为SHUTDWON
private void advanceRunState(int targetState) {
// 自旋
for (;;) {
int c = ctl.get();
// 条件一成立：假设targetState == SHUTDOWN，说明当前线程池状态是 >= SHUTDOWN
// 条件一不成立：假设targetState == SHUTDOWN，说明当前线程池状态是 RUNNING
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
3.9、tryTerminate() 方法分析
final void tryTerminate() {
// 自旋操作
for (;;) {
// 获取最新ctl的值
int c = ctl.get();
// 条件一：isRunning(c) 成立：直接返回就行了，线程池很正常
// 条件二：runStateAtLeast(c, TIDYING) 说明已经有其他线程在执行 TIDYING 转到 TERMIATION 状态了，当前线程直接回去
// 条件三：runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()
// SHUTDOWN 特殊情况，如果是这种情况，直接回去，得等队列中得任务处理完后再转化状态
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
// 什么情况会执行到这里？
// 1.线程池状态为 STOP 得时候
// 2.线程池状态为 SHUTDWON并且队列已经空了
// 条件成立：当前线程池中得线程数量 > 0
if (workerCountOf(c) != 0) { // Eligible to terminate
// 中断一个空闲线程
// 空闲线程在哪空闲呢？queue.take() 或者 queue.poll()
// 1.唤醒后的线程会在getTask方法返回null
// 2.执行退出逻辑得时候，会再次调用 tryTerminate 方法，唤醒下一个空闲线程
// 3.因为线程池状态是（线程池状态为 STOP 得时候 | 线程池状态为 SHUTDWON并且队列已经空了） 最终调用addWorker得时候会失败得
// 最终空闲线程都会在这里退出，非空闲线程当执行完当前task得时候，也会调用tryTerminate方法，有可能会走到这里
interruptIdleWorkers(ONLY_ONE);
return;
}
// 执行到这里得线程是谁？
// workerCountOf(c) == 0得时候，会来到这里
// 最后一个退出得线程，咱们知道，在（线程池状态 == STOP | 线程池状态为 SHUTDWON并且队列已经空了）
// 线程唤醒后，都会执行退出逻辑，退出过程中会先将 workerCount 计数 -1 => ctl中得计数-1
// 调用 tryTerminate方法之前，已经减过了，所以 0 得时候，表示这是最后一个退出得线程了
final ReentrantLock mainLock = this.mainLock;
// 获取全局锁
mainLock.lock();
try {
// 设置线程池状态为 TIDYING
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
// 调用钩子方法
terminated();
} finally {
// 设置线程池状态为 TERMINATED 状态
ctl.set(ctlOf(TERMINATED, 0));
// 唤醒调用 awaitTermination() 方法得线程
termination.signalAll();
}
return;
}
} finally {
// 释放全局锁
mainLock.unlock();
}
// else retry on failed CAS
}
}
3.10、shutdownNow() 方法分析
public List<Runnable> shutdownNow() {
// 返回值引用
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
// 获取线程池的全局锁
mainLock.lock();
try {
// 校验权限
checkShutdownAccess();
// 设置线程池状态为STOP
advanceRunState(STOP);
// 中断线程池中的所有线程
interruptWorkers();
// 导出未处理的task
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
// 返回当前任务队列中未处理的任务
return tasks;
}
至此，线程池 ThreadPoolExecutor 类源码就告一段落了，下面会开始更新 AQS 部分的内容，如果有错误，请指正！
标签：0000,worker,源码,线程,当前,ctl,null,ThreadPoolExecutor 来源： https://blog.csdn.net/weixin_46410481/article/details/122864251