[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方法。