JUC源码分析-线程池篇（一）：ThreadPoolExecutor

JUC源码分析-线程池篇（一）：ThreadPoolExecutor

Java 中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。在开发过程中，合理地使用线程池能够带来 3 个好处。

• 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
• 第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

1. ThreadPoolExecutor 执行流程

ThreadPoolExecutor 执行 execute 方法分下面 4 种情况。

1）如果当前运行的线程少于 corePoolSize，则创建新线程来执行任务（注意，执行这一步骤需要获取全局锁）。

2）如果运行的线程等于或多于 corePoolSize，则将任务加入 BlockingQueue。

3）如果无法将任务加入 BlockingQueue（队列已满），则创建新的线程来处理任务（注意，执行这一步骤需要获取全局锁）。

4）如果创建新线程将使当前运行的线程超出 maximumPoolSize，任务将被拒绝，并调用 RejectedExecutionHandler.rejectedExecution() 方法。

ThreadPoolExecutor 采取上述步骤的总体设计思路，是为了在执行 execute() 方法时，尽可能地避免获取全局锁（那将会是一个严重的可伸缩瓶颈）。在 ThreadPoolExecutor 完成预热之后（当前运行的线程数大于等于 corePoolSize），几乎所有的 execute() 方法调用都是执行步骤2，而步骤2不需要获取全局锁。

上面的流程分析让我们很直观地了解了线程池的工作原理，让我们再通过源代码来看看是如何实现的，线程池执行任务的方法如下。我们从 execute 入手分析源码。

2. ThreadPoolExecutor 源码分析

2.1 主要属性

2.1.1 线程池生命周期

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; // 关闭线程池后，线程全部关闭后的状态，之后回调 terminated
private static final int TERMINATED =  3 << COUNT_BITS; // 回调 terminated 方法后状态变为 TERMINATED

线程池用 ctl 的低 29 位表示线程池中的线程数，高 3 位表示当前线程状态。

• RUNNING：运行状态，高3位为111；
• SHUTDOWN：关闭状态，高3位为000，在此状态下，线程池不再接受新任务，但是仍然处理阻塞队列中的任务；
• STOP：停止状态，高3位为001，在此状态下，线程池不再接受新任务，也不会处理阻塞队列中的任务，正在运行的任务也会停止；
• TIDYING：高3位为010；
• TERMINATED：终止状态，高3位为011。

2.1.2 线程状态标识 ctl

// ctl 高3位表示线程池状态，低29位表示当前工作线程数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;         // 低29位表示工作线程数
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;    // 最大线程数 0x1fffffff

// 获取线程池状态、线程总数、构造 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; }

2.1.3 其它属性

// 全局锁，创建工作线程等操作时需要获取全局锁
private final ReentrantLock mainLock = new ReentrantLock();
private final Condition termination = mainLock.newCondition();

// 工作线程
private final HashSet<Worker> workers = new HashSet<Worker>();
private int largestPoolSize;
private volatile int corePoolSize;

2.2 任务提交 execute

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    // ctl 高3位表示线程池状态，低29位表示当前工作线程数
    int c = ctl.get();
    // 1. 小于核心线程数，创建新的线程执行任务。需要获取全局锁
    if (workerCountOf(c) < corePoolSize) {
        // addWorker 创建新的工作线程，true 表示核心线程数，false 表示最大线程数
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 2. 核心线程已满，将任务提交到队列中。不需要获取全局锁
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 2.1 刚好此时线程池关闭了，则需要将任务从队列中踢除
        if (!isRunning(recheck) && remove(command))
            reject(command);    // 任务被踢除后回滚，执行拒绝任务
        // 2.2 线程池工作线程为0，创建一个新的工作线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3. 队列满后且线程数小于最大线程数，则创建新的线程执行任务。需要获取全局锁
    // 4. 超出最大线程拒绝任务
    else if (!addWorker(command, false))
        reject(command);
}

2.3 工作线程 Worker

工作线程：线程池创建线程时，会将线程封装成工作线程 Worker，Worker 在执行完任务后，还会循环获取工作队列里的任务来执行。我们可以从 Worker 类的 run() 方法里看到这点。

// Worker 是对线程 Thread 的包装，实现了 AbstractQueuedSynchronizer
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
    final Thread thread;    // 包装的线程
    Runnable firstTask;     // 线程初始化时的任务，可以为 null

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

    public void run() {
        runWorker(this);
    }
}

思考：Worker 为什么要继承 AbstractQueuedSynchronizer 实现自己的锁，而不使用 ReentrantLock 呢？

实际上 ReentrantLock 是可重入锁，而 Worker 实现的是独占锁，只有三种状 -1(初始化)、0(释放锁)、1(占有锁)。Worker 之所以实现独占锁是为了避免在线程执行的时候被 interrupted 中断（下面会讲到）。

2.4 创建工作线程 addWorker

// addWorker 创建一个新的工作线程
// firstTask 线程初始化任务，可以为 null；core 表示是核心线程还是最大线程
private boolean addWorker(Runnable firstTask, boolean core) {
    // 1. 通过自旋线程数+1 compareAndIncrementWorkerCount
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // 1.1 一、STOP 不能创建新线程
        //     二、SHUTDOWN 时 workQueue 为空，也不能创建新线程
        //        firstTask 表示线程初始化任务，是新提交的任务，SHUTDOWN 时拒绝新提交的任务
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
            return false;
        // 1.2 自旋使线程数+1
        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)    // 不断检查线程池状态变化
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    // 2. 创建线程 Worker
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 2.1 初始化工作线程 Worker，使用全局锁添加到 workers 队列中
        w = new Worker(firstTask);
        final Thread t = w.thread;  // threadFactory 可能创建线程失败，返回 null
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                int rs = runStateOf(ctl.get());
                // 2.2 一、RUNNING可以创建新线程
                //     二、SHUTDOWN不接收新任务，但会执行完 workQueue 的任务 ，因此可以创建空任务的线程
                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 表示线程池运行过程中达到的最大线程数
                        largestPoolSize = s;
                    workerAdded = true;         // 工作线程添加到 workers 成功
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                t.start();
                workerStarted = true;           // 启动线程成功
            }
        }
    } finally {
        // 2.3 创建工作线程失败，回滚
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

总结：

1. addWorker 前半部分主要是判断能否新建工作线程，如果允许则执行 compareAndIncrementWorkerCount(c)，利用 CAS 原则，将线程数量+1。
2. addWorker 后半部分则是真正创建工作线程并启动，这个过程需要获取全局锁。创建失败则需要回滚 addWorkerFailed。

addWorker 的 4 种调用方式：

1. addWorker(command, true) 线程数 < coreSize 时，则创建新线程
2. addWorker(command, false) 当①阻塞队列已满，②线程数 < maximumPoolSize 时，则创建新线程
3. addWorker(null, true) 同 1。只是线程初始化任务为 null，相当于创建一个新的线程。实际的使用是在 prestartCoreThread() 等方法，有兴趣的读者可以自行阅读，在此不做详细赘述。
4. addWorker(null, false) 同 2。只是线程初始化任务为 null，相当于创建一个新的线程，没立马分配任务；

2.4 线程执行 runWorker

在 addWorker 创建线程后调用 t.start() 启动线程，run 方法主要干了一件事，调用 runWorker(this)，接下来我们来看看 runWorker 的具体实现。

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;    // 线程初始化任务 task
    w.firstTask = null;
    // 1. Worker 是独占锁，此时状态由 -1 -> 0，也就是其它线程才能获取w的锁，进而interrupt
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // 2. 循环通过 getTask 获取任务，如果不能获取任务了，退出循环，关闭线程池
        //    也就是说 getTask 返回 null 时线程就关闭了
        while (task != null || (task = getTask()) != null) {
            w.lock();   // 获取锁，这样在线程执行过程中不能中断线程(interrupt)
            // 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
            //
            // 3.1 线程池已经STOP，如果线程还没有被中断(wt.isInterrupted=false)，则调用wt.interrupt中断线程
            // 3.2 如果runStateAtLeast(ctl.get(), STOP)=false，则说明线程池处于RUNNING或SHUTDOWN状态
            //     调用 Thread.interrupted() 后会清空线程的 interrupted 状态
            //     Thread.interrupted()&& false 结果始终为 false，这里仅仅是为了调用Thread.interrupted()
            //  实际上就是：一如果线程已经STOP，则一定要将线程 interrupt
            //             二如果线程处于运行状态(包括SHUTDOWN)，则一定不能 interrupt(也就是要清除 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;              // true时表示正常退出，false表示异常退出
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

总结，runWoker 具体实现：

1. 线程启动后，释放锁，设 AQS 状态为 0，释放锁。此时其它线程才可以获取锁，中断线程 interrupt；
2. 获取 firstTask 任务并执行，执行任务前后可定制 beforeExecute 和 afterExecute;
3. 如果 getTask 从阻塞队列获取等待任务执行，如果获取的任务为 null，while 则退出循环，线程关闭。
4. 如果线程已经STOP，则一定要将线程 interrupt。如果线程处于运行状态(包括SHUTDOWN)，则一定不能 interrupt。但实际上 interrupt() 方法并不一定能中断正在运行的线程，它只能唤醒 wait 阻塞的线程或给线程设置一个标记位。业务线程必须对 interrupt 做出响应才能中断线程，否则会一直等线程执行结束才会销毁。

2.5 获取任务 getTask

// 注意 getTask 前 worker 释放了锁，也就是可能被 interrupt 唤醒
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?
    for (;;) {      // 自旋获取任务
        int c = ctl.get();
        int rs = runStateOf(c);

        // 1. ①STOP直接销毁线程，②SHUTDOWN时任务队列为空时也直接销毁线程
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();      // 原子性更新，工作线程数-1
            return null;
        }

        int wc = workerCountOf(c);      // 当前工作线程数
        // 2.1 timed表示是否可以销毁线程。timed=true表示超时获取任务，则可能返回null
        //     当线程数大于核心线程数或允许销毁核心线程时 timed=true
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        // 2.2 一是超过了最大线程数，当线程池启动后手动修改最大线程数可能会出现这种情况
        //     二是当允许销毁线程时，获取任务超时
        // 2.3 三是线程池中至少有一个工作线程或任务队列为空，则可以销毁线程
        if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))      // 失败重试，此时线程数已经-1
                return null;
            continue;
        }

        try {
            // 3. 获取任务，无限等待则不会返回 null，也就不会销毁线程。而限时等待则可能返回 null
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;   // 其它线程唤醒等待的线程
        }
    }
}

总结，整个 getTask 循环实现：

1. getTask 时，worker 已经释放了锁，也就是说其它线程可以调用 wt.interrupt() 唤醒等待的线程。
2. 如果当前线程数大于最大线程数，或允许核心线程销毁时，如果获取任务超时则返回 null，即销毁线程。

2.6 线程关闭

2.6.1 shutdown 和 shutdownNow

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();      // 权限检查
        advanceRunState(SHUTDOWN);  // 更新线程池状态为 SHUTDOWN
        interruptIdleWorkers();     // 关闭所有的空闲线程
        onShutdown();               // 子类实现，如 ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate();     // 尝试停止线程池
}

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();  // 权限检查
        advanceRunState(STOP);  // 更新线程池状态为 SHUTDOWN
        interruptWorkers();     // 关闭所有的线程
        tasks = drainQueue();   // 返回还未执行的任务
    } finally {
        mainLock.unlock();
    }
    tryTerminate();     // 尝试停止线程池
    return tasks;
}

总结，shutdown 和 shutdownNow 区别：

1. shutdown 会执行完成已提交的任务后关闭线程池，而 shutdownNow 则会踢除已提交的任务。
2. shutdown 调用 interruptIdleWorkers 关闭空闲的线程，而 shutdownNow 调用 interruptWorkers 强行中断所有的线程。

2.6.2 interruptIdleWorkers 和 interruptWorkers

// 关闭所有的空闲线程
private void interruptIdleWorkers() {
    interruptIdleWorkers(false);
}

// 中断线程实际上是调用 t.interrupt()，需要获取线程锁 w.tryLock
private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) {
            Thread t = w.thread;
            // 只有空闲线程才能获取锁，正在执行的线程无法获取锁，也就无法中断
            // 这也就是为什么 Worker 要实现独占锁的原因。
            if (!t.isInterrupted() && w.tryLock()) {    // 需要获取w的独占锁
                try {
                    t.interrupt();  // 实际上是调用 t.interrupt() 中断线程
                                    // 实际上是给能线程设置一个标记位
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}

interruptIdleWorkers 只会尝试获取锁，因此只会中断空闲线程。而 interruptWorkers 不需要获取锁，强行中断线程。实际上业务线程必须对 interrupt 做出响应才能中断线程，否则会一直等线程执行结束才会销毁。

private void interruptWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers)
            w.interruptIfStarted();
    } finally {
        mainLock.unlock();
    }
}
// 调用Worker#interruptIfStarted 不需要获取锁
void interruptIfStarted() {
    Thread t;
    if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
        try {
            t.interrupt();
        } catch (SecurityException ignore) {
        }
    }
}

而 interruptIdleWorkers 和 interruptWorkers 都是 interrupt 所有线程， 因此大部分线程将立刻被中断。之所以是大部分，而不是全部，是因为 interrupt() 方法能力有限。 如果线程中没有 sleep 、wait、Condition、定时锁等应用, interrupt() 方法是无法中断当前的线程的。所以，ShutdownNow() 并不代表线程池就一定立即就能退出，它可能必须要等待所有正在执行的任务都执行完成了才能退出。 如下面这个线程永远不会中断，因为该线程没有响应 Thread.interrupted() 或者是直接将 InterruptedException 异常 catch 了。

// 无法响应 interrupted，线程永远无法中止。
executorService.submit(() -> { while (true) System.out.println("go go go"); });
executorService.shutdownNow();

2.6.3 tryTerminate

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        // 1. RUNNING或SHUTDOWN还有任务执行时不能关闭，TIDYING则已经关闭
        if (isRunning(c) ||                 // 1.1 正在运行，不能中断
            runStateAtLeast(c, TIDYING) ||  // 1.2 已经中断，不需要执行
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))   // 1.3 SHUTDOWN时还有任务执行
            return;
        // 2. 还有线程则关闭空闲线程
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 3. 工作线程数为0时，可以关闭线程池了，设置线程状态为TIDYING，
            //    并回调terminated后，线程的状态最终变为TERMINATED
            // 4. 线程状态设置失败，则 CAS 自旋
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    terminated();
                } finally {
                    ctl.set(ctlOf(TERMINATED, 0));
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

除了 shutdown 和 shutdownNow 外，addWorkerFailed、processWorkerExit、remove 等方法也会调用 tryTerminate 方法。

参考：

1. 《Java并发编程的艺术》

---

每天用心记录一点点。内容也许不重要，但习惯很重要！