前言
没看本文，面试挂了，别说没提醒你！
没看本文，面试挂了，别说没提醒你！
没看本文，面试挂了，别说没提醒你！
相信很多人都接触过线程池，我们知道线程池有核心线程和非核心线程之分，其中核心线程是一直存活在线程池中的，而非核心线程是在执行完任务之后超时销毁的。但是大家应该都知道一点，当Thread执行完Runnable任务之后就会销毁，而且就算执行完任务之后把线程挂起也没有办法再去执行其他任务，那线程池是如何做到核心线程复用的呢？下面就通过阅读源码的方法带大家了解背后的原因。
大家可以对着这个流程图去学习源码，把这个图掌握了，线程池原理也就差不多了
首先来看一下执行线程任务的方法，里面很简单，就是根据工作线程数量去执行不同的策略，里面分成了3种情况，但是都会执行addWoker()方法
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
/*
* 如果当前活跃线程数小于核心线程数，就会添加一个worker来执行任务；
* 具体来说，新建一个核心线程放入线程池中，并把任务添加到该线程中。
*/
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//程序执行到这里，说明要么活跃线程数大于核心线程数；要么addWorker()失败
/*
* 如果当前线程池是运行状态，会把任务添加到队列
*/
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);
}
//程序执行到这里，说明要么线程状态不是RUNNING；要么workQueue队列已经满了
//调用addWorker方法去创建非核心线程，
//如果当前线程数已经达到 maximumPoolSize，执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}这个方法就和名字一样，添加一个工人来完成任务；而这个工人就是Thread，任务就是Runnable。
private boolean addWorker(Runnable firstTask, boolean core) {
...省略一些不重要的
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//Worker是实现了Runnable接口的包装类
w = new Worker(firstTask);
//Thread是在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());
//检查线程池状态，分为2种情况
//1、线程池处于RUNNING
//2、线程池处于SHUTDOWN并且firstTask==null
//这2种情况都会创建Worker来执行队列中的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
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;
}到这里，我们大概知道是通过创建Worker来执行任务的，而且线程是在Worker内部创建的，我们也能猜到Thread需要的Runnable应该也在Worker内部，所有我们继续看一下Worker类。
Worker
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}Worker居然是一个Runnable任务，而且Worker的构造方法中创建了Thread对象。这样的话，在之前的addWorker()方法中调用t.start();就会执行到Worker的run()方法。
继续来看看runWorker()方法，这里很关键，一定要仔细看。
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
//这个就是addWorker传进来的Runnable
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//如果task不为null或从workQueue中获取任务不为null
//就会一直执行
while (task != null || (task = getTask()) != null) {
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
//检查线程池状态，如果线程池处于中断状态，将调用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();
} 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);
}
}这里的关键在于这个while()条件判断，当第一次创建Worker时就有任务，当执行完这个任务后，这个方法并没有结束，而是不断地调用getTask()方法从阻塞队列中获取任务然后调用task.run()执行任务。
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())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 1.allowCoreThreadTimeOut表示是否允许核心线程超时销毁，默认是false,也就是说核心线程即使空闲也不会被销毁
//当然，如果设置为true，核心线程是会销毁的
//这样的话，只有正在工作的线程数大于核心线程数才会为true，否则返回false
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//2.如果timed为true，通过poll取任务；如果为false，通过take取任务
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}这个方法是通过一个死循环取任务，取任务的话是通过workQueue这个阻塞队列去完成的，在默认不改变allowCoreThreadTimeOut的前提下，如果工作线程数大于核心线程数，则通过poll()从队列取任务；如果工作线程数小于核心线程数，则通过take()从队列取任务；这2个方法等区别是take()取任务时，如果队列中没有任务了会调用await()阻塞当前线程。这样的话，是不是已经搞清楚线程池中的核心线程复用的原因了。
线程的唤醒是在execute时，当调用workQueue.offer()方法，将任务放入阻塞队列时，会调用Condition.signal()方法唤醒一个之前阻塞的线程。这部分不细讲，感兴趣的同学自行查看。
总结
1、当Thread的run方法执行完一个任务之后，会循环地从阻塞队列中取任务来执行，这样执行完一个任务之后就不会立即销毁了；
2、当工作线程数小于核心线程数，那些空闲的核心线程再去队列取任务的时候，如果队列中的Runnable数量为0，就会阻塞当前线程，这样线程就不会回收了
