[JUC] 线程池实现原理,ThreadPoolExecutor 源码分析
第一天，了解基础
1.线程池是什么？
线程池，是一种管理多个线程的工具。常见的有，Mysql 数据库连接池。
线程的创建和销毁是会带来额外的开销，并且过多的线程也会让系统承受不住。所以，线程池就是用来解决这两个问题。1.线程池会保持一定数目的核心线程一直存活。这样任务可以及时的处理，也不会有创建带来的开销。2.线程池也会管理线程，过多的任务会进入线程池的阻塞队列中，并不会立即创建线程。
使用线程池带来的好处：
- 降低资源的消耗，重复利用资源。当线程池中核心线程执行完任务之后，并不会直接销毁。而是重复使用。
- 提高响应速度。一直有存活的线程，当任务提交过来，立即执行。
- 可以有效管理线程。线程池，可以设置空闲线程的存活时间，超时回收空闲的线程。并且提供线程的状态监视。
- 线程池还有可扩展性。比如ScheduledThreadPoolExecutor。该线程池可以延时定时执行任务。
2.线程池解决的问题是什么？
解决的是资源的管理问题。系统并不能确定，有多少任务需要执行，有多少线程需要创建。
3. 线程池的7个参数，4个拒绝策略，JDK提供的线程池，阻塞队列
4.线程池的5种状态
- RUNNING：接收新任务并排队
- SHUTDOWN：不接收新任务，但会处理当前线程池中的任务
- STOP：不接收任务，同时会调用interruptIdleWorkers()方法，中断正在执行任务的异常。会返回未执行任务的集合
- TIDYING：所有任务都已终止，工作线程数为0。且会运行钩子方法terminated()，转换到下一个状态
- TERMINATED：terminated() 已完成。
5.线程池怎么预热
可以调用prestartAllCoreThreads()方法，提前一次创建所有核心线程。或者调用prestartCoreThread()方法，提前创建一个。
6.如何“优雅”的关闭线程池
调用shutdown()方法，会保证线程池中的任务执行完。
调用shutdownNow()方法，粗暴的终结掉线程池，所有线程必须结束。有任务被中断。
第二天，原理分析
1. 线程池的继承关系
在JDK1.8中的线程池的核心实现类的ThreadPoolExecutor
依次说明：
Executor是顶级接口。从顶层到核心实现类，一层一层的实现线程池的功能。Executor提供了给用户更简易的使用。用户只需要提交任务。而不需要关注任务是如何执行，线程如何调度。该接口将提交任务与执行任务解耦。
ExecutorService接口，是对Executor接口的拓展，增加了一些管理线程池的方法，比如shutdown()。增加了可以提交一个(submit)或多个任务(invokeAll)的方法，并可返回Future。
AbstractExecutorService抽象类：实现了上层接口的方法，除去最为复杂的任务执行和线程调度的方法。保证下层ThreadPoolExecutor只需要关注最为主要的方法。
ThreadPoolExecutor一方面维护自身的生命周期，一方面管理线程和任务
ThreadPoolExecutor简要执行流程图
通过这张图可以看出：
任务分配：一个任务提交过来会有三种执行策略。这三种对应着三种状态。第一种，任务直接执行，此时线程池工作线程必然<corePoolSize，于是会新建一个线程并马上执行当前任务。第二种缓存执行，是当任务过多，多过了corePoolSize，且此时并无空闲线程，就会将任务暂时缓存到阻塞队列，等待空闲线程执行。第三种，即被拒绝执行，当任务队列满了且线程数已达到maximumPoolSize，则会执行任务的拒绝策略(4种+自定义)。
线程管理：而线程则是必然会进入线程池中。当线程数<corePoolSize，新建的线程会直接执行该任务，然后被线程池管理，之后获取任务队列中的任务。而当处于corePoolSize<=threads<maximumPoolSize时，会直接被线程池管理，获取任务队列中的任务。最终获取不到任务，则超时/立即回收。
通过这里我们发现线程池核心工作就是任务分配，和线程分配，同时还得维护自身的状态。同时，当观察任务队列，我们可以发现任务分配相当于是生产者，而线程获取任务则是消费者。这里生产者和消费者解耦，并不直接关联，从而良好的缓存队列，复用线程。
所有我们接下来就描述线程池的状态，任务管理，线程管理
线程池的生命周期
就是第一天的5的详细介绍。线程池维护了一个AtomicInteger变量，来代表5个状态和工作线程的数量。在并发情况下，需要维护的变量越少，代码的可维护性就越高。
其中COUNT_BITS = Integer.SIZE - 3，而 int SIZE = 32 。经过这样处理，将状态左移了29位。相当于使用高三位表示5个状态。
线程工作数量和线程池状态，在源代码中是一起使用的。维护成一个变量就不用担心出现不一致的情况。拆分这个ctl，是有提供方法的
int CAPACITY = (1 << COUNT_BITS) - 1; 就是00011111111111111111111111111111 这样获取运行时状态， c & ~CAPACITY 就是取反保留高三位
而获取工作线程就直接&就行了。ctlOf()//通过状态和线程数生成ctl
这5种状态怎么转换的？
线程池状态描述第一天有
2.任务执行机制
1. 任务调度
任务调度就是线程池的主要入口，提交的任务有这里判断之后的执行逻辑。在ThreadPoolExecutor的execute()方法中进行具体代码实现。由上面的简要执行流程图可知，有三种执行策略。分析源代码，在方法注释中有详细描述。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
//如果当前工作线程数小于corePoolSize，则直接创建线程执行任务，执行情况1
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//检查线程池状态，此时会将任务提交到缓冲队列，在此刻工作线程数>corePoolSize且缓冲队列未满，执行情况2
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//任务刚提交，此时调用了shutdown/now，则移除缓冲队列中当前任务，并执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
//发现可运行的线程数是 0，就初始化一个线程，这里是个极限情况，入队的时候，突然发现可用线程都被回收了
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//此时缓冲队列满了，就开启线程到maximumPoolSize，在addWorker中开启，如果开启失败就执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
文字步骤如下(JDK注释)：
1. 如果运行的线程少于corePoolSize，则尝试使用给定命令作为其第一个任务启动一个新线程。addWorker的调用会自动检查runState和workerCount，从而通过返回false来防止在不应该添加线程时产生的错误警报。
2. 如果一个任务可以成功排队，那么我们仍然需要再次检查是否应该添加一个线程(因为现有的线程在上次检查后已经死亡)，或者在进入这个方法后池关闭。因此，我们重新检查状态，如果有必要，则在停止排队时回滚排队;如果没有线程，则启动一个新线程。
3. 如果不能对任务进行排队，则尝试添加一个新线程。如果它失败了，我们知道自己被关闭或饱和了，所以拒绝这项任务。
流程图如下：
2. 任务缓冲
由阻塞队列实现，阻塞队列是支持两个附加操作的队列。在阻塞队列为空时，线程会等待队列变为非空，阻塞队列满时，线程会等待队列变的可用。
阻塞队列有很多种，可查看第一天的3
而且线程的核心和非核心，线程的回收也是通过获取阻塞队列的不同方式来实现的。
3.任务申请
就是线程获取任务。线程执行任务，第一种是还未达到核心线程数时创建的线程，此时直接执行当前的任务。第二种是线程从任务队列中获取任务，执行。空闲下来继续从任务队列中获取。第一种仅存在于线程初创的时候，第二种情况为大多数。
线程获取任务，是由getTask()方法，进行具体的代码实现。源代码分析
TIP：从阻塞队列中获取任务，若阻塞等待后还没取到任务就会返回null，从而使当前线程在runWorker方法中退出while循环被回收
private Runnable getTask() {
boolean timedOut = false;//标识是否超时
//这是用来使非核心线程，在空闲等待时间keepAliveTime超过后，可以返回null，即未获取到任务
for (;;) {//自旋获取
int c = ctl.get();
int rs = runStateOf(c);//获取当前线程池运行状态
//1.线程池被shutdown，此时如果任务队列不为null，则仍需处理任务，不能返回null
//2.线程池被shutdownNow了，直接让工作线程数减一，然后返回null，此时处于STOP下，任务队列中即使有任务也不处理
//3.线程池处于SHUTDOWN下，且任务队列空了，就可以返回null了
//返回null，即意味着线程将被回收。runWorker()
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);//当前工作线程数
//allowCoreThreadTimeOut：允许核心线程超时，默认false。核心非核心线程在代码中都是Thread
//所以需判断当wc>corePoolSize，才是非核心线程，会有keepAliceTime
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//有3种返回null的情况
//1.wc > maximumPoolSize cas递减 只要超过最大线程数，就必须减不管其它的
//2.timed为true(允许回收核心线程或wc > corePoolSize) && timedOut为true(当前获取任务已超时)
//&& wc>1(回收后最少还有一个线程)
//3.timed为true(允许回收核心线程或wc > corePoolSize) && timedOut为true(当前获取任务已超时)
//&& workQueue.isEmpty(队列空，留着一个线程也没用，回收)
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//核心代码使用take()方法获取，此方法会一直阻塞，等待获取任务。于是就形成了核心线程不会被回收的局面
//而非核心线程，即当前 wc > corePoolSize，调用poll方法，超时返回，不会阻塞在这里
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)//如果有任务，则返回任务。
return r;
timedOut = true;//没有，则意味着非核心线程超时，可以返回null了，在下一次for时，返回null
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
文字流程
任务申请兼具着线程回收。申请到则执行任务。核心线程申请不到会一直阻塞，而非核心(当前线程数>corePoolSize)会超时获取任务，超过时间就会返回null。
-
第一次判断，线程池，是否停止，停止了返回null，即当前线程可回收了
-
第二次判断，有三种返回null的情况
-
wc > maximumPoolSize cas递减 只要超过最大线程数，就必须减不管其它的，【此时不能再让线程获取任务了，必须回收该线程，必须符合线程池参数定义，线程数不能大于maximumPoolSize 】。
-
timed为true(允许回收核心线程或wc > corePoolSize) && timedOut为true(当前获取任务已超时) && wc>1(回收后最少还有一个线程)，【线程池参数性质，非核心线程空闲了keepAliveTime之后被回收】
-
timed为true(允许回收核心线程或wc > corePoolSize) && timedOut为true(当前获取任务已超时) && workQueue.isEmpty(队列空，留着一个线程也没用，回收)
疑问：当线程数大于corePoolSize，且任务队列满了之后，创建的非核心线程数，在超时后就会被回收吗？
可看2，3条，发现超时回收还有俩个&&，即wc>1 || workQueue.isEmpty。当前非核心线程超时获取不到任务时，任务队列应当是空的(因为空，获取不到任务，才会超时)。即正常流程，当非核心线程被回收时，workQueue.isEmpty()应该是满足的。但是，是不是会存在一种情况，当workQueue不为空时，超时获取不到任务。同时，wc此时就刚刚好为1.就不会被回收。 -
从任务队列中获取任务（take或poll），若拿到了就返回，没拿到就将超时（timedOut）设置为true
注：只有timed为true才会使用poll然后等待KeepAliveTime时间，否则会使用take一直等待下去
-
流程图：
4.任务拒绝
任务拒绝是保护线程池，JDK提供4种拒绝策略，默认为AbortPolicy。可见第一天3
拒绝策略是一个接口，其设计如下：
public interface RejectedExecutionHandler {
void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
ThreadPoolExecutor方法中调用:
reject(command);
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
用户可以通过实现这个接口去定制拒绝策略，也可以选择JDK提供的四种已有拒绝策略。
第三天，补充【Worker线程管理】
1.Woreker类
在线程池中一个线程被封装成了一个Worker类。
问题：为什么要封装，直接来任务就创建Thread处理，或者线程获取任务队列任务执行这样不就完了？
一句话，封装成Worker是为了更好的管理线程的中断，源码中类注释：类Worker主要维护运行任务的线程的中断控制状态。详细说，在线程池shutdown()时，怎么让正在工作的线程不中断，而是等待任务执行完毕。看下Worker的继承关系就知道了
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
final Thread thread;
Runnable firstTask;
}
Worker继承了AQS，而AQS是做什么的？它是实现同步器的基础。提供了线程排队，线程管理，同步状态管理的方式。所以继承了AQS就是实现了一个同步器。Worker就是实现了一个不可重入独占锁。实现独占锁之后，worker运行会上锁，执行 shutdown，setCorePoolSize，setMaximumPoolSize等方法时会试着中断线程（interruptIdleWorkers） ，在这个方法中断方法中会先尝试获取 worker 的锁，如果不成功，说明 worker 在运行中，此时会先让 worker 执行完任务再关闭 worker 的线程，实现优雅关闭线程的目的
Worker也实现了Runnable，拥有一个Thread和一个firstTask。thread是在调用构造方法时通过ThreadFactory来创建的线程，可以用来执行任务。而firstTask可以为null。如果是非空，则对应着初始创建核心线程，此时firstTask就是创建时提交的任务，会马上被执行。而firstTask为null时，则是创建的非核心线程，此时会通过任务队列获取任务，之后执行。
Worker执行任务模型：
Worker类源代码分析：
//Worker类实现的同步锁，只需重写AQS的可重写方法，并调用其模板方法
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
//这个类永远不会被序列化，但是我们提供了一个serialVersionUID来抑制javac警告
private static final long serialVersionUID = 6138294804551838833L;
// 实际执行任务的线程
final Thread thread;
// 上文提到，如果当前线程数少于核心线程数，创建线程并将提交的任务交给 worker 处理，
// 此时 firstTask 即为此提交的任务，如果 worker 从 workQueue 中获取任务，则 firstTask 为空
Runnable firstTask;
// 计数器，统计完成的任务数
volatile long completedTasks;
//构造方法中创建线程，使用ThreadFactory工厂类。并且提交任务
Worker(Runnable firstTask) {
setState(-1); // 在runWorker之前禁止中断，得开始之后才能中断。下面interruptIfStarted()方法
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
//这里只是初始化，并管理线程的中断。执行交予类外的runWorker方法
public void run() {
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
protected boolean isHeldExclusively() {//判断是否已经被锁。1表示已被锁，0表示未锁
return getState() != 0;
}
protected boolean tryAcquire(int unused) {//尝试获取锁，重写AQS的方法
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {//尝试释放锁
setExclusiveOwnerThread(null);
setState(0);
return true;
}
//加锁，调用AQS模板方法，在这个acquire方法中会调用重写的tryAcquire方法尝试获取锁，
//失败会被加入到等待队列中
public void lock() { acquire(1); }
//直接尝试获取锁，可以获取到返回true，获取不到返回false
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
//判断当前锁状态
public boolean isLocked() { return isHeldExclusively(); }
// 中断线程，这个方法会被 shutdowNow 调用，从中可以看出 shutdownNow 要中断线程不需要获取锁，
//也就是说如果线程正在运行，照样会给你中断掉，所以一般来说我们不用 shutdowNow 来中断线程，太粗暴了，
//中断时线程很可能在执行任务，影响任务执行
void interruptIfStarted() {
Thread t;
//这里判断当前任务是否执行，即调用runWorker方法。构造方法中-1，在此时初始化调用shutdownDown不能被中断。
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
文字描述：
已知Worker继承了AQS，实现了独占锁。但是ReentrantLock不是也是锁吗？为什么不用？因为ReentrantLock是可重入的，Worker自己实现就是为了实现不可重入的特性。
1. lock方法一旦获取了独占锁，表示当前线程正在执行任务中
2. 如果正在执行任务，则不应该中断线程
3. 如果该线程现在不是独占锁的状态，也就是空闲的状态，说明它没有在处理任务，这时可以对该线程进行中断。
4. 线程池在执行shutdown方法或tryTerminate方法时会调用interruptIdleWorkers方法来中断空闲的线程，interruptIdleWorkers方法会使用tryLock方法来判断线程池中的线程是否是空闲状态；如果线程是空闲状态则可以安全回收。
2.Worker线程增加
增加线程使用的是addWorker()方法，该功能的方法就是增加一个线程。该方法两个参数firstTask若非空，则意为着此时为核心线程直接执行该任务，空则是说创建非核心线程从任务队列获取任务，core参数为true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize。
addworker源代码分析：
private boolean addWorker(Runnable firstTask, boolean core) {
// break retry 跳到retry处，且不再进入循环
// continue retry 跳到retry处，且再次进入循环
retry:
for (;;) {//这个for循环就是各种状态的校验，并增加线程数量WorkerCount
int c = ctl.get();
int rs = runStateOf(c);
// 线程池·任务队列状态检测
if (rs >= SHUTDOWN &&!(rs == SHUTDOWN &&firstTask == null &&!workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
//(core ? corePoolSize : maximumPoolSize) core为true判断是否超过核心线程数，创建线程都是在
//这个方法内，所以需要core这个参数来区别当前是超corePoolSize还是超maximumPoolSize。
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//cas操作，势必要增加工作线程数
if (compareAndIncrementWorkerCount(c))
break retry;//成功跳出双重循环，失败继续自旋+1 跳到retry:
c = ctl.get(); // Re-read ctl
// 如果线程运行状态发生变化，跳到外层循环继续执行
if (runStateOf(c) != rs)
continue retry;
}
}
//前面的状态，WorkerCount+1都没问题，就开始创建线程了，执行在runWorker()方法
//创建worker，并添加到workers容器中
boolean workerStarted = false;//看线程启动成功没，用于
boolean workerAdded = false;//添加到workers中成功没，true成功
Worker w = null;
try {
w = new Worker(firstTask);//Worker类的构造方法，创建线程
final Thread t = w.thread;
//将worker加入worker容器，线程回收实现方式
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
// 加锁是因为，可能有多个线程同时要将worker放入worker容器
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
//进入if
//1.线程池状态为RUNNING 或者
//2.线程池状态为SHUTDOWN且firstTask==null，此时只会创建线程执行任务队列中的方法，不会接收新任务。
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) //线程已启动，则抛异常，此时本方法还未启动线程，你启动了必然有问题
throw new IllegalThreadStateException();
//private final HashSet<Worker> workers = new HashSet<Worker>();
workers.add(w);//加入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 方法，主要做了将 worker 从 workers 中移除，减少线程数，并尝试着关闭线程池这样的操作
addWorkerFailed(w);
}
return workerStarted;
}
分析之后，总结文字流程：
-
刚进入会做线程池状态，任务队列是否空检测。
- 线程池状态异常，返回false
- 工作线程数过多，返回false
- 成功则cas++
-
创建Worker
- 创建worker，通过线程工厂
- 加锁，将新建worker加入workers容器中。
-
启动worker中的线程，调用逻辑是：Thread#start -> Worker#run -> runWorker()
流程图：
3.Worker线程回收
线程池中线程的销毁依赖JVM自动的回收，线程池做的工作是根据当前线程池的状态维护一定数量的线程引用，防止这部分线程被JVM回收，当线程池决定哪些线程需要回收时，只需要将其引用消除即可。Worker被创建出来后，就会不断地进行轮询，然后获取任务去执行，核心线程可以无限等待获取任务，非核心线程要限时获取任务。当Worker无法获取到任务，也就是获取的任务为空时，循环会结束，Worker会主动消除自身在线程池内的引用。
源代码：
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中。可以看出核心线程初创时会携带任务，在这里直接执行，不会
//去任务队列获取
while (task != null || (task = getTask()) != null) {
w.lock();
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();
}
}
//只要退出while就会执行，会在processWorkerExit方法中判断减少工作线程数。这里如果之前异常退出了都不会被执行
//processWorkerExit中是completedAbruptly==true 会将cas 执行线程池减 1 操作
completedAbruptly = false;
} finally {
//只要抛异常或者正常退出都会执行这个方法。非核心线程获取不到任务会超时退出，这里回收非核心线程。
//会加锁安全移除线程
processWorkerExit(w, completedAbruptly);
}
}
4.线程执行任务
调用runWorker()，源代码在3
- while循环不断地通过getTask()方法获取任务。
- getTask()方法从阻塞队列中取任务。
- 如果线程池正在停止，那么要保证当前线程是中断状态，否则要保证当前线程不是中断状态。
- 执行任务。
- 如果getTask结果为null则跳出循环，执行processWorkerExit()方法，销毁线程。
在这里回想第二天的任务申请，可以发现任务申请不到，返回null。这里跳出while循环，就必然会执行到回收线程的processWorkerExit方法。
2494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
