首先要知道在线程池中空余线程被回收的条件：当线程池中的线程数量大于 corePoolSize 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过 keepAliveTime。还有就是线程池执行 Task 的流程（这里借用《Java 并发编程的艺术》这本书中的一张图）：
JUC 中的线程池使用很简单，但是源码还是有一定的复杂度的，那么这个地方从何下手呢。首先需要猜测判断回收条件的时机。根据上面的回收条件可以很自然的想到先去看看 getTask() 方法，这个方法就是从工作队列中获取 Task：
/** * 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}
从这个方法中貌似没有找到很明显的具体的时机，但是可以结合线程池执行任务时从 BlockingQueue 中 getTask() 和 这个方法注释中的第 4 点：
* 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.
可以考虑去看看线程池的执行 Task 的方法，线程池执行 Task 本质就是通过 ThreadFactory 构建出来的 Thread 去 执行 Worker 中的 run() 方法：
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 }
可以看到这个 processWorkerExit() 方法是在 runWorker() 方法的 finally 代码块中。即如果跳出了 runWorker() 方法的 while 循环，就会执行 processWorkerExit() 方法。跳出 while 循环的条件是 task 为 null 或者 getTask() 获取的结果为 null。在 processWorkerExit() 中，会从 workers 中移除 worker。说白了整个 Worker 的生命周期大致可以理解为：线程池干活了（execute() / submit()），然后就是正式干活了（runWorker()），使用 getTask() 获取任务（中间会有一系列的判断（corePoolSize 是否达到，任务队列是否满了，线程池是否达到了 maximumPoolSize，超时等），如果没有 task 了，就进行后期的扫尾工作并且从 workers 中移除 worker。
注意上面的 addWorker(null, false); 这个其实是个注意点优化点 当执行一开始自己写的Runnable command 的run方法如果执行异常 也会走上面的代码completedAbruptly=true 然后执行addWorker(null, false); 创建一个空的worker线程继续执行
重点：所以run里最好是把所有的异常捕获 而不要抛出 不然抛出异常 就会立刻销毁线程 然后创建一个新线程 线程池的作用就没有
其中，核心线程数也是可以被销毁的
int min = allowCoreThreadTimeOut ? 0 : corePoolSize; allowCoreThreadTimeOut 默认是false,但是如果设置成true，核心线程数也可以销毁
