线程池 ThreadPoolExecutor 源码详细分析

1、线程池的作用

一方面当执行大量一步任务的时候线程池能够提供较好的性能,在不使用线程池的时候,每当需要执行异步的时候都是直接 new 一线程进行运行,而线程的创建和销毁都是需要开销的。使用线程池的时候,线程池里面的线程是可复用的,不会每次执行异步任务的时候都重新创建和销毁线程。

另一方面线程池提供了一种资源限制和管理的手段,比如可以限制线程的个数,动态新增线程等,每个 ThreadPoolExecutor 也保留了一些基本的统计数据,比如当前线程池完成的任务数目等。

2、ThreadPoolExecutor 继承体系

线程池 ThreadPoolExecutor 源码详细分析

  • Executor:只定义了一个方法 execute(),用于执行提交的任务
  • ExecutorService:定义了一些线程池管理、任务提交、线程检测的方法
  • AbstractExecutorService:提供了 ExecutorService 接口执行方法的默认实现,用于同一处理 Callable 任务和 Runnable 任务。

下面介绍一下线程池的拒绝策略

当线程池的任务缓存队列已经满了并且线程池中的线程数目达到 maximumPoolSize 的时候,如果还有任务到来就会采取任务拒绝策略,通常有以下四种拒绝策略:

  • AbortPolicy:直接抛出一个 RejectedExecutionException 的异常,让你感知到任务被拒绝了,下面你可以根据业务逻辑选择重试或者放弃提交。
  • DisCardPolicy:当新任务被提交后直接被丢弃,也不会给你任何的通知,可能造成数据丢失的现象。
  • DisCardOldestPolicy:如果线程池没有关闭且没有能力执行,则会丢弃任务队列中的头结点,然后重新提交被拒绝的任务。通常是存活时间最长的任务,这种策略与第二种不同之处在于它丢弃的任务不是最新提交的,而是队列中存活时间最长的,这样就可以腾出资源给新提交的任务,但是同理也存在一定的数据丢失风险。
  • CallerRunsPolicy:当有新任务提交的时候,如果线程池没被关闭且没有能力执行,则把这个任务交于提交任务的线程执行,也就是谁提交任务,谁就负责执行任务。这样做主要有两点好处:
    • 提交的新任务不会被丢弃,这样也就不会造成业务损失。
    • 由于谁提交任务谁就要负责执行,这样提交任务的线程就得负责执行任务,而执行任务又是比较耗时得,在这段期间,提交任务得线程被占用,也就不会提交新的任务,减缓了任务提交得速度,相当于是一个负反馈。在此期间,线程池中的线程也可以充分利用这段时间来执行掉一部分任务,腾出一定的空间,相当于是给了线程池一定的缓冲期。

阻塞队列

BlockingQueue

BlockingQueuejava.util.concurrent 包下,其他阻塞类都实现自 BlockingQueue 接口,BlockingQueue 提供了线程安全的队列访问方式,当向队列中插入数据的时候,如果队列已经满了,线程则会阻塞等待队列中的元素被取出后再插入;当从队列中取数据的时候,如果队列为空,则线程会阻塞等待队列中有新元素再获取。

LinkedBlockingQueue

LinkedBlockingQueue 是一个由链表实现的线程安全的有界阻塞队列,容量默认值为 Integer.MAX_VALUE,也可以自定义容量,建议指定容量大小,默认大小在添加速度大于删除速度的情况下有造成内存溢出的风险,LinkedBlockingQueue 是先进先出的方式存储元素。

ArrayBlockingQueue

ArrayBlockingQueue 是一个有边界的阻塞队列,它的内部实现是一个数组。它的容量是有限的,我们在其初始化的时候指定它的容量大小,容量大小一旦指定就不可改变。ArrayBlockingQueue 也是先进先出的方式存储数据,ArrayBlockingQueue 内部的阻塞队列通过 ReenterLockCondition 条件队列实现的,因此 ArrayBlockingQueue 中的元素存在公平访问和非公平访问的区别,对于公平访问队列,被阻塞的线程可以按照阻塞的先后顺序访问队列,即先阻塞的线程先访问队列。而非公平队列,当队列可用的时候,阻塞的线程将进入争夺访问资源的竞争中,也就是说谁先抢到谁就执行,没有固定的先后顺序。

DelayQueue

DelayQueue 是一个支持延时获取元素的*阻塞队列,队列中的元素必须实现 Delayed 接口,在创建元素的时候可以指定延迟时间,只有到达了延迟的时间之后,才能获取到该元素。实现了 Delayed 接口必须重写两个方法,getDelay(TimeUnit)compareTo(Delayed)

PriorityQueue

PriorityQueue 是一个基于优先级堆的*优先级队列。优先级队列的元素按照其自然顺序进行排序,或者根据构造队列的时候提供的 Comparator 进行排序,具体取决于所使用的构造方法。优先级队列不允许使用 null 元素。

PriorityQueue 需要注意的点

  • PriorityQueue 是非线程安全的,在多线程情况下可使用 PriorityBlockingQueue 类替代。
  • PriorityQueue 不允许插入 null 元素。

LinkedTransferQueue

LinkedTransferQueue 是一个由链表结构组成的*阻塞队列,相对于其他阻塞队列,LinkedTransferQueue 采用一种预占模式。意思就是消费者线程取元素的时候,如果队列不为空,则直接取走数据,若是队列为空,那就生成一个节点(节点元素为 null)入队,然后消费者线程被等待在这个节点上,后面生产者线程入队的时候发现有一个元素为 null 的节点,生产者线程就不入队了,直接就将元素填充到该节点,并唤醒该节点等待的线程,被唤醒的消费者线程取走元素,从调用的方法返回。我们称这种节点操作为 匹配 方式。

总结

队列 有界性 数据结构
ArrayBlockingQueue bounded 加锁 arraylist
LinkedBlockingQueue optionally-bounded 加锁 linkedlist
ConcurrentLinkedQueue unbounded 无锁 linkedlist
LinkedTransferQueue unbounded 无锁 linkedlist
PriorityBlockingQueue unbounded 加锁 heap
DelayQueue unbounded 加锁 heap

五种常用线程池

  • newCachedThreadPool:可缓存的线程池
    • newCachedThreadPool 用于创建一个可缓存的线程池,之所以叫可缓存线程池,是因为它在创建新线程的时候如果有可重用的线程,则重用它们,否则创建一个新线程并将其添加到线程池中。
    • 在线程池的 keepAliveTime 时间超过默认的 60秒后,该线程会被终止并从缓存中移除,因此在没有线程任务运行的时候,newCachedThreadPool 将不会占用系统的线程资源
  • newFixedThreadPool:固定大小的线程池
    • newFixedThreadPool 可用于创建一个固定的线程数量的线程池
    • 如果任务数量大于等于指定线程池中线程的数量,则新提交的任务将在阻塞队列中排队,直到有可用的线程资源。
  • newScheduledThreadPool:可做任务调度的线程池
    • newScheduledThreadPool 用于创建可定时调度的线程池,可设置在给定延迟时间后执行或者定期执行某个线程任务。
  • newSingleThreadPool :单个线程的线程池
    • newSingleThreadPool:创建的线程池会确保池中永远有且只有一个可用的线程
    • 在该线程停止或者发生异常的时候,newSingleThreadPool 线程池会启动一个新的线程代替该线程继续执行任务
  • newWorkStealingPool:足够大小的线程池
    • newWorkStealingPool 用于创建持有足够多线程的线程池来达到快速运算的目的。
    • 在内部通过使用多个队列来减少各个线程调度产生的竞争
    • 足够的线程指的是 JDK 根据当前线程的运行需求向操作系统中申请足够多的线程,以保障线程的快速执行

3、ThreadPoolExecutor 源码分析

3.1、成员属性

// 高三位:表示当前线程池运行状态,除去高三位的低位29位:表示当前线程池中所拥有的线程数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

// 表示在ctl 中,低 COUNT_BITS 位是用于存放当前线程数量的位数
// 这里为什么不直接使用29,而是使用 Integer.SIZE - 3 表示?
// 小概率情况,防止 Integer在JDK版本变更中所占的字节位数不是4个字节了
private static final int COUNT_BITS = Integer.SIZE - 3; // 29

// 低 COUNT_BITS 位 所能表达的最大数值
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits  在ctl中的高三位所代表的运行状态
// -1 负数在计算机中以补码的形式存在 1110 0000 0000 0000 0000 0000 0000 0000 转换成整数是一个负数
private static final int RUNNING    = -1 << COUNT_BITS;

// 0000 0000 0000 0000 0000 0000 0000 000
private static final int SHUTDOWN   =  0 << COUNT_BITS;

// 0010 0000 0000 0000 0000 0000 0000 0000
private static final int STOP       =  1 << COUNT_BITS;

// 0100 0000 0000 0000 0000 0000 0000 0000
private static final int TIDYING    =  2 << COUNT_BITS;

// 0110 0000 0000 0000 0000 0000 0000 0000
private static final int TERMINATED =  3 << COUNT_BITS;

// 任务队列,当线程池中的线程达到核心线程数的时候,再提交的时候就会直接提交到 workQueue
// workQueue instanceof ArrayBrokingQueue LinkedBrokingQueue 同步队列
private final BlockingQueue<Runnable> workQueue;

// 线程池的全局锁,增加worker,减少worker 的时候需要持有mainLock,修改线程池运行状态的时候也需要
private final ReentrantLock mainLock = new ReentrantLock();

// 线程池真正存放worker -> thread的地方
private final HashSet<Worker> workers = new HashSet<Worker>();

// 当外部线程调用 awaitTermination() 方法的时候,外部线程会等待当前线程池状态为 Terminated 为止
// 等待是如何实现的?就是将外部线程封装成waitNode放入到 Condition 队列中了,waitNode.thread 就是外部线程,会被park掉(处于WAITING 状态)
// 当线程池状态变为 Termination的时候,会去唤醒这些线程,通过 termination.signAll() ,唤醒之后这些线程会进入到阻塞队列,头结点会去抢占mainLock
// 抢到锁的线程会继续执行 awaitTermin() 后面的程序,这些线程最后都会正常执行
// 简单理解,termination.await() 会将线程阻塞在这里
//         termination.signAll() 会将阻塞在这里的线程依次唤醒
private final Condition termination = mainLock.newCondition();

// 记录线程池生命周期内线程数最大值
private int largestPoolSize;

// 记录线程池所完成的任务总数,当worker 退出的时候会将 worker 完成的任务累计到completedTaskCount
private long completedTaskCount;

// 创建线程的时候会使用线程工厂,当我们使用 Executors.newFix.. newCache.. 创建线程池的时候使用的是 DefaultThreadFactory
// 一般不建议使用 DefaultThreadFactory,推荐自己实现 ThreadFactory,为什么不推荐使用DefaultThreadFactory?
// 因为DefaultThreadFactory创建线程的时候给赋值给线程的名字是 namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"
// 当线程池中的某个线程出现问题的时候,并不能通过该线程名字去定位到哪个地方出现了问题,这是很浪费时间的
private volatile ThreadFactory threadFactory;

// 拒绝策略:juc包中默认提供了四种方式,默认采用 AbortPolicy,直接抛出异常的方式
private volatile RejectedExecutionHandler handler;

// 空闲线程存活时间,当allowCoreThreadTimeOut == false的时候,会维护核心线程数内的线程存活,超出时间的线程会超时
// allowCoreThreadTimeOut == true的时候,核心线程数量内的线程空闲的时候,也会被回收
private volatile long keepAliveTime;

// 控制核心线程数量内的线程是否可以被回收 true,可以,false 不可以
private volatile boolean allowCoreThreadTimeOut;

// 核心线程数量限制
private volatile int corePoolSize;

// 线程池最大线程数量限制
private volatile int maximumPoolSize;

// 缺省的拒绝策略:采用的是 AbortPolicy 直接抛出异常的方式
private static final RejectedExecutionHandler defaultHandler =
    new AbortPolicy();

构造方法

// 构造方法
public ThreadPoolExecutor(int corePoolSize, // 核心线程数量限制
                          int maximumPoolSize, // 最大线程数限制
                          // 空闲线程存活时间,当allowCoreThreadTimeOut == false的时候,会维护核心线程数内的线程存活,超出时间的线程会超时
                          // allowCoreThreadTimeOut == true的时候,核心线程数量内的线程空闲的时候,也会被回收
                          long keepAliveTime,
                          TimeUnit unit, // 时间单位 seconds nano..
                          // 任务队列,当线程池中的线程达到核心线程数的时候,再提交的时候就会直接提交到 workQueue
                          // workQueue instanceof ArrayBrokingQueue LinkedBrokingQueue 同步队列
                          BlockingQueue<Runnable> workQueue,
                          // 创建线程的时候会使用线程工厂,当我们使用 Executors.newFix.. newCache.. 创建线程池的时候使用的是 DefaultThreadFactory
                          // 一般不建议使用 DefaultThreadFactory,推荐自己实现 ThreadFactory,为什么不推荐使用DefaultThreadFactory?
                          // 因为DefaultThreadFactory创建线程的时候给赋值给线程的名字是 namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"
                          // 当线程池中的某个线程出现问题的时候,并不能通过该线程名字去定位到哪个地方出现了问题,这是很浪费时间的
                          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.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

3.2、成员预热方法

// Packing and unpacking ctl
// 获取当前线程池运行状态
// ~CAPACITY & c = ctl => ~0001 1111 1111 1111 1111 1111 1111 1111 & 1110 0000 0000 0000 0000 0000 0000 0011(假设是RUNNING状态)
// ~CAPACITY =>      1110 0000 0000 0000 0000 0000 0000 0011
// ctl =>            1110 0000 0000 0000 0000 0000 0000 0000
// ~CAPACITY & c =>  1110 0000 0000 0000 0000 0000 0000 0000
private static int runStateOf(int c)     { return c & ~CAPACITY; }

// 获取当前线程池线程数量
// c == ctl =>      1110 0000 0000 0000 0000 0000 0000 0111
// CAPACITY =>      0001 1111 1111 1111 1111 1111 1111 1111
// c & CAPACITY =>  0000 0000 0000 0000 0000 0000 0000 0111
private static int workerCountOf(int c)  { return c & CAPACITY; }

// 用在重置当前线程池 ctl 值的时候会用到
// rs:代表线程池状态  wc:代表当前线程池 worker(线程)数量
// rs:     1110 0000 0000 0000 0000 0000 0000 0000 (假设位RUNNING状态)
// wc:     0000 0000 0000 0000 0000 0000 0000 0111
// rs | wc:1110 0000 0000 0000 0000 0000 0000 0111 == 重置为ctl的值
private static int ctlOf(int rs, int wc) { return rs | wc; }

// 比较当前线程池ctl所表示的状态,是否小于某个状态s
// c = 1110 0000 0000 0000 0000 0000 0000 0111 < 0000 0000 0000 0000 0000 0000 0000 0000 == true
// 所有情况下,RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
private static boolean runStateLessThan(int c, int s) {
    return c < s;
}

// 比较当前线程池 ctl 所表示的状态,是否大于等于某个状态
private static boolean runStateAtLeast(int c, int s) {
    return c >= s;
}

// 小于SHUTDOWN 一定是 RUNNING 状态 SGUTDOWN == 0
private static boolean isRunning(int c) {
    return c < SHUTDOWN;
}

// 使用 CAS 的方式让 ctl 的值 + 1,成功返回true,失败返回false
private boolean compareAndIncrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect + 1);
}

// 使用 CAS 的方式让 ctl 的值 -1,成功返回true,失败返回false
private boolean compareAndDecrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect - 1);
}

// 将ctl 的值减-1,这个方法一定成功
private void decrementWorkerCount() {
    // 这里会一直进行重试,直到成功为止
    do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}

3.3、Worker 内部类分析

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    // Worker 采用了AQS 的独占模式
    // 独占模式:两个重要属性 state 和 ExclusiveOwnerThread
    // state:0的时候,表示未被占用,>0 的时候表示被占用,<0 的时候,表示初始状态,这种情况下不能被抢锁
    // ExclusiveOwnerThread:表示独占锁线程
    private static final long serialVersionUID = 6138294804551838833L;

    /** Thread this worker is running in.  Null if factory fails. */
    // Worker 内部封装的工作线程
    final Thread thread;
    /** Initial task to run.  Possibly null. */
    // 假设 firstTask 不为空,那么当 worker 启动后(内部的线程启动)会优先执行 firstTask,当执行完firstTask后,会当workQueue中去获取下一个任务
    // 初始化任务,只在worker 第一次执行任务的时候执行,之后都是从workqueue中获取任务执行
    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)
     */
    // firstTask 可以为 null,为null启动后会到 queue中获取
    Worker(Runnable firstTask) {
        // 设置 AQS 独占模式为初始化状态,不能被抢占锁
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        // 使用线程工厂创建了一个线程,并且将当前 worker 指定为 Runnable,也就是说当 thread启动的时候,会以worker.run()为入口
        this.thread = getThreadFactory().newThread(this);
    }

    /** Delegates main run loop to outer runWorker  */
    // 当worker 启动的时候,会执行run()方法
    public void run() {
        // ThreadPoolExector -> runWork(Worker w) 这个是核心方法,等后面分析worker启动后逻辑的时候会以这里为切入点
        runWorker(this);
    }

    // Lock methods
    //
    // The value 0 represents the unlocked state.
    // The value 1 represents the locked state.
    // 判断当前worker的独占锁是否被独占
    // 0 表示未被占用
    // 1 表示已经占用
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }

    // 尝试去占用当前 worker 的独占锁
    //
    protected boolean tryAcquire(int unused) {
        // 使用 CAS 修改 AQS 中的state,期望值为0(0的时候表示未被占用),修改成功表示当前线程修改成功
        // 那么设置 ExclusiveOwnerThread 为当前线程
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    // 尝试释放当前 worker 的独占锁
    // 外部不会直接调用该方法,这个方法是 AQS的,外部调用 unlock的时候,unlock -> AQS.release -> tryRelease
    protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    // 加锁,加锁失败的时候,会阻塞当前线程,直到获取到锁位置
    public void lock()        { acquire(1); }

    // 尝试去加锁,如果当前锁是未被持有状态,加锁成功后会返回true,否则不会阻塞当前线程,直接返回false
    public boolean tryLock()  { return tryAcquire(1); }

    // 一般情况下,咱们调用unlock 要保证当前线程是持有锁的
    // 特殊情况,当 worker 的 state == -1的时候,调用 unlock 表示初始化state,设置 state == 0
    // 启动worker 之前会先调用 unlock() 这个方法,会强制刷新ExclusiveOwnerThread == null 和 state == 0
    public void unlock()      { release(1); }

    // 就是返回当前 worker 的lock 是否被占用
    public boolean isLocked() { return isHeldExclusively(); }

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

3.4、execute(Runnable command) 方法分析

// 线程池提交方法
// Runnable command:可以是普通的 Runnable 实现类,也可以是 FutureTask
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    // 获取ctl 最新值 ctl:高三位 表示线程池状态,低位表示当前线程池线程数量
    int c = ctl.get();
    // workerCountOf(c):获取当前线程池数量
    // 条件成立:表示当前线程数量小于核心线程数量,此次提交任务,直接创建一个新的worker,对应线程池中多了一个新线程
    if (workerCountOf(c) < corePoolSize) {
        // addWorker 即为创建线程的过程,会创建worker对象,并且将command作为fistTask
        // core == true:表示采用核心线程数量限制,false:表示采用 maximumPoolSize
        if (addWorker(command, true))
            // 创建成功后直接返回,addWorker 方法里面会启动新创建的worker,将firstTask执行
            return;
        // 执行到这条语句,说明addWorker 一定是失败了
        // 有几种可能?
        // 1.存在并发现象,execute 方法是有可能有多个线程同时调用的,当workerCountOf(c)<corePoolSize成立后
        // 其他线程可能也成立了,并且向线程池中创建了worker,这个时候线程池中线程数量已经达到了核心线程数,所以当前线程失败了
        // 2.当前线程池状态发生改变了,RUNNING SHUTDOWN STOP TIDYING TERMINATION
        // 当线程池状态是非 RUNNING 状态的时候,addWorker(firstWorker != null,true | false) 一定会失败
        // SHUTDOWN 状态下,也有可能创建成功,前提 firstTask == null 而且当前queue不为空,特殊情况,在addWorker方法中有说明
        c = ctl.get();
    }

    // 执行到这里有几种情况?
    // 1.当前线程数量已经达到了 corePoolSize
    // 2.addWorker 失败,并发导致
    // 条件成立:说明当前线程池处于RUNNING 状态,则尝试将 task 放入到workqueue中
    if (isRunning(c) && workQueue.offer(command)) {
        // 进入到内部的前提条件:当前线程池中的线程数量大于等于corePoolSize,并且当前线程池处于RUNNING状态,而且当前线程将command放入到workqueue成功
        // 再次获取ctl的值
        int recheck = ctl.get();
        // 条件一:! isRunning(recheck) 成立:说明你提交到队列之后,线程池状态被外部线程给修改了,比如:shutdown() shutdownNow()
        // 这种情况成立的话,说明线程池状态被外部线程给修改了,需要把刚刚提交的任务给删除掉
        // 条件二:remove(command) :有可能成功,也有可能失败
        // 成功:提交之后,线程池中的线程还未消费(处理)
        // 失败:提交之后,在shutdown() shutdownNow() 之前,就被线程池中的线程给处理了
        if (! isRunning(recheck) && remove(command))
            // 提交之后,线程状态为非RUNNING了且移除任务队列成功,走个拒绝策略
            reject(command);

        // 有几种情况会走到这里?
        // 1.当前线程池是RUNNING 状态
        // 2.线程池状态是非 RUNNING 状态,但是 remove 提交的任务失败
        // 担心当前线程池是 RUNNING 状态,但是线程池中的存活数量是0,这个时候,会很尴尬,任务没线程去跑了
        // 这里其实是一个担保机制,保证线程池在RUNNING 状态下,最起码得有一个线程在工作
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 执行到这里,有几种情况?
    // 1.workqueue.offer(command)失败,说明当前队列满了
    // 2.当前线程是非RUNNING 状态

    // 1.offer失败,需要做什么?说明当前queue满了,这个时候,如果当前线程数量尚未达到maximumPoolSize得话,尝试创建新得worker,直接执行command
    // 假设线程数量达到 maximumPoolSize 得话,这里会也会失败,也会走拒绝策略
    // 2.线程池状态为非RUNNING 状态,这个时候因为 command != null addWorker 一定是返回false
    else if (!addWorker(command, false))
        reject(command);
}

3.4、addWorker(Runnable firstTask, boolean core) 方法分析(重点)

// 返回值总结:
// true:表示worker 创建成功,且线程启动成功
// false:表示创建失败
// 1.线程池状态 rs > SHUTDOWN (STOP TIDYING TERMINATION)
// 2.rs == shutdown 但是队列中已经没有任务了 或者 当前状态是SHUTDOWN 且队列未空,但是当前任务的firstTask不为null
// 3. 当前线程池已经达到指定指标(corePoolSize / maximumPoolSize)
// 4.threadFactory 实现类创建的线程为null
// Runnable firstTask:可以为null,表示启动worker之后,worker 自动到queue中去获取任务,如果不是null,则worker优先执行 firstTask
// boolean core:表示采用的线程池的线程数限制,true:采用核心线程数限制,false:采用maximumPoolSize线程数限制
private boolean addWorker(Runnable firstTask, boolean core) {
    // 自旋操作:判断当前线程池状态是否允许创建线程
    retry:
    for (;;) {
        // 获取当前ctl值保存到c中
        int c = ctl.get();
        // 获取当前线程池运行状态保存到rs中
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        // 条件一:rs >= SHUTDOWN 成立:说明当前线程池状态不是RUNNING 状态
        // 条件二:前置条件:当前线程池状态不是RUNNING 状态 ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())
        // rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()
        // 表示:当前线程池状态是SHUTDOWN状态 && 当前提交的任务是null addWorker这个方法可能不是execute去调用的 && 当前任务队列不是空
        // 排除掉这种情况,当前线程池状态是SHUTDOWN状态,但是队列里面还有任务尚未处理,这个时候是允许添加worker的,但是不允许再次提交task
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            // 什么情况下会返回false?
            // 线程池状态 rs >= SHUTDOWN
            // rs == SHUTDOWN 但是队列中已经没有任务了 或者 rs == SHUTDOWN 且 firstTask != null
            return false;

        // 上面这些代码,就是判断当前线程池状态是否允许添加worker

        // 内部自旋操作:获取创建线程令牌的过程
        for (;;) {
            // 获取当前线程池中的线程数量,保存到wc中
            int wc = workerCountOf(c);
            // 条件一:wc >= CAPACITY 永远不成立,因为CAPACITY是一个5亿多的数字
            // 条件二:wc >= (core ? corePoolSize : maximumPoolSize)
            // core == true,判断当前线程数量是否 >= corePoolSize,会拿核心线程数量做限制
            // core == false,判断当前线程数量是否 >= maximumPoolSize,会拿最大线程数量做限制
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                // 执行到这里,说明当前已经无法添加线程了,已经达到指定限制了
                return false;

            // 条件成立:说明记录线程数量已经加1成功,相当于申请到了一块令牌
            // 条件失败:说明可能有其他线程,修改过ctl这个值了,CAS 发生了冲突
            // 可能发生过什么冲突?
            // 1.其他线程execute() 申请过令牌了,在这之前,改变了ctl的值,期望值c与内存中的ctl的值不符合,导致CAS 失败
            // 2.外部线程可能调用过 shutdown() 或者 shutdownNow() 导致线程池状态发生了变化了,ctl高三位表示线程池状态
            // 线程池状态改变后,CAS 操作也会失败
            if (compareAndIncrementWorkerCount(c))
                // 进入到这里,一定是CAS 失败,申请到令牌了,跳出外部自旋操作
                break retry;
            // CAS 失败,没有成功的申请到令牌
            // 获取最新的 ctl 值
            c = ctl.get();  // Re-read ctl
            // 判断当前线程池状态是否发生过变化,如果外部在这之前调用过shutdown 或者shurdownNow会导致线程池状态发生变化
            if (runStateOf(c) != rs)
                // 线程池状态发生变化后,直接返回到外层循环,外层循环负责判断当前线程池状态,是否允许创建线程
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    // CAS 成功,跳出外部自旋操作来到了这里

    // workerStarted:表示当前创建的worker是否已经启动 false:未启动 true:已经启动
    boolean workerStarted = false;
    // workerAdded:表示创建的worker是否添加到线程池中 false:未添加 true:已经添加
    boolean workerAdded = false;
    // w:表示后面创建worker 的一个引用
    Worker w = null;
    try {
        // 创建worker
        w = new Worker(firstTask);
        // 将新创建的worker 节点的线程赋值给t
        final Thread t = w.thread;
        // 为什么这里还要做 t != null 这个判断?
        // 为了防止ThreadFactory 实现类有bug,因为ThreadFactory 是一个接口,谁都可以实现
        // 防止程序员自己实现的ThreadFactory 实现类有bug,导致创建出来的Thread为null
        if (t != null) {
            // 将全局锁的引用保存到mainLock变量中
            final ReentrantLock mainLock = this.mainLock;
            // 持有全局锁,可能会阻塞,直到获取成功为止,同一时刻操作线程池内部相关的操作都必须持有锁
            mainLock.lock();

            // 从这里加锁之后,其他线程是无法修改线程池状态的
            try {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                // 获取最新的线程池运行状态保存到rs中
                int rs = runStateOf(ctl.get());

                // 条件一:rs < SHUTDOWN 成立:当前线程池处于RUNNING 状态,最正常的状态
                // 条件二: 前置条件:当前线程池状态不是RUNNING 状态
                // (rs == SHUTDOWN && firstTask == null):当前状态为SHUTDOWN 状态且firstTask为null
                // 其实判断的就是SHUTDOWN 状态下的特殊情况,只不过这里不再判断队列是否为空了
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    // t.isAlive() 当前线程start 后,线程isAlive 会返回true
                    // 防止程序员在ThreadFactory实现类创建线程返回给外部之前,将线程给start了
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // 将咱们创建的worker 添加到线程池中
                    workers.add(w);
                    // 获取最新当前线程池的线程数量
                    int s = workers.size();
                    // 条件成立:说明当前线程数量是一个新高,更新lagestPoolSize线程池中的线程最大数量
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    // 表示线程已经加入到线程池中了
                    workerAdded = true;
                }
            } finally {
                // 释放线程池全局锁
                mainLock.unlock();
            }
            // 条件成立:说明当前添加worker成功
            // 条件失败:说明线程池在lock之前,线程池状态发生了变化导致添加失败
            if (workerAdded) {
                // 成功后则将创建的worker启动
                t.start();
                // 启动标记设置为true
                workerStarted = true;
            }
        }
    } finally {
        // 条件成立:说明添加当前线程到线程池失败或者启动线程失败,需要做清理工作
        // 1.释放令牌
        // 2.将当前worker 清理出workers集合
        if (! workerStarted)
            addWorkerFailed(w);
    }
    // 返回新创建的线程是否启动
    return workerStarted;
}

addWorkerFailed(Worker w) 方法

// addWorker添加线程到线程池中失败或者线程启动失败的后续工作,两个操作
// 1.释放令牌
// 2.将当前worker 清理出workers集合
private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    // 持有线程池全局锁,因为操作的是线程池相关的东西
    mainLock.lock();
    try {
        // 条件成立:需要将worker 在workers 中清理除去
        if (w != null)
            workers.remove(w);
        // 线程池计数恢复-1,前面+1获取令牌了,这里因为失败,所以要-1,相当于归还令牌
        decrementWorkerCount();
        // 回头讲,shutdown shutdownNow再说
        tryTerminate();
    } finally {
        // 释放线程池全局锁
        mainLock.unlock();
    }
}

3.5、runWorker(Worker w) 方法分析

// w:就是启动worker
final void runWorker(Worker w) {
    // wt == w.thread
    Thread wt = Thread.currentThread();
    // 将初始执行的task赋值给task
    Runnable task = w.firstTask;
    // 清空当前w.firstTask的引用
    w.firstTask = null;
    // 这里为什么先调用unlock? 就是为了初始化worker state = 0 和 ExclusiveOwnerThread = null
    // 启动worker 之前会先调用 unlock() 这个方法,会强制刷新ExclusiveOwnerThread == null 和 state == 0
    w.unlock(); // allow interrupts

    // 是否是突然退出?如果为true,表示发生异常了,当前线程突然退出的,回头需要做一些处理 false:表示正常退出的
    boolean completedAbruptly = true;

    try {
        // 条件一:task != null 指的就是firstTask 是否为null 如果是null,直接执行循环体里面
        // 条件二:(task = getTask()) != null 条件成立:说明当前线程在queue中获取任务成功,getTask是会阻塞线程的方法
        // getTask()如果返回null,说明当前线程需要执行退出逻辑
        while (task != null || (task = getTask()) != null) {
            // worker 设置独占锁为当前线程
            // 为什么要设置独占锁呢?就是怕shutdown()的时候会判断当前worker状态,根据独占锁是否空闲来判断当前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

            // 条件一:runStateAtLeast(ctl.get(), STOP) 说明线程池状态大于等于STOP,线程池目前处于STOP/TIDYING/TERMINATION,此时线程一定要给它一个中断信号
            // 条件一成立:(runStateAtLeast(ctl.get(), STOP) && !wt.isInterrupted()
            // 上面条件如果成立,说明当前线程池状态是大于等于STOP且当前线程是未设置中断状态的,此时需要进入到if里面,给当前线程一个中断

            // 假设:(runStateAtLeast(ctl.get(), STOP) == false
            // (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))
            // Thread.interrupted() 获取当前中断状态,且设置中断位为false,连续调用两次interrupted()方法,第二次一定是返回false
            // runStateAtLeast(ctl.get(), STOP):大概率这里还是false
            // 其实它在强制刷新当前线程的中断标记为false,因为有可能上一次执行task的时候,业务代码里面将线程的中断标记位设置为了true且没有做处理
            // 所以这里一定要强制刷新一下,不会再影响到后面的task了
            // 假如:Thread.interrupted() == true && runStateAtLeast(ctl.get(), STOP) == true
            // 这种情况有可能发生嘛?
            // 有可能,因为外部线程再当前线程第一次(runStateAtLeast(ctl.get(), STOP) == false后,有机会调用shutdown shutdownNow方法将线程池状态修改
            // 这个时候也会将当前线程的中断标记位再次设置为中断状态
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();

            try {
                // 钩子方法,留给子类实现的
                beforeExecute(wt, task);
                // 表示异常情况,如果thrown不为空,表示task运行过程中发生了异常,向上层抛出了异常
                Throwable thrown = null;
                try {
                    // task可能是firstTask,也可能是普通的runnable接口实现类
                    // 如果前面是通过submit()提交的runnable/callable会被封装成FutureTask对象
                    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
                task = null;
                // 更新worker完成任务数量
                w.completedTasks++;
                // worker 处理完一个任务后会释放独占锁,然后再次到queue中获取任务
                // 1.正常情况下会再次回到getTask()那里获取任务 while(getTask())
                // 2.task.run()内部抛出异常了
                w.unlock();
            }
        } // while
        // 什么情况下会来到这里?
        // getTask()返回null的时候,说明当前线程应该执行退出逻辑了
        completedAbruptly = false;
    } finally {
        // task.run() 内部抛出异常的时候,当上面的finally执行完以后跳到这里
        // 正常提出 completedAbruptly = false 异常退出:completedAbruptly = true
        // 这个方法以后再说
        processWorkerExit(w, completedAbruptly);
    }
}

3.6、getTask() 方法分析(重点)

// 什么情况下会返回null?
// 1.rs >= STOP成立说明:当前线程池的状态最低也是STOP状态,一定要返回null了
// 2.说明当前线程池状态为SHUTDOWN状态且任务队列已经为null,此时一定要返回null
// 3.线程池中的线程数量超过最大限制的时候,会有一部分线程返回为null
// 4.线程池中的线程数超过corePoolSize的时候,会有一部分线程超时后返回null
// 到当前的任务队列queue中去获取任务
private Runnable getTask() {
    // 表示当前线程获取任务是否超时 默认false true表示已经超时
    boolean timedOut = false; // Did the last poll() time out?

    // 自旋
    for (;;) {

        // 获取最新ctl的值保存到c中
        int c = ctl.get();
        // 获取当前线程池的运行状态
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        // 条件一:rs >= SHUTDOWN 条件成立:说明当前线程池是非RUNNING 状态,可能是SHUTDOWN/STOP/TIDYING/TERMINATION//
        // 条件二:rs >= STOP || workQueue.isEmpty()
        // 2.1:rs >= STOP成立说明:当前线程池的状态最低也是STOP状态,一定要返回null了
        // 2.2:前置条件:状态是SHUTDOWN,workqueue.isEmpty() 条件成立:说明当前线程池状态为SHUTDOWN状态且任务队列已经为null,此时一定要返回null
        // 返回null,runworker()方法就会将返回null的线程执行退出线程池的逻辑
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            // 使用CAS + 死循环的方式将ctl的值-1
            decrementWorkerCount();
            return null;
        }

        // 执行到这里,有几种情况:
        // 1.线程池是RUNNING 状态
        // 2.线程池是SHUTDOWN 状态,但是队列queue还未为空,此时可以创建线程(添加worker)

        // 获取线程池中的线程数量
        int wc = workerCountOf(c);

        // timed == true:表示当前这个线程获取task的时候是支持超时机制的,使用queue.poll(时间单位,数量)
        // 当获取task超时的情况下,下一次自旋就可能返回null了
        // timed == false:表示当前这个线程获取task的时候是不支持超时机制的,当前线程会使用 queue.take()

        // 情况一:allowCoreThreadTimeOut == true 表示核心线程数量内的空闲线程可以被回收,所有线程都是使用queue.poll()超时机制这种方式获取task
        // 情况二:allowCoreThreadTimeOut == false 表示当前线程池会维护核心数量内的线程

        // wc > corePoolSize:条件成立:当前线程池中的线程数量是大于核心线程数的,此时让所有路过这里的线程都使用poll,超时的方式去获取任务
        // 这样就可能会有一部分线程获取不到任务,返回null,然后runworker会执行线程退出逻辑
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        // 条件一:(wc > maximumPoolSize || (timed && timedOut)
        // 1.1:wc > maximumPoolSize 为什么会成立?setMaximumPoolSize() 方法,可能外部线程将线程池最大线程数设置为比初始化时的要小
        // 1.2:timed && timedOut 条件成立:前置条件,当前线程使用poll()的方式从队列queue中获取worker执行,上一次循环的时候,使用poll的方式获取任务的时候,超时了
        // 条件一为true:表示线程可以被回收,达到回收的标准,当确实需要回收的时候再回收
        // 条件二:wc > 1 || workQueue.isEmpty()
        // 2.1:wc > 1:条件成立,说明当前线程池中还有其他线程,当前线程不需要从队列中获取任务可以直接回收
        // 2.2:workQueue.isEmpty():前置条件,条件成立:wc == 1 ,说明当前任务队列已经空了,最后一个线程,也可以放心的退出
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            // 使用 CAS 机制,将ctl的值减去1,减一成功的线程返回null
            // CAS 失败?为什么会CAS 失败?
            // 1.其他线程先你一步推出了
            // 2.线程池状态发生变化了
            if (compareAndDecrementWorkerCount(c))
                return null;
            // 再次自旋的时候,timed有可能就是false了,因为当前线程CAS失败,很有可能是因为其他线程成功退出导致的,再次查询的时候
            // 检查发现,当前线程就可能属于不需要回收范围内了
            continue;
        }

        // 获取任务的逻辑
        try {
            // poll(long timeout, TimeUnit unit):从BlockingQueue取出一个队首的对象,如果在指定时间内,
            // 队列一旦有数据可取,则立即返回队列中的数据。否则直到时间超时还没有数据可取,返回失败。
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                // take 方法:获取队列中的第一个元素,如果被阻塞,则等待
                workQueue.take();

            // 条件成立:返回任务
            if (r != null)
                return r;
            // 说明当前线程超时了
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

3.7、processWorkerExit(Worker w, boolean completedAbruptly) 方法分析

// 线程退出的逻辑
// w:线程执行的worker要获取任务
// completedAbruptly:线程是否发生异常 true:表示线程发生了异常 false:表示线程没有发生异常
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    // 条件成立:代表当前w这个worker 是发生异常退出的 task任务执行过程中向上抛出了异常
    // 异常退出的时候,ctl的线程数量并没有-1
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();

    // 获取线程池的全局锁引用
    final ReentrantLock mainLock = this.mainLock;
    // 加锁
    mainLock.lock();
    try {
        // 将当前worker完成的task数量,汇总到线程池的completedTaskCount
        completedTaskCount += w.completedTasks;
        // 将worker 从任务中移除
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }

    // 回头再说
    tryTerminate();

    // 获取最新的ctl值
    int c = ctl.get();
    // 条件成立:说明当前线程池状态为RUNNING 或者 SHUTDOWN 状态
    if (runStateLessThan(c, STOP)) {
        // 条件成立:说明当前线程是正常退出的
        if (!completedAbruptly) {
            // min:表示线程池最低持有的线程数量
            // allowCoreThreadTimeOut == true:说明核心线程数内的线程,也会超时被回收 min = 0
            // allowCoreThreadTimeOut == false:说明核心线程数内的线程,不会超时被回收 min = corePoolSize
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;

            // 前提状态:线程池状态为RUNNING SHUTDOWN
            // 条件一: min == 0成立
            // 条件二:! workQueue.isEmpty() 说明任务队列中还有任务,最起码留一个线程
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;

            // 条件成立:线程池中还拥有足够的线程
            // 考虑一个问题:workerCountOf(c) >= min => (0 >= 0)
            // 有可能!
            // 什么情况下,当线程池中的核心线程数是可以被回收的,会出现这种情况,这种情况下,当前线程池中的线程数会变为0
            // 下次再提交任务的时候,会再次创建线程
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }

        // 1.当前线程再执行task的时候发生异常,这里一定要创建一个新的worker顶上去
        // 2.! workQueue.isEmpty() 说明任务队列中还有任务,最起码要留一个线程,当前状态为 RUNNING | SHUTDOWN
        // 3.线程数量小于corePoolSize值,此时会创建线程,维护线程池中的线程数量在corePollSize左右
        addWorker(null, false);
    }
}

3.8、shutdown() 方法分析

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    // 获取线程池的全局锁
    mainLock.lock();
    try {
        // 判断是否有权限
        checkShutdownAccess();

        // 设置线程池的状态为 SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 中断空闲线程
        interruptIdleWorkers();
        // 空方法,子类可以扩展
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        // 释放线程池全局锁
        mainLock.unlock();
    }
    // 后面再说
    tryTerminate();
}

// 中断空闲线程
private void interruptIdleWorkers() {
    interruptIdleWorkers(false);
}

// 通过自旋操作设置线程池的状态为SHUTDWON
private void advanceRunState(int targetState) {
    // 自旋
    for (;;) {
        int c = ctl.get();
        // 条件一成立:假设targetState == SHUTDOWN,说明当前线程池状态是 >= SHUTDOWN
        // 条件一不成立:假设targetState == SHUTDOWN,说明当前线程池状态是 RUNNING
        if (runStateAtLeast(c, targetState) ||
            ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
            break;
    }
}

3.9、tryTerminate() 方法分析

final void tryTerminate() {
    // 自旋操作
    for (;;) {
        // 获取最新ctl的值
        int c = ctl.get();
        // 条件一:isRunning(c) 成立:直接返回就行了,线程池很正常
        // 条件二:runStateAtLeast(c, TIDYING) 说明已经有其他线程在执行 TIDYING 转到 TERMIATION 状态了,当前线程直接回去
        // 条件三:runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()
        // SHUTDOWN 特殊情况,如果是这种情况,直接回去,得等队列中得任务处理完后再转化状态
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;

        // 什么情况会执行到这里?
        // 1.线程池状态为 STOP 得时候
        // 2.线程池状态为 SHUTDWON并且队列已经空了
        // 条件成立:当前线程池中得线程数量 > 0
        if (workerCountOf(c) != 0) { // Eligible to terminate
            // 中断一个空闲线程
            // 空闲线程在哪空闲呢?queue.take() 或者 queue.poll()
            // 1.唤醒后的线程会在getTask方法返回null
            // 2.执行退出逻辑得时候,会再次调用 tryTerminate 方法,唤醒下一个空闲线程
            // 3.因为线程池状态是(线程池状态为 STOP 得时候 | 线程池状态为 SHUTDWON并且队列已经空了) 最终调用addWorker得时候会失败得
            // 最终空闲线程都会在这里退出,非空闲线程当执行完当前task得时候,也会调用tryTerminate方法,有可能会走到这里
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        // 执行到这里得线程是谁?
        // workerCountOf(c) == 0得时候,会来到这里
        // 最后一个退出得线程,咱们知道,在(线程池状态 == STOP | 线程池状态为 SHUTDWON并且队列已经空了)
        // 线程唤醒后,都会执行退出逻辑,退出过程中会先将 workerCount 计数 -1 => ctl中得计数-1
        // 调用 tryTerminate方法之前,已经减过了,所以 0 得时候,表示这是最后一个退出得线程了
        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
    }
}

3.10、shutdownNow() 方法分析

public List<Runnable> shutdownNow() {
    // 返回值引用
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    // 获取线程池的全局锁
    mainLock.lock();
    try {
        // 校验权限
        checkShutdownAccess();
        // 设置线程池状态为STOP
        advanceRunState(STOP);
        // 中断线程池中的所有线程
        interruptWorkers();
        // 导出未处理的task
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    // 返回当前任务队列中未处理的任务
    return tasks;
}

至此,线程池 ThreadPoolExecutor 类源码就告一段落了,下面会开始更新 AQS 部分的内容,如果有错误,请指正!

上一篇:Lotus | Filecoin | Sector-storage部分源码与模块理解


下一篇:【转】Android APK反编译就这么简单 详解(附图)