目录
1 前言
ThreadPoolExecutor的基本概念和用法已经在之前的文章线程池ThreadPoolExecutor简介 、Executor框架完整解读中做过详细的说明，这里主要基于JDK1.8对ThreadPoolExecutor从源码级别分析其实现原理。
ThreadPoolExecutor是ExecutorService的最重要的实现类，ThreadPoolExecutor不直接实现ExecutorService接口，它直接继承于AbstractExecutorService抽象类（AbstractExecutorService的源码实现在AbstractExecutorService源码完全解析已做过分析。）， AbstractExecutorService对ExecutorSerivice接口中的一些方法做过的默认实现 。
线程池有两个重要的概念一个是任务队列,另一个是工作者线程 。
任务队列是存放任务的容器，工作者线程会依次不断地到队列中获取任务并执行。
2 重要的成员内部类Worker
Worker继承于AbstractQueuedSynchronizer抽象类，它又实现了Runnable接口。
Worker可以理解为一个工作者线程，但内部属性又不只有一个Thread属性，除此之外还有首任务firstTask、线程所完成的任务数completedTasks。
Worker类主要是维护执行任务的线程的中断状态的控制，及其他次要的一些标记功能。它继承AQS,它相当于一个不可重入的排他锁.
1) 成员变量
thread表示Worker执行任务的线程，firstTask表示worker执行的第一个任务(对于后来的其他任务它会到任务队列中去获取)，completedTasks表示当前worker线程所完成的任务数
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;// 一般不为空，这由ThreadFactory决定
/** Initial task to run. Possibly null. */
Runnable firstTask;//可能为空
/** Per-thread task counter */
volatile long completedTasks;//此工作线程完成的任务数
2) 构造方法
构造方法主要涉及对成员变量的初始化，方法体内调用了父类AQS的setState方法将state置为负数-1，它的主要目的是防止线程被过早中断，直到runWorker开始执行任务时才清除state的负数状态(成员内部类的一个对象与外部类的对象相互绑定，成员内部类可直接访问外部类的全局变量和实例、静态方法）。
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker 调用AQS的setState，设置状态
this.firstTask = firstTask;
//getThreadFactory是外部类的ThreadPoolExecutor的实例方法，返回一个实现ThreadFactory接口的对象.
//newThread根据当前worker所代表（Worker实现了Runnable接口，worker也是Runnable对象）的Runnable对象
//创建一个线程对象。所以this.thread线程启动就会执行worker.run().
this.thread = getThreadFactory().newThread(this);
}
3)方法实现
①run方法
run方法是执行任务方法，它直接委托给外部类ThreadPoolExecutor的runWorker方法来实现,runWorker方法的实现细节在之后会详细说明。
/** Delegates main run loop to outer runWorker */
public void run() {
//
当Worker.thread.start()调用后，Worker.thread线程启动，就会执行这里的run方法，run方法又委托给runWorker
//换句话说，worker线程启动后，最终会执行runWorker方法。
runWorker(this);
}
②与锁相关的方法
isHeldExclusively、 tryAcquire 、tryRelease这3个方法均是父类AQS的模板方法所调用的应被重写的方法，其具体原理在之前AbstractQueuedSynchronizer实现原理分析帖子中做过说明，这里不再细说。
lock、 tryLock 、unlock 、isLocked这4个方法也与显式锁ReentrantLock实现原理基本一致，之前对ReentrantLock的实现做过说明，这里也不再细说。
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) {
//与ReentrantLock的区别在于，这里未检测在释放锁前是否已获得锁
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(); }
③interruptIfStarted中断线程，调用此方法可以在任务启动后中断线程。
void interruptIfStarted() {
Thread t;
//state不能小于0,为负数表明worker线程还未启动
//(在构造方法中将state初始为-1，在worker线程启动后runWorker方法开头处的w.unLock会将state置为0)
//!t.isInterrupted()如果线程已经是中断状态，也不需要再去中断它了。
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
3 内置的拒绝策略
ThreadPoolExecutor内部实现了4种拒绝策略，默认使用AbortPolicy策略，这4种拒绝策略都实现RejectedExecutionHandler接口，这4个类都是ThreadPoolExecutor的静态内部类。当线程池执行器饱和时，会调用RejectedExecutionHandler的rejectedExecution方法处理任务。
CallerRunsPolicy, 使用任务提交者的所在线程执行任务；AbortPolicy，直接抛出异常，这是默认的拒绝策略；DiscardPolicy, 不执行任务，将任务丢弃；DiscardOldestPolicy,丢弃队列中最近的任务，然后执行当前任务
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() {
}
//使用调用者的线程执行任务
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() {
}
//直接抛出异常
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
public static class DiscardPolicy implements RejectedExecutionHandler {
public DiscardPolicy() {
}
//啥也不做，丢弃任务
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() {
}
//丢弃队列中最近的任务，然后执行当前任务
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
4 静态常量与成员变量
ThreadPoolExecutor有一个重要的成员变量ctl，它是一个int型的原子变量，它是线程池执行器状态控制的主要属性。它复合了线程池执行器的两个重要状态，一个是workerCount，它表示有效线程数，另一个是runState，它表示线程池执行器是否正在运行、正在关闭等。ctl共有32个二进制位，runState占用ctl的高3位，workerCount占用ctl的低29位，可调用runStateOf(ctl)方法来取ctl的高3位，可调用workerCountOf(ctl)方法来取ctl的低29位，另外还可调用ctlOf(runState, workerCount)根据runState、workerCount算出ctl的值。
//线程池主要的状态控制属性
//初始值为-536870912,二进制开形式为 0b10100000_00000000_00000000_00000000
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//workerCount在ctl中的二进制位数，占29位
private static final int COUNT_BITS = Integer.SIZE - 3; //29
//workerCount的最大值， 二进制形式 0b00011111_11111111_11111111_11111111;
private static final int CAPACITY = (1 << COUNT_BITS) - 1;//536870911
// runState is stored in the high-order bits
//表示ctl中的最高3位的runState值
private static final int RUNNING = -1 << COUNT_BITS;//二进制形式 0b10100000_00000000_00000000_00000000
private static final int SHUTDOWN = 0 << COUNT_BITS;//二进制形式 0b00000000_00000000_00000000_00000000
private static final int STOP = 1 << COUNT_BITS;//二进制形式 0b00100000_00000000_00000000_00000000
private static final int TIDYING = 2 << COUNT_BITS;//二进制形式 0b01000000_00000000_00000000_00000000
private static final int TERMINATED = 3 << COUNT_BITS;//二进制形式 0b01100000_00000000_00000000_00000000
// Packing and unpacking ctl
private static int runStateOf(int c) {
return c & ~CAPACITY; //c & 0b11100000_00000000_00000000_00000000
}
private static int workerCountOf(int c) {
return c & CAPACITY; //c & 0b00011111_11111111_11111111_11111111
}
private static int ctlOf(int rs, int wc) {
return rs | wc; }
workerCount是已被允许启动但不允许停止的工作线程数。 该值可能与活动线程的实际数量暂时不等，例如，当ThreadFactory在被要求创建，但创建线程失败，该值会与之不等。 用户可见的线程池大小为workers.size()(workers是一个HashSet类型的对象，它是也是一个成员变量，用来存放Worker的容器)。
runState提供线程池执行器主要的生命周期控制，它有以下几种可取的值：
- RUNNING：接受新任务并处理排队的任务
- SHUTDOWN：不接受新任务，但处理已入队的任务
- STOP：不接受新任务 、不处理已入队的任务，并中断执行中的任务
- TIDYING：所有任务已终止，workerCount为零，将线程的状态设为TIDYING，并将调用回调方法
Terminated() - TERMINATED：方法
terminate()已执行完
runState是有序的，它随时间单调增加，但其生命周期并非一定会经历下面的所有状态。状态转换过程是
- RUNNING -> SHUTDOWN：在调用
shutdown()时，可能隐式在finalize()中调用 - RUNNING/SHUTDOWN -> STOP：调用
shutdownNow()时 - SHUTDOWN -> TIDYING：当任务队列和工作者线程池都为空时
- STOP -> TIDYING：当工作者线程池为空时
- TIDYING -> TERMINATED：当
terminate()已执行完时
状态变为TERMINATED时，在awaitTermination()中等待的线程将返回。
检测到从SHUTDOWN到TIDYING间的状态转换并不简单，因为在SHUTDOWN状态期间，任务队列在非空之后可能会变空，反之亦然，但是只有在看到它为空之后才能看到workerCount 为0 。
其它字段
private final ReentrantLock mainLock = new ReentrantLock();
private final HashSet<Worker> workers = new HashSet<Worker>();
private final Condition termination = mainLock.newCondition();
private int largestPoolSize;
private long completedTaskCount;
//构造方法的要参数对应初始化的成员变量
private final BlockingQueue<Runnable> workQueue;
private volatile ThreadFactory threadFactory;
private volatile RejectedExecutionHandler handler;
private volatile long keepAliveTime;
private volatile int corePoolSize;
private volatile int maximumPoolSize;
private volatile boolean allowCoreThreadTimeOut;
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
private static final RuntimePermission shutdownPerm =
new RuntimePermission("modifyThread");
private final AccessControlContext acc;
private static final boolean ONLY_ONE = true;
mainLock： 一个可重入的排他锁，这个锁主要是保证访问属性workers的线程安全及与之相关清除、标记 。
workers：它保存所有的工作者线程，访问此属性前必须先获得mainLock锁。
termination：一个等待条件，此属性主要为awaitTermination()方法中的线程通信提供支持。
largestPoolSize：反映线程池实际曾达到的最大线程数 ，访问此属性前必须先获得mainLock锁。
completedTaskCount：线程池已完成的任务数，它只会在工作者线程终止时更新，访问此属性前必须先获得mainLock锁。
workQueue、 threadFactory、 handler、 keepAliveTime 、corePoolSize 、maximumPoolSize这6个属性，在之前的文章中有过说明，这里不再赘述。
allowCoreThreadTimeOut: 此属性默认为false. 如果它为false，则即使处于空闲状态，核心线程也保持活动状态； 如果为true，则核心线程使用keepAliveTime超时等待任务。
defaultHandler：默认的拒绝策略，当线程池饱和后，只要有新任务到达它就会直接抛出异常。
shutdownPerm 、acc：均是安全权限相关的字段。
ONLY_ONE： 中断时默认只中断一个工作者线程，tryTerminate方法会用到此常量
5 构造方法
ThreadPoolExecutor有4个构造方法，分别需要若干个参数，构造方法只简单地涉及对成员变量的初始化，其参数个数最多的构造方法共有7个参数，其他的构造方法都是直接调用这个构造方法来实现的（各个参数的含义在线程池ThreadPoolExecutor简介 有详细说明）。
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;
}
6 主要方法
execute是线程池执行器的入口方法，它会调用addWorker创建并启动(thread.start)工作者线程，而工作者线程启动后又会调用runWorker去执行任务。因此可以看出execute、 addWorker 、runWorker 是线程池执行器最重要的3个方法(点击绿色的方法名快速跳至目标方法)。
1) 成员变量ctl相关方法
runStateOf(ctl)方法来取ctl的高3位，获取runState，
workerCountOf(ctl)方法来取ctl的低29位，获取workerCount
ctlOf(runState, workerCount)根据runState、workerCount算出ctl的值。
runStateLessThan(int,int)返回第一个参数（表示runState）是否小于第二个参数的布尔值
runStateAtLeast返回第一个参数（表示runState）是否大于等于第二个参数的布尔值
isRunning(int)返回runState是否为RUNNING（接受新任务并处理排队的任务）的布尔值
compareAndIncrementWorkerCount(int)尝试CAS更新ctl,将workerCount加1
compareAndDecrementWorkerCount(int)尝试CAS更新ctl,将workerCount减1
decrementWorkerCount(int)CAS自旋更新ctl,只有成功将workerCount减1，方法才能返回
advanceRunState(int targetState) 将runState设为targetState，若runState已经至少targetState级别则不改变原runState值。
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; }
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
private void decrementWorkerCount() {
do {
} while (! compareAndDecrementWorkerCount(ctl.get()));
}
private void advanceRunState(int targetState) {
for (;;) {
int c = ctl.get();
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
2) interruptWorkers系列方法
1) interruptIdleWorkers(boolean)
interruptIdleWorkers的实现比较简单，它在执行核心逻辑之前要先获取两类锁，一个锁是mainLock锁，另一个锁是Worker本身的锁。它遍历所有Worker中对应的线程，若线程是未被中断且是空闲线程就中断此线程 。若参数onlyOne是true，则最多只会中断一个空闲线程。
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//获取mainLock
try {
for (Worker w : workers) {
Thread t = w.thread;
//线程已经是中断状态就不再中断它
//尝试获取worker锁，允许抢锁失败。
//若抢锁失败表明worker线程正在执行任务，它不是空闲线程，准备去获取下一个worker锁
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)//onlyOne是true，就只中断一个空闲线程，然后退出
break;
}
} finally {
mainLock.unlock();
}
}
2) interruptIdleWorkers()
interruptWorkers()中断线程池中所有的空闲线程 ，我们来看看interruptWorkers()如何实现的。
interruptIdleWorkers()直接委托给interruptIdleWorkers(boolean)去实现，上面已经对interruptIdleWorkers(boolean)分析过了，这里就不再说了。
private void interruptIdleWorkers() {
interruptIdleWorkers(false);
}
3) interruptWorkers()
interruptWorkers()中断所有已启动线程, 我们来看看interruptWorkers()如何实现的。
interruptWorkers方法很简单，它先获取mainLock锁，然后遍历所有worker线程，并中断已启动的worker线程。
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();//中断已启动的worker线程（active thread，即线程的start方法已被调用）
} finally {
mainLock.unlock();
}
}
3) terminate系列方法
(1) isTerminating()
isTerminating()返回线程池执行器是否正在被终止的布尔值，此方法不是ExecutorService接口中的方法，这是ThreadPoolExecutor自身添加的一个API。这种状态一般出现在①shutdown 、②shutdownNow、③ tryTerminate方法调用后（tryTerminate中CAS成功将runState更新为TIDYING但调用terminate()方法还未执行完的时候）。
public boolean isTerminating() {
int c = ctl.get();
//runState>=SHUTDOWN 且runState<TERMINATED ,那么runState则可能是SHUTDOWN、STOP、TIDYING其中之一
return ! isRunning(c) && runStateLessThan(c, TERMINATED);
}
(2) isTerminated()
isTerminating()返回线程池执行器是否已被终止的布尔值。
public boolean isTerminated() {
//runState>=TERMINATED ，此时runState只能是TERMINATED
return runStateAtLeast(ctl.get(), TERMINATED);
}
(3) awaitTermination()
awaitTermination()阻塞等待所有任务完成。此方法需要设置超时时间，它会阻塞当前线程直到所有任务完成(返回ture)或发生超时(返回false)或当前线程被中断。
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//获取锁
try {
for (;;) {
//runState是否为TERMINATED 。TERMINATED状态时，所有任务已终止，线程池为空。
if (runStateAtLeast(ctl.get(), TERMINATED))
//已经是TERMINATED了，返回true
return true;
if (nanos <= 0)//已经超时，返回false
return false;
//当前线程阻塞等待，
//直到“达到超时时间”或“被termination.signal通知"(tryTerminate会调用termination.signalAll) 时
//当前线程才能被唤醒
nanos = termination.awaitNanos(nanos);
}
} finally {
mainLock.unlock();
}
}
(4) tryTerminate()
tryTerminate()检查runState否应转为TERMINATED状态，若状态应该转换则执行相应的teminate工作.
其实现细节是：
①若是在“runState是RUNNING状态”或“runState至少是TIDYING状态”或“runState是SHUTDOWN但队列中还有任务”这三种情况下，将runState不能转为TERMINATED ,方法直接返回。反之则进入下一步。
②再检查线程数workerCount是否为零，若workerCount不为零则调用interruptIdleWorkers中断一个空闲线程 ，反之则进入下一步。
③先获取mainLock锁 ，然后CAS尝试将runState设为TIDYING(这里cas更新失败将自旋重试)，再然后执行terminated()（空方法，留给子类实现）方法，待terminated()执行完后，再将runState无条件设为TERMINATED并唤醒等待termination条件的所有线程
final void tryTerminate() {
for (; ; ) {
int c = ctl.get();
if (isRunning(c) ||//runState是RUNNING状态
runStateAtLeast(c, TIDYING) || //至少是TIDYING状态
(runStateOf(c) == SHUTDOWN && !workQueue.isEmpty()))//runState是SHUTDOWN但队列中还有任务
//这三种情况下不能将runState转为TERMINATED，方法直接返回
return;
//runState可以转为TERMINATED,但池中还有一些线程，就中断池中一个空闲线程，然后方法返回
if (workerCountOf(c) != 0) {
// Eligible to terminate
interruptIdleWorkers(ONLY_ONE);//中断一个空闲线程
return;
}
//runState可以转为TERMINATED且池中没有任何线程时
//
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//尝试CAS更新，将runState设为TIDYING
// (TIDYING状态表示所有任务都已终止且线程数workerCount为零)
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();//空方法，留后子类实现
} finally {
//terminated执行后，无条件地将runState设为TERMINATED状态
//(TERMINATED状态表示terminated方法执行完成)
ctl.set(ctlOf(TERMINATED, 0));
//唤醒等待termination条件的所有线程
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
4 )addWorker系列方法
(1) addWorker(Runnable,boolean)
addWorker是一个重要的方法，它的主要作用是启动工作者线程Worker,其返回值表示启动Worker是否成功。它有两个参数，第一个参数是新创建线程的第一个执行的任务（可以为空），第二个参数是表示是否为核心线程的布尔值.
它的主要逻辑分为两部分
①第一部分是两层for循环自旋，它主要是检查runState、workerCount，并将workerCount加1 。
细节上是：先检查执行器是被关闭且工作队列为空，若是，则直接返回false。然后再检查线程数是否超出给定的边界值（核心线程数或可允许最大线程数值），若超出则直接返回false。尝试CAS更新workerCount，将workerCount加1，若CAS更新成功，则退出for循环，进入下一部分，若CAS更新失败，则需再次进入内循环自旋重试。若runState被其他线程修改了，则要重新进入外层循环重试。
②第二部分主体是一个try-finally块，它主要先获取mainLock锁，再向成员变量workers中添加一个worker对象，若添加失败则调用addWorkerFailed进行回滚。
细节上是：先尝试创建并启动一个新的worker。如果线程工厂无法创建线程(创建的线程为null)，将返回false。 如果线程池已停止或即将关闭，也将返回false。 如果worker线程启动失败（由于线程工厂返回null或发生异常），将调用addWorkerFailed进行回滚。
private boolean addWorker(Runnable firstTask, boolean core) {
/**
* 主要是检查runState 和workerCount，时机合适就将workerCount加1
*/
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);//获取runState
// Check if queue empty only if necessary.
//如果线程池已关闭且工作队列为空，添加Worker失败,直接返回false
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);//获取线程数workerCount
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))//不能大于corePoolSize 、maximumPoolSize
//线程数大于规定的线程数（最大容量的线程数，配置的核心线程数、配置的可允许最大线程数）
// ，添加Worker失败,返回false
return false;
if (compareAndIncrementWorkerCount(c))//CAS失败，需要再次进入内循环自旋重试
//workerCount加1成功,退出外层for循环 ，线程数已更新，
// 接下来进入实际添加的向成员变量workers中Worker操作
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)//runState被其他线程修改了，需要跳到外层for循环的开头处重试
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
/**
* 向成员变量workers中添加worker，
* 若无法添加worker或线程启动失败，则要调用addWorkerFailed进行回滚
*/
boolean workerStarted = false;//worker线程是否启动的标志
boolean workerAdded = false;//worker是否添加成功的标记
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
//t是线程工厂创建出来的线程，可以自己重写ThreadFactory接口的newThread方法，
// newThread返回值是否为空不确定，这里有必要对t进行非空判断
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//先获取锁
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
//线程池处于RUNNING状态或虽处于SHUTDOWN状态但任务为空 ，总之线程池还是可用的
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
//预先检查线程是否已经被启动了
if (t.isAlive()) // precheck that t is startable
//线程已预先被启动了，抛出异常
throw new IllegalThreadStateException();
workers.add(w);//添加worker对象到workers集合中
int s = workers.size();
//检查更新largestPoolSize（表示线程池实际曾达到的最大线程数）
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;//更新worker是否添加成功的标记
}
} finally {
mainLock.unlock();//释放锁
}
if (workerAdded) {
//worker成功添加后，启动线程
t.start();//**worker.run方法将执行，worker.run又会调用runWorker()
workerStarted = true;//更新worker线程是否启动的标志
}
}
} finally {
if (! workerStarted)
//添加worker失败,(根据前面的逻辑可看出,在未发生异常时,workerAdded若是false,workerStarted则也为false）
//就调用addWorkerFailed(),对addWorker方法进行回滚
addWorkerFailed(w);
}
return workerStarted;
}
(2) addWorkerFailed(Worker)
addWorkerFailed主要是回滚创建worker线程的失败。
它先要获取mainLock锁，然后它做了3件事：
①从workers中移除这个worker;
②将workerCount减1;
③检查runState否应转为TERMINATED状态，若是则执行相应的teminate工作。
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//先获取锁
try {
if (w != null)
workers.remove(w);//从workers中移除worker
decrementWorkerCount();//将workerCount减1
tryTerminate();//尝试终止线程池
} finally {
mainLock.unlock();
}
}
5) runWorker相关方法
(1) runWorker(Worker)
runWorker(Worker)主要是循环往复地从任务队列中获取任务执行。核心逻辑：
①将Worker的state从-1置为0（调用worker.unlock），保证之后worker线程能被中断、worker锁能被获取。
②到worker.firstTask属性或任务队列中获取任务。若获取的任务不为空就进入下一步，反之则worker线程准备终止，进入步骤6。
③获取woker锁，准备执行任务。
④检查runState，若runState是STOP级就确保当前线程是中断的，若runState不是STOP级就确保当前线程之后不是中断的。
⑤调用task.run开始执行任务,捕获执行任务过程中可能出现的异常。在任务执行完后，将worker的任务完成数completedTasks加1，再释放worker锁。再次获取任务，跳回步骤2。
⑥在worker线程即将终止退出(包括因异常退出的情况)时，执行processWorkerExit方法处理worker终止的后续工作
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;//
//在获取w.firstTask后，将w.firstTask设为空，因为之后worker会到任务队列中获取任务
w.firstTask = null;
//这里并不是真的释放锁，而只是将父类AQS的state从初始的-1置为0。
//否则worker线程不能被中断(worker初始化时state为-1，interruptIfStarted方法中要求state>0才中断线程)，
//worker锁也一直无法被获取(尝试获取锁时compareAndSetState(0, 1)返回true才能成功抢锁，若state为-1，它永远返回false)
w.unlock(); // allow interrupts
boolean completedAbruptly = true; //worker异常终止的标志
try {
//firstTask不空或任务队列中还能获取到任务，
while (task != null || (task = getTask()) != null) {
//成功获取到worker锁后,表明worker线程就要执行任务，不再是空闲状态了。
//w.isLock可以判断线程是否空闲等待，如果返回false,表明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
//如果runState是STOP且线程未被中断，就使用wt.interrupt()中断线程，确保wt是中断的;
//如果runState不是STOP就用Thread.interrupted()保证之后wt不是中断状态
//（若某线程t是中断状态，调用静态方法Thread.interrupted()会在清除线程t的中断标记后
//返回true，下次调用实例方法t.isInterrupted()将返回false,这是因为中断标记之前已被清除）
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++;//已完成任务数加1
w.unlock();
}
}
completedAbruptly = false;//worker没有因异常死亡
} finally {
processWorkerExit(w, completedAbruptly);//清除和标记woker终止后的后续工作
}
}
(2) getTask()
getTask()从任务队列获取任务。其核心逻辑：
①检查runState，若runState状态表明执行器不需要再执行任务(“runState>=STOP” 或 “runState>=SHUTDOWN且任务队列为空”)时，将workerCount减1，返回空任务，此worker线程即将终止。反之则进入下一步
②若当前线程数大于maximumPoolSize或等待任务出队超时或任务队列为空时，就尝试CAS将workerCount减1，反之则进入步骤3。 若CAS更新workerCount成功则返回空任务，反之则自旋重试，跳回步骤1。
③阻塞等待任务出队，如果任务出队成功，就返回这个任务，反之则自旋重试，跳回步骤1。
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.
//“runState>=STOP” 或 “runState>=SHUTDOWN且任务队列为空”，
// 表明执行器已经关闭了，worker线程将终止，返回空任务，worker不再执行任务。
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();//因工作线程退出，workerCount减1
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
//是否要应用超时策略的布尔值（中断空闲线程）
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//wc > maximumPoolSize workerCount大于maximumPoolSize，因为maximumPoolSize被重设了
// timed && timedOut 在运用超时策略时最终还真的等待超时了
// "wc >1 || workQueue.isEmpty()"当前只有一个线程或任务队列空了
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
//尝试CAS将workState减1
if (compareAndDecrementWorkerCount(c))
//CAS更新成功，返回空任务
return null;
continue;//CAS更新失败，自旋重试获取任务
}
try {
//如果要应用超时策略，就等待指定时长让任务出队，
//若不应用超时策略，就无限长时间地等待任务出队
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;//成功出队了，返回此任务
timedOut = true;//poll返回null,等待超时了
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
(3) processWorkerExit(Worker,boolean)
processWorkerExit(Worker,boolean)处理worker线程终止退出的后续扫尾工作。
其主要逻辑：
①若worker线程是因异常而突然终止的，就将workerCount减1
②获取manLock锁，将worker.completedTasks同步到ThreadPoolExecutor.completedTaskCount中，从workers中移除这个即将终止的worker
③检查runState是否应转为TERMINATED状态及与之相关的处理
④当runState<=STOP时，如果时机合适就启动一个新worker来替代即将终止的worker
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
//worker因异常而终止,workerCount不能自适应改变，手动将workerCount减1
decrementWorkerCount();//
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//当一个worker终止时，需要将其completedTasks同步到ThreadPoolExecutor.completedTaskCount上
completedTaskCount += w.completedTasks;
workers.remove(w);//从成员变量workers中移除这个worker
} finally {
mainLock.unlock();
}
tryTerminate();//检查runState是否应转为TERMINATED状态及与之相关的处理
int c = ctl.get();
//runState是RUNNING或SHUTDOWN时，这两种情况下还可以启动worker
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
//worker正常死亡时 判断是需要启动新worker来替代已死的worker
//min表示线程池中能长久驻存的线程数（不会因长久空闲等待而终止的线程数）
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
//只有一个长久驻存的线程但队列中还有任务
min = 1;
if (workerCountOf(c) >= min)
//当前线程数多于能长久驻存的线程数，不需要启动新worker来替代已死的worker,直接返回
return; // replacement not needed
}
//启动新的worker替代已死worker
addWorker(null, false);
}
}
6) execute(Runnable)
execute(Runnable)方法非常重要,它是ThreadPoolExecutor的入口方法，父类AbstractExecutorService已实现ExecutorService接口中的sumbit 、invokeXXX方法，这些方法的核心逻辑都委托给execute实现，详细说明见之前的文章AbstractExecutorService源码完全解析。
execute(Runnable)的核心逻辑分为三步：
①如果当前有效线程数少于corePoolSize，则调用addWorker尝试启动一个核心线程执行任务。若成功启动，方法就直接返回，反之则进入下一步。
②若执行器还在运行(runState=RUNNING)且任务入队成功，则需要再次检查workerCount和runState, 反之则进入步骤3。若执行器已关闭(runState>RUNNING)且成功将刚入队的任务从队列中移除，则使用拒绝策略处理此任务；反之再检查当前有效线程数是否为零，若实际线程数为零，则新启动一个非核心线程(保证线程池中至少有一个线程)。
③(一般是队列已满)尝试启动一个非核心线程去执行此任务。 如果启动失败则表明执行器已关闭或已饱和，因此使用拒绝策略处理此任务。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get(); //先获取原子变量ctl的值
//工作者线程数少于corePoolSize，
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))//尝试创建核心线程执行任务
return;//成功就返回
c = ctl.get();//若失败(可能是执行器被关闭了或线程启动失败)，要重新获取ctl值
}
//工作者线程数大于等于corePoolSize，意味着要尝试将任务放入队列到队列中
//isRunning(c)线程池能接受任务
//workQueue.offer(command)任务入队成功
if (isRunning(c) && workQueue.offer(command)) {
//重新获取ctl，将再次检查runState和workerCount因为有可能上次检查后线程被终止了或线程池被关闭了
int recheck = ctl.get();
//线程池已关闭时尝试将这个已入队的任务从队列中移除(上面的"workQueue.offer(command)"已成功入队)
if (! isRunning(recheck) && remove(command))
//移除任务成功时，使用拒绝策略处理任务
reject(command);//
//"线程池已关闭且从任务队列中移除任务失败(可能是任务已被完成了)" 或"线程池还处于RUNNING状态"
//将检查池中的线程数是否为0
else if (workerCountOf(recheck) == 0)
//线程数为零时, 创建非核心线程，但不立即执行任务(这里的addWorker中的Runnable为空)
// 因为之前已经将此任务放入工作队列了，空闲线程会到队列中去获取任务来执行
addWorker(null, false);
}
//入队失败，可能是因为队列已满，尝试创建一个非核心线程去执行任务
else if (!addWorker(command, false))
//addWorker失败，使用拒绝策略处理任务
reject(command);
}
上面的execute中调用了几个我们不熟悉的方法，分别是remove(Runnable) 、reject(Runnable),下面我们分别来看看这两个方法。
(1) remove(Runnable)
remove(Runnable)方法逻辑很简单，就是先将任务从任务队列中移除，再调用tryTerminate()检查是否应转为TERMINATED状态及其相关的处理，最后返回是否成功移除任务的布尔值。
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}
(2) reject(Runnable)
reject(Runnable)直接委托给拒绝策略handler调用rejectedExecution方法。
handler是实现RejectedExecutionHandler接口的对象，表示线程池饱和时的饱和策略rejectedExecution是此接口的唯一方法，它一般在构造方法中指定。
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
7) shutdown系列方法
(1) shutdown()
shutdown()方法是用来关闭线程池执行器的，它的主要逻辑是：
先将runState至少设为SHUTDOWN级，然后中断池中的空闲线程，调用onShutdown空方法(钩子函数,留给子类实现)，最后检查runState是否应转为TERMINATED状态及与之相关的处理。
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//先获取锁
try {
checkShutdownAccess();//检查权限
advanceRunState(SHUTDOWN);//若runState已至少是STOP级就不做任何处理,反之将runState设为STOP,
interruptIdleWorkers();//中断池中的空闲线程
//空方法，留后子类实现，它是一个钩子函数 其子类ScheduledThreadPoolExecutor重写了此方法
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();//检查runState是否应转为TERMINATED状态及与之相关的处理
}
(2) shutdownNow()
shutdownNow()方法是用来立即关闭线程池执行器的，它的主要逻辑是：
先将runState至少设为STOP级，然后中断所有已启动的线程，再从任务队列中移除所有待执行的任务，再然后检查runState是否应转为TERMINATED状态及与之相关的处理，最后返回这些待执行的任务列表。
可以看出shutdown和shutdownNow之间的区别在于：
①shutdown将runState至少设为SHUTDOWN，而shutdownNow将runState至少设为STOP.
②shutdown只中断空闲线程，而shutdownNow会中断所有线程。换而言之，shutdown不去停止正在执行的任务，而shutdownNow会让正在执行的任务(如果任务能响应中断的话)停止。
③shutdown不去任务队列中移除任务，而shutdownNow会从任务队列中移除所有的任务。换而言之，shutdown之前提交的任务还能被执行，而shutdownNow之前提交的任务不能被执行了。
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//先获取锁
try {
checkShutdownAccess();//检查权限
advanceRunState(STOP);//若runState>STOP就不做任何处理,反之将runState设为STOP,
//中断所有已启动的线程(包括正在执行任务的非空闲线程和等待任务的空闲线程)，不响应中断的任务可能无法被终止
interruptWorkers();
tasks = drainQueue();//从队列中移除所有任务
} finally {
mainLock.unlock();
}
tryTerminate();//检查runState是否应转为TERMINATED状态及与之相关的处理
return tasks;
}
shutdownNow()方法体中调用drainQueue()从队列中移除所有任务, 我们来看看drainQueue()如何做的。
① drainQueue()
drainQueue所实现的逻辑很简单：它只将将工作队列中的所有任务移除，并将这些任务返回。
private List<Runnable> drainQueue() {
BlockingQueue<Runnable> q = workQueue;
ArrayList<Runnable> taskList = new ArrayList<Runnable>();
q.drainTo(taskList);//BlockingQueue的drainTo方法会一次性取出所有可用元素，在取出后会在队列中删除这些元素。
if (!q.isEmpty()) {
//DelayQueue等类型的队列直接出队可能失败，再次用remove方法获取之前出队失败的元素。
for (Runnable r : q.toArray(new Runnable[0])) {
if (q.remove(r))
taskList.add(r);
}
}
return taskList;
}
(3) isShutdown()
isShutdown()返回线程池执行器是否被关闭的布尔值。从方法实现上可以看出，它是根据runState的值判断线程池执行器是否被关闭，只要runState不小于SHUTDOWN，执行器就是关闭状态。
public boolean isShutdown() {
return ! isRunning(ctl.get());
}
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
8) 配置相关setter/getter
(1) ThreadFactory
setThreadFactory/getThreadFactory用于设置/获取线程工厂，只要实现ThreadFactory接口就可以自定义线程工厂。
public void setThreadFactory(ThreadFactory threadFactory) {
if (threadFactory == null)
throw new NullPointerException();
this.threadFactory = threadFactory;
}
public ThreadFactory getThreadFactory() {
return threadFactory;
}
(2) RejectedExecutionHandler
setRejectedExecutionHandler/getRejectedExecutionHandler用于设置/获取饱和策略，当线程池和队列均已满时，调用RejectedExecutionHandler.rejectedExecution处理新任务。
public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
if (handler == null)
throw new NullPointerException();
this.handler = handler;
}
public RejectedExecutionHandler getRejectedExecutionHandler() {
return handler;
}
(3) CorePoolSize
setCorePoolSize/getCorePoolSize用于设置/获取核心线程数
public void setCorePoolSize(int corePoolSize) {
if (corePoolSize < 0)
throw new IllegalArgumentException();
int delta = corePoolSize - this.corePoolSize;
this.corePoolSize = corePoolSize;//更新corePoolSize属性
//如果实际线程数已经多于最新的corePoolSize，就中断所有空闲线程。
if (workerCountOf(ctl.get()) > corePoolSize)
interruptIdleWorkers();
//“当前实际线程数少于新corePoolSize”且"新corePoolSize大于原来的corePoolSize" 时
//就预先启动足够的新worker线程(最大为新的corePoolSize)以处理队列中的当前任务数，
//但是如果在添加worker过程中队列变为空则停止添加。
else if (delta > 0) {
// We don't really know how many new threads are "needed".
// As a heuristic, prestart enough new workers (up to new
// core size) to handle the current number of tasks in
// queue, but stop if queue becomes empty while doing so.
int k = Math.min(delta, workQueue.size());
while (k-- > 0 && addWorker(null, true)) {
if (workQueue.isEmpty())
break;
}
}
}
public int getCorePoolSize() {
return corePoolSize;
}
prestartCoreThread()方法启动一个核心线程，若所有核心线程已启动则返回false.
ensurePrestart()方法与prestartCoreThread()类似，但它能保证池中至少有一个线程。
prestartAllCoreThreads()方法将一次性启动所有核心线程，若所有核心线程已启动将返回0。
public boolean prestartCoreThread() {
//当前线程数小于corePoolSize就创建一个核心线程
return workerCountOf(ctl.get()) < corePoolSize &&
addWorker(null, true);
}
void ensurePrestart() {
int wc = workerCountOf(ctl.get());
if (wc < corePoolSize)
//当前线程数小于corePoolSize创建一个核心线程
addWorker(null, true);
else if (wc == 0)
//corePoolSize为0，当前线程数也为0,就创建一个非核心线程。池中至少有这个刚启动的线程了
addWorker(null, false);
}
public int prestartAllCoreThreads() {
int n = 0;
while (addWorker(null, true))//一次性启动所有核心线程
++n;
return n;//返回此方法启动的核心线程数
}
(4) MaximumPoolSize
setMaximumPoolSize/getMaximumPoolSize用于设置/获取最大可允许创建的线程数
public void setMaximumPoolSize(int maximumPoolSize) {
if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
throw new IllegalArgumentException();
this.maximumPoolSize = maximumPoolSize;//更新maximumPoolSize属性
//若当前实际的线程数多于新的maximumPoolSize，就中断所有空闲线程
if (workerCountOf(ctl.get()) > maximumPoolSize)
interruptIdleWorkers();
}
public int getMaximumPoolSize() {
return maximumPoolSize;
}
(5) KeepAliveTime
setKeepAliveTime/setKeepAliveTime用来设置/获取线程的最大空闲时间。
public void setKeepAliveTime(long time, TimeUnit unit) {
if (time < 0)
throw new IllegalArgumentException();
if (time == 0 && allowsCoreThreadTimeOut())
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
long keepAliveTime = unit.toNanos(time);
long delta = keepAliveTime - this.keepAliveTime;
this.keepAliveTime = keepAliveTime;//更新maximumPoolSize属性
if (delta < 0)//新的keepAliveTime小于原keepAliveTime,就中断所有空闲线程
interruptIdleWorkers();
}
//处理KeepAliveTime的时间单位转换
public long setKeepAliveTime(TimeUnit unit) {
return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
}
public long getKeepAliveTime(TimeUnit unit) {
return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
}
默认情况下keepAliveTime，只适用于非核心线程，即核心线程不会因空闲等待太久而被终止, 但使用allowCoreThreadTimeOut()方法并将参数设为true就可改变这种默认效果，使keepAliveTime对核心线程同样有效。
public boolean allowsCoreThreadTimeOut() {
return allowCoreThreadTimeOut;
}
public void allowCoreThreadTimeOut(boolean value) {
if (value && keepAliveTime <= 0)
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
if (value != allowCoreThreadTimeOut) {
allowCoreThreadTimeOut = value;//更新allowCoreThreadTimeOut属性
if (value)//若允许核心线程超时，就中断所有空闲线程
interruptIdleWorkers();
}
}
(6) WorkQueue
getQueue用于获取任务队列。
public BlockingQueue<Runnable> getQueue() {
return workQueue;
}
9) 状态监控相关方法
(1) getPoolSize()
getPoolSize()返回当前线程池中的工作线程总数
public int getPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Remove rare and surprising possibility of
// isTerminated() && getPoolSize() > 0
//若runState是TIDYING或TERMINATED时，workerCount一定为0(之前在tryTerminate中分析过)
//反之就取workers.size()
return runStateAtLeast(ctl.get(), TIDYING) ? 0
: workers.size();
} finally {
mainLock.unlock();
}
}
(2) getActiveCount()
getActiveCount() 返回当前活动(正在执行任务)的工作线程数
public int getActiveCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int n = 0;
for (Worker w : workers)
if (w.isLocked())//Worker锁被持有，表示正在执行任务
++n;
return n;
} finally {
mainLock.unlock();
}
}
(3) getLargestPoolSize()
getLargestPoolSize()返回曾经创建过的最大线程数。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过。
public int getLargestPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
return largestPoolSize;
} finally {
mainLock.unlock();
}
}
(4) getTaskCount()
getTaskCount()返回执行器从启动到现在所接受的任务总数。
public long getTaskCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
long n = completedTaskCount;//先获取表示完成的任务数的成员变量completedTaskCount
for (Worker w : workers) {
//还有一些记录有worker中的已完成任务数（尚未同步到completedTaskCount中）
n += w.completedTasks;
//另外还要加上正在执行的任务(还未完成)
if (w.isLocked())//此worker正在执行任务
++n;
}
return n + workQueue.size();//最后加上任务队列中的任务数
} finally {
mainLock.unlock();
}
}
(5) getCompletedTaskCount()
getCompletedTaskCount() 返回执行器完成的任务总数。
public long getCompletedTaskCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
long n = completedTaskCount;//先获取表示完成的任务数的成员变量completedTaskCount
for (Worker w : workers)
//还有一些记录有worker中的已完成任务数（尚未同步到completedTaskCount中）
n += w.completedTasks;
return n;
} finally {
mainLock.unlock();
}
}
(6) 空实现的钩子函数
除此之外，线程池还提供了3个空方法，beforeExecute方法在执行一个任务前被调用，afterExecute方法在一个任务完成后被调用，terminated()方法在线程池停止时被调用。
我们可继承ThreadPoolExecutor来实现自己的线程池，并以此为基础重写这3个方法来实现自己的监控逻辑。
10) finalize()
finalize()方法是顶级父类Object的方法，此方法在对象被GC回收前调用，一般用来清理释放占用的资源。ThreadPoolExecutor重写了此方法，其核心逻辑是调用shutdown()方法关闭执行器。
protected void finalize() {
SecurityManager sm = System.getSecurityManager();
if (sm == null || acc == null) {
shutdown();
} else {
PrivilegedAction<Void> pa = () -> {
shutdown(); return null; };
AccessController.doPrivileged(pa, acc);
}
}
7 工作流程
以sumbit(Runnable/Callable)方法为例，说明线程池执行器ThreadPoolExecutor的主要工作流程。
sumbit(Runnable/Callable)在父类AbstractExecutorService中已有基本实现，但其核心逻辑execute方法仍要子类实现，所以ThreadPoolExecutor实现了excute方法。
submit(Runnable/Callable)方法的主要工作流程：
①它先将Runnable/Callable任务统一封装成FutureTask。那么FutureTask是如何封装原始任务的? FutureTask将Runnable或Callable任务设为它的(若原任务的类型是Runnable就使用适配器模式将其适配为Callable类型)Callable类型属性callable；另外FutureTask也实现了Runnable接口，而它的run()方法核心内容就是执行callable.call、并记录任务结果或任务执行发生的异常信息
②然后执行execute(task)的核心逻辑是addWorker(), addWorker()会启动一个新的工作线程，即worker.thread启动。worker.thread线程启动后，worker.thread线程将执行worker.run()方法，而worker.run()方法又委托给外部类ThreadPoolExecutor的runWorker方法实现。
③runWorker基本逻辑是：循环往复从worker.firstTask或工作队列中获取并执行任务 。若获取的任务为空，此线程不再执行任务，worker.run方法将结束，此线程即将终止。若获取到任务不为空就调用FutureTask.run执行任务. 这里的FutureTask.run执行会FutureTask.callable.call()并记录任务结果或发生的异常。这里的callable.call()才是最原始的任务执行内容。
