线程池中的空余线程是如何被回收的

/**
  * Performs blocking or timed wait for a task, depending on
  * current configuration settings, or returns null if this worker
 4 * must exit because of any of:
 5 * 1. There are more than maximumPoolSize workers (due to
 6 *    a call to setMaximumPoolSize).
 7 * 2. The pool is stopped.
 8 * 3. The pool is shutdown and the queue is empty.
 9 * 4. This worker timed out waiting for a task, and timed-out
10 *    workers are subject to termination (that is,
11 *    {@code allowCoreThreadTimeOut || workerCount > corePoolSize})
12 *    both before and after the timed wait, and if the queue is
13 *    non-empty, this worker is not the last thread in the pool.
14 *
15 * @return task, or null if the worker must exit, in which case
16 *         workerCount is decremented
17 */
18  private Runnable getTask() {
19    //上次从队列中 poll() 是否超时
20    boolean timedOut = false; // Did the last poll() time out?
21
22    for (;;) {
23        int c = ctl.get();
24        int rs = runStateOf(c);
25
26        // Check if queue empty only if necessary.
27        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
28            decrementWorkerCount();
29            return null;
30        }
31                //从名称中可以判断，工作的线程数
32        int wc = workerCountOf(c);
33
34        // Are workers subject to culling?  从这里开始，值得关注
35          //是否剔除 worker？核心线程是否超时或工作线程数大于核心线程数
36              // allowCoreThreadTimeOut：If false (default), core threads stay alive even when idle.If true, core threads use keepAliveTime to time out waitingfor work.
37        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
38                //由于可能在这个过程中执行了 setMaximumPoolSize() 方法。
39        //（（如果工作线程数大于最大线程数）或者（上次从队列中 poll()是否超时 且 需要剔除工作线程））且（工作线程数大于 1 或 工作队列是空的）
40        if ((wc > maximumPoolSize || (timed && timedOut))
41            && (wc > 1 || workQueue.isEmpty())) {
42            if (compareAndDecrementWorkerCount(c))
43                return null;
44            continue;
45        }
46
47      //poll() 和 take() 都可以从队列中获取任务出来。具体使用哪个方法根据 timed 来判断。
         take() 是没有就阻塞直到有，这里的 poll() 加了一个超时控制。
         其实熟悉阻塞队列就应该知道取出元素的方法有两个poll()和take(),
         前者是一个非阻塞方法,如果当前队列为空,直接返回,而take()是一个阻塞方法,
         即如果当前队列为空,阻塞线程,封装线程到AQS的条件变量的条件队列中,
          而上面的方法是一个介于二者之间的方法,语义是如果队为空,该方法会阻塞线程,
            但是有一个阻塞时间,如果到时见还没有被唤醒,就自动唤醒;
        看到这里就应该知道了,我们的线程在获取任务时,如果队列中已经没有任务,
       会在此处阻塞keepALiveTime的 时间,如果到时间都没有任务,
        就会return null(不是直接返回null,是最终),然后在runWorker()方法中,执行
        processWorkerExit(w, completedAbruptly);终止线程;
48        try {
49            Runnable r = timed ?
50                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
51                workQueue.take();
52            if (r != null)
53                return r;
54            timedOut = true;
55        } catch (InterruptedException retry) {
56            timedOut = false;
57        }
58    }
59}

* 4. This worker timed out waiting for a task, and timed-out
2 *    workers are subject to termination (that is,
3 *    {@code allowCoreThreadTimeOut || workerCount > corePoolSize})
4 *    both before and after the timed wait, and if the queue is
5 *    non-empty, this worker is not the last thread in the pool.

1 /** Delegates main run loop to outer runWorker  */
2        public void run() {
3            runWorker(this);
4        }
 1 final void runWorker(Worker w) {
 2        ...
 3        ...
 4        try {
 5          while (task != null || (task = getTask()) != null) {
 6           ...
 7          }
 8        } finally {
 9            processWorkerExit(w, completedAbruptly);
10        }
11    }
 1/**
 2     * Performs cleanup and bookkeeping for a dying worker. Called
 3     * only from worker threads. Unless completedAbruptly is set,
 4     * assumes that workerCount has already been adjusted to account
 5     * for exit.  This method removes thread from worker set, and
 6     * possibly terminates the pool or replaces the worker if either
 7     * it exited due to user task exception or if fewer than
 8     * corePoolSize workers are running or queue is non-empty but
 9     * there are no workers.
10     *
11     * @param w the worker
12     * @param completedAbruptly if the worker died due to user exception
13     */
14    private void processWorkerExit(Worker w, boolean completedAbruptly) {
15        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
16            decrementWorkerCount();
17
18        final ReentrantLock mainLock = this.mainLock;
19        mainLock.lock();
20        try {
21            completedTaskCount += w.completedTasks;
22              //从 workers 中 remove 了一个 worker，即移除了一个工作线程
23            workers.remove(w);
24        } finally {
25            mainLock.unlock();
26        }
27
28        tryTerminate();
29
30        int c = ctl.get();
31        if (runStateLessThan(c, STOP)) {
32            if (!completedAbruptly) {
33                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
34                if (min == 0 && ! workQueue.isEmpty())
35                    min = 1;
36                if (workerCountOf(c) >= min)
37                    return; // replacement not needed
38            }
39            addWorker(null, false);
40        }
41    }

int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
allowCoreThreadTimeOut 默认是false,但是如果设置成true，核心线程数也可以销毁