深入理解Java并发编程（四）：ThreadPoolExecutor分析

前言

ThreadPoolExecutor的构造参数、饱和策略等已在深入理解Java并发编程（三）：线程池中介绍过了。本篇主要通过源码，分析ThreadPoolExecutor的执行流程。

执行流程

1、如果线程池中的线程数量少于核心线程数corePoolSize，就新建核心线程来执行新添加的任务；

2、如果线程池中的线程数量大于等于核心线程数corePoolSize，但队列workQueue未满，则将新添加的任务放到workQueue中；

3、如果线程池中的线程数量大于等于核心线程数corePoolSize，且队列workQueue已满，但线程池中的线程数量小于最大线程数maximumPoolSize，则新建非核心线程来处理被添加的任务；

4、如果线程池中的线程数量等于maximumPoolSize，就用RejectedExecutionHandler来执行拒绝策略。

线程池状态

    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

    // Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

其中ctl这个AtomicInteger原子操作类的功能很强大，其高3位用于维护线程池运行状态，低29位维护线程池中线程数量。

1、RUNNING：-1<<COUNT_BITS，即高3位为111，低29位为0，该状态的线程池会接收新任务，也会处理在阻塞队列中等待处理的任务；

2、SHUTDOWN：0<<COUNT_BITS，即高3位为000，低29位为0，该状态的线程池不会再接收新任务，但还是会处理已经提交到阻塞队列中等待处理的任务；

3、STOP：1<<COUNT_BITS，即高3位为001，低29位为0，该状态的线程池不会再接收新任务，不会处理在阻塞队列中等待的任务，而且还会中断正在运行的任务；

4、TIDYING：2<<COUNT_BITS，即高3位为010，低29位为0，所有任务都被终止了，线程数量workerCount为0，为此状态时还将调用terminated()方法，terminated()方法由子类实现；

5、TERMINATED：3<<COUNT_BITS，即高3位为011，低29位为0，terminated()方法调用完成后变成此状态。

这些状态均由int型表示，大小关系为 RUNNING<SHUTDOWN<STOP<TIDYING<TERMINATED，这个顺序基本上也是遵循线程池从运行到终止这个过程。

runStateOf(int c)方法：c & 高3位为1，低29位为0的~CAPACITY，用于获取高3位保存的线程池状态。

workerCountOf(int c)方法：c & 高3位为0，低29位为1的CAPACITY，用于获取低29位的线程数量。

ctlOf(int rs, int wc)方法：参数rs表示runState，参数wc表示workerCount，即根据runState和workerCount打包合并成ctl。

任务提交

execute()：必须实现Runnable接口，该方式提交的任务不能获取返回值，因此无法判断任务是否执行成功。

submit()：可以获取任务执行完的返回值。

任务执行

execute()：提交任务

public void execute(Runnable command) {
        if (command == null)// 任务不能为NULL，否则抛空指针异常
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        // 1、判断线程数是否小于核心线程数
        // 若小于，则新建核心线程执行当前任务
        // 若线程数不小于核心线程数或者新建核心线程失败，则进行后续操作
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 2、判断线程池是否处于RUNNING状态，并且是否入队成功
        if (isRunning(c) && workQueue.offer(command)) {
            // 进行双重校验
            int recheck = ctl.get();
            // 若线程池状态不为RUNNING，且成功将任务从队列中移除，则拒绝当前任务
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)// 若线程数量为0，则新建一个没有初始任务的非核心线程
                addWorker(null, false);
        }
        // 3、若线程池不处于RUNNING状态，或者入队失败，则尝试开启一个新的非核心线程
        // 若开启新的非核心线程失败，则拒绝当前任务
        else if (!addWorker(command, false))
            reject(command);
    }

参数：

-- command：提交执行的任务，不能为空。

1、如果线程池当前线程数量少于核心线程数，则addWorker(command, true)创建核心线程，如创建成功则返回，如没创建成功，则执行后续步骤；这里addWorker(command, true)失败可能有以下两种原因（可以从addWorker代码中分析得出）：

（1）线程池已经SHUTDOWN，SHUTDOWN的线程池不再接收新任务；

（2）由于并发，别的线程先创建了worker线程，导致线程数量大于或者等于核心线程数。

2、如果线程池还在RUNNING状态，将任务加入workQueue阻塞队列中，如果加入成功，进行双重校验，如果加入失败（可能是队列已满），则执行后续步骤；双重校验主要目的是判断刚加入workQueue阻塞队列的任务是否能被执行。

3、如果线程池不是RUNNING状态或者无法入队列，尝试开启新线程，扩容至最大线程数量，如果addWork(command, false)失败了，则拒绝当前任务。

addWorker()：添加worker线程

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        // 判断线程池状态
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            // 当线程池状态至少为SHUTDOWN，且以下三个条件任意一个为false时，则返回false，拒绝创建新的worker
            // 1、rs == SHUTDOWN的false情况：线程池状态已经超过shutdown，可能是stop、tidying、terminated其中一个，即线程池已经终止
            // 2、firstTask == null的false情况：firstTask不为空，场景是在线程池已经shutdown后，还要添加新的任务，拒绝
            // 3、!workQueue.isEmpty()的false情况：workQueue为空，且rs >= SHUTDOWN，那么就没有添加新worker线程的必要了
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                // 这里判断线程数量是否超过边界，根据参数true or false来选择corePoolSize or maximumPoolSize，若超过边界，则拒绝任务
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                // 这里若成功将将线程数量+1，则跳出retry循环
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                // 若没有成功将线程数量+1，则判断线程状态是否有改变，若改变了，则跳到外层循环重新执行之前的流程，若状态没有改变，则继续内层循环
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
        // worker数量+1成功的后续操作，添加到workers Set集合，并启动worker线程
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            // 1、设置worker这个AQS锁的同步状态state=-1
            // 2、将firstTask设置给worker的成员变量firstTask
            // 3、使用worker自身这个runnable，调用ThreadFactory创建一个线程，并设置给worker的成员变量thread
            w = new Worker(firstTask);
            final Thread t = w.thread;
            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==null（可能是workQueue中仍有未执行完成的任务，创建没有初始任务的worker线程执行）
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        // 线程已经启动，抛非法线程状态异常
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    // 释放锁
                    mainLock.unlock();
                }
                if (workerAdded) {
                    // 启动线程
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            // 若启动线程失败，将worker从workers中移除，worker数量-1，并尝试中断线程
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

参数：

-- firstTask：worker线程的初始任务，可以为空。

-- core：true，将corePoolSize作为上限；false，将maximumPoolSize作为上限。

1、判断线程池当前是否为可以添加worker线程的状态，可以则继续下一步，不可以return false；

2、线程池当前线程数量是否超过上限（corePoolSize或maximumPoolSize），超过了return false，没超过则对workerCount+1，继续下一步；

3、在线程池的ReentrantLock保证下，向Workers Set中添加新创建的worker实例，添加完成后解锁，并启动worker线程，如果这一切都成功了，return true，如果添加worker入Set失败或启动失败，调用addWorkerFailed()逻辑进行回滚。

Worker

/**
 * Worker继承了AQS，实现了Runnable，说明其既是一个可运行的任务，也是一把锁（不可重入）
 */
private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /**
         * This class will never be serialized, but we provide a
         * serialVersionUID to suppress a javac warning.
         */
        private static final long serialVersionUID = 6138294804551838833L;

        /** Thread this worker is running in.  Null if factory fails. */
        final Thread thread;
        /** Initial task to run.  Possibly null. */
        Runnable firstTask;
        /** Per-thread task counter */
        volatile long completedTasks;

        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            // 设置AQS的同步状态，是一个计数器，大于0代表锁已经被获取
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** Delegates main run loop to outer runWorker  */
        public void run() {
            runWorker(this);
        }

        // Lock methods
        //
        // The value 0 represents the unlocked state.
        // The value 1 represents the locked state.

        protected boolean isHeldExclusively() {
            return getState() != 0;
        }

        /**
         * 尝试获取锁
         * 重写AQS的tryAcquire()，AQS本来就是让子类来实现的
         */
        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        /**
         * 尝试释放锁
         */
        protected boolean tryRelease(int unused) {
            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(); }

       /**
        * 中断（如果运行）
        * shutdownNow时会循环对worker线程执行
        * 且不需要获取worker锁，即使在worker运行时也可以中断
        */
        void interruptIfStarted() {
            Thread t;
            // 如果state>=0、t!=null、且t没有被中断
            // new Worker()时state==-1，说明不能中断
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

Worker类继承了AbstractQueuedSynchronizer来简化在执行任务时的获取、释放锁的过程，这样防止了中断在运行中的任务，只会唤醒（中断）在等待从workQueue中获取任务的线程。

为什么不直接执行execute(command)提交的command，而要在外面包一层Worker呢？主要是为了控制中断，用AQS锁，当运行时上锁，就不能中断，TreadPoolExecutor的shutdown()方法中断前都要获取Worker锁，只有在等待从workQueue中获取任务getTask()时才能中断。Worker实现了一个简单的不可重入的互斥锁，而不是用ReentrantLock可重入锁。

runWorker()：执行任务

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        // new Worker()是state==-1，此处是调用Worker类的tryRelease()方法，将state置为0，而interruptIfStarted()中只有state>=0才允许调用中断
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                // 上锁，不是为了防止并发执行任务，而是为了在shutdown()时不终止正在运行的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
                // 确保只有在线程stop时，才会被设置中断标示，否则清除中断标示
                // 1、如果线程池状态>=stop，且当前线程没有设置中断状态，wt.interrupt()
                // 2、如果一开始判断线程池状态<stop，但Thread.interrupted()为true，即线程已经被中断，又清除了中断标示，再次判断线程池状态是否>=stop
                // 是，再次设置中断标示，wt.interrupt()
                // 否，不做操作，清除中断标示后进行后续步骤
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

1、Worker线程启动后，通过Worker类的run()方法调用runWorker(this)；

2、执行任务之前，首先worker.unlock()，将AQS的state置为0，允许中断当前worker线程；

3、开始执行firstTask，调用task.run()，在执行任务前会上锁wroker.lock()，在执行完任务后会解锁，为了防止在任务运行时被线程池一些中断操作中断；

4、在任务执行前后，可以根据业务场景自定义beforeExecute()和afterExecute()方法；

5、无论在beforeExecute()、task.run()、afterExecute()发生异常上抛，都会导致worker线程终止，进入processWorkerExit()处理worker退出的流程；

6、如正常执行完当前task后，会通过getTask()从阻塞队列中获取新任务，当队列中没有任务，且获取任务超时，那么当前worker也会进入退出流程。

getTask()：获取任务

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.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

1、首先判断是否可以满足从workQueue中获取任务的条件，不满足return null；主要从线程池状态和数量来判断是否满足：

（1）shutdown状态 + workQueue为空或stop状态，都不满足，因为被shutdown后还是要执行workQueue剩余的任务，但workQueue也为空，就可以退出了；stop状态，shutdownNow()操作会使线程池进入stop，此时不接受新任务，中断正在执行的任务，workQueue中的任务也不执行了，故return null返回；

（2）线程数量超过maximumPoolSize可能是线程池在运行时被调用了setMaximumPoolSize()被改变了大小，否则已经addWorker()成功不会超过maximumPoolSize；如果当前线程数量>corePoolSize，才会检查是否获取任务超时，这也体现了当线程数量达到maximumPoolSize后，如果一直没有新任务，会逐渐终止worker线程直到corePoolSize。

2、如果满足获取任务条件，根据是否需要定时获取调用不同方法：

（1）workQueue.poll()，如果在keepAliveTime时间内，阻塞队列还是没有任务，返回null;

（2）workQueue.take()，如果阻塞队列为空，当前线程会被挂起等待；当队列中有任务加入时，线程被唤醒，take方法返回任务。

3、在阻塞从workQueue中获取任务时，可以被interrupt()中断，代码中捕获了InterruptedException，重置timedOut为初始值false，再次执行第1步中的判断，满足就继续获取任务，不满足return null，会进入worker退出的流程。

processWorkerExit()：worker线程退出

private void processWorkerExit(Worker w, boolean completedAbruptly) {
        
        /**
         * 1、worker数量-1
         * 如果是突然终止，说明是task执行时异常情况导致，即run()方法执行时发生了异常，那么正在工作的worker线程数量需要-1
         * 如果不是突然终止，说明是worker线程没有task可执行了，不用-1，因为已经在getTask()方法中-1了
         */
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();

        /**
         * 2、从Workers Set中移除worker
         */
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 将当前线程的完成任务数量加到线程池的完成数量上
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }

        /**
         * 3、在对线程池有负效益的操作时，都需要“尝试终止”线程池
         * 主要是判断线程池是否满足终止的状态
         * 如果状态满足，但还有线程池还有线程，尝试对其发出中断响应，使其能进入退出流程
         * 没有线程了，更新状态为tidying->terminated
         */
        tryTerminate();

        /**
         * 4、是否需要增加worker线程
         * 线程池状态是running 或 shutdown
         * 如果当前线程是突然终止的，addWorker()
         * 如果当前线程不是突然终止的，但当前线程数量 < 要维护的线程数量，addWorker()
         * 故如果调用线程池shutdown()，直到workQueue为空前，线程池都会维持corePoolSize个线程，然后再逐渐销毁这corePoolSize个线程
         */
        int c = ctl.get();
        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
            }
            addWorker(null, false);
        }
    }

参数：

-- worker：要结束的worker。

-- completedAbruptly：是否突然完成（是否因为异常退出）。

1、判断是否需要将worker数量-1；

2、从Workers Set中移除worker，删除时需要上锁mainlock；

3、tryTerminate()：在对线程池有负效益的操作时，都需要“尝试终止”线程池；

4、是否需要增加worker线程，如果线程池还没有完全终止，仍需要保持一定数量的线程。

shutdown()：终止线程池，停止接收新任务，但仍执行队列中的任务

public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 判断调用者是否有权限shutdown线程池
            checkShutdownAccess();
            // CAS+循环设置线程池状态为shutdown
            advanceRunState(SHUTDOWN);
            // 中断所有空闲线程
            interruptIdleWorkers();
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

1、上锁，mainLock是线程池的主锁，是可重入锁，当要操作workers set这个保持线程的HashSet时，需要先获取mainLock，还有当要处理largestPoolSize、completedTaskCount这类统计数据时需要先获取mainLock；

2、判断调用者是否有权限shutdown线程池；

3、使用CAS操作将线程池状态设置为shutdown，shutdown之后将不再接收新任务；

4、中断所有空闲线程interruptIdleWorkers()；

5、onShutdown()，ScheduledThreadPoolExecutor中实现了这个方法，可以在shutdown()时做一些处理；

6、解锁；

7、尝试终止线程池tryTerminate()。

interruptIdleWorkers()：中断空闲线程

/** 只有当终止流程已经开始，但线程池还有worker线程时,tryTerminate()方法会做调用onlyOne为true的调用
 * （终止流程已经开始指的是：shutdown状态且workQueue为空，或者stop状态）
 * 在这种情况下，最多有一个worker被中断，为了传播shutdown信号，以免所有的线程都在等待
 * 为保证线程池最终能终止，这个操作总是中断一个空闲worker
 * 而shutdown()中断所有空闲worker，来保证空闲线程及时退出
 */
private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                // 
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

interruptIdleWorkers()首先会获取mainLock锁，因为要迭代workers set，在中断每个worker前，需要做两个判断：

1、线程是否已经被中断，是就什么都不做；

2、worker.tryLock()是否成功。

第二个判断比较重要，因为Worker类除了实现了可执行的Runnable，也继承了AQS，本身也是一把锁，tryLock()调用了Worker自身实现的tryAcquire()方法，这也是AQS规定子类需要实现的尝试获取锁的方法。tryAcquire()先尝试将AQS的state从0-->1，返回true代表上锁成功，并设置当前线程为锁的拥有者。可以看到compareAndSetState(0, 1)只尝试了一次获取锁，且不是每次state+1，而是0-->1，说明锁不是可重入的。

tryTerminated()：尝试终止线程池

final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
            /**
             * 线程池是否需要终止
             * 如果以下3中情况任一为true，return，不进行终止
             * 1、还在运行状态
             * 2、状态是TIDYING、或 TERMINATED，已经终止过了
             * 3、SHUTDOWN 且 workQueue不为空
             */
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            /**
             * 只有shutdown状态 且 workQueue为空，或者 stop状态能执行到这一步
             * 如果此时线程池还有线程（正在运行任务，正在等待任务）
             * 中断唤醒一个正在等任务的空闲worker
             * 唤醒后再次判断线程池状态，会return null，进入processWorkerExit()流程
             */
            if (workerCountOf(c) != 0) { // Eligible to terminate
                interruptIdleWorkers(ONLY_ONE);
                return;
            }

            /**
             * 如果状态是SHUTDOWN，workQueue也为空了，正在运行的worker也没有了，开始terminated
             */
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        // 需子类实现
                        terminated();
                    } finally {
                        ctl.set(ctlOf(TERMINATED, 0));
                        // 唤醒调用了等待线程池终止的线程awaitTermination() 
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }

1、判断线程池是否需要进入终止流程；

2、判断线程池中是否还有线程，有则interruptIdleWorkers(ONLY_ONE) 尝试中断一个空闲线程（正是这个逻辑可以再次发出中断信号，中断阻塞在获取任务的线程）；

3、如果状态是SHUTDOWN，workQueue也为空了，正在运行的worker也没有了，开始terminated。会先上锁，将线程池置为tidying状态，之后调用需子类实现的terminated()，最后线程池置为terminated状态，并唤醒所有等待线程池终止这个Condition的线程。

shutdownNow()：终止线程池，中断所有线程，抛弃队列中未执行的任务

public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 判断调用者是否有权限shutdown线程池
            checkShutdownAccess();
            // CAS+循环设置线程池状态为stop
            advanceRunState(STOP);
            // 中断所有线程，包括正在运行任务的
            interruptWorkers();
            // 将workQueue中的元素放入一个List并返回
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        // 尝试终止线程池
        tryTerminate();
        return tasks;
    }

shutdownNow()和shutdown()的大体流程相似，差别是：

1、将线程池更新为stop状态；

2、调用interruptWorkers()中断所有线程，包括正在运行的线程；

3、将workQueue中待处理的任务移到一个List中，并在方法最后返回，说明shutdownNow()后不会再处理workQueue中的任务。

interruptWorkers()：中断所有线程，包括正在运行的

private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }

interruptWorkers()很简单，循环对所有worker调用 interruptIfStarted()，其中会判断worker的AQS state是否大于0，即worker是否已经开始运作，再调用Thread.interrupt()。

需要注意的是，对于运行中的线程调用Thread.interrupt()并不能保证线程被终止，task.run()内部可能捕获了InterruptException，没有上抛，导致线程一直无法结束。

awaitTermination()：等待线程池终止

public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (;;) {
                if (runStateAtLeast(ctl.get(), TERMINATED))
                    return true;
                if (nanos <= 0)
                    return false;
                nanos = termination.awaitNanos(nanos);
            }
        } finally {
            mainLock.unlock();
        }
    }

参数：

-- timeout：超时时间。

-- unit：超时时间的单位。

返回：

-- true：线程池终止。

-- false：超过timeout指定时间。

在发出一个shutdown请求后，在以下3种情况发生之前，awaitTermination()都会被阻塞：

1、所有任务完成执行。

2、到达超时时间。

3、当前线程被中断。

awaitTermination()循环的判断线程池是否terminated终止或是否已经超过超时时间，然后通过termination这个Condition阻塞等待一段时间。

termination.awaitNanos()是通过LockSupport.parkNanos(this, nanosTimeout)实现的阻塞等待。

阻塞等待过程中发生以下具体情况会解除阻塞（对上面3种情况的解释）：

1、如果发生了termination.signalAll()（内部实现是 LockSupport.unpark()）会唤醒阻塞等待，且由于ThreadPoolExecutor只有在 tryTerminated()尝试终止线程池成功，将线程池更新为terminated状态后才会signalAll()，故awaitTermination()再次判断状态会return true退出；

2、如果达到了超时时间 termination.awaitNanos()也会返回，此时nano==0，再次循环判断return false，等待线程池终止失败；

3、如果当前线程被Thread.interrupt()，termination.awaitNanos()会上抛InterruptException，awaitTermination()继续上抛给调用线程，会以异常的形式解除阻塞。