线程池如何维护核心线程

1、前言

对于线程池有分核心线程和非核心线程，我们知道线程池的核心线程数达到上限，会先尝试加入等待队列，如果无法加入等待队列或者等待队列已满，就会创建非核心线程来执行任务，如果无法创建非核心线程那么就会拒绝（有关线程池的知识可以看线程池中的线程是如何运行的）

2、添加任务

我们先看下添加任务的代码

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

        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            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);
    }

这里可以看到就是按照我们上面所说的规律去添加任务的，区分核心线程的就是addWorker里的第二个参数，设置为true就相当于创建核心线程，false就不是创建核心线程，但这样说非常笼统，详细看下这个参数有什么用

  private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            //...

            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
            }
        }

        // ....
    }

core参数只在一个地方用到了，就是用来控制，当前工作线程的数目是要跟corePoolSize（核心线程数）比较还是maximumPoolSize（最大线程数）比较，仅此而已，也就是如果传入ture，那么wc如果大于等于corePoolSize就相当于达到核心线程数上限，返回false创建失败；传入false就跟maximumPoolSize比较，如果大于等于相当于达到最大线程数上限，返回false创建失败

也就是说我们所说的核心线程和非核心线程其实都是同一个类worker，并且worker类本身并没有任何标志表明他是核心线程还是非核心线程

3、销毁非核心线程

那既然没有标记，那么我们之前了解到，非核心线程在空闲的时候要被销毁的，那怎么去销毁这个非核心线程呢？以及怎么判断要销毁呢？

    final void runWorker(Worker w) {
        //...
        //这个是用来判断线程是不是被中断的
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                //...
                try {
                    //...
                    try {
                        task.run();
                    } 
                    //...
                } 
                //...
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

我们知道我们线程池的线程实际执行的是这个方法，通过while循环不断去任务队列中获取任务，如果退出了while循环，那么也意味这这个线程的 任务 结束了，那么来看下getTask()什么时候会返回null

    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())) {
                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;
            }
        }
    }

可以看到有这两种情况返回null

1. 当rs已经是SHUTDOWN以上的状态，并且任务队列为空或状态是STOP以上，返回null，因为此时线程池已经被要求停止工作了
2. 对第二个if里的条件进行解析，其中一个是：如果允许核心线程超时（allowCoreThreadTimeOut是个布尔值）或者当前工作线程数大于核心线程数，那么timed是true，并且在上次取任务的时候超时了（timedOut为true），该条件满足 ；另一个是：工作线程的数目大于最大线程数了，该条件满足；这两个条件满足一个，然后工作线程大于1个或者任务队列为空，那么就会返回null，这个相当于是通过多个条件判断是否要停止该线程

下面来解析一下

第一个条件很容易理解，但是第二个条件就稍微有点复杂，首先什么时候取任务会超时，可以看到有两种取任务的方式，一个是poll，一个是take，这个根据timed条件来控制，当timed为true，即允许核心线程超时或者此时工作线程数目已经超过核心线程数，那么就会通过poll来获取任务，这个poll是有个超时时间的（创建线程池的时候设置的），如果到超时时间任务队列还是为空，那么poll会返回null，此时timedOut = true，而take是阻塞等待，是等到任务返回才退出。

通过这种方式在工作线程数大于核心线程的情况下，让空闲的线程销毁（可以发现如果允许核心线程超时，那么核心线程也有可能被销毁）

4、销毁线程方法

来看下线程销毁的方法是怎么样的

    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)) {
            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);
        }
    }

如果该线程不是被异常中断的，那么会去判断，是否允许核心线程超时。如果允许，那么会保证工作线程至少为1，如果不允许，min就按照最小线程数为核心线程数，如果发现工作线程数大于等于这个min，这个线程就会被return（终于挂了），如果小于会创建一个新的worker顶上。这样做是因为并发情况下可能会出现一些预料之外的问题，所以才要多重判断