线程池ThreadPoolExecutor底层原理解析

在平常的开发中，线程池是经常有所接触的。当没有使用线程池的时候，执行异步任务就需要使用new创建一个线程来执行任务，在任务完成后线程便直接销毁了，这样的操作是有很大的开销的。而线程池为了解决在大量执行异步任务时，能够提供较好的性能，因为线程池中的线程是可以复用的。且线程池可以控制和管理资源，譬如限制线程的个数、动态新增线程等。

Java中的ThreadPoolExecutor中有提供可调参数和可扩展的接口，以此来满足不同场景下的需求，开发人员可以方便的使用Executors中的工厂方法，如：newCachedThreadPool（线程个数最多可达Integer.MAX_VALUE，线程自动回收）、newFixedThreadPool（固定大小的线程池）、newSingleThreadExecutor（单线程线程池），另外，开发人员还能进行自定义。

常见的几种创建线程池的方法

首先来看下ThreadPoolExecutor的类图，如下：

从上面的类图中可以看到Executor是顶层接口，在它里面只有一个execute()方法，ExecutorService继承自Executor，且也是一个接口，在这个接口中定义了关闭的功能，且定义了两种方式：shutDown和shutDownNow，shutdown 方法将允许先前提交的任务进行终止，而 shutdownNow 方法可以阻止等待的任务启动并尝试停止当前正在执行的任务。对于AbstractExecutorService这个抽象类，主要是实现了ExecutorService接口中的定义的一些执行方法。

ThreadPoolExecutor则是继承了AbstractExecutorService，在ThreadPoolExecutor类中有一个ctl原子变量，其主要作用是用于记录线程池状态和线程池中的线程个数。接下来，我们来简单看下ThreadPoolExecutor中定义的一些属性，代码如下：

    // 高3位用来便是线程池状态，低29位用来表示线程的个数
    // 默认是running状态，线程个数为0
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    // 线程个数掩码位数，并不是所有平台的int类型都是32位的，准确的说是在具体平台下的二进制位数-3后的剩余位数所表示的数才是线程个数          
    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
    // 接收新任务并且处理阻塞队列里的任务
    private static final int RUNNING    = -1 << COUNT_BITS;
    // 拒绝新任务但是处理阻塞队列里的任务
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    // 拒绝新任务并且抛弃阻塞队列里的任务，同时会中断正在处理的任务
    private static final int STOP       =  1 << COUNT_BITS;
    // 所有任务执行完（包含队列里的任务）后，当前线程池活动线程数为0，将要调用terminated方法

    private static final int TIDYING    =  2 << COUNT_BITS;
    // 终止状态，terminated方法调用完成以后的状态
    private static final int TERMINATED =  3 << COUNT_BITS;

    // Packing and unpacking ctl
    // 获取高3位（运行状态）
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    // 获取低29位（线程个数）
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    // 计算ctl新值（线程状态与线程个数）
    private static int ctlOf(int rs, int wc) { return rs | wc; }

关于线程池状态的转换如下：

• RUNNING->SHUTDOWN：显示低啊用shutdown方法，或者隐式调用用finalize()方法里的shutdown()方法。
• RUNNING或SHUTDOWN->STOP：显式调用shutdownNow()方法。
• SHUTDOWN->TIDYING：当线程池和任务队列都为空时。
• STOP->TIDYING：当线程池为空时。
• TIDING->TERMINATED：当terminated()hook方法执行完成时。

前面开始的时候提到了newCachedThreadPool（线程个数最多可达Integer.MAX_VALUE，线程自动回收）、newFixedThreadPool（固定大小的线程池）、newSingleThreadExecutor（单线程线程池）这几个方法，在说这几个方法之前需要先解释一下在ThreadPoolExecutor中几个相关的属性，如下：

• corePoolSize：线程池核心线程个数。
• maximumPoolSize：线程池最大线程数。
• keepAliveTime：存活时间，如果当前线程池中的线程数量比核心线程数量多，并且是闲置状态，则这些闲置的线程能存活的最大时间。
• TimeUnit：存活时间的时间单位
• workQueue：用于保存等待执行的任务阻塞队列，比如基于数组的有界队列ArrayBlockingQueue、基于链表的无界LinkedBlockingQueue、最多只有一个元素的SynchronousQueue，以及优先级队列PriorityBlockingQueue等。
• ThreadFactory：创建线程池的工厂。
• RejectedExecutionHandler：饱和策略，当队列满并且线程个数达到maximunPoolSize后所采取的的策略，比如AbortPolicy（抛出异常）、CallerRunsPolicy（使用调用者所在线程来运行任务）、DiscardOldestPolicy（调用poll丢弃一个任务，执行当前任务），DiscardPolicy（默默丢弃，不抛异常）。

这个方法的作用是用于创建一个按需创建线程的线程池，初识线程池为0，最多线程个数为Integer.MAX_VALUE，阻塞队列为SynchronousQueue。keepAliveTime=60表示当前线程在60s内空闲则回收，这个方法的特殊之处在于加入同步队列后会立马执行任务，因为队列中最多只允许有一个任务。代码如下：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

newFixedThreadPool

这里用于创建一个核心线程个数和最大线程个数都为nThreads的线程池，且阻塞队列长度为Integer.MAX_VALUE。keepAliveTime=0说明了线程个数比核心线程个数多并且当前空闲则回收。代码如下：

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory);
}

newSingleThreadExecutor

创建一个核心线程个数和最大线程个数都为1的线程池，且阻塞队列的长队为Integer.MAX_VALUE，keepAliveTime=0说明了线程个数比核心线程个数多并且当前空闲则回收。代码如下：

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

在上面的类图中的Worker，这个类继承了AQS和Runnable接口，它是具体承载任务的对象，Worker不仅继承了AQS，还自己简单的实现了不可重入锁，其中的state为0时，则表示锁未被获取，state=1时表示锁已经被获取，state=-1时时创建Worker时的默认状态，创建时设置state为-1是为了避免该线程在运行runWorker()方法前被中断。代码如下：

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    // 正在运行woker线程
    final Thread thread;
    // 传入的任务
    Runnable firstTask;
    // 完成的任务数 监控用
    volatile long completedTasks;

    Worker(Runnable firstTask) {
        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;
    }

    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(); }

    void interruptIfStarted() {
        Thread t;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

execute方法

ThreadPoolExecutor#execute方法的作用是吧任务提交到线程池中进行执行，客户端提交任务到线程池的流程图答题如下：

 

从上图的运行中，可以看出ThreadPoolExecutor的实现实际上是一个生产消费者模式，当客户端添加任务到线程池时相当于生产者生产元素，workers线程工作集中的线程直接执行任务或者从任务队列里获取任务时，则相当于消费者消费元素。execute方法的具体代码如下：

public void execute(Runnable command) {
    // （1）如果任务为null，抛空指针异常
    if (command == null)
        throw new NullPointerException();
     
     // （2）获取当前线程池的状态和线程个数变量的组合值
    int c = ctl.get();
    // （3）当前线程池中的数量是否小于核心线程池，小于则开启新线程运行
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // （4）如果线程池处于RUNING状态，则添加任务到阻塞队列
    if (isRunning(c) && workQueue.offer(command)) {
        //（4.1）二次检查
        int recheck = ctl.get();
        // (4.2)如果当前线程池状态不是RUNNING，则从任务队列中删除任务，并执行拒绝策略。
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // （4.3）否则如果当前线程池为空，则添加一个线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    //（5）如果队列已满，则新增线程，新增失败则执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

上面代码中主要步骤可分三步，但是这里我们对其进行了一下细分，（1）、（2）两步为非主要步骤，这里就不赘述了，第（3）步代码判断当前线程池中的线程个数如果小于corePoolSize，便会向workes中新增一个核心线程来执行任务。

如果当前当前线程池中的线程数大于等于corePoolSize，则执行第（4）步，在这里首先会判断当前线程池的状态是否为RUNNING，是则添加当前任务到队列中。这里判断线程池的状态，是因为有可能线程池已经处于非RUNNING状态了，而非RUNNING状态下是要抛弃新任务的。

当向队列中添加任务成功，还需要对其进行二次检查，便执行（4.2）代码，这里进行二次检查的原因，是因为在添加任务到队里中后，执行（4.2）前线程池的状态可能已经发生了变化。如果当前线程池状态不是RUNNING状态，便把任务从队列中移除，移除后在执行拒绝策略。如果通过路二次校验，便会执行（4.3）来重新判断当前线程池里面是否还有线程，没有的话则添加一个空任务到队列中。

如果（4）执行不通过的话，则说明任务队列已满，便会执行（5）来添加一个任务，如果当前线程池线程个数大于maximumPoolSize，便会添加失败，然后执行拒绝策略。

在分析完ThreadPoolExecutor#execute方法后，我们还需要对其方法中的ThreadPoolExecutor#addWorker方法来进行简单的分析，代码如下：

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        // 获取当前线程池的状态和线程个数变量的组合值
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        // (1) 检查队列是非只在必要时为空，如果判断线程状态是否为非运行状态，并且为非SHUTDOWN状态、firstTask为空、队列非空，就不能新增线程
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        // (2) CAS循环增加线程个数
        for (;;) {
            // 计算线程个数
            int wc = workerCountOf(c);
            // (2.1)如果线程个数超限，则返回false。
            // 如果当前线程大于等于最大线程数、等于核心线程数，非核心线程大于线程池数，说明已经到了阈值，表示不能再新增线程路。
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // （2.2）CAS新增线程个数，同时只有一个线程活动。
            // ctl+1 工作线程池数量+1， 如果成功，就跳出死循环。cas操作如果为true,表示新增成功，然后退出。
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // （2.3）CAS失败路，则看线程池状态是否变化了，变化则跳出外层循环，重新尝试获取线程池状态，否则内层循环，重新执行CAS。
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    // (3)到此便说明前面执行全部通过
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // (3.1)创建worker
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            // (3.2) 加独占锁，为了实现workers同步，因为可能多个线程调用了线程池的execute方法
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                // (3.3)重新检查线程池状态，以避免在获取锁之前，调用了shutdown方法
                int rs = runStateOf(ctl.get());
                // rs小于 SHUTDOWN，就是表示此时是 RUNNING 状态，rs等于 SHUTDOWN 和firstTask 为空，表示是从队列中处理任务，那就可以放到集合中
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    // 线程还没start，就是alive，直接抛异常。
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // （3.4）添加任务
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        // 记录最大线程数
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // （3.5）添加成功后启动任务
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        // （3.6）//失败回退，从wokers移除w，线程数减1，尝试结束线程池。
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

这段代码比较长，但主要可分为两部分，第一部分是通过双重循环CAS操作增加线程数，第二部分是并发安全的任务添加到workers里面，并启动任务。这里首先看第(1)步代码的判断逻辑：

rs >= SHUTDOWN &&

        ! (rs == SHUTDOWN &&

        firstTask == null &&

        ! workQueue.isEmpty())

这段代码可以等价于：

rs >= SHUTDOWN &&

        (rs != SHUTDOWN ||                 I

        firstTask != null ||                        II

        workQueue.isEmpty())              III

• I 表示当前线程池状态为STOP、TIDYING或TERMINATED。
• II 表示当前线程池状态为SHUTDOWN，并且已经有了第一个任务。
• III 表示当前线程池状态为SHUTDOWN，并且任务队列已空。

内存循环的作用是使用CAS操作增加线程数，代码（2.1）判断如果线程个数超限则返回false，否则执行（2.2）CAS，来操作设置线程个数。CAS成功则退出双循环，CAS失败则执行（2.3），看当前线程池的状态是否发生了变化，如果变了，贼再次进入外层循环重新获取线程池状态，否则进入内循环继续进行CAS尝试。

执行带（3）时，则表示前面的CAS成功增加路线程个数，但是现在任务还没开始执行。这里使用全局独占锁来控制把新增的Worked添加到workers中。在（3.1）处创建了一个工作线程Worker，（3.2）处获取路独占锁，（3.3）处重新检查了线程池状态，这里检查的目的是为了避免在获取锁之前，其他的线程执行shutdown方法关闭了线程池。如果线程池已经关闭了，则释放锁，新增线程失败，否则执行（3.4）添加工作线程到workers中去然后释放锁，最后（3.5）判断如果新增工作线程成功，则启动工作线程。

工作线程Worker的执行

当任务提交到线程池后，便由Worker来执行，这里先看下Worker的构造函数，代码如下：

Worker(Runnable firstTask) {
    setState(-1); // 在调用runworker之前，禁止中断
    this.firstTask = firstTask;
    this.thread = getThreadFactory().newThread(this); // 创建一个线程
}

在构造函数中首先设置Worker的状态为-1，这里为了避免当前的Worker在调用runWorker方法前被中断（当其他线程调用了线程池的shutdownNow时，如果Worker的状态大于等于0时，则会中断该线程）。这里设置了线程状态为1，所以线程不会被中断，在执行runWorker的时候才会把state设置为0，在这个时候调用shutdownNow的便可以中断线程。代码如下：

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    // （1）将state设置为0，允许中断
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // （2）task不为空 或者阻塞队列中拿到了任务
        while (task != null || (task = getTask()) != null) {
            // （2.1）获取独占锁
            w.lock();
            // 如果当前线程池状态等于stop 就中断
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                // （2.2）执行前做一些准备
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // （2.3）执行任务
                    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 {
                    // （2.4）执行完任务做一些事情
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                // （2.5）统计当前worker完成了多少任务
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // （3）执行清理工作
        processWorkerExit(w, completedAbruptly);
    }
}

上面的代码中，首先会在（1）处将state设置为0，表示线程可以中断。当执行到（2）处的时候，如果当前task==null或者getTask从任务队列获取的时候返回null，便跳到（3）处执行。如果task不等于null，则执行（2.1）去获取工作线程内部持有的独占锁，然后再执行扩展接口代码（2.2），再具体任务执行前做些事情。当执行到（3.3）的时候，便是执行具体任务，代码（3.4）处表示在任务执行完之后再做点事情，（2.5）表示统计当前worker完成了多少任务，并释放锁。这段代码中在具体任务期间枷锁，是为了避免在任务运行期间，其他线程调用路shutdown后，这样正在执行的任务便会被中断（shutdown只会中断当前被阻塞挂起的线程）。（3）处代码如下：

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();
    // （3.1）统计整个线程池完成的任务个数，并从工作集中删除当前Worker
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
    // （3.2）尝试设置线程池状态为TERMINATED，如果当前是SHUTDOWN状态并且工作队列为空，或者当前是STOP状态，当前线程池里没有活动线程。
    tryTerminate();

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

上面的代码中，（3.1）处代码统计线程池完成任务个数，并且在统计前加了全局锁，把在当前工作线程中完成的任务累加到全局计数器中，然后从工作集中删除当前Worker，代码（3.2）处判断如前线程池状态如果是SHUTDOWN并且工作队列为空，或当前线程池状态是STOP，并且当前线程池里面没有活动的线程，则设置线程池状态为TERMINATED。如果设置为TERMINATED状态，则需要调用条件变量termination的singAll()方法激活所有因为调用线程池的awaitTermination方法被阻塞的线程。代码（3.3）处判断当前线程池里面的线程个数是否小于核心线程数，如果是则新增一个线程。

shutdown和shutdownNow操作

ThreadPoolExecutor#shutdown

在调用shutdown方法后，线程池就不能接受新的人物路，但是工作队列里面的任务还是要执行的。该方法会立刻返回并不会等待任务队列完成再返回。代码如下：

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //（1）权限检查
        checkShutdownAccess();
        // （2）设置当前线程池 状态为SHUTDOWN，如果已经是SHUTDOWN，则直接返回
        advanceRunState(SHUTDOWN);
        // （3）设置中断标志位
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    // （4）尝试将状态设置为TERMINATED
    tryTerminate();
}

上面代码在（1）处会进行权限检查，查看是否设置了安全管理器，是则看当前调用shutdown命令的线程时候有关闭线程的权限，如果有权限还要看调用线程是否有中断工作线程的权限，如果没有则抛出SecurityException或者NullPointerException。代码（2）处是表示如果当前线程池状态大于等于SHUTDOWN则直接返回，否则设置为SHUTDOWN状态，代码如下：

private void advanceRunState(int targetState) {
    for (;;) {
        int c = ctl.get();
        if (runStateAtLeast(c, targetState) ||
            ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
            break;
    }
}

 （3）处代码如下，这里设置所有空闲的线程为中断标志，首先加了把全局锁，同时只有一个线程可以调用shutdown方法设置中断标志，然后尝试获取Worker自己的锁，获取成功则设置中断标志。由于正在执行的任务已经获取到锁，所以正在执行的任务没有被中断。这里中断的是阻塞到getTask方法并企图从队列里面获取到任务的线程，也就是空闲线程。

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();
    }
}

（4）处代码如下，这段代码中首先使用CAS设置当前线程的状态为TIDYING，如果设置成功则执行扩展接口terminated在线程池状态变为TERMINATED之前做些事情，然后设置当前线程池的状态为TERMINATED。最后调用termination.signalAll()激活因调用条件变量termination的await系列方法而被阻塞的所有线程。

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(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));
                    // 激活因调用条件变量termination的await系列方法而被阻塞的所有线程
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

ThreadPoolExecutor#shutdownNow

调用ThreadPoolExecutor#shutdownNow方法后，该线程池就不会接受新的任务，并且丢弃工作队列里面的任务，正在执行的任务不会被中断，该方法会立刻返回，并不等待激活的任务执行完成。返回值为这时候队列里面被丢弃的任务列表。代码如下：

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //（1）权限检查
        checkShutdownAccess();
         //（2）设置当前线程池状态为STOP
        advanceRunState(STOP);
        // （3）中断所有线程
        interruptWorkers();
        // 将任务队列任务移到tasks中
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

上面代码中首先进行权限检查，然后设置当前线程状态为STOP，最后中断所有线程，这里需要注意的是，中断的所有线程包含空闲线程和正在执行任务的线程。最后把当前任务移到tasks列表中去。