java8 线程池 ThreadPoolExecutor 源码解析

前言

在看 Java 线程池源码实现之前，只知道线程池是为了多线程执行任务时线程复用，防止创建过多的线程销毁系统资源。但是对线程复用只有一个模糊的概念，什么是线程复用，如何线程复用，确实说不出个所以然来。看过源码后，疑惑也就解决了。在线程池中它本身会创建一些线程，这些线程干嘛的呢？就是执行你扔到线程池里的 Runnable 的 run() 方法。说的更浅显点，你实现了 Thread 类和其 run() 方法，把 thread 提交到线程池中，这个线程池并不是调用 thread.start() 启动该线程。而是线程池本身存活着一些线程，这些线程的 run() 方法直接调用你提交到线程池的 Runnable的 run 方法。比如你线程池里面维持着 5 个线程，你提交 100 个 Runnale 给线程池，那么这 5个线程的 run 方法执行折 100 个 Runnable 的 run() 方法。这样就达到了线程复用，而不是启动这 100 个 Runnable。明白了这些，再看看线程池源码中是如何具体的实现的。

构造器

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue)

这是我们创建线程池常用的构造方法。

corePoolSize

线程池核心线程的数量，当线程池中添加任务的时候，每添加一个 Runnable 任务就会创建一个核心线程，直到数量达到 corePoolSize。

workQueue

队列，当核心线程已满，且都在执行任务的时候，再往线程池提交的任务会缓存在workQueue 中。

maximumPoolSize

线程池可以创建线程的上限数量。当线程池核心线程和 workQueue 都已经达到上限的情况下，再往线程池塞任务，会创建非核心线程来执行新任务，非核心线程和核心线程的数量和阈值为 maximumPoolSize。后文说的工作线程包括核心线程和非核心线程。

keepAliveTime

非核心线程空闲 keepAliveTime 时间后会进行回收。当然，核心线程也可以开启空闲 keepAliveTime 后进行回收，默认没有开启。

unit

keepAliveTime 的时间单位

通过构造器的参数介绍，也就大概明白线程池的大致逻辑 了。

线程池状态

ThreadPoolExecutor 很巧妙的用一个原子变量 ct1 来代表线程池的状态和当前执行任务的数量。

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

ct1 变量的 32 位的最高三位表示线程池状态，分别代表了 5 种状态：

 private static final int COUNT_BITS = Integer.SIZE - 3; // 等于29

    // 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;

Running:线程池可接收新任务，32 位的最高三位为 101，所以其值是 -1<<29

SHUTDOWN:线程池不再接收新任务，但是缓存在 workQueue 中的任务还会执行，最高三位为 000

STOP：线程池不再接收新任务，不再处理 workQueue 中的任务，正在执行的任务打上中断标志。状态为 001.

TIDYING:线程池中所有任务都已经暂停，线程池不再存活工作线程。可以通过 terminated() 钩子方法进入该状态。状态位为 010

TERMINATED: terminated() 执行完成。

从值大小的角度来看，各个状态值是从小到大的。那么各个状态是如何转换的呢？
当运行中的线程池执行 shutdown() 方法，会从 RUNNING 状态转到 SHUTDOWN。当执行 shutdownNow() 方法时，会从 RUNNING 或者 SHTDOWN 状态转换到 STOP 状态。当线程池没有线程存活且缓存队列为空时，会从 STOP 转换到 TIDYING。当钩子方法 terminated() 执行完成，会从 TIDYING 转换到 TERMINATED。这就是类似于线程池的生命周期了。

ctl 变量的后 29 位表示线程池的工作线程数量，所以创建工作线程的最大容量为：

private static final int CAPACITY   = (1 << COUNT_BITS) - 1; //2^29 -1

所以，我们可以通过 ctl 变量的最高三位得到当前线程池状态，后 29 位得到工作线程数量

private static int runStateOf(int c)     { return c & ~CAPACITY; } //获得状态值
    private static int workerCountOf(int c)  { return c & CAPACITY; } // 获得工作线程数量

execute

我们创建线程池对象后，通过 execute 方法将 Runnable 任务提交到线程池中执行。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();

        int c = ctl.get(); // 表示状态和工作线程数量的变量值大小
        if (workerCountOf(c) < corePoolSize) { //工作线程数量小于核心线程数量
            if (addWorker(command, true)) //创建核心线程，执行 command 任务
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) { //核心线程已满，检测任务是否能塞入缓存队列中
            int recheck = ctl.get(); //重新检查 ctl 值
            if (! isRunning(recheck) && remove(command)) //此时不处于 Running 状态，不接受新任务
                reject(command); //报错
            else if (workerCountOf(recheck) == 0)
            //没有工作线程，创建一个非核心工作线程，用来执行塞入队列中的任务
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
         // 任务添加队列失败，看是否可以再添加一个工作线程，工作线程数在（corePoolSize, maximumPoolSize）之间
            reject(command);
    }

总体逻辑如下：
当线程池工作线程数量小于核心线程时，创建一个核心线程执行新任务;否则尝试将新任务塞入到缓存队列中，塞入成功后继续再次判断当前工作线程数量，如果此时没有工作线程了，创建一个非核心工作线程，用来执行塞入队列中的任务。（那么怎样读取队列中的任务并执行呢？后文将介绍）如果塞入队列失败，则尝试创建一个非核心线程执行新任务。

创建工作线程

那么如何创建工作线程执行任务呢？

/**
* core ： true 核心线程 false: 非核心线程
*/
 private boolean addWorker(Runnable firstTask, boolean core) {
        retry: //retry 循环
        for (;;) { //自旋锁
            int c = ctl.get();
            int rs = runStateOf(c); //线程池当前状态

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && 
                    ! (rs == SHUTDOWN &&
                            firstTask == null &&
                            ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c); //当前工作线程数量
                if (wc >= CAPACITY ||
                        wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c)) // ctl 的工作线程数量加1（原子操作）
                    break retry; //终止 retry循环
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask); //创建新的工作线程，work 为工作线程的包装类
            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()); //再次检测状态，防止多线程中被改动

                    if (rs < SHUTDOWN ||
                            (rs == SHUTDOWN && firstTask == null)) {
                            //线程池处于 Running 或者 SHUTDOWN 但是 firstTask 为 null 
                            //线程池 SHUTDOWN，缓存队列中有任务但是工作线程数量为0，此时也需要创建新线程进行处理
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w); //保存新建的工作线程 work
                        int s = workers.size();  //当前线程池最新工作线程数量
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start(); //启动工作线程
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w); //启动工作线程失败，报错
        }
        return workerStarted;
    }

整个添加新的工作线程逻辑就是判断当前线程池的状态，根据不同的状态做出不同处理。
这里需要根据 ctl 值作出不通的操作，所以需要 ReentrantLock 锁保证多线程安全性。
当需要创建一个新的工作线程时，会将任务塞到 Worker 中， Worker 是工作线程的封装类，Worker 的 run() 方法会执行 firstTask 的run() 方法，这是线程复用的原理所在。所以必须看看 Work 类。

Worker – 工作线程封装类

private final class Worker
            extends AbstractQueuedSynchronizer
            implements Runnable
    {

        private static final long serialVersionUID = 6138294804551838833L;
        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); //创建Worker线程
        }

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

Worker 是内部类，它本身继承了 Runnable。

addWorker(Runnable firstTask, boolean core){
    ....
     w = new Worker(firstTask);  
     ...
     final Thread t = w.thread;
     ....
     t.start();

}

可以看到，在前面介绍的创建工作线程方法中，创建了新的 worker 实例， t 指向 Worker 构造器创建的 worker 线程，所以 t.start() 启动的是 Worker 的 run() 方法执行。Worker 的 run() 方法委托给 runWorker(this) 实现。

runWorker 方法

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask; // worker 中插入的新任务
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                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
                if ((runStateAtLeast(ctl.get(), STOP) ||
                        (Thread.interrupted() &&
                                runStateAtLeast(ctl.get(), STOP))) &&
                        !wt.isInterrupted())
                        //shouDownNow() 后，如果本线程没有打中断标记，则打上
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run(); //执行任务的 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
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

可见，Runnable 任务是在 runWorker 中执行的。这样一来，前面的逻辑就可以串联起来了。当往线程池提交一个 Runnable 任务，判断完线程池的状态和工作线程数量后，当需要创建新的工作线程执行该任务时，就创建一个 Worker 线程实例，并传入该任务，启动 Worker 线程，在 Worker 线程的 run() 方法中执行任务的 run() 方法。这样，任务就被执行了。

这时候，你可能会有疑惑，那之前塞入到缓存队列的任务怎么执行的呢？ 非核心线程时如何回收的呢？你有没有注意到，在 runWorker(Worker w) 中，有个循环条件。

while (task != null || (task = getTask()) != null)

当创建 Worker 时传入的 task 执行完成后，会置空。所以当 while() 再循环执行的时候， task 为 null,则往 getTask 中取。getTask 就是往缓存队列里面取任务了。

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())) {
            //当线程池 SHUTDOWN 且 缓存队列空
            //或者线程池为 STOP 缓存队列的任务不再执行
                decrementWorkerCount(); // worker 线程跳出 while 循环结束，工作线程数量减1
                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; // keepAliveTime 没取到任务，超时
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

至此，整个线程池提交任务的逻辑结束完毕了。

shutDown 和 shutDowmNow

线程池的 shutDown() 和 shutDownNow() 逻辑比较简单，就是原子更新 ctl 值中的状态位。两个区别的是 shutDown() 后线程池中缓存队列的任务还会执行，shutDownNow() 则缓存队列的任务不再执行了。
需要注意的是，这两个方法只是给线程打上关闭标志，不会强行关闭线程执行。所以，在我们编写任务的 run() 方法时，当有循环执行时，最好判断下当前线程是否打上了中断标志位，并做出处理。
另一点注意的是，当缓存队列满了才会再创建非核心线程执行新任务，这时候缓存队列的任务还在等待，所以线程池中后插入的任务未必后执行。