在前面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，即使当前线程池线程数量小于核心线程数，也需要指定超时时间，超过指定的时间之后，如果还没有获取到任务，就销毁当前线程
总结
所以：基于以上学习，我们就可以把整个流程串起来
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
