Java ThreadPoolExecutor 源码分析

1.背景

    了解过Java线程池的同学一定对Executors不陌生，我们可以用它的静态方法很快的创建出我们需要的线程池，比如：

我们需要一个固定数目的线程池，那么可以这样：

     Executors.newFixedThreadPool(5)  创建一个只有5个线程的线程池。

也可以通过：

     Executors.newCachedThreadPool()  创建一个没有数量限制的线程池。

用起来很简单方便，那么这两个功能都是如何实现的呢？

其实，它们底层都利用了ThreadPoolExecutor来实现的，这也是我们这篇博客的重点。

2.基本用法

 ThreadPoolExecutor提供了创建线程池的方法以及灵活的配置。日常开发中，我们可以根据项目需要去配置符合要求的线程池，通常来说有以下参数支持配置：

• corePoolSize : 线程池核心线程的数目。
• maximumPoolSize ：线程池最大可以容纳的线程的数目。
• keepAliveTime ：线程池中空闲线程最大可以存活的时间，这个指定了数值，其单位由TimeUnit指定。
• unit：TimeUnit，keepAliveTime指定数值的单位。
• workQueue：线程等待队列，如果当前线程池中已经有了corePoolSize个线程在运行，那么如果再新增一个任务，就会添加到这个等待队列中。
• threadFactory：线程工厂，提供线程的创建能力。<可选>
• rejectedHandler：当线程池内线程数目达到maximumPoolSize的时候，如果再新增任务，线程池就会直接拒绝添加，这个时候就会回调到rejectedHandler。<可选>

所以通常的构造方法是这样的：

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

一般来说，添加一个任务到线程池中，判断的优先级是：

coolPoolSize  >  workQueue > maximumPoolSize 

先判断是否达到coolPoolSize、再判断workQueue是否充满、最后判断是否达到了maximumPoolSize。

OK，基本用法了解之后，下面让我们看下源码，看看是如何实现的。

3.源码分析

在开始看源码之前，还有些知识需要了解下。了解它们利于我们看懂源码。

ThreadPoolExecutor线程池有以下几种运行状态：

• RUNNING  : 可以添加新的任务 ；处理等待队列中的任务。
• SHUTDOWN : 不能添加新的任务；可以处理等待队列中的任务。
• STOP : 不能添加新的任务、不能处理等待队列中的任务，中断正在运行中的任务。
• TIDYING : 所有的任务都被终止了，所有的任务数目为0，会回调terminate()方法
• TERMINATED : terminate()方法执行完毕。

代码里面使用int值的高3位bit去标识上述状态：

   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; //000 1111 1111 1111 1111 1111 1111 1111 1

    // runState is stored in the high-order bits
    private static final int RUNNING = -1 << COUNT_BITS;      // 111 0000 0000 0000 0000 0000 0000 0000 0
    private static final int SHUTDOWN = 0 << COUNT_BITS;      // 000 0000 0000 0000 0000 0000 0000 0000 0
    private static final int STOP = 1 << COUNT_BITS;          // 001 0000 0000 0000 0000 0000 0000 0000 0
    private static final int TIDYING = 2 << COUNT_BITS;       // 010 0000 0000 0000 0000 0000 0000 0000 0
    private static final int TERMINATED = 3 << COUNT_BITS;    // 011 0000 0000 0000 0000 0000 0000 0000 0

通过注释可以看到对应的数值以及运算规律。

OK，接下来就让我们看源码：

通常情况下，我们会通过ExecutorService.submit(Runnable runnable)来添加任务，而这个方法会调用ThreadPoolExecutor.execute方法：

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();  //获取当前值
        if (workerCountOf(c) < corePoolSize) { //小于corePoolSize -> addWorker
            if (addWorker(command, true)) {
                return;
            }
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) { //添加到队列
            int recheck = ctl.get();
            if (!isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0) {
                addWorker(null, false);
            }
        } else if (!addWorker(command, false)) {
            reject(command);
        }
    }

方法内部的注释 基本上解释了这端代码逻辑：

1.  当前运行任务数量小于corePoolSize，新增一个线程，同时把当前任务作为第一个任务传递给线程。然后触发addWorker方法（方法内部会检查runState和workerCount），如果添加成功则直接return。
2. 如果当前线程正在运行 同时成功添加了任务到等待队列，那么需要再次检测下线程池是否停止运行或者 是否应该添加线程，因为有可能上次检查到运行的线程死掉了。
3. 如果无法添加线程到等待队列，尝试添加线程，如果失败的话，那么说明线程池死掉了，那么拒绝添加。

逻辑很清楚，上述变量 ctl 的类型是AtomicInteger，用来表示当前线程池内：总的线程数目（低29位）+线程池的状态（高3位）

而workerCountOf 和 isRunning方法的实现如下：

private static int workerCountOf(int c) {
        return c & CAPACITY; // 最大数目 2^29
}
private static boolean isRunning(int c) {
        return c < SHUTDOWN;
}

根据上面说的背景知识，方法的实现很容易理解。

下面我们看下添加新线程方法：addWorker的实现：

private boolean addWorker(Runnable firstTask, boolean core) {
        //1. 乐观的检测方式，循环的目的在于：判断运行状态和获取下一个workerCount的值，因为考虑到并发，所以需要多次循环保证。
        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); //当前worker的数量
                if (wc >= CAPACITY ||
                        wc >= (core ? corePoolSize : maximumPoolSize)) //核心的情况下，大于CorePoolSize则算是异常
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry; //跳转循环
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs) //如果c的运行状态和之前的不一致
                    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);  //2. 新建一个worker
            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)) {
                        if (t.isAlive()) { // precheck that t is startable  //t已经运行了
                            throw new IllegalThreadStateException();
                        }
                        workers.add(w); //3.添加到workers中。
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {  //4 添加成功之后触发start
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (!workerStarted)  //5.没有添加成功，则触发添加失败方法
                addWorkerFailed(w);
        }
        return workerStarted;
    }

addWorker方法里面 有5个主要步骤：

1. 通过双层循环确保当前线程池的状态是对的，同时获取到新的、正确的workerCount。
2. 通过传入的firstTask创建一个worker。
3. 添加worker到workers中。
4. 添加成功后，触发worker.thread.start
5. worker没有start成功的话，那么触发失败方法。

先看下步骤2，通过firstTask创建worker，对应的构造方法是：

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

Worker 实现了Runnable接口，可以看到构造方法内，保存了firstTask，同时把自身作为Runnable参数构造了Thread。

所以上述步骤4，worker.thread.start 会触发 Worker的run方法

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

调用内部的runWorker方法

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {  //firstTask不为空或者获取到的task不为空。
                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())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task); //开始执行之前的回调。
                    Throwable thrown = null;
                    try {
                        task.run();  //  执行Runnable
                    } 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); //处理线程退出。
        }
    }

可以看到runWorker方法内，通过while循环不断获取task去执行，同时回调对应的方法以及统计相关完成的次数。

第一个任务是通过firstTask获取的，接下来的任务都是通过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())) { //状态大于STOP或者队列为空 才返回null
                decrementWorkerCount();
                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;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

    可以看到getTask方法内部 会不断的从workQueue中获取runnable返回，如果超时或者超过最大线程数目，则会返回null，使得线程挂掉。如果没有超时逻辑，那么则会通过workQueue.take()方法阻塞。直到其他地方调用了interrupt方法，比如tryTerminate方法里面。

  这样基本上看完了任务提交和执行的过程，下面我们看些异常逻辑，addWorker方法内，finally方法块里有个processWorkerExit(w, completedAbruptly)处理Worker退出的流程，我们看下：

/**
     *
     * @param w                 the worker
     * @param completedAbruptly if the worker died due to user exception ：是否由于异常退出。
     */
    private void processWorkerExit(Worker w, boolean completedAbruptly) {
        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)) { //状态比stop要小，running或者shutdown
            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); //原有线程异常退出、增加一个Thread
        }
    }

可以看到方法内部移除worker，然后如果线程池状态小于Stop的时候，会尝试新增一个WorkThread做替换。

processWorkExit会调用tryTerminate() 方法,我们去看下

 final void tryTerminate() {
        for (; ; ) { //无限循环。
            int c = ctl.get();
            if (isRunning(c) ||
                    runStateAtLeast(c, TIDYING) ||
                    (runStateOf(c) == SHUTDOWN && !workQueue.isEmpty()))  //正在运行、已经死掉、状态是SHTUDOWN但任务队列不为空，不符合退出条件。
                return;
            if (workerCountOf(c) != 0) { // Eligible to terminate //数目不为空，尝试唤醒空闲的线程。
                interruptIdleWorkers(ONLY_ONE);
                return;
            }

            final ReentrantLock mainLock = this.mainLock; //走终止流程。
            mainLock.lock();
            try {
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { //设置TIDYING状态
                    try {
                        terminated(); //触发terminated方法，这里是空实现。
                    } finally {
                        ctl.set(ctlOf(TERMINATED, 0)); //设置TERMINATED状态
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }

方法内部通过无限循环保证对ctl的赋值是成功的。逻辑也是比较清晰，先判断状态、再尝试唤醒线程，最后设置状态。

4.总结

    可以看到理解ThreadPoolExecutor原理的关键就在于，几种线程池的状态以及对应的表示方法，这个也是值得我们学习的地方。