线程池核心线程是如何保持住的？

概述

本文尝试回答以下几个问题：
1、核心线程池是如何保持住的？
2、当没有任务时，超过核心线程数的线程是如何回收的？
3、线程队列为什么必须是BlockingQueue，普通队列行不行？

背景知识

以下是一些背景知识，方便后面分析问题，如果明白可以跳过，否则建议重温下。

线程参数

1. corePoolSize：核心线程数。
2. maximumPoolSize：最大线程数。
3. keepAliveTime：空闲线程存活时间。
4. TimeUnit：时间单位。
5. BlockingQueue：线程池任务队列。
6. ThreadFactory：创建线程的工厂。
7. RejectedExecutionHandler：拒绝策略，包括Abort、callRuns，discard，discardOld.

线程池结构

以ThreadPoolExecutor为例，它的结构如下所示：

最重要的两个类就是我们的ThreadPoolExecutor和Worker，其中ThreadPoolExecutor就是线程池本池了，Worker是对Thread的一个简单封装，它实现了Runnable接口，我们可以把它当作线程Thread本身。我们需要知道这些字段的含义是怎样的：

提交任务做了什么？

创建线程池没有任何有价值的东西，就是对ThreadPoolExecutor的属性进行赋值，例如我们刚才提到的那几个重要的属性，所以我们从execute提交任务开始探索内部。
![在这里插入图片描述](https://img-blog.csdnimg.cn/b8b29d220ece460798819a451e1a34b4.png
当我们创建了线程池，调用execute提交一个Runnable任务，执行流程如下所示：

执行流程
1、任务到来时，看CORE线程数有没有满，如果没有满则新创建线程处理。
2、如果core线程数量满了，则放入队列中。
3、如果队列也满了，则看看线程数量是否达到了maxPoolSize值，如果没有则创建新线程处理。
4、如果已经达到了maxPoolSize的值，则根据拒绝策略处理任务。
所以当有人问execute做了什么时候，可以回答这个执行流程，这是面试时经常问的问题。知道这个流程后，我们再来看下代码是怎么写的(按照惯例，省略了无关代码)：

public void execute(Runnable command) {
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) { // 当线程数量小于核心线程数时，创建新的线程，请注意这里给了command，也就是我们自定义的Runnable任务，后面会再次提到它！
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) { // 上面没有走到，说明核心线程数量已经满了，则尝试将任务添加到任务队列中，也就是这里的workQueue
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false)) // 添加队列失败，说明队列满了。尝试依赖maxPoolSize创建线程，如果失败则根据拒绝策略处理任务
            reject(command);
    }

是不清晰多了？不过我们需要继续深挖，看看addWorker()干了什么？第二个boolean参数又是干嘛用的？

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) { // for循环主要通过cas更新线程worker数量
            int c = ctl.get(); // 拿到线程数量
           
            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize)) // 因为核心线程数和最大线程数控制着线程的上限，这个boolean参数就是检查是不是还能创建线程。
                    return false;
                if (compareAndIncrementWorkerCount(c))  // 线程数量+1
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        // 创建worker
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask); // 看清楚了！这里就是真正的创建线程了，并把任务作为参数传递进去
            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); // 把worker添加到worker集合中
                        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;
    }

我们用流程图表示下：

从上面的流程图我们可以知道，addworker做了3件事情：
1、更新worker数量
2、创建worker对象，其中包括创建Thread对象并设置好runnable任务
3、启动线程
第二个boolean参数，实际上就是控制创建worker对线程数量做检查时，需要和什么对比，是和核心线程数量配置对比还是和最大线程数量配置做比对。

worker启动干了什么？

worker实现了Rnnable接口，所以线程启动后，会调用run方法：

我们需要看看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) { // 这里非常重要！！！
                w.lock();
                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;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

实际上这里最关键的就两步：
1、获取任务
2、执行任务

获取任务是从worker中拿到的，我们注意到有一行非常重要的判断：

什么情况下task为空，什么情况下需要调用getTask()去获取任务？
请回想一下我们线程池execute的执行流程，其中1，2步骤就曾经说过：
1、任务到来时，看CORE线程数有没有满，如果没有满则新创建线程处理。这个时候创建worker的调用是：

addWorker(command, true)

这就保证我们运行获取任务时是非空的。
2、如果core线程数量满了，则放入队列中。这个时候调用的是：

workQueue.offer(command)

这就保证我们getTask（）时能取到任务！

现在重点来了，我们今天要回答的问题就和这个getTask有莫大的关系！在理解下面的代码前，我们先假设corePoolSize < 线程数量 < MaxPoolSize 并且 队列里面已经没有任务了，也就是没有任务的时候，有一些线程需要被回收。

private Runnable getTask() {
        boolean timedOut = false; // 上一次通过poll从任务队列获取任务是否超时，如果超时说明任务队列没有任务了
        for (;;) {// 这是一个循环
            int c = ctl.get();
            int rs = runStateOf(c);
            int wc = workerCountOf(c); // 获取线程数量

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; // 我们先撇开allowCoreThreadTimeOut这个参数，当线程数量大于核心线程数配置，说明在没有任务的时候可以对一些剩余的线程去做回收操作。

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {// timed=true,timeOut=true，队列也空了，对线程数量-1
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();// 这里就是重点了！当线程数量>核心线程数时，走的是poll代码块
                if (r != null)
                    return r;
                timedOut = true; // 因为take会阻塞线程直到有任务到达，所以这里只能是poll没有拿到任务，也就是任务队列是空，然后返回循环去做线程-1
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

如果是核心线程获取任务（核心非核心没有标记区别，这里是做个假设），因为timed为false，会走到workQueue.take()方法，如果任务队列为空，线程会被阻塞。非核心线程获取任务会走到workQueue.poll()，尝试在超时时间内获取任务，然后返回。

到此为止我们可以回答“核心线程池是如何保持住的？”答案就是通过workQueue.take()方法对线程进行阻塞，让我们线程保持住不被数量-1而回收掉。
然后我们可以回答“线程队列为什么必须是BlockingQueue，普通队列行不行？”答案就是不行，我们需要通过阻塞队列对线程进行阻塞，保证线程不会被回收掉。关于BlockingQueue怎么实现阻塞的，建议温习下java阻塞队列原理。这也是面试经常会被问到的。
我们知道需要回收条件触发时（当线程数量大于核心线程数配置，任务队列中没有任务），线程数量会被 - 1，那么回收具体时怎么操作的呢？
回到我们的任务执行方法runWorker中，最后有一步processWorkerExit调用：

private void processWorkerExit(Worker w, boolean completedAbruptly) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w); // 把线程从线程集合中删除，通过jvm回收
        } finally {
            mainLock.unlock();
        }
        int c = ctl.get();
        if (runStateLessThan(c, STOP)) {
            if (!completedAbruptly) { // 线程异常时，completedAbruptly会被设置为true
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                if (workerCountOf(c) >= min) // 线程数本身就大于核心线程数量，不用补偿
                    return; // replacement not needed
            }
            addWorker(null, false); // 线程异常后的一种补偿，重新创建一个线程替换异常线程
        }
    }

到此我们可以回答“当没有任务时，超过核心线程数的线程是如何回收的？”，答案是先将线程数-1，然后将woker从worker列表中删除，通过jvm回收。

总结

通过对线程池的学习，我们知道了线程池的执行流程：
1、任务到来时，看CORE线程数有没有满，如果没有满则新创建线程处理。
2、如果core线程数量满了，则放入队列中。
3、如果队列也满了，则看看线程数量是否达到了maxPoolSize值，如果没有则创建新线程处理。
4、如果已经达到了maxPoolSize的值，则根据拒绝策略处理任务。

然后我们可以回答这些问题：
1、核心线程池是如何保持住的？

通过workQueue.take()方法对线程进行阻塞，让我们线程保持住不被数量-1而回收掉

2、当没有任务时，超过核心线程数的线程是如何回收的？

先将线程数-1，然后将woker从worker列表中删除，通过jvm回收

3、线程队列为什么必须是BlockingQueue，普通队列行不行？

不行，我们需要通过阻塞队列对线程进行阻塞，保证线程不会被回收掉。

如果我们看的仔细，我们实际上还可以回答诸如下面的问题：
1、如果我想在任务执行前后做一些诸如打日志看耗时的操作，有办法吗？
2、核心线程池的线程永远都是这些线程吗？会不会变化？
3、如果线程池运行中动态设置了corePoolSize > 原始corePoolSize，现有线程数量小于新的corePoolSize，任务队列中还有任务，会自动创建线程吗？是怎么做的？
4、keepAliveTime是空闲线程超时时间，是有定时任务回收空闲线程吗？
5、为什么获取任务时，workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)写死了NANOSECONDS，明明创建线程的时候是可以指定时间单位的？

大家可以尝试自行回答下，答案进行了base64编码，可在base64解码解码后查看。

MeOAgeWmguaenOaIkeaDs+WcqOS7u+WKoeaJp+ihjOWJjeWQjuWBmuS4gOS6m+ivuOWmguaJk+aXpeW/l+eci+iAl+aXtueahOaTjeS9nO+8jOacieWKnuazleWQl++8nwoKPiDmnInlip7ms5XjgILnur/nqIvmiafooYznmoTml7blgJnkvJrmnInliY3nva7lkI7nva7mianlsZXngrnvvIzlj6/ku6XlnKjlrZDnsbvkuK3ov5vooYzlrp7njrDjgIIKCjLjgIHmoLjlv4Pnur/nqIvmsaDnmoTnur/nqIvmsLjov5zpg73mmK/ov5nkupvnur/nqIvlkJfvvJ/kvJrkuI3kvJrlj5jljJbvvJ8KCj4g5LiN5piv44CC5b2T57q/56iL5omn6KGM5byC5bi45pe277yM5Lya5pyJ6KGl5YG/5py65Yi277yM5Yib5bu65paw55qE57q/56iL5pu/5o2i44CCCgoz44CB5aaC5p6c57q/56iL5rGg6L+Q6KGM5Lit5Yqo5oCB6K6+572u5LqGY29yZVBvb2xTaXplID4g5Y6f5aeLY29yZVBvb2xTaXpl77yM546w5pyJ57q/56iL5pWw6YeP5bCP5LqO5paw55qEY29yZVBvb2xTaXpl77yM5Lu75Yqh6Zif5YiX5Lit6L+Y5pyJ5Lu75Yqh77yM5Lya6Ieq5Yqo5Yib5bu657q/56iL5ZCX77yf5piv5oCO5LmI5YGa55qE77yfCgo+IOS8muOAguS5n+aYr+mAmui/h2FkZFdvcmtlcuWIm+W7uuOAggoKNOOAgWtlZXBBbGl2ZVRpbWXmmK/nqbrpl7Lnur/nqIvotoXml7bml7bpl7TvvIzmmK/mnInlrprml7bku7vliqHlm57mlLbnqbrpl7Lnur/nqIvlkJfvvJ8KCj4g5rKh5pyJ44CC5LuO5Lu75Yqh6Zif5YiX6I635Y+W5Lu75Yqh5pe277yM5pyJ6LaF5pe25pe26Ze077yM5bCx5piv6L+Z5Liqa2VlcEFsaXZlVGltZe+8jOi2heaXtuayoeacieiOt+WPluWIsOS7u+WKoe+8jOS8mui/lOWbnm51bGzvvIznhLblkI7lvIDlp4vlm57mlLbnur/nqIvjgIIKCjXjgIHkuLrku4DkuYjojrflj5bku7vliqHml7bvvIx3b3JrUXVldWUucG9sbChrZWVwQWxpdmVUaW1lLCBUaW1lVW5pdC5OQU5PU0VDT05EUynlhpnmrbvkuoZOQU5PU0VDT05EU++8jOaYjuaYjuWIm+W7uue6v+eoi+eahOaXtuWAmeaYr+WPr+S7peaMh+WumuaXtumXtOWNleS9jeeahO+8nwoKPiDliJvlu7rnur/nqIvmsaDnmoTml7blgJnvvIzpgJrov4d1bml0LnRvTmFub3Moa2VlcEFsaXZlVGltZSnovazmjaLlpb3kuobml7bpl7TljZXkvY3jgII=