首先放上ThreadPoolExecutor的继承实现图:
ThreadPoolExecutor继承实现图
代码如下:
public class ThreadPoolExecutor extends AbstractExecutorService {}
public abstract class AbstractExecutorService implements ExecutorService {}
public interface ExecutorService extends Executor {}
我们先debug代码来走一遍流程:
- ThreadPoolTest:
请注意我使用的是
ExecutorService service = Executors.newFixedThreadPool(1);
来生成线程，使用别的线程池流程跟我的不一样。但是最后进入的方法还会是execute().
ThreadPoolTest
-
AbstractExecutorService对ExecutorService一些方法做了默认的实现，主要是submit和invoke方法。
AbstractExecutorService#submit -
最后进入的实现方法是ThreadPoolExecutor中的execute().这个方法会在后面有更为详细的解答。
ThreadPoolExecutor#execute
变量
镜头给到变量和一些状态量，这些很好理解。
//int类型数字，高三位表示线程池状态，后29位表示worker数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//29
private static final int COUNT_BITS = Integer.SIZE - 3;
//线程池允许的最大线程数，1左移29位，也就是2的29次方-1
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
//线程的状态
// << COUNT_BITS代表左移 COUNT_BITS位，也就是 111,000,001,010,011后面跟29个0
private static final int RUNNING = -1 << COUNT_BITS;//可以接受新线程，可以继续执行队列中的任务
private static final int SHUTDOWN = 0 << COUNT_BITS;//不再接受新任务，但可以继续执行队列中的任务
private static final int STOP = 1 << COUNT_BITS;//新任务和队列中的任务都拒绝执行和接受，并中断正在执行的任务
private static final int TIDYING = 2 << COUNT_BITS;//所有任务已被中断
private static final int TERMINATED = 3 << COUNT_BITS;//已清理完现场
核心变量
//池中所保存的线程数,不包括空闲线程,线程池里一直不会被销毁的线程数量
//活动线程小于corePoolSize则直接创建，大于等于则先加到workQueue中，队列满了才创建新的线程。
private volatile int corePoolSize;
//池中允许的最大线程数
private volatile int maximumPoolSize;
//线程数大于核心数时，此为多余的空闲线程在终止前等待新任务的最大等待时间
private volatile long keepAliveTime;
//执行程序创建新线程使用的工厂
private volatile ThreadFactory threadFactory;
//执行前保存任务的队列，此队列仅保持由execute方法提交的Runnable任务
private final BlockingQueue workQueue;
//由于超出线程范围和队列容量而使执行的拒绝策略
private volatile RejectedExecutionHandler handler;
关于创建线程时根据核心线程数还有最大线程数的这些判断来生成线程会在后面方法介绍中更详细说明，在这里需要多说一点关于拒绝策略。也就是
private volatile RejectedExecutionHandler handler;
线程池是有容量大小的，肯定没有办法无限制增长，这个变量便是针对线程无法提交到线程池时产生的。
内部类
ThreadPoolExecutor是有5个内部类的，代码和图如下:
内部类
可以分为两类，一类是Worker,一类是执行的拒绝策略。Worker会在后面说明。执行策略如下：
-
CallerRunsPolicy
CallerRunsPolicy -
AbortPolicy：
AbortPolicy -
DiscardPolicy：
DiscardPolicy -
DiscardOldestPolicy：
DiscardOldestPolicy
AbortPolicy策略是默认拒绝策略。
方法
看源码的方法我一般跳过getXXX，setXXX方法，构造方法带着看。
public void execute(Runnable command)
我觉得这是这个类最重要的方法，所以放在第一个讲，来牵扯出其它的方法。
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();
}
//worker数量超过核心线程数，任务直接进入队列
//线程是运行状态并且扔到队列成功
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//线程池不是running状态，说明执行过shutdown命名，需要对新加入的任务执行reject命令
//这里需要recheck原因在于任务加入队列，线程池状态可能发生变化
if (! isRunning(recheck) && remove(command))
reject(command);
//核心线程数允许为0
//发现线程池数量是0
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//线程池不是运行状态，或者任务进入队列失败，则尝试创建worker执行任务
//1：线程池不是运行状态，addworker内部会判断线程池状态
//2:addworker第二个参数表示是否创建核心线程
//3:addWorker返回false，表示创建失败，需要执行reject操作
else if (!addWorker(command, false))
reject(command);
}
我们可以看到核心代码是3个if-elseif代码块，但其实这里执行了4个逻辑:
1:活动线程小于corePoolSize的时候创建新的线程,不排队
2:活动线程大于corePoolSize并且入队成功(也就是队列没满)加入到任务队列当中
3:执行addWorker(command, false),也就是表示活动线程大于 corePoolSize 且小于 maximumPoolSize ，且等待队列已满,(addWorker核心逻辑就是判断时候小于maximumPoolSize )
4::倘若addWorker(command, false)返回false，也就是表示活动线程大于 corePoolSize 且大于 maximumPoolSize ，且等待队列已满，则调用拒绝策略来处理该任务
看完这个方法，我想你对addWorker这个方法肯定想一探究竟:
private boolean addWorker(Runnable firstTask, boolean core)
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
//外层自旋
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// (rs>=SHUTDOWN) || (rs == SHUTDOWN && firsttask != null) || (rs==SHUTDOWN && workerQueue.isEmpty())
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
//内部自旋
for (;;) {
int wc = workerCountOf(c);
//worker数量超过容量，直接返回false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//cas方式 增加worker数量+1
//若增加成功，跳出外循环进入第三部分
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 {
w = new Worker(firstTask);
//这个thread看worker可以看出来
//这个thread就是我们要启动的thread
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
//worker添加是串行的，需要加锁
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)) {
//worker已经调用过start，则不再创建worker
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//因为workers不是线程安全的,所以前面需要上锁
workers.add(w);
int s = workers.size();
//更新largestPoolSize
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
//启动
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
//worker启动失败，说明线程池状态发生变化(关闭操作被执行)，需要进行shutdown操作
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
这个方法分两部分，一部分是双层自旋，一部分是下面的真正执行线程的代码，你需要明白下面这些地方:
- 双层自旋来不停的以保证在线程状态没有变化的情况下以cas方式将ctl变量+1(compareAndIncrementWorkerCount(c)),然后跳出双层循环执行下面的启动线程步骤，否则返回false表示失败。
- 加入HashSet
workers队列，并执行线程
Worker#runWorker
执行线程就是Worker类中的run()方法,这个方法调用了runWorker();
public void run() {
runWorker(this);
}
final void runWorker(Worker w) {
//拿到当前线程
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//允许外部能够中断
w.unlock(); // allow interrupts
//线程执行异常判断标志
boolean completedAbruptly = true;
try {
//自旋
//拿到task
while (task != null || (task = getTask()) != null) {
//加锁
//1.降低锁范围，提升性能
//2.保证每个worker是串行的
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
//线程池正在停止，则对当前线程进行中断操作
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
//beforeExecute()和afterExecute()拓展功能，在这路是空实现
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 {
//帮助gc
task = null;
//完成任务数+1，volatile类型
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
//自旋操作被退出，说明线程池正在结束
processWorkerExit(w, completedAbruptly);
}
}
getTask
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
//必要情况下需要检查workQueue是否为空
// Check if queue empty only if necessary.
//SHUTDOWN状态下还是可以执行队列中的线程，所以判断是否是更高状态STOP，同时队列为空也不会再执行了。
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
//wc > corePoolSize成立代表当前线程数大于核心线程数，那么超过corePoolSize的的线程必定有超时
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//根据超时与否拿到执行线程
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
processWorkerExit
private void processWorkerExit(Worker w, boolean completedAbruptly) {
//是否异常退出，如果不是在runWorker的getTask方法workerCount已经被减一了
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//在前面runWorker() finally代码块中+1
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
// 尝试停止线程池
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
// 线程不是异常结束
if (!completedAbruptly) {
// 线程池最小空闲数，允许core thread超时就是0，否则就是corePoolSize
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
// 如果min == 0但是队列不为空要保证有1个线程来执行队列中的任务
if (min == 0 && ! workQueue.isEmpty())
min = 1;
// 线程池还不为空那就不用担心了
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// 1.线程异常退出
// 2.线程池为空，但是队列中还有任务没执行，看addWoker方法对这种情况的处理
addWorker(null, false);
}
}
tryTerminate()
final void tryTerminate() {
for (;;) {
int c = ctl.get();
// 以下状态直接返回：
// 1.线程池还处于RUNNING状态
// 2.SHUTDOWN状态但是任务队列非空
// 3.runState >= TIDYING 线程池已经停止了或在停止了
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
// 只能是以下情形会继续下面的逻辑：结束线程池。
// 1.SHUTDOWN状态，这时不再接受新任务而且任务队列也空了
// 2.STOP状态，当调用了shutdownNow方法
// workerCount不为0则还不能停止线程池,而且这时线程都处于空闲等待的状态
// 需要中断让线程“醒”过来，醒过来的线程才能继续处理shutdown的信号。
if (workerCountOf(c) != 0) { // Eligible to terminate
// runWoker方法中w.unlock就是为了可以被中断,getTask方法也处理了中断。
// ONLY_ONE:这里只需要中断1个线程去处理shutdown信号就可以了
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 进入TIDYING状态
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
// 子类重载：一些资源清理工作，可以自定义实现功能
terminated();
} finally {
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
shutdown():
将runState置为SHUTDOWN，会终止所有空闲的线程。
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 线程池状态设为SHUTDOWN，如果已经至少是这个状态那么则直接返回
advanceRunState(SHUTDOWN);
// 注意这里是中断所有空闲的线程：runWorker中等待的线程被中断
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// tryTerminate方法中会保证队列中剩余的任务得到执行。
tryTerminate();
}
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
Thread t = w.thread;
//w.tryLock()能拿到锁就表示该线程空闲
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
shutdownNow():
将runState置为STOP。和shutdown方法的区别，这个方法会终止所有的线程。
public List shutdownNow() {
List tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// STOP状态：不再接受新任务且不再执行队列中的任务
advanceRunState(STOP);
// 中断所有线程
interruptWorkers();
// 返回队列中还没有被执行的任务。
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
以上。