Java源码分析--java.util.concurrent.ThreadPoolExecutor

声明：该博文大部分摘自JoonWhee的博客

文章链接：Java并发：线程池详解（ThreadPoolExecutor）

基础知识

• 进程与线程、并行与并发

  进程：每个进程都有独立的代码和空间，例如QQ和WeChat
  线程：程序执行运算的最小单位，在同一进程中共享资源
  并发：在同一时刻，一个cpu只能执行一个线程，但是速度快，它可以快速的在线程间切换
  并行：多个cpu同时执行一段代码，达到真正意义上的并行

• 线程的使用

//使用以下两种方式，并重写run方法:
public class MyThread extends Thread;
public class MyThread implements Runnable;
/*-------------------------------------------------------------*/
//带返回值的线程
Callable ca2 = new Callable(){
        @Override
        public Object call() throws Exception {
            return null;
    }
};
FutureTask<String> ft2 = new FutureTask<String>(ca2);
new Thread(ft2).start();//启动线程
ft2.get();//获取线程返回结果，如果线程还未返回，则阻塞直至返回

线程池

• 线程池的简介

  定义：管理一组同构工作线程的资源池。
  特性：重用线程。
  意义：避免频繁的线程构建与销毁，提升运行速度。

• 基础属性，参考 JoonWhee：Java并发：线程池详解（ThreadPoolExecutor）

/**
 * ctl低29位表示 workerCount ：有效的线程数量；
 * ctl高3位表示runState：运行状态，运行，关闭等
 */
// 初始化时有效的线程数为0, 此时ctl为: 1010 0000 0000 0000 0000 0000 0000 0000 
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); 
// 高3位用来表示运行状态，此值用于运行状态向左移动的位数，即29位（Integer.SIZE=32）
private static final int COUNT_BITS = Integer.SIZE - 3;     
// 线程数容量，低29位表示有效的线程数, 0001 1111 1111 1111 1111 1111 1111 1111
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

/**
 * 大小关系：RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED，
 * 源码中频繁使用大小关系来作为条件判断。
 * 1010 0000 0000 0000 0000 0000 0000 0000 运行
 * 0000 0000 0000 0000 0000 0000 0000 0000 关闭
 * 0010 0000 0000 0000 0000 0000 0000 0000 停止
 * 0100 0000 0000 0000 0000 0000 0000 0000 整理
 * 0110 0000 0000 0000 0000 0000 0000 0000 终止
 */
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; // 终止

/**
 * 功能：获取运行状态
 * @param c：ctl值
 * @return runState（运行状态）
 */
private static int runStateOf(int c)     { return c & ~CAPACITY; }  
/**
 * 功能：获取当前线程数量
 * @param c：ctl值
 * @return：workerCount（当前线程数量）
 */
private static int workerCountOf(int c)  { return c & CAPACITY; }   
/**
 * 功能：获取ctl值
 * @param rs：运行状态值(runState)
 * @param wc：当前线程数量(workerCount)
 */
private static int ctlOf(int rs, int wc) { return rs | wc; }    

// 状态c是否小于s
private static boolean runStateLessThan(int c, int s) { 
    return c < s;
}
// 状态c是否大于等于s
private static boolean runStateAtLeast(int c, int s) {
    return c >= s;
}
// 状态c是否为RUNNING（小于SHUTDOWN的状态只有RUNNING）
private static boolean isRunning(int c) {
    return c < SHUTDOWN;
}

// 使用CAS增加一个有效的线程
private boolean compareAndIncrementWorkerCount(int expect) {    
    return ctl.compareAndSet(expect, expect + 1);
}

// 使用CAS减少一个有效的线程
private boolean compareAndDecrementWorkerCount(int expect) {    
    return ctl.compareAndSet(expect, expect - 1);
}

// 减少一个有效的线程
private void decrementWorkerCount() {
    do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}

/** 工作队列：
  * ArrayBlockingQueue：列表形式的工作队列，必须要有初始队列大小，有界队列，先进先出。
  * LinkedBlockingQueue：链表形式的工作队列，可以选择设置初始队列大小，有界/无界队列，先进先出。
  * SynchronousQueue：SynchronousQueue不是一个真正的队列，而是一种在线程之间移交的机制。要将一个元素放入SynchronousQueue中, 必须有另一个线程正在等待接受这个元素. 如果没有线程等待，并且线程池的当前大小小于最大值，那么ThreadPoolExecutor将创建 一个线程, 否则根据饱和策略，这个任务将被拒绝。使用直接移交将更高效，因为任务会直接移交给执行它的线程，而不是被首先放在队列中, 然后由工作者线程从队列中提取任务。只有当线程池是无解的或者可以拒绝任务时，SynchronousQueue才有实际价值。
  * PriorityBlockingQueue：优先级队列，有界队列，根据优先级来安排任务，任务的优先级是通过自然顺序或Comparator（如果任务实现了Comparator）来定义的。
  * DelayedWorkQueue：延迟的工作队列，无界队列。
  */
private final BlockingQueue<Runnable> workQueue;    

// 锁
private final ReentrantLock mainLock = new ReentrantLock(); 

// 包含线程池中的所有工作线程,只有在mainLock的情况下才能访问,Worker集合
private final HashSet<Worker> workers = new HashSet<Worker>();

private final Condition termination = mainLock.newCondition();

// 跟踪线程池的最大到达大小，仅在mainLock下访问
private int largestPoolSize;

// 总的完成的任务数
private long completedTaskCount;

/**
  * 线程工厂，用于创建线程
  * DefaultThreadFactory：默认线程工厂，创建一个新的、非守护的线程，并且不包含特殊的配置信息。
  * PrivilegedThreadFactory：通过这种方式创建出来的线程，将与创建privilegedThreadFactory的线程拥有相同的访问权限、 AccessControlContext、ContextClassLoader。如果不使用privilegedThreadFactory， 线程池创建的线程将从在需要新线程时调用execute或submit的客户程序中继承访问权限。
  * 自定义线程工厂：可以自己实现ThreadFactory接口来定制自己的线程工厂方法。
  */
private volatile ThreadFactory threadFactory;

/**
  * (饱和)拒绝策略
  * AbortPolicy：中止策略。默认的饱和策略，抛出未检查的RejectedExecutionException。调用者可以捕获这个异常，然后根据需求编写自己的处理代码。
  * DiscardPolicy：抛弃策略。当新提交的任务无法保存到队列中等待执行时，该策略会悄悄抛弃该任务。
  * DiscardOldestPolicy：抛弃最旧的策略。当新提交的任务无法保存到队列中等待执行时，则会抛弃下一个将被执行的任务，然后尝试重新提交新的任务。（如果工作队列是一个优先队列，那么“抛弃最旧的”策略将导致抛弃优先级最高的任务，因此最好不要将“抛弃最旧的”策略和优先级队列放在一起使用）。
  * CallerRunsPolicy：调用者运行策略。该策略实现了一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者（调用线程池执行任务的主线程），从而降低新任务的流程。
  *    它不会在线程池的某个线程中执行新提交的任务，而是在一个调用了execute的线程中执行该任务。当线程池的所有线程都被占用，并且工作队列被填满后，下一个任务会在调用execute时在主线程中执行（调用线程池执行任务的主线程）。
  *    由于执行任务需要一定时间，因此主线程至少在一段时间内不能提交任务，从而使得工作者线程有时间来处理完正在执行的任务。在这期间，主线程不会调用accept，因此到达的请求将被保存在TCP层的队列中。如果持续过载，那么TCP层将最终发现它的请求队列被填满，因此同样会开始抛弃请求。
  *    当服务器过载后，这种过载情况会逐渐向外蔓延开来——从线程池到工作队列到应用程序再到TCP层，最终达到客户端，导致服务器在高负载下实现一种平缓的性能降低。
  */
private volatile RejectedExecutionHandler handler;

/**
 * 线程超时时间，当线程数超过corePoolSize时生效, 
 * 如果有线程空闲时间超过keepAliveTime, 则会被终止
 */
private volatile long keepAliveTime;    

// 是否允许核心线程超时，默认false，false情况下核心线程会一直存活。
private volatile boolean allowCoreThreadTimeOut;

// 核心线程数：当前线程池中线程数小于corePoolSize时，即使有线程空闲，依然创建新的线程执行任务
private volatile int corePoolSize;

// 最大线程数
private volatile int maximumPoolSize;

// 默认饱和策略（拒绝策略）, 抛异常
private static final RejectedExecutionHandler defaultHandler = 
    new AbortPolicy();

private static final RuntimePermission shutdownPerm =
    new RuntimePermission("modifyThread");

/**
 * Worker类，每个Worker包含一个线程、一个初始任务、一个任务计算器
 */
private final class Worker   
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    private static final long serialVersionUID = 6138294804551838833L;

    final Thread thread;    // Worker对应的线程
    Runnable firstTask; // 运行的初始任务。
    volatile long completedTasks;   // 每个线程的任务计数器

    Worker(Runnable firstTask) {
        setState(-1); // 禁止中断，直到runWorker
        this.firstTask = firstTask; // 设置为初始任务
        // 使用当前线程池的线程工厂创建一个线程
        this.thread = getThreadFactory().newThread(this);  
    }

    // 将主运行循环委托给外部runWorker
    public void run() {
        runWorker(this);
    }

    // Lock methods
    //
    // The value 0 represents the unlocked state.
    // The value 1 represents the locked state.
    /**
     * 通过AQS的同步状态来实现锁机制。state为0时代表锁未被获取（解锁状态），
     * state为1时代表锁已经被获取（加锁状态）。
     */
    protected boolean isHeldExclusively() { // 
        return getState() != 0; 
    }
    protected boolean tryAcquire(int unused) {  // 尝试获取锁
        if (compareAndSetState(0, 1)) { // 使用CAS尝试将state设置为1，即尝试获取锁
            // 成功将state设置为1，则当前线程拥有独占访问权
            setExclusiveOwnerThread(Thread.currentThread());    
            return true;
        }
        return false;
    }
    protected boolean tryRelease(int unused) {  // 尝试释放锁
        setExclusiveOwnerThread(null);  // 释放独占访问权：即将独占访问线程设为null
        setState(0);    // 解锁：将state设置为0
        return true;
    }
    public void lock()        { acquire(1); }   // 加锁
    public boolean tryLock()  { return tryAcquire(1); } // 尝试加锁
    public void unlock()      { release(1); }   // 解锁
    public boolean isLocked() { return isHeldExclusively(); }  // 是否为加锁状态 
    void interruptIfStarted() { // 如果线程启动了，则进行中断
        Thread t;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

• 工作机制

1. 默认情况下，创建完线程池后并不会立即创建线程, 而是等到有任务提交时才会 创建线程来进行处理。（除非调用prestartCoreThread或prestartAllCoreThreads方法）
2. 当线程数小于核心线程数时，每提交一个任务就创建一个线程来执行，即使当前有线程处于空闲状态，直到当前线程数达到核心线程数。
3. 当前线程数达到核心线程数时，如果这个时候还提交任务，这些任务会被放到队列里，等到线程处理完了手头的任务后，会来队列中取任务处理。
4. 当前线程数达到核心线程数并且队列也满了，如果这个时候还提交任务，则会继续创建线程来处理，直到线程数达到最大线程数。
5. 当前线程数达到最大线程数并且队列也满了，如果这个时候还提交任务，则会触发饱和策略。
6. 如果某个线程的控线时间超过了keepAliveTime，那么将被标记为可回收的，并且当前线程池的当前大小超过了核心线程数时，这个线程将被终止。

• 一些方法

// 使用submit提交时，会运行该方法
public void execute(Runnable command) {
    if (command == null)    // 为空校验
        throw new NullPointerException();

    int c = ctl.get();  // 拿到当前的ctl值
    if (workerCountOf(c) < corePoolSize) {  // 如果有效的线程数小于核心线程数
        if (addWorker(command, true))   // 则新建一个线程来处理任务（核心线程还不够，创建核心线程）
            return;
        c = ctl.get();  // 拿到当前的ctl值
    }
    // 走到这里说明有效的线程数已经 >= 核心线程数
    if (isRunning(c) && workQueue.offer(command)) {// 如果当前状态是运行, 尝试将任务放入工作队列
        int recheck = ctl.get();    // 再次拿到当前的ctl值
        // 如果再次检查状态不是运行, 则将刚才添加到工作队列的任务移除
        if (! isRunning(recheck) && remove(command)) 
            reject(command);    // 并调用拒绝策略
        else if (workerCountOf(recheck) == 0) // 如果再次检查时,有效的线程数为0, 
            addWorker(null, false); // 则新建一个线程(核心线程已满，创建非核心线程)
    }
    // 走到这里说明工作队列已满
    else if (!addWorker(command, false))//尝试新建一个线程来处理任务(非核心)
        reject(command);    // 如果失败则调用拒绝策略
}


/**
 * 添加一个Worker，Worker包含一个线程和一个任务，由这个线程来执行该任务。
 */
private boolean addWorker(Runnable firstTask, boolean core) {   
    retry:
    for (;;) {
        int c = ctl.get();  // c赋值为ctl
        int rs = runStateOf(c); // rs赋值为运行状态
        /**
         * 1.如果池停止或有资格关闭，则此方法返回false；
         * 如果线程工厂在被询问时未能创建线程，它也返回false。 
         * 包括以下5种情况：
         * 1).rs为RUNNING，通过校验。
         * 2).rs为STOP或TIDYING或TERMINATED，返回false。
         * （STOP、TIDYING、TERMINATED：已经停止进入最后清理终止，不接受任务不处理队列任务）
         * 3).rs为SHUTDOWN，提交的任务不为空，返回false。
         * （SHUTDOWN：不接受任务但是处理队列任务，因此任务不为空返回false）
         * 4).rs为SHUTDOWN，提交的任务为空，并且工作队列为空，返回false。
         * （状态为SHUTDOWN、提交的任务为空、工作队列为空，则线程池有资格关闭，直接返回false）
         * 5).rs为SHUTDOWN，提交的任务为空，并且工作队列不为空，通过校验。
         * （因为SHUTDOWN状态下刚好可以处理队列任务）
         * ps:shutdown可以看作一个缓冲期，在此期间内，不再接任务，等待手里的任务结束后关门
         */
        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;
            // 使用CAS将workerCount+1, 修改成功则跳出循环，否则进入下面的状态判断
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // 重新读取ctl
            // 判断当前运行状态，如果不等于上面获取的运行状态rs，
            // 说明rs被其他线程修改了，跳到retry重新校验线程池状态
            if (runStateOf(c) != rs)
                continue retry;
            // 走到这里说明compareAndIncrementWorkerCount失败; 
            // 重试内部循环（状态没变，则继续内部循环，尝试使用CAS修改workerCount）
        }
    }

    boolean workerStarted = false;  // Worker的线程是否启动
    boolean workerAdded = false;    // Worker是否成功增加
    Worker w = null;
    try {
        w = new Worker(firstTask);  // 用firstTask和当前线程创建一个Worker
        final Thread t = w.thread;  // 拿到Worker对应的线程
        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并且firstTask为空，则通过校验
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive())    // 预先校验线程是可以启动的
                        throw new IllegalThreadStateException();
                    workers.add(w); // 将刚创建的worker添加到工作者列表
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {  // 如果Worker添加成功，则启动线程执行
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)    // 如果Worker的线程没有成功启动
            addWorkerFailed(w); // 则进行回滚, 移除之前添加的Worker
    }
    return workerStarted;
}


/**
 * Rolls back the worker thread creation.
 * - removes worker from workers, if present
 * - decrements worker count
 * - rechecks for termination, in case the existence of this
 *   worker was holding up termination
 */
private void addWorkerFailed(Worker w) {    // 回滚Worker的添加，就是将Worker移除
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (w != null)
            workers.remove(w);  // 移除Worker
        decrementWorkerCount(); // 有效线程数-1
        tryTerminate(); // 有worker线程移除，可能是最后一个线程退出需要尝试终止线程池
    } finally {
        mainLock.unlock();
    }
}

/**
 * Worker的线程开始执行任务
 */
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread(); // 获取当前线程
    Runnable task = w.firstTask;    // 拿到Worker的初始任务
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;   // Worker是不是因异常而死亡
    try {
        while (task != null || (task = getTask()) != null) {// Worker取任务执行，第一执行自己的firstTask，之后从队列中拿task，直至getTask返回null
            w.lock();   // 加锁
            /**如果线程池停止，确保线程中断; 如果不是，确保线程不被中断。
             * 在第二种情况下进行重新检查，以便在清除中断的同时处理shutdownNow竞争
             * 线程池停止指运行状态为STOP/TIDYING/TERMINATED中的一种
             */
            if ((runStateAtLeast(ctl.get(), STOP) ||    // 判断线程池运行状态
                 (Thread.interrupted() &&   // 重新检查
                  runStateAtLeast(ctl.get(), STOP))) && // 再次判断线程池运行状态
                !wt.isInterrupted())// 走到这里代表线程池运行状态为停止,检查wt是否中断
                wt.interrupt(); // 线程池的状态为停止并且wt不为中断, 则将wt中断
            try {
                beforeExecute(wt, task);// 执行beforeExecute（默认空，需要自己重写）
                Throwable thrown = null;
                try {
                    task.run(); // 执行任务
                } catch (RuntimeException x) {
                    thrown = x; throw x; //如果抛异常,则completedAbruptly为true
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    afterExecute(task, thrown);// 执行afterExecute（需要自己重写）
                }
            } finally {
                task = null;    // 将执行完的任务清空
                w.completedTasks++; // Worker完成任务数+1
                w.unlock();
            }
        }
        completedAbruptly = false;  // 如果执行到这里，则worker是正常退出
    } finally {
        processWorkerExit(w, completedAbruptly);// 调用processWorkerExit方法
    }
}

/**
  * 返回null的情况：当前线程可以被移除 && keepAliveTime时间内获取不到任务
  */
private Runnable getTask() {    // Worker从工作队列获取任务
    boolean timedOut = false; // poll方法取任务是否超时

    for (;;) {  // 无线循环
        int c = ctl.get();  // ctl
        int rs = runStateOf(c); // 当前运行状态

        // 如果线程池运行状态为停止，或者可以停止（状态为SHUTDOWN并且队列为空）
        // 则返回null，代表当前Worker需要移除
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {    
            decrementWorkerCount(); // 将workerCount - 1
            // 返回null前将workerCount - 1,
            // 因此processWorkerExit中completedAbruptly＝false时无需再减
            return null;
        }

        int wc = workerCountOf(c);  // 当前的workerCount

        /** 
          * 判断当前线程有无超时时间（即是否可以被移除）
          * 如果 allowCoreThreadTimeOut = True：所有线程都有超时时间
          * 如果 workerCount > corePoolSize：当前线程是有超时时间的
          */ 
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;    

        // 如果wc超过最大线程数 或者 当前线程会超时并且已经超时，
        // 并且wc > 1 或者 工作队列为空，则返回null，代表当前Worker需要移除
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {   // 确保有Worker可以移除 
            if (compareAndDecrementWorkerCount(c))
                // 返回null前将workerCount - 1，
                // 因此processWorkerExit中completedAbruptly＝false时无需再减
                return null;    
            continue;
        }

        try {
            // 根据线程是否会超时调用相应的方法，poll为带超时的获取任务方法，keepAliveQueue时间内获取不到任务，就返回null
            // take()为不带超时的获取任务方法，会 一直阻塞 直到获取到任务
            Runnable r = timed ? 
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;    // 走到这代表当前线程获取任务超时
        } catch (InterruptedException retry) {
            timedOut = false;   // 被中断
        }
    }
}


private void processWorkerExit(Worker w, boolean completedAbruptly) {   // Worker的退出
    // 如果Worker是异常死亡（completedAbruptly=true），则workerCount-1；
    // 如果completedAbruptly为false的时候（正常超时退出），则代表task=getTask()等于null，
    // getTask()方法中返回null的地方，都已经将workerCount - 1，所以此处无需再-1
    if (completedAbruptly) 
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();    // 加锁
    try {
        completedTaskCount += w.completedTasks; // 该Worker完成的任务数加到总完成的任务数
        workers.remove(w);  // 移除该Worker
    } finally {
        mainLock.unlock();
    }

    tryTerminate(); // 有Worker线程移除，可能是最后一个线程退出，需要尝试终止线程池

    int c = ctl.get();  // 获取当前的ctl
    if (runStateLessThan(c, STOP)) {  // 如果线程池的运行状态还没停止（RUNNING或SHUTDOWN）
        if (!completedAbruptly) {   // 如果Worker不是异常死亡
            // min为线程池的理论最小线程数:如果允许核心线程超时则min为0,否则min为核心线程数
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;    
            // 如果min为0,工作队列不为空,将min设置为1,确保至少有1个Worker来处理队列里的任务 
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            // 当前有效的线程数>=min，直接返回;
            if (workerCountOf(c) >= min)
                return; // replacement not needed 
            // 如果代码走到这边，代表workerCountOf(c) < min，此时会走到下面的addWorker方法。
            // 通过getTask方法我们知道，当allowCoreThreadTimeOut为false
            // 并且workerCount<=corePoolSize时，是不会走到processWorkerExit方法的。
            // 因此走到这边只可能是当前移除的Worker是最后一个Worker，但是此时工作
            // 队列还不为空，因此min被设置成了1，所以需要在添加一个Worker来处理工作队列。
        }
        addWorker(null, false); // 添加一个Worker
    }
}


final void tryTerminate() { // 尝试终止线程池
    for (;;) {
        int c = ctl.get();
        // 只有当前状态为STOP 或者 SHUTDOWN并且队列为空，才会尝试整理并终止
        // 1: 当前状态为RUNNING，则不尝试终止，直接返回
        // 2: 当前状态为TIDYING或TERMINATED，代表有其他线程正在执行终止，直接返回
        // 3: 当前状态为SHUTDOWN 并且 workQueue不为空，则不尝试终止，直接返回
        if (isRunning(c) || // 1
            runStateAtLeast(c, TIDYING) ||  // 2
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))   // 3
            return;
        // 走到这代表线程池可以终止（通过上面的校验）
        // 如果此时有效线程数不为0， 将中断一个空闲的Worker，以确保关闭信号传播
        if (workerCountOf(c) != 0) { // Eligible to terminate 
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();    // 加锁，终止线程池
        try {
            // 使用CAS将ctl的运行状态设置为TIDYING，有效线程数设置为0
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {  
                try {
                    terminated();   // 供用户重写的terminated方法，默认为空
                } finally {
                    // 将ctl的运行状态设置为TERMINATED，有效线程数设置为0
                    ctl.set(ctlOf(TERMINATED, 0));  
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}