ThreadPoolExcutor源码解析_通俗易懂

写在前面

是这样的，我简单说一下。我之前写了一篇关于 CompletableFuture 的源码分析。但是在学习过程中，简单看了一下 ForkJoinPool 的源码，发现很多状态名称或者变量属性非常的模糊。比如 ForkJoinPool 中的 ctl 是什么，他是怎么控制线程数量的等等。这些变量在 ThreadPoolExcutor 源码中都是非常重要的属性。由于我当时只是简单了解线程池基本原理，但压根就不知道这些属性是什么东西，当时就非常的难受。而我也对 ThreadPoolExcutor 源码非常的好奇。基于此，觉得很有必要研究一下 ThreadPoolExcutor 的源码，对其有一个更深的理解。

阅读本文章需要对 ThreadPoolExcutor 的使用有个基本了解，并且简单理解其原理。

线程池状态

在 ThreadPoolExcutor 中，线程池状态由 ctl 属性保存。关于什么是 ctl，在源码中，有一段非常清晰的注释，大意是这样的：

主线程池的控制状态，ctl，是一个打包两个概念的原子整数字段，包括指示线程有效运行数量 workerCount 以及线程状态 runState，用来指示是否运行和关闭等状态。为了将他们打包到一个 int 上，我们将 workerCount 限制为（2 ^ 29 ）-1 约为 5 亿个线程。而不是（2 ^ 31）-1（ 20 亿）个线程。如果将来有问题，可以使用 AtomicLong 进行替换。并调整 shift / mask 常数。但是在需要之前，使用 int 可以使代码更快，更简单。workCount 是允许被启动不停止的 worker 数量，该值可能与活动线程的实际数量有暂时的不同，例如，ThreadFactory 在被请求的时候未能创建线程，以及当退出线程任在终止之前执行记账操作等，用户可见的池大小报告为工作集合的当前大小。

runState 提供了主生命周期控制，其值为:

运行状态	状态描述
RUNNING	接收新提交任务，并且也能处理阻塞队列中的任务。
SHUTDOWN	关闭状态，不再接受新提交得任务，但却可以继续处理阻塞队中已保存的任务。
STOP	不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。
TIDYING	所有任务都已终止，workerCount (有效线程数)为 0。
TERMINATED	在 terminated() 方法执行完成后进入该状态。

这些值之间的数字顺序很重要，可以进行有序的比较。runState 随时间单调增加，但不必达到每个状态。可以按如下方式过渡：

检测从 SHUTDOWN 到 TIDYING 的转换并不像您想要的那样简单，因为在 SHUTDOWN 状态期间，队列在非空之后可能变为空，反之亦然，但是只有在看到它为空之后才能看到 workerCount 为 0。

ctl 属性

ctl 是 ThreadPoolExecutor 对线程状态 runState 和线程池 workerCount 的一个综合字段。将这两个属性打包放置在 AtomicInteger 上，ctl 长度为 32 位，前面 3 位用于存放 runState，后面 29 位存放 workerCount。因此线程池最大的线程数量位 2^29-1。其代码如下：

	private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
	// Integer.SIZE 为 32，为什么减去3呢
	// 3 是指前面 3 位存放 runStatus
	// 那问题又来了，为什么需要 3 位呢。因为线程池有 5 个状态，而两位最多只能表示 4 个状态
    private static final int COUNT_BITS = Integer.SIZE - 3;// 结果 29
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
	// 注意：负数第一位为 1 
    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;
	//如果想查看上面变量的二进制表现形式，可以通过方法 Integer.toBinaryString(int i) 查看

我们可以看看各状态的二进制情况：（其实下图已经非常的形象了，不懂二进制的可以先网上学习一下）

可以看到，通过位移操作，将最高的三位用于标识 runState 状态，而后面 29 位用于存放 workerCount。

下面的这三个方法也非常的重要

	// Packing and unpacking ctl
	//传递ctl参数，返回runState
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
	//传递ctl参数，返回workerCount
    private static int workerCountOf(int c)  { return c & CAPACITY; }
	//这个方法是线程池初始化时，何如把线程状态和线程数合并成一个int,也就是ctl
	//rs | wc的或运算，一个为真则为真，完美把runState和workerCount合并
    private static int ctlOf(int rs, int wc) { return rs | wc; }

方法 runStateOf 和 workerCountOf 则可以将这两部分数据通过位运算的方式取出来： 如下图所示，假定需要计算的 c 为 0110 0000 0000 0000 0000 1110 0110 0000，那么位移过程如下：

这两个方法就可以很快的计算出结果。 而 ctlOf 方法，rs | wc，这就非常容易理解了。

上图就非常方便的将 runState 和 workerCount 进行了组合。 而根据第一张图可以看到，RUNNING 状态为负数，是最小的，这些状态的全部 ctl 满足如下规则：

RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED

另外，与 runState 相关的还有几个比较重要的方法

	/*
     * Bit field accessors that don't require unpacking ctl.
     * These depend on the bit layout and on workerCount being never negative.
     */

    private static boolean runStateLessThan(int c, int s) {
        return c < s;
    }

    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }

	// 可以发现的是，比 SHUTDOWN 小的任何状态都是 iRUNNING状态。
	// 这也是 isRunning 方法的原因。
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }

方法 runStateLessThan 和 runStateAtLeast 则是根据上述规则判断线程池当前所处的状态。

此外还提供了基于 CAS 的增减 WorkerCount 的方法：

	// cas 线程数 +1
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }

    // 线程数-1
    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }

    // 自旋 cas 更新线程数
    private void decrementWorkerCount() {
        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
    }

核心逻辑源码

Worker

ThreadPoolExcutor 的构造参数就不说了，那是基础。再此之前，我先介绍 ThreadPoolExcutor 的一个内部类 Worker，可以理解为线程。

private final class Worker
     extends AbstractQueuedSynchronizer
     implements Runnable
      {
    private static final long serialVersionUID = 6138294804551838833L;
    // 这个是真正的线程，任务靠你啦
    final Thread thread;
   	// Runnable 也就是任务。为什么叫 firstTask？因为在创建线程的时候，如果同时指定了
    // 这个线程起来以后需要执行的第一个任务，那么第一个任务就是存放在这里的(线程可不止执行这一个任务)
    // 当然了，也可以为 null，这样线程起来了，自己到任务队列（BlockingQueue）中取任务（getTask 方法）就行了
    // 比如，还没达到核心线程，此时提交新任务，此时是需要新创建现线程的，那么这个新任务就是这个 firstTask
    Runnable firstTask;
    
    // 用于存放此线程完全的任务数，注意了，这里用了 volatile，保证可见性
    volatile long completedTasks;
    // Worker 只有这一个构造方法，传入 firstTask，也可以传 null
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
       	this.firstTask = firstTask;
       	// 调用 ThreadFactory 来创建一个新的线程
        this.thread = getThreadFactory().newThread(this);
    }
    // 这里调用了外部类的 runWorker 方法
    public void run() {
        //非常重要，线程start()时会调用该方法
        runWorker(this);
    }
    // 其他几个方法没什么好看的，就是用 AQS 操作，来获取这个线程的执行权，用了独占锁
}

这里解释一下为什么继承 AbstractQueuedSynchronizer，其作用是在运行任务时锁住该 worker (有点类似于自己锁住自己)，也就是说，用于控制线程在执行任务过程中不被中断。某一个线程能被中断是因为队列没任务了，又或者强制中断（调用 shutdownNow 方法）。

还是不明白的话，没关系，先往下看。

execute()

有了上面的这些基础后，我们终于可以看看 ThreadPoolExecutor 的 execute 方法了

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
  
    // 前面说的那个表示 “线程池状态” 和 “线程数” 的整数
    int c = ctl.get();
  
    // 如果当前线程数少于核心线程数，那么直接添加一个 worker 来执行任务，
    // 创建一个新的线程，并把当前任务 command 作为这个线程的第一个任务(firstTask)
    if (workerCountOf(c) < corePoolSize) {
        // 添加任务成功，那么就结束了。提交任务嘛，线程池已经接受了这个任务，这个方法也就可以返回了
        // 至于执行的结果，到时候会包装到 FutureTask 中。
        // 返回 false 代表线程池不允许提交任务
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了
  
    // 如果线程池处于 RUNNING 状态，把这个任务添加到任务队列 workQueue 中
    if (isRunning(c) && workQueue.offer(command)) {
        /* 这里面说的是，如果任务进入了 workQueue，我们是否需要开启新的线程
         * 因为线程数在 [0, corePoolSize) 是无条件开启新的线程
         * 如果线程数已经大于等于 corePoolSize，那么将任务添加到队列中，然后进到这里
         */
        int recheck = ctl.get();
        // 如果线程池已不处于 RUNNING 状态，那么移除已经入队的这个任务，并且执行拒绝策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 如果线程池还是 RUNNING 的，并且线程数为 0，那么开启新的线程
        // 到这里，我们知道了，这块代码的真正意图是：担心任务提交到队列中了，但是线程都关闭了
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 如果 workQueue 队列满了，那么进入到这个分支
    // 以 maximumPoolSize 为界创建新的 worker，
    // 如果失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

刚开始看这段代码可能还是会有点懵。我说一下我刚开始的疑问吧，也许也就是你的疑问。也就是最常见的一种情况，比如线程数量已经大于等于核心线程数，此时再提交任务是怎么样？又或者线程数量已经大于等于核心线程数，并且队列已经满了，此时添加任务又是怎么样

由上面源码可以看到，第一种情况，此时再提交任务的话，是直接添加到队列中就返回了。其实在没看源码之前，我也知道是这么一回事，但是，他是怎么被消费？worker 内部死循环从队列获取 task 消费？

那第二种情况呢 ，可以看到，队列满了，调用了addWorker() 方法，并把这个 task 作为这个 worker 的 firstTask。问题又来了，有可能这个 work 执行完这个 task 之后，队列任务少了好几个（也就是队列没满），此时这个 worker 会怎样？直接在线程池中移除？还是继续循环从队列里获取任务，直到队列没任务可以获取呢？

上面这些一时半会也不可能全部消化搞定，我们先继续往下吧，到时候再回头看几遍。

addWorker()

这个方法非常重要 addWorker(Runnable firstTask, boolean core) 方法，我们看看它是怎么创建新的线程的：

// 第一个参数是准备提交给这个线程执行的任务，之前说了，可以为 null
// 第二个参数为 true 代表使用核心线程数 corePoolSize 作为创建线程的界线，也就说创建这个线程的时候，
// 		如果线程池中的线程总数已经达到 corePoolSize，那么不能响应这次创建线程的请求
// 		如果是 false，代表使用最大线程数 maximumPoolSize 作为界线
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // 这个非常不好理解
        // 这里的判断条件有点多，拆成 rs>=SHUTDOWN 和 !(rs == SHUTDOWN && firstTask == null &&!workQueue.isEmpty())
        // !(rs == SHUTDOWN && firstTask == null &&!workQueue.isEmpty()) 逆着考虑 ,如下：
        // rs!=SHUTDOWN 也就是为大于 shutdown，为 stop,tidying,terminated
        // firstTask != null
        // workQueue.isEmpty()
        // 如果线程池处于关闭状态，且满足下面条件之一的，不创建 worker
        //      线程池处于 stop,tidying,terminated 状态
        //      firstTask != null
        //      workQueue.isEmpty()
        // 注意：如果线程池处于 shutdown，且 firstTask 为 null,同时队列不为空，允许创建 worker
        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
        for (;;) {
            int wc = workerCountOf(c);
            // 工作线程数大于最大容量或者工作线程数超过线程数的边界(根据 core 的值取不同的值) 时 不创建worker
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 如果成功，那么就是所有创建线程前的条件校验都满足了，准备创建线程执行任务了
            // 这里失败的话，说明有其他线程也在尝试往线程池中创建线程
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // 由于有并发，重新再读取一下 ctl
            c = ctl.get();
            // 正常如果是 CAS 失败的话，进到下一个里层的for循环就可以了
            // 可是如果是因为其他线程的操作，导致线程池的状态发生了变更，如有其他线程关闭了这个线程池
            // 那么需要回到外层的for循环
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
    /* 
     * 到这里，我们认为在当前这个时刻，可以开始创建线程来执行任务了，
     * 因为该校验的都校验了，至于以后会发生什么，那是以后的事，至少当前是满足条件的
     */
  
    // worker 是否已经启动
    boolean workerStarted = false;
    // 是否已将这个 worker 添加到 workers 这个 HashSet 中
    boolean workerAdded = false;
    Worker w = null;
    try {
        final ReentrantLock mainLock = this.mainLock;
        // 把 firstTask 传给 worker 的构造方法
        w = new Worker(firstTask);
        // 取 worker 中的线程对象，之前说了，Worker的构造方法会调用 ThreadFactory 来创建一个新的线程
        final Thread t = w.thread;
        if (t != null) {
            // 这个是整个类的全局锁，持有这个锁才能让下面的操作“顺理成章”，
            // 因为关闭一个线程池需要这个锁，至少我持有锁的期间，线程池不会被关闭
            mainLock.lock();
            try {
                int c = ctl.get();
                int rs = runStateOf(c);
                // 小于 SHUTTDOWN 那就是 RUNNING，这个自不必说，是最正常的情况
                // 如果等于 SHUTDOWN，前面说了，不接受新的任务，但是会继续执行等待队列中的任务
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    // worker 里面的 thread 可不能是已经启动的
                    if (t.isAlive())
                        throw new IllegalThreadStateException();
                    // 加到 workers 这个 HashSet 中
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize 用于记录 workers 中的个数的最大值
                    // 因为 workers 是不断增加减少的，通过这个值可以知道线程池的大小曾经达到的最大值
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 添加成功的话，启动这个线程
            if (workerAdded) {
                // 启动线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        // 如果线程没有启动，需要做一些清理工作，如前面 workCount 加了 1，将其减掉
        if (! workerStarted)
            addWorkerFailed(w);
    }
    // 返回线程是否启动成功
    return workerStarted;
}

简单看下 addWorkFailed 的处理：

// workers 中删除掉相应的 worker
// workCount 减 1
private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (w != null)
            workers.remove(w);
        decrementWorkerCount();
        // rechecks for termination, in case the existence of this worker was holding up termination
        tryTerminate();
    } finally {
        mainLock.unlock();
    }
}

runWorker()

上面有一个很重要的调用 ，相信你也看到了 t.start() 实际上，其 run 方法会调用 runWorker 方法：

// Worker 类的 run() 方法
public void run() {
    runWorker(this);
}

继续往下看 runWorker 方法：

// 此方法由 worker 线程启动后调用，这里用一个 while 循环来不断地从等待队列中获取任务并执行
// 前面说了，worker 在初始化的时候，可以指定 firstTask，那么第一个任务也就可以不需要从队列中获取
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()是一个阻塞方法
        while (task != null || (task = getTask()) != null) {
            w.lock();          
            // 如果线程池状态大于等于 STOP，那么意味着该线程也要中断
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();//todo 
            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) {
                    // 这里不允许抛出 Throwable，所以转换为 Error
                    thrown = x; throw new Error(x);
                } finally {
                    // 也是一个钩子方法，将 task 和异常作为参数，留给需要的子类实现
                    afterExecute(task, thrown);
                }
            } finally {
                // 置空 task，准备 getTask 获取下一个任务
                task = null;
                // 累加完成的任务数
                w.completedTasks++;
                // 释放掉 worker 的独占锁
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // 如果到这里，需要执行线程关闭：
        // 1. 说明 getTask 返回 null，也就是说，这个 worker 的使命结束了，执行关闭
        // 2. 任务执行过程中发生了异常
        // 第一种情况，已经在代码处理了将 workCount 减 1，这个在 getTask 方法分析中会说
        // 第二种情况，workCount 没有进行处理，所以需要在 processWorkerExit 中处理
        // 限于篇幅，我不准备分析这个方法了，感兴趣的读者请自行分析源码
        processWorkerExit(w, completedAbruptly);//todo 
    }
}

看到这里，我上面提的疑问大概就有答案了。一个启动的 worker，首先是消费该 worker 的 firstTask，然后无论当前线程数如何（比如大于核心线程数），队列情况如何（比如队列没满），都会尝试从队列中获取 task 去消费。

getTask()

我们看看 getTask() 是怎么获取任务的，这个方法写得真的很好，每一行都很简单，组合起来却所有的情况都想好了：

// 此方法有三种可能：
// 1. 阻塞直到获取到任务返回。我们知道，默认 corePoolSize 之内的线程是不会被回收的，
//    它们会一直等待任务
// 2. 超时退出。keepAliveTime 起作用的时候，也就是如果 keepAliveTime 时间内都没有任务，那么应该执行关闭
// 3. 如果发生了以下条件，此方法必须返回 null:
//    - 线程池处于 SHUTDOWN，而且 workQueue 是空的，前面说了，这种不再接受新的任务
//    - 线程池处于 STOP，不仅不接受新的线程，连 workQueue 中的线程也不再执行
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?
  
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // 两种可能
        // 1. rs == SHUTDOWN && workQueue.isEmpty()
        // 2. rs >= STOP
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            // CAS 操作，减少工作线程数
            decrementWorkerCount();
            return null;
        }
        boolean timed;      // Are workers subject to culling?
        for (;;) {
            int wc = workerCountOf(c);
            // 允许核心线程数内的线程回收，或当前线程数超过了核心线程数，那么有可能发生超时关闭
            timed = allowCoreThreadTimeOut || wc > corePoolSize;
            // 这里 break，是为了不往下执行后一个 if (compareAndDecrementWorkerCount(c))
            // 两个 if 一起看：如果当前线程数 wc > maximumPoolSize，或者超时，都返回 null
            // 那这里的问题来了，wc > maximumPoolSize 的情况，为什么要返回 null？
            //    换句话说，返回 null 意味着关闭线程。
            // 那是因为有可能开发者调用了 setMaximumPoolSize 将线程池的 maximumPoolSize 调小了
            if (wc <= maximumPoolSize && ! (timedOut && timed))
                break;
            if (compareAndDecrementWorkerCount(c))
                return null;
            c = ctl.get();  // Re-read ctl
            // compareAndDecrementWorkerCount(c) 失败，线程池中的线程数发生了改变
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
        // wc <= maximumPoolSize 同时没有超时
        try {
            // 到 workQueue 中获取任务
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) ://限时获取任务
                workQueue.take();//无限等待获取任务
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            // 如果此 worker 发生了中断，采取的方案是重试
            // 解释下为什么会发生中断，这个读者要去看 setMaximumPoolSize 方法，
            // 如果开发者将 maximumPoolSize 调小了，导致其小于当前的 workers 数量，
            // 那么意味着超出的部分线程要被关闭。重新进入 for 循环，自然会有部分线程会返回 null
            timedOut = false;
        }
    }
}

Worke r被创建出来后，就会不断地进行轮询，然后获取任务去执行，核心线程可以无限等待获取任务，非核心线程要限时获取任务。当 Worker 无法获取到任务，也就是获取的任务为空时，循环会结束，Worker 会主动消除自身在线程池内的引用（ JVM 回收）。

非核心线程要限时（keepAliveTime）阻塞获取任务，这里非常的关键。当线程数大于核心线程时，并且队列为空时，该线程就会阻塞，在 keepAliveTime 时间后，还获取不到任务的话，就会返回空。返回空意味着跳出 runWorker() 方法（跳出 worker 死循环），并且执行 processWorkerExit(w, completedAbruptly) 方法处理退出程序…

到这里，基本上也说完了整个流程

关于线程池关闭

线程池中线程的销毁依赖 JVM 自动的回收，线程池做的工作是根据当前线程池的状态维护一定数量的线程引用，防止这部分线程被 JVM 回收，当线程池决定哪些线程需要回收时，只需要将其引用消除即可。

processWorkerExit()

我们再看看上述方法提到的线程退出的时候执行的方法

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 {
        // 计算线程池完成的任务个数，并从 worke r线程集中删除当前 worker 线程
        completedTaskCount += w.completedTasks;
        workers.remove(w);//importtant
    } finally {
        mainLock.unlock();
    }
    // 尝试把线程池的状态设置为 TERMINATED，该方法在后面分析
    tryTerminate();

    int c = ctl.get();
    // 线程池状态至少为 STOP
    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(null, false);
    }
}

tryTerminate ()

这个方法是每次线程退出的时候就触发，尝试判断线程池是否可以 Terminate

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        // 如果处于下面三种任意一种情况，就不能把线程池的状态设为 TERMINATED
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
        // 代码执行到这里，说明有资格终止了。但是如果这个时候线程个数非 0，就中断一个空闲的线程来确保 shutdown 信号传播
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);//todo 为什么only one
            return;
        }

        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
    }
}

到这里，你可能会有疑问，interruptIdleWorkers(ONLY_ONE)，为什么只中断一个 idle 线程，甚至还不知道 interrupt 的意义是什么。先别急，我下面会说到。

shutdown()

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        // 权限校验
        checkShutdownAccess();
        // 设置线程池状态为 SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 中断空闲线程
        interruptIdleWorkers();//only one
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    // 尝试设置线程池状态为 TERMINATED
    tryTerminate();
}

我当时在学习这个方法的源码时，有这样一个疑问：调用这个方法后，线程是如何一个个减少的,直到线程数为 0 的?

可以看到，调用了interruptIdleWorkers() 再来看看该方法干了什么

interruptIdleWorkers()

private void interruptIdleWorkers(boolean onlyOne) {
    //获得锁
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //遍历workers
        for (Worker w : workers) {
            Thread t = w.thread;
            //获得AQS的锁，如果能获得AQS的锁且不处于中断状态则进行中断
            if (!t.isInterrupted() && w.tryLock()) {
                try {
                   //调用线程的中断方法
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                   //worker的AQS解锁
                    w.unlock();
                }
            }
            //是否只执行1次的标识
            if (onlyOne)
                break;
        }
    } finally {
        //解锁
        mainLock.unlock();
    }
}

调用中断的时候，需要回去两层锁，一层是 mainLock，另外一层是线程的 AQS 锁，如果被占用则该线程不会被打断。这样一来就可以明白，再最开始刚创建的 worker 是不会被打断的，另外处于工作中的线程也不会被打算，只有 wait 状态的(也就是 getTask 阻塞中) worker 才会被打断。

问题又来了, t.interrupt()打断意味着什么?

意味着阻塞中的或者正在运行的线程会抛出 InterruptException ，也就是说队列为空时(代表已经执行完所有任务)，getTask()方法返回了空，返回空也就是会执行 processWorkerExit() 线程退出

又由于 processWorkerExit() 方法都会调用 tryTerminate () 方法（尝试停止整个线程池，正常情况下，线程池是不会被停止的），当线程为 0 时（什么会是 0 ？线程池调用shutdown()或者shutdownNow()方法，该线程池个数会慢慢减少），最终执行 terminated() 方法，线程池终止

shutdownNow

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        // 权限校验
        checkShutdownAccess();
        // 设置线程池状态为 STOP
        advanceRunState(STOP);
        // 中断所有线程
        interruptWorkers();
        // 将任务队列中的任务移动到 tasks 中
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    // 尝试设置线程池状态为 TERMINATED
    tryTerminate();
    return tasks;
}

决绝策略

在回到最开始最重要的方法 execute()，当队列满了，会调用 reject(task)方法。那么调用这个方法干什么事。

final void reject(Runnable command) {
    // 执行拒绝策略
    handler.rejectedExecution(command, this);
}

此处的 handler 我们需要在构造线程池的时候就传入这个参数，它是 RejectedExecutionHandler 的实例。

RejectedExecutionHandler 在 ThreadPoolExecutor 中有四个已经定义好的实现类可供我们直接使用，当然，我们也可以实现自己的策略，不过一般也没有必要。

// 只要线程池没有被关闭，那么由提交任务的线程自己来执行这个任务。
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {//线程没有被关闭
            r.run();//
        }
    }
}
// 不管怎样，直接抛出 RejectedExecutionException 异常
// 这个是默认的策略，如果我们构造线程池的时候不传相应的 handler 的话，那就会指定使用这个
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()) {
            //获取对头task,什么都不干
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

到这里，ThreadPoolExecutor 的重要源码算是分析结束了。单纯从源码的难易程度来说，ThreadPoolExecutor 的源码还算是比较简单的（至少比 ForkJoinPool 的源码好理解 /手动捂脸），结合源码解释理解，问题不大…

最后，给大家介绍一遍关于线程池原理解析的文章，写的是真的好！美团技术网站