ThreadPoolExecutor源码解析

ThreadPoolExecutor

阅读原文请访问我的博客BrightLoong's Blog

一. 线程池概述

在介绍线程池之前,先说一下为什么在开发中要使用线程池,个人认为主要有一下的原因:

  • 开发中使用线程的时候,大部分线程执行的时间很短,频繁的创建、启动、销毁线程带来不必要的资源消耗。
  • 线程的创建、挂起、唤醒等操作都需要依靠CPU调度,大量的线程会频繁进行上下文切换,特别是任务执行时间短、任务数量多的情况,大量时间将花在上下文切换上,又耗时,又耗资源。
  • 无法对任务做统一的管理、分配、和监控等。

线程池主要通过ThreadPoolExecutor来实现,在ThreadPoolExecutor类注释上有下面一段话(下面是翻译过来的):

线程池解决了两个不同的问题:由于减少了每个任务的调用开销,改进了执行大量异步任务的性能;并且它还提供了一种任务执行时限制和管理资源(包括线程)的方法。 同时每个ThreadPoolExecutor还维护一些基本统计信息,例如已完成任务的数量。

二. 线程池的构造方法参数解析

构造方法中各个参数的含义

先上一张图,有个大概的印象。

threadPool
  • 这里任务加入可以看做是放入了两个地方,一是线程池中,另一个是任务队列中。
  • 放入线程池的又分为两个部分,一是corePoolSize,暂且叫做核心线程(下图红色部分),另一部分是非核心线程(下图橙色部分),核心线程+非核心线程 <= maximumPoolSize。
参 数 含 义
corePoolSize 核心线程数,当向线程池中添加新任务的时候,如果此时线程数量小于corePoolSize,哪怕线程池中有空闲的线程,此时也会重新新建一个线程来处理这个任务请求。同时corePoolSize也是线程池中维持的线程数量,就算都是空闲线程的也会存在,除非设置了allowCoreThreadTimeOut。
maximumPoolSize 线程池中最大的线程数量,当向线程池中添加新任务的时候如果此时线程数量大于corePoolSize,小于maximumPoolSize,并且队列已经满了,将会新建线程来处理这个任务请求。
keepAliveTime 非核心线程在空闲后存活的是时间。
unit keepAliveTime的单位
workQueue 任务队列,常用的有三种:SynchronousQueue、LinkedBlockingQueue、ArrayBlockingQueue
threadFactory 创建线程的工厂,默认使用DefaultThreadFactory
handler 被拒绝后的处理,拒绝处理策略。
a. CallerRunsPolicy,由调用execute方法提交任务的线程来执行这个任务
b. AbortPolicy,抛出异常RejectedExecutionException拒绝提交任务
c. DiscardPolicy,直接抛弃任务,不做任何处理
d. DiscardOldestPolicy,去除任务队列中的第一个任务,重新提交

构造方法

//使用默认的ThreadFactory和拒绝处理策略
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
    
//使用默认的拒绝处理策略    
 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

//使用默认的ThreadFactory
 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

//传入所有参数,并且对参数进行校验   
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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

三. 工作原理

其原理如下图所示:

theory

当一个新加一个任务的时候执行如下步骤:

  1. 首先尝试新建核心线程启动任务
  2. 核心线程已经满了,尝试加入到队列中
  3. 队列已经满了,尝试新建非核心线程启动任务
  4. 非核心线程已满,执行拒绝策略

同时,当线程池中的工作线程执行完一个Task后会从队列中take任务执行。

四. UML类图

UML
  • AbstractExecutorService,提供了ExecutorService的默认实现。
  • ExecutorService,定义了管理终止任务的一些方法以及让任务返回Future的方法。
  • Executor,只定义了一个execute()方法,任务的提交执行。
  • AbortPolicy、DiscardOldestPolicy、DiscardPolicy、CallerRunsPolicy,ThreadPoolExecutor内部定义的拒绝策略类。
  • Worker,是实现线程池重要的内部类,其UML类图如下:
Worker

Worker类主要是运行任务的以及维护线程的中断控制状态,以及其他状态的记录。Worker类继承AbstractQueuedSynchronizer以简化每个任务执行时候的锁的获取和释放。

五. 源码分析

注意区分Worker和Taks,Worker是指工作线程,也就是用来执行任务的线程,Task是线程执行的任务(添加到队列中的就是任务)。

ThreadPoolExecutor关键变量

ThreadPoolExecutor使用一个原子integer(AtomicInteger)变量ctl(32位),来表示线程池的控制状态,这个状态值实际上由两部分组成:

  1. workerCount:有效的线程数,最大(2^29)-1,为ctl的低29位
  2. runState:线程池运行状态,保存在ctl高位3位。
//ctl初始化的时候状态为RUNNING,workerCount为0
 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
 
    //workerCount位数
    private static final int COUNT_BITS = Integer.SIZE - 3;
    //workerCount容量,(2^29)-1
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState 的状态
    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;


    // 获取runState
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    //获取workerCount
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

说一下上面线程池的几种状态:

  • RUNNING:可以接受新的任务,并且处理在队列中的任务。
  • SHUTDOWN:不再接受新的任务,但是会把队列中的任务处理完成。
  • STOP:不再接受新的任务,也不处理队列中的任务,并且正在处理的任务会被中断。
  • TIDYING:所有任务都终止了,线程要转换到TIDYING状态,需要运行terminated()钩子方法。
  • TERMINATED:terminated()执行完成,到达这个状态时候awaitTermination()方法返回。

在ThreadPoolExecutor类注释中提到状态之间的转换情况:

  • RUNNING -> SHUTDOWN:调用shutdown(),或者隐式调用finalize()。
  • (RUNNING or SHUTDOWN) -> STOP:调用shutdownNow()。
  • SHUTDOWN -> TIDYING:当线程池和队列都为空的时候。
  • STOP -> TIDYING:线程池为空的时候。
  • TIDYING -> TERMINATED:钩子方法terminated()执行完成。

execute(Runnable command)

execute(Runnable command),提交任务。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
       
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果线程池状态为Running(其他状态拒绝添加新任务到队列)将任务添加到队列中。
        if (isRunning(c) && workQueue.offer(command)) {
            //添加成功后进行recheck
            int recheck = ctl.get();
            //如果当前状态不是Running,从队列中移除任务。
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //刚刚在队列中加入了任务,保证线程池中至少有一个工作线程可以处理任务。
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //
        else if (!addWorker(command, false))
            reject(command);
    }

分为3步来执行:

  1. 如果workerCount小于corePoolSize,将任务作为first Task新建线程来执行任务。
  2. 将任务添加到队列中,如果添加成功依然需要检查,在进入任务之前,如果线程池被关闭,那么将任务从队列中移除;如果当前线程池中没有工作线程,而刚刚在队列中加入了任务,要保证线程池中至少有一个工作线程可以处理任务。
  3. 如果不能将任务加入队列中,尝试新加一个线程来执行任务,但是并不定会成功,可能是线程池被shut down或者线程池达到了饱和(maximumPoolSize),如果失败了执行拒绝策略。

关于Worker的构造函数

在介绍addWorker(Runnable firstTask, boolean core)之前我们来看看Worker的构造函数。

Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

Worker实现了Runnable,这里将其构造为Thread赋值给thread。第一步中的setState(-1),这一步很有意思,将AQS中的同步状态设置为-1,到后面我们会看到,线程池使用AQS中的同步状态来判断该工作线程是否可以被中断。-1:初始化值,此时工作线程还没有启动,也没有中断的必要;0:表示接受中断,此时工作线程为空闲状态;1:表示此时工作线程正在执行任务。

addWorker(Runnable firstTask, boolean core)

检查根据当前线程池的工作状态和给定的界限限制(corePoolSize 和maximumPoolSize)是否可以添加新的工作线程。 如果添加了新的工作线程,workerCount会相应调整,并且如果可能的话将firstTask作为其第一个任务运行。 如果线程池停止(Stop)或关闭(ShutDown),此方法返回false。如果线程工厂未能创建线程,它也会返回false。如果线程创建失败,无论是由于线程工厂返回null还是由于异常(通常是Thread.start()中的OutOfMemoryError),都会进行回滚。


/**
 *@Param core:如果为true把corePoolSize作为解析,否则把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())
            //上面的可以这样理解,只有在同时满足三个条件的情况下才会返回false,所以话句话说,只要有一个不满足,就会返回true
            //将上面的判断修改为 (rs != SHUTDOWN || firstTask != null ||  workQueue.isEmpty())
            //rs != SHUTDOWN:基于rs >= SHUTDOWN的前提下,当rs != SHUTDOWN,不再创建新的线程。
            //firstTask != null:基于rs >= SHUTDOWN的前提下,不再接受新的任务。
            //workQueue.isEmpty():任务队列为空,不用再创建新的工作线程来处理任务。
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                //检查工作线程数是否超过了界限,超过了返回false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //使用CAS修改workerCount,加1,成功跳出循环
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                //+1操作失败,其他任务添加修改了workerCount值,继续循环。
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }
        
        //工作线程是否启动
        boolean workerStarted = false;
        
        //工作线程是否添加成功
        boolean workerAdded = false;
        Worker w = null;
        try {
            //新加一个工作线程,Worker本身也实现了Runabble
            w = new Worker(firstTask);
            
            //这路获取到的其实是使用Worker生成的Thread
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    
                    //在获取到锁之后再次检查状态
                    int rs = runStateOf(ctl.get());
                    
                    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) {
                    //启动工作线程,其实执行的是Worker中的run()
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

Worker中的run()

Worker的run()方法实际调用的是runWorker(this),启动工作线程(注意这里不是直接启动的任务),在工作线程中执行任务。

工作线程在这循环,反复的从队列中获取任务并执行它们。

  1. 启动了初始的任务,也就是最开始创建工作线程的时候的firstTask。否则,只要线程池还在运行中,使用getTask()从队列中获取任务来执行。如果改变了线程池的工作状态,或者工作参数,getTask()返回null,此时工作线程将退出。或者工作线程因为异常而退出,此时异常退出标记completedAbruptly为true,之后会通过processWorkerExit新建一个工作线程来替换它。
  2. 在运行所有任务之前,需要获取锁,来保证当任务在运行的时候不会被中断,除非线程池正在停止(Stop)
public void run() {
            runWorker(this);
        }
        
final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        //获取任务
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // 将AQS同步状态设置为0(初始值为-1),表示当前工作线程为闲置状态,可以被中断了。
        //异常退出标记。
        boolean completedAbruptly = true;
        try {
            //getTask()从队列中获取任务
            while (task != null || (task = getTask()) != null) {
                w.lock();
                //再次检查工作线程状态
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    //执行前的钩子方法
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        //注意区分和start(),调用run()并不会另启线程,而是在当前线程中执行,所以任务其实是在工作线程中执行的。
                        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);
        }
    }

getTask()

从队列中获取Task,大概分为以下几个步骤。

  1. 判断线程池以及队列的状态,如果线程池状态在STOP以上,此时线程池不处理队列中的任务;或者线程池处于SHUTDOWN但是队列为空(SHUTDOWN不再接受新的任务),workerCount减1,返回null,注意此时只是将变量减1,其实工作线程并没有终止真正的终止在 processWorkerExit(w, completedAbruptly);中。
  2. 如果通过了状态检查,判断是否要进行线程回收,如果需要workerCount数量减1,成功后返回null。
  3. 根据timed(timed表示需要进行超时闲置线程回收),选择是限时等待还是阻塞的方式从队列中获取任务。
private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // 如果线程池已经关闭(STOP状态不再处理队列中的任务),或者队列为空,workerCount减1,返回空。
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // allowCoreThreadTimeOut,是否允许回收核心线程。
            // timed表示需要进行超时闲置线程回收。
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            
            //1. (wc > maximumPoolSize || (timed && timedOut):如果工作线程数量大于maximumPoolSize,或者闲置线程超时。
            //2. (wc > 1 || workQueue.isEmpty()):队列不为空时,至少需要保留一个工作线程来处理队列中的任务
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                //workerCount数量减1,CAS操作,失败了会不断循环。
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                //根据timed,选择是限时等待还是阻塞的方式从队列中获取任务。
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                //workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 一段时间拿不到返回null,表示超时。
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

说到getTask()顺便介绍几种队列:

  • SynchronousQueue:Executors.newCachedThreadPool()中使用的队列。与其他BlockingQueue不同,SynchronousQueue是一个不存储元素的BlockingQueue,每一个put操作必须要等待一个take操作,否则不能继续添加元素,反之亦然。所以使用这个队列,任务会直接提交给线程处理,所以一般会把maximumPoolSize指定成Integer.MAX_VALUE。
  • ArrayBlockingQueue:有界队列,队列可以限定长度,当添加新任务的时候,如果当前工作线程数量小于corePoolSize,则新建线程执行任务,否则如队列,以为队列是有限的,如果队列已经满了就会新建非核心线程执行任务,如果非核心线程也饱和了就会被拒绝,执行拒绝策略。
  • LinkedBlockingQueue(不设置预定值):无界队列,因为是无界队列,所以maximumPoolSize这个属性的设定失效,线程池中的工作线程数用于不会大于corePoolSize。

processWorkerExit(Worker w, boolean completedAbruptly)

工作线程退出后的操作,在这里进行线程池的终止以及工作线程的回收。

private void processWorkerExit(Worker w, boolean completedAbruptly) {
        //如果是异常退出,workerCount数量减1
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            //从工作线程组中移除工作线程
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
        
        //尝试终止线程池
        tryTerminate();

        int c = ctl.get();
        if (runStateLessThan(c, STOP)) {
            //如果是异常退出,直接新加一个工作线程。
            if (!completedAbruptly) {
                //如何设置了allowCoreThreadTimeOut,最小工作线程数为0,否则为corePoolSize
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                //如果最小工作线程数为0,而队列又不为空,说明至少要保留一个工作线程
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                //如果当前工作线程数还大于最小工作线程数,直接返回,不添加新的工作线程
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            addWorker(null, false);
        }
    }

tryTerminate()

尝试终止线程池。

 final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
            //以下三种情况表示不需要终止线程池。
            //1. isRunning(c):处于Running状态。
            //2. runStateAtLeast(c, TIDYING):TIDYING或者TERMINATED,已经在关闭了,不用重复关闭。
            //3. (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()):线程池处于SHUTDOWN状态,但是队列中还有任务没处理完。
            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状态,调用terminated()钩子方法
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        terminated();
                    } finally {
                        //终止操作完成,设置状态为TERMINATED
                        ctl.set(ctlOf(TERMINATED, 0));
                        // 释放在termination条件上等待的所有线程
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // CAS操作失败后不断的循环。
        }
    }

interruptIdleWorkers(boolean onlyOne)

中断闲置工作线程。重点是如何判断哪些是闲置的工作线程,并且可以被中断。满足 !t.isInterrupted() && w.tryLock() :

  1. !t.isInterrupted()表示没有被中断。
  2. w.tryLock()表示能获取到锁,获取到锁AQS的同步状态为0,表示工作线程闲置。
//tru表示只中断一个线程
private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                //如果没有被中断,并且能成功获取到锁(获取到锁AQS的同步状态为0,表示工作线程闲置),那么就进行中断,不能获取到锁表示队列中有任务正在执行。
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        //进行中断操作。
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                //如果只中断一个,中断一个跳出。
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

shutdown()

调用shutdown(),拒绝接受新的任务加入,会将正在执行的任务以及等待执行的任务执行完成,终止所有的闲置工作线程。

public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //检查是否有Shutdown权限
            checkShutdownAccess();
            //设置线程池状态为SHUTDOWN
            advanceRunState(SHUTDOWN);
            //关闭闲置的工作线程,最后调用的是interruptIdleWorkers(false)
            interruptIdleWorkers();
            //钩子方法
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            mainLock.unlock();
        }
        //终止
        tryTerminate();
    }

shutdownNow()

调用shutdownNow()会尝试停止所有执行的任务,也不会对队列中的等待任务进行处理,并返回等待执行的任务列表,它会终止所有的工作线程,与shutdown()不同,shutdown()只会终止所有的空闲工作线程。

public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //检查是否有Shutdown权限
            checkShutdownAccess();
            //设置线程池状态为STOP
            advanceRunState(STOP);
            //终止所有工作线程
            interruptWorkers();
            //获取等待执行的任务列表
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        //尝试终止线程池。
        tryTerminate();
        return tasks;
    }

interruptWorkers() 以及 interruptIfStarted()

终止所有的工作线程。主要看看interruptIfStarted()中是如何判断哪些工作线程是可以被终止的,满足 getState() >= 0 && (t = thread) != null && !t.isInterrupted() :

  1. getState() >= 0 获取CAS同步状态,上面说到同步状态初始化为-1,-1表示不可以被中断(可以看做当前工作线程没有启动),0表示闲置工作线程,1表示正在执行任务的工作线程。
  2. (t = thread) != null 这个不用说了,为空还终止个啥。
  3. !t.isInterrupted(),没有终止,避免重复调用。
private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }
    
        void interruptIfStarted() {
            Thread t;
            //getState()用于判断线程是否启动,具体看上面的解释。
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

推荐阅读更多精彩内容