Java线程池ThreadPoolExecutor源码解析
今天看到Java的线程池，又看到一款这么好看的markdown的编写工具，顺便就写一篇读源码笔记，作为学习和读源码的第一步。本文会将ThreadPoolExecutor的部分源码粘贴到这边，然后一步一步的注释和解读关键部分。
public class ThreadPoolExecutor extends AbstractExecutorService {
// 初始化线程池，线程状态是Running，线程数为0个，这个要看ctlOf方法，做了按位或操作，高3位是111，剩余的全是0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 线程池容量，采用一个int表示线程状态和线程数量，线程数占29位，状态占3位
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// 线程的各个状态
// RUNNING状态，-1的补码是1111 1111 1111 1111 1111 1111 1111 1111，左移29位之后，就变成了E0000000，高3位为111
private static final int RUNNING = -1 << COUNT_BITS;
// 000 表示关闭状态
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 001 表示线程停止状态
private static final int STOP = 1 << COUNT_BITS;
// 010 表示线程的一个中间状态，当线程池为空时，会短暂的进入到这个状态，然后会进入到TERMINATED状态
private static final int TIDYING = 2 << COUNT_BITS;
// 010 表示终止状态
private static final int TERMINATED = 3 << COUNT_BITS;
*
此处要说一下SHUTDOWN，STOP，TERMINATED三者的区别：
SHUTDOWN：表示线程池关闭，不在接受新的任务，但是会处理完阻塞队列里面任务，然后终止
STOP：立即停止正在运行的任务，同时不再接受新任务，也不会执行阻塞队列里面的任务
TERMINATED：中断状态
*
// 获取线程池的状态
private static int runStateOf(int c) { return c & ~CAPACITY; }
private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
// 下面这3个是3个状态比较的函数，isRunning这个用的地方非常多，判断线程是不是运行状态
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
// 下面2个是cas的自旋方法，线程数+1或-1
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
// 线程终止时，直接循环将所有的线程数减1
private void decrementWorkerCount() {
do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}
// 阻塞队列，超出最大线程数的线程，将进入到阻塞队列里面
private final BlockingQueue<Runnable> workQueue;
// 可重入锁
private final ReentrantLock mainLock = new ReentrantLock();
// 实际执行的work线程，放到hashSet里面
private final HashSet<Worker> workers = new HashSet<Worker>();
// 条件
private final Condition termination = mainLock.newCondition();
// 最大线程数
private int largestPoolSize;
// 已经完成的任务数
private long completedTaskCount;
// 线程工厂类
private volatile ThreadFactory threadFactory;
// 拒绝策略
private volatile RejectedExecutionHandler handler;
// 活跃时间，可以设置活跃时长，空线程的等待超时时间
private volatile long keepAliveTime;
// 是否允许核心线程超时
private volatile boolean allowCoreThreadTimeOut;
// 核心线程数
private volatile int corePoolSize;
// 最大线程数，当线程池内达到核心线程数之后，会判断是否超出最大线程数，如果没超出，会创建新的线程，否则会进入到阻塞队列
private volatile int maximumPoolSize;
// 默认的拒绝策略
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
// 权限，停止任务需要权限
private static final RuntimePermission shutdownPerm =
new RuntimePermission("modifyThread");
// 最核心的代码，添加和运行核心线程
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
// 获取线程当前状态和线程数
int c = ctl.get();
int rs = runStateOf(c);
// 这个地方有点绕，咱们一步一步说明
// 第一个条件：rs >= SHUTDOWN 只有running状态的值才会小于0，所以大于等于0的，都是非running的，非running状态的，才有可能直接返回，否则才有可能加入到执行队列里面。
// 第二个条件：rs== SHUTDOWN && firstTask == null && !workQueue.isEmpty() 意思就是线程池状态为0，任务为null，并且等待队列非空 意味着线程池的状态虽然处于关闭状态，但是等待队列里面仍然还有任务，那么依然会执行任务添加，将所有任务执行完，这个就是shutdown之后，并不会立即停止线程池，而是会将以有的任务执行完之后，再停止。
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
// 获取当前的线程数
int wc = workerCountOf(c);
// 如果当前的线程数超出容量，直接return，如果是一个核心任务，要判断一下是否超出核心线程数
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 线程数加1，并跳出循环，加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
}
}
// 下面的这段就是生成work线程，并将work线程加入到works的hashSet里面
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 初始化一个work线程，一般是加锁创建，防止并发
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
// 线程池状态是否满足running状态，work线程是否有正在执行的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 线程创建成功，并执行Worker类的run方法，run方法里面是执行runWorker方法
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
// 添加失败的话，需要将线程从work里面移除，并将线程数减1，并尝试着中断这个线程。
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w);
decrementWorkerCount();
tryTerminate();
} finally {
mainLock.unlock();
}
}
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly)
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
// 获取阻塞队列里面的任务
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.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 允许核心线程超时或者线程数大于核心线程数
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;
}
}
}
// 执行work线程
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
//获取work线程绑定的task
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 循环从workQueue里面，获取任务，调用getTask方法
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
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 实际的执行方法，每个task都是一个Runnable，直接执行run方法
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();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
// 起始于execute，线程执行
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 步骤1
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 步骤2
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 步骤3
else if (!addWorker(command, false))
reject(command);
}
}
上述内容是线程池的基本的一些配置参数和运行时的代码分析，下面简单来描述一下execute的过程
execute方法内部分3种情况处理任务：
-
第一步：如果当前正在执行的Worker数量比corePoolSize(基本大小)要小。直接创建一个新的Worker执行任务，会调用addWorker方法
-
第二步：当前线程池是运行状态，且workQueue已经满了，无法入队，则直接到步骤3；否则如果线程正在运行，且队列没有满，则直接将任务放到阻塞队列里面。如果在这个过程中，线程池处于非运行状态了，则需要将该线程剔除掉，从线程池里面移除。当前如果没有任务，则直接添加一个null
-
第三步：第三步比较有意思，也是充分体现了线程池的灵活性，当工作线程work的数量超出corePoolSize数，并且阻塞队列workQueue也满了的时候，在addWorker的时候，会判断线程数是否超过最大线程数maximumPoolSize,如果没有超过最大线程数，会创建一个新的线程，否则会执行拒接策略。
另外Worker执行任务的时候调用的是Runnable的run方法，而不是start方法，调用了start方法就相当于另外再起一个线程了。
Worker在回收的时候会尝试终止线程池。尝试关闭线程池的时候，会检查是否还有Worker在工作，检查线程池的状态，没问题的话会将状态过度到TIDYING状态，之后调用terminated方法，terminated方法调用完成之后将线程池状态更新到TERMINATED。
结束语
线程池在java里面，还是非常常用的，比单一一个线程，要好很多，主要是涉及到资源管理这块，线程池容易管理，而且用起来比较方便，其次，我感觉他们的这个设计，是真的好，一个线程池，状态+线程数等等东西，用一个字段就可以表示，实在是写的很好。感谢各位小伙伴的阅读，希望小伙伴点个赞，支持我继续写下去，虽然一开始会比较浅显，但是随着时间和经验的增长，以后会写出有深度的技术文章的，求赞、求赞、求赞。。。。。
