在前面ThreadPoolExecutor源码学习(一) -核心属性及应用这篇博客中,记录了线程池核心的参数和方法,这篇笔记主要把这些核心参数和方法串起来
提交任务
在提交一个任务的时候,会调用execute方法
/**
* 线程池提交任务用的就是该方法
* submit是可以有返回值得方式,但是底层也是调用的该方法
*
* 1.先判断当前运行线程数量是否小于corePoolSize,如果小于,就添加核心线程到线程池中
* 2.如果添加失败或者 大于核心线程数,就判断:如果线程池是运行状态,就将任务添加到任务队列中
* 3.如果任务队列添加失败,就添加非核心线程到线程池
* 4.如果非核心线程也添加失败,就执行拒绝策略
* @param command
*/
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
/**
* 注释一
* 检查当前线程池中的线程数是否达到了常驻线程数,如果未达到,就添加一个核心线程,如果添加失败,执行下面的
* 如果添加成功,返回即可
*
* addWorker方法的第二个参数,表示限制添加线程的数量是根据corePoolSize?还是maximumPoolSize来判断
* true:根据corePoolSize来判断,也就是说创建的是核心线程
* false:根据maximumPoolSize来判断,创建的是非核心线程
*
* 核心的代码,就是addWorker这个方法
*/
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
/**
* 添加失败之后要重新获取当前线程池中的线程数量
* 失败的原因可能是:其他并发创建了线程,导致线程数量超过了核心线程数量
* 或者是线程池被关闭等
*/
c = ctl.get();
}
/**
* 如果当前线程池处于运行状态,且将任务添加到了队列中
*
* 如果当前线程不是运行状态,就不允许往队列中添加任务
*/
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
/**
* 注释二
* 1.判断当前线程池是否是running状态,如果不是运行状态,就remove刚才添加的任务
* 移除成功之后,执行拒绝策略
* 因为有可能在任务插入到队列的过程中,把线程池停掉了
*
* 2.如果线程依旧是运行状态,就判断当前线程池中的线程的数量
*
* 这种场景:有可能是设置允许核心线程超时,这样的话,核心线程在处理完所有的任务之后,就会销毁,也就是说:任务队列刚执行完,线程都已经销毁了,但是我又写入了一个任务
*
* 如果线程池中核心线程和非核心线程的数量为0,就添加一个空任务到线程池中
* 这里添加一个空的任务,是为了让线程池去队列中取刚才放进去的任务执行,也就是启动一个线程,去执行getTask()
*
* 所以,在将任务添加到队列中之后,有两个操作
* 1.再次判断当前线程池是否允许入队任务,如果不允许,就remove,并且执行拒绝策略
* 2.如果允许,就判断当前工作的线程数是否大于0,如果不满足,就添加一个空线程池
*/
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
/**
* 如果线程池是非运行状态,或者是队列已经满了,插入任务失败,就会把当前任务放入到线程池中,用非核心线程去执行任务
* 如果任务写入线程池失败,就执行拒绝策略
*/
else if (!addWorker(command, false))
reject(command);
}
这里面的注释二这里,是比较特殊的一个点,在线程池中,有一个重要的参数,允许核心线程超时,所以,在把任务添加到队列之后,需要判断下当前在工作的线程数是否为0,为0的话,需要添加一个空任务,去执行队列中的任务
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
/**
* 这里是一个死循环,如果不return或者break,会一直循环
* 这个死循环中,会判断两个内容:
* 1.线程池状态
* 2.线程池中线程数量
*
* 这里的c:是ctl对应的value
* rs:是当前线程池的状态
*/
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
/**
* 判断线程池状态和任务队列是否满足要求,不满足返回false,满足继续执行
*
* 1.如果线程池状态大于running,且不是shutdown状态,就直接return,因为rs > shutdown的时候,是不允许添加任务的,也不会执行线程池中的任务
* 2.如果线程池状态大于running,且是shutdown状态,就需要再判断下,如果添加的任务不为null,就return false,因为shutdown状态不允许添加任务
* 如果是shutdown状态,且添加的任务是null,且任务队列为空,就不允许添加worker,因为此时添加一个空worker,是没有意义的
* 所以:如果是shutdown状态,并且任务队列不为空,且添加的任务是null,此时是可以继续添加worker的,此时添加的worker,就是启动一个线程,去执行任务队列中的任务
*
* 所以,这个判断总结而言:
* 1.如果rs > shutdown,就不允许添加
* 2.如果rs = shutdown,且任务队列不为空,且添加的worker中的任务是null,此时可以添加
*
* 我们也可以认为:不进入这个if条件的,只有两种情况
* 1.线程池是running状态
* 2.线程池是shutdown状态,且任务队列不为空,且firstTask(新添加的任务)为null
*/
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
/**
* 获取到当前线程池中的工作线程
*/
int wc = workerCountOf(c);
/**
* 判断当前线程池中的线程数量,是否超过了最大容量
* 或者是corePoolSize或者maximumPoolSize
* 如果超过了,就返回false,表示添加失败
*/
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
/**
* 这里是将线程池中的线程数量+1
* 如果cas失败,就继续循环
*/
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
/**
* 根据当前要提交的任务,声明一个worker对象
* worker对象是继承了AQS
* 正常情况下,创建了worker对象之后,绑定的thread,是不为null的,然后此时会进行加锁
* 因为在往线程池中添加任务的时候,有可能是并发的
*/
w = new Worker(firstTask);
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());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
/**
* 上面这个if应该就是判断线程池以及线程是否正常
* 如果正常,就把当前worker添加到一个set集合中
* largestPoolSize:应该是表示线程池中历史中出现的最大线程数量
*/
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
/**
* 如果worker正常添加到了set中,那就会去执行worker的run方法
* 这里是启动了worker中的线程,worker中的线程,会去执行run方法
*/
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
/**
* 如果启动失败,就会执行下面的方法,将worker从worker集合中remove
* 将线程池中线程数量 - 1
*/
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
这个addWorker方法代码很长,但是总结起来,就是两个点:
1、校验当前线程池状态,是否允许添加任务
2、如果允许,就把当前任务包装成内部的Worker对象,然后启动任务
这里在判断线程池状态是否允许添加任务时,这个if判断实在是太牛B了,我自己学习的时候,看了半天,才理解是什么意思,不得不说,代码足够简洁,但是新手实现是难以理解
启动任务
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
/**
* 这里的unlock,是将state设置为0,表示当前任务是可以中断的
*/
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
/**
* 线程池在执行完一个任务之后,会接着从队列中获取其他任务进行执行,就是在下面这个while条件中实现的
* 下面的getTask()极速从队列中take任务,所以:
* 当前线程在处理完任务之后,会接着从任务队列中获取任务执行
*
* 这个while条件的意思是:
* 如果程序员执行的task不为null,就运行程序员的任务
* 如果为null,就尝试从任务队列中获取排队的任务执行,这样就可以复用线程
*
* 所以,我们也可以认为,线程池可以重用,最根本的原因,就是这里的while
*/
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
/**
* 如果线程池状态 >= stop需要中断线程
*/
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;
/**
* 将当前线程完成的任务数量 +1
*/
w.completedTasks++;
w.unlock();
}
}
/**
* 如果代码跳出while循环,表示当前线程超时,或者是任务队列中没有线程了
* 就可以销毁当前线程了
*/
completedAbruptly = false;
} finally {
/**
* 如果代码执行到这里,我认为有两种场景
* 1.while循环条件不成立,退出循环,这种是正常场景,比如:当前任务执行完了,这种场景,completedAbruptly是false
* 2.task.run()执行异常,会最终走到这里,但是这个场景,completedAbruptly是true
* 这里的true和false,对后面其他任务的处理,有很大的影响,可以跟到下面这个方法中看一下
*/
processWorkerExit(w, completedAbruptly);
}
}
在这个方法中,while循环是需要着重关注的,这个方法的意思,也简单,启动之后,先执行当前任务task,第一次进来的时候,task大部分场景下不为null(除非当前线程池允许核心线程超时,在添加任务到队列之后,会添加一个空任务,此时task为null,否则,其他场景,都是不为null的)
执行完任务之后,task == null,会接着执行getTask()方法,尝试从队列中获取任务执行
getTask()
/**
* 这是从任务队列中获取任务
* 结束该方法的运行有三种场景
* 1.线程池状态 >= STOP 或者线程池是SHUTDOWN 且任务队列为null,此时会将wc -1,返回null,结束运行
* 2.当前线程数量超过了最大的阈值,或者是线程超时,且任务队列为空或者线程数量 >1,此时会将wc -1 并return null
* 3.正常获取到了队列中的任务,此时就返回任务,执行该任务方法
*
* 关于第二点:
* 1、当前wc超过了最大阈值,且wc > 1
* 2、当前wc未超过最大阈值,但是线程超时了(在指定时间内未获取到任务),且wc > 1
*
* @return
*/
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.
/**
* 判断当前线程池状态:
* 如果线程池状态是大于shutdown,而且任务队列为空
* 或者线程池状态是大于stop的,就将worker集合中的worker进行remove,因为
* 如果是大于shutdown状态,并且任务队列为空,此时就不需要worker了,因为此时不会再接收新的任务
* 如果是大于stop状态,无论任务队列是否为空,都不会执行,所以 remove即可
* 需要注意的是:这里只是将线程池中线程数量减1
*/
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
/**
* allowCoreThreadTimeOut 默认为false
* wc:表示当前线程池中工作的线程数量
*
* 如果程序员设置了核心线程允许超时,或者是线程数量超过了corePoolSize,就把timed设置为true
* 表示允许超时,如果这个变量为true,在从队列中取任务的时候,就会带上超时时间
*/
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
/**
* 这里其实就是我们常说的:如果非核心线程空闲时间超过了设置的阈值,就会把非核心线程从线程池中remove的源码
*
* timeOut表示线程已经超时了
*
* 先看判断条件:
* 如果工作线程 > 最大值 或者允许超时且已经超时
* 并且工作线程数量大于1,或者任务队列为空,此时就将线程数量-1
*
* 需要注意的是:这里只是把线程池中的线程数量 -1;真正将线程remove,是在外面
*
* 这里判断wc > 1我觉得是为了保证下面能够将数量 -1
*/
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
/**
* 在超时或者是任务队列为空的时候,表示当前线程可以推出了,就会把线程池中的工作线程数量 - 1
*/
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
/**
* 我们常说:非核心线程在空闲一定的时间之后,就会被回收
* 如果线程空闲时间超过了keepAliveTime,就会把timeOut设置为true,在上面的if判断中,就会将线程池中线程数 -1,然后return null
*
* 如果获取到的任务是null,就继续下一次循环,并将timeOut设置为true,表示已经超时
* 如果获取到的任务不是null,就return,执行任务
*/
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
这个方法是从队列中获取任务,其中有一行代码是比较有意思的
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
这里的allowCoreThreadTimeOut就是前面一直在说的,可以设置是否允许核心线程超时
1、在默认情况下,这个参数是FALSE,所以,timed为TRUE的,唯一条件就是当前线程数超过了核心线程数
2、如果allowCoreThreadTimeOut为true,那无论当前工作的线程数量是否超过核心线程数,timed都是TRUE
timed是控制在从队列中取任务的时候,是否会带超时时间,如果为timed为false,我们可以认为,当前线程池的线程数量已经小于了corePoolSize,剩下的线程都是核心线程,不允许被销毁
但是如果allowCoreThreadTimeOut为true,即使当前线程池线程数量小于核心线程数,也需要指定超时时间,超过指定的时间之后,如果还没有获取到任务,就销毁当前线程
总结
所以:基于以上学习,我们就可以把整个流程串起来