线程池ThreadPoolExecutor的使用上一篇博客中已经有所介绍了，线程池的使用主要是创建线程池对象，通过execute()方法提交任务，简单代码示例如下
public class ThreadPoolExecutorTest {
//核心线程数
private static final Integer CORE_POOL_SIZE = 10;
//最大线程数
private static final Integer MAXIMUM_POOL_SIZE = 20;
//线程空闲超时时长
private static final Long KEEP_ALIVE_TIME = 120L;
public static void main(String[] args) {
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
MAXIMUM_POOL_SIZE,
KEEP_ALIVE_TIME,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 2; i++) {
poolExecutor.execute(() -> {
System.out.println(Thread.currentThread().getName() + "：hello.....");
});
}
}
}从代码中可以看到，我们查阅源码的话，需要注意两个地方，一个是创建ThreadPoolExecutor对象时的构造函数，另一个就是调用execute()方法。构造函数在上一篇博客已经有所介绍，这篇文章主要是对execute()方法的源码阅读。
1. execute()方法源码
execute()方法是线程池的核心方法了。线程池提交任务最终都是通过改方法来进行逻辑的处理，源码的注释如下
/**
* 核心方法execute详解
* @param command 任务
*/
public void execute(Runnable command) {
//空判断，防止提交null的任务
if (command == null)
throw new NullPointerException();
//获取clt的值并转成int类型，高3位表示状态，后29位表示线程个数
int c = ctl.get();
// workerCountOf：获取工作线程数量
//校验工作线程数量是否 小于 核心线程数
if (workerCountOf(c) < corePoolSize) {
//核心线程数还没到达最大值，创建核心线程
if (addWorker(command, true))
//创建成功，任务结束
return;
//创建失败，重新获取clt的值
c = ctl.get();
}
//逻辑到此表示：工作线程数量 大于 核心线程数
// isRunning()：校验线程池是否处于RUNNING状态
//如果是RUNNING状态，将任务command放入阻塞队列中
if (isRunning(c) && workQueue.offer(command)) {
//逻辑到此：表示任务已经放入阻塞队列中
int recheck = ctl.get();
//再次校验线程池状态是否正常，如果状态是非RUNNING状态，就将刚才添加到阻塞队列的任务删除
if (! isRunning(recheck) && remove(command))
//拒绝任务
reject(command);
else if (workerCountOf(recheck) == 0)
/**
* 逻辑到这存在这么几种情况
* 1. 线程池状态为RUNNING状态
* 2. 线程池状态不为RUNNING状态，但是在执行移除任务方法remove(command)时移除失败
* 出现以上两种中的任何一种，逻辑都会进入else if (workerCountOf(recheck) == 0)
* 判断workerCountOf(recheck) == 0为true时，表示线程池中已经没有工作线程了
* 故而需要创建一个空任务线程来处理队列中的任务，
* 因为在最外层workQueue.offer(command)会将任务放入队列，但是如果线程池正常运行，
* 这段if (! isRunning(recheck) && remove(command))中的remove(command)会被断言无法执行，
* 故而队列中必然还存在任务
*/
addWorker(null, false);
}
//创建非核心工作线程
else if (!addWorker(command, false))
//如果非核心线程创建失败，执行拒绝策略
reject(command);
}该方法的逻辑图示如下
从execute可以看到，创建核心线程和非核心线程，或者创建任务未空的线程都是通过addWorker方法来实现的，所以我们需要在跟踪一下addWorker的源码。
2. addWorker方法的源码
addWorker方法是线程池中真正创建任务线程的方法，该方法的源码注释如下
/**
* 创建工作线程方法源码
*
* @param firstTask 任务
* @param core 是否创建核心线程 true：创建核心线程 false：创建非核心线程
*/
private boolean addWorker(Runnable firstTask, boolean core) {
//标记位，用于退出外层for循环
retry:
for (;;) {
//获取clt的值并转化为一个int值
int c = ctl.get();
//获取线程池状态
int rs = runStateOf(c);
/**
* rs >= SHUTDOWN（0）校验结果如果为true，表示线程池已经是非RUNNING状态了，
* 则继续判断(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty())部分的逻辑，整体为false，取反后为true，返回创建失败
* rs == SHUTDOWN：当rs的状态是非RUNNING时，判断是不是SHUTDOWN状态，如果是SHUTDOWN状态，
* 校验传入的任务是否为空，如果是为null，表示该线程创建是用来处理队列里面的任务的，所以就需要判断队列是否为null
* !workQueue.isEmpty()用来校验队列是否为空，为空，取反结果为false，最外层再次取反，整体结果为true，表示队列没有任务需要处理，也就不在需要创建线程了
* 反之需要创建线程处理队列中的任务
*/
if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
//返回创建失败
return false;
//逻辑到了这，说明需要创建工作线程了
for (;;) {
//获取线程池中的工作线程数量
int wc = workerCountOf(c);
/**
* CAPACITY：线程池最大容量
* wc >= CAPACITY：校验线程池的线程数量是否超过了最大的线程数。如果为true：表示已经超过了，直接返回创建失败，如果为false，进行wc >= (core ? corePoolSize : maximumPoolSize)的判断
* core是方法入参，true：表示需要创建核心线程 false：表示需要创建非核心线程
* wc >= (core ? corePoolSize : maximumPoolSize)：用来校验线程池中的线程数是否超过了核心线程数或者非核心线程数，如果为true，表示已经超过了，返回创建失败
*/
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
//返回创建失败
return false;
//将线程数加1
if (compareAndIncrementWorkerCount(c))
//添加成功后，跳出外层for循环
break retry;
c = ctl.get();
//再次校验线程池状态是否有变化
if (runStateOf(c) != rs)
//如果有变化，本次内循环结束，重新走一次内层for循环
continue retry;
}
}
//标记worker开始状态
boolean workerStarted = false;
//标记worker添加状态
boolean workerAdded = false;
//工作线程
Worker w = null;
try {
//new对象，通过构造函数传入任务firstTask
w = new Worker(firstTask);
//获取Worker中的线程t
final Thread t = w.thread;
//健壮性非空校验
if (t != null) {
//获取ReentrantLock锁对象
final ReentrantLock mainLock = this.mainLock;
//加锁
mainLock.lock();
try {
//获取线程池状态
int rs = runStateOf(ctl.get());
/**
* (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null))
* rs < SHUTDOWN：如果为true，程序断言，后面的逻辑不处理。表示线程池是RUNNING状态
* rs < SHUTDOWN：如果为false，状态是非RUNNING状态，校验(rs == SHUTDOWN && firstTask == null)部分的校验逻辑
* rs == SHUTDOWN && firstTask == null：校验状态是不是为SHUTDOWN，如果为true，任务firstTask是否为null，两者为空的话
* 结合前面的了解，这个线程是用来实例队列里面堆积的任务的
*/
if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
//校验线程t是否存活，存活返回true，反之false
if (t.isAlive())
throw new IllegalThreadStateException(); //如果t是存活状态，说明已经创建了，无需再次创建
//将新创建的工作队列存放到工作队列HashSet集合中
workers.add(w);
//获取工作线程个数，如果数量超过历史最大线程数，更新历史最大线程数的值
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
//将worker添加状态改为true
workerAdded = true;
}
} finally {
//释放锁
mainLock.unlock();
}
//线程成功添加到集合HashSet中的话
if (workerAdded) {
//调用线程的start()方法启动线程，这个线程启动后，会执行Worker的run()方法,然后执行runWorker(this)方法
t.start();
//将worker的开始状态改为true
workerStarted = true;
}
}
} finally {
//如果开始状态未改变，表示线程失败了
if (!workerStarted)
//将刚才添加到工作线程集合HashSet中的Worker从集合中删除
addWorkerFailed(w);
}
//将worker的开始状态返回
return workerStarted;
}从源码中可以看到，当工作线程创建成功后，会将会当前任务Runnable通过构造函数传给Worker的属性Runnable，另外创建属性中的thread属性，将this传入，相当于Worker在创建对象的时候，将Worker赋值给了Worker的thread属性，该属性是一个线程Thread类。启动线程，调用线程的启动方法start()方法。然后执行Worker的run()方法。run()方法中执行Worker的构造函数源码如下
Worker(Runnable firstTask) {
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}run()方法中执行runWorker(this)方法，其源码如下
public void run() {
runWorker(this);
}我们继续阅读runWorker方法的源码。源码如下
/**
* 运行工作线程
*
* @param w 工作线程
*/
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
//task：任务。接收Worker的任务，如果在SHUTDOWN状态下创建的线程，这个firstTask就是为null
Runnable task = w.firstTask;
//将这个任务置为null？疑问点。线程复用？
w.firstTask = null;
w.unlock(); //允许中断
//表示完成状态
boolean completedAbruptly = true;
try {
/**
* 先校验传入的任务是否为空，如果不为空，线程处理该任务，如果任务为空，通过getTask()获取任务，
* 这里是while循环，会一直查询获取知道拿到任务为止
*/
while (task != null || (task = getTask()) != null) {
//加锁
w.lock();
/**
* runStateAtLeast(ctl.get(), STOP)：校验线程池状态值是否大于等于STOP，为true的话，表示线程池已经停止了，并且终止处理任何任务，在处理中的任务也会终止
* Thread.interrupted()测试当前线程是否被中断，返回一个boolean并清除中断状态。wt.isInterrupted()只测试此线程是否被中断 ，不清除中断状态。wt.interrupt()中断此线程
* 线程池状态校验和线程状态校验
*/
if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted())
wt.interrupt();
try {
//空方法，用于拓展
beforeExecute(wt, task);
Throwable thrown = null;
try {
//执行任务的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，便于线程复用
task = null;
//完成次数累加
w.completedTasks++;
//解锁
w.unlock();
}
}
//如果任务为空，并且阻塞队列中也没有拿到任务，完成状态为false
completedAbruptly = false;
} finally {
//如果completedAbruptly结果为true，那么更新任务完成次数
//如果completedAbruptly结果为false，删除工作队列中的该任务线程，并调用terminated()方法使线程池状态变为TERMINATED结束状态
processWorkerExit(w, completedAbruptly);
}
}其中我觉得需要注意两个地方一个是while (task != null || (task = getTask()) != null)这段代码，另外一个是getTask()方法。其中while循环，可以理解为线程一直在获取任务，如果没有获取到任务，就一直循环，达到了线程阻塞的效果。另外一个就是getTask()方法。当传入的任务为空时，用过该方法用来获取队列中的任务。所以该方法的源码我们也是需要去阅读的。
3. getTask方法的源码
该方法用于线程从阻塞队列中获取任务进行处理，该方法的源码如下
/**
* 获取任务task方法
*/
private Runnable getTask() {
//是否超时的标记
boolean timedOut = false;
//等价于while(true)循环
for (;;) {
//取clt的值并转为int值
int c = ctl.get();
//获取线程池状态
int rs = runStateOf(c);
//校验线程池状态并检查队列是非为null，整体结果如果为true，返回null，并完成任务次数减1
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
//获取线程池中的工作线程数量
int wc = workerCountOf(c);
//校验是否设置了超时或者 最大线程数是否超过了最大核心线程数
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//判断 线程池线程数量是否大于最大线程数量 或者超时校验和校验队列中任务是否为null
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
//完成次数减1 并返回空任务
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//workQueue.poll：该方法取出元素时，如果队列为空，则阻塞给定的时间，如果存在任务，取出第一个任务
//workQueue.take()：队列中取出任务task
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
//取到任务返回
if (r != null)
return r;
//更新标记值
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}如果只考虑线程池的工作原理，代码阅读到这就已经结束了，但是线程池本身就是多线程环境，线程之间的资源竞争导致并发问题是必然需要考虑的，源码中也有对应的处理方案，就是通过加锁来实现，使用的锁是ReentrantLock，由于本文是阅读线程池的源码，未对ReentrantLock做过多的解释，这方面的知识也还在学习整理中。另外就将ThreadPoolExecutor类的整个类的源码理解完整展示一下，源码理解如下
public class ThreadPoolExecutor extends AbstractExecutorService {
/**
* ctl可以理解为是一个int类型，有两个作用。1：标识当前线程池的状态 2：记录线程池中的线程数量
* ctl是理解为一个int值，iint占32位，
* 其中高三位[从左往右数3位即为高3位]用来标识线程池状态。
* 后29位用来记录线程池中的线程个数
*/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
/**
* COUNT_BITS：固定值29[Integer.SIZE = 32,32-3=29]
*/
private static final int COUNT_BITS = Integer.SIZE - 3;
/**
* CAPACITY：线程池最大容量
*/
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
/**
* ======================线程池状态解释start=================
* 线程池状态
* RUNNING：状态值为 -1。接受新任务并处理排队的任务
* SHUTDOWN：状态值为 0。不接受新任务，但还会处理排队的任务
* STOP：状态值为 1。不接受新任务、不处理排队的任务和会中断正在进行的任务
* TIDYING：状态值为 2。所有的任务都已经结束，工作线程数量为0，该状态是一个过渡状态，表示线程池即将调用terminated()方法
* TERMINATED：状态值为3。terminated()方法已经执行结束，线程池结束
*
* 线程池状态流转：
* 1. RUNNING -> SHUTDOWN：调用shutdown()方法
* 2. (RUNNING或SHUTDOWN) -> STOP：调用shutdownNow()方法
* 3. SHUTDOWN -> TIDYING：当队列和线程池都是空的时候状态会改变为TIDYING
* 4. STOP -> TIDYING：当线程池是空的时候状态会改变为TIDYING
* 5. TIDYING -> TERMINATED：当方法terminated()执行完成后状态就会变化为TERMINATED
*/
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;
/**======================线程池状态解释end=================*/
/**
* 获取线程池状态
*/
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; }
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
/**
* 校验线程池是否是RUNNING状态
*/
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
private void decrementWorkerCount() {
do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}
/**
* 阻塞队列
*/
private final BlockingQueue<Runnable> workQueue;
/**
* 锁
*/
private final ReentrantLock mainLock = new ReentrantLock();
/**
* 工作队列集合
*/
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;
/**
* 设置核心线程是否超时，默认为false：即核心线程即使空闲状态也保持活跃状态，设置为true：核心线程也会空闲超时
*/
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 final AccessControlContext acc;
/**
* 实现了Runnable表示Worker也是一个线程类
*/
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread;
Runnable firstTask;
volatile long completedTasks;
/**
* Worker构造函数
* this.thread = getThreadFactory().newThread(this)创建Worker对象的时候进行thread赋值
* 赋值的时候传入Worker本身this，这段代码等价于===>new Thread(new Worker())
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
//线程启动后，执行run方法
public void run() {
runWorker(this);
}
protected boolean isHeldExclusively() {
return getState() != 0;
}
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
private void advanceRunState(int targetState) {
for (;;) {
int c = ctl.get();
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
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
}
}
private void checkShutdownAccess() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(shutdownPerm);
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
security.checkAccess(w.thread);
} finally {
mainLock.unlock();
}
}
}
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
Thread t = w.thread;
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
private void interruptIdleWorkers() {
interruptIdleWorkers(false);
}
private static final boolean ONLY_ONE = true;
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
void onShutdown() {
}
final boolean isRunningOrShutdown(boolean shutdownOK) {
int rs = runStateOf(ctl.get());
return rs == RUNNING || (rs == SHUTDOWN && shutdownOK);
}
private List<Runnable> drainQueue() {
BlockingQueue<Runnable> q = workQueue;
ArrayList<Runnable> taskList = new ArrayList<Runnable>();
q.drainTo(taskList);
if (!q.isEmpty()) {
for (Runnable r : q.toArray(new Runnable[0])) {
if (q.remove(r))
taskList.add(r);
}
}
return taskList;
}
/**
* 创建/添加工作线程方法
*
* @param firstTask 任务
* @param core 是否创建核心线程 true：创建核心线程 false：创建非核心线程
*/
private boolean addWorker(Runnable firstTask, boolean core) {
//标记位，用于退出外层for循环
retry:
for (;;) {
//获取clt的值并转化为一个int值
int c = ctl.get();
//获取线程池状态
int rs = runStateOf(c);
/**
* rs >= SHUTDOWN（0）校验结果如果为true，表示线程池已经是非RUNNING状态了，
* 则继续判断(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty())部分的逻辑，整体为false，取反后为true，返回创建失败
* rs == SHUTDOWN：当rs的状态是非RUNNING时，判断是不是SHUTDOWN状态，如果是SHUTDOWN状态，
* 校验传入的任务是否为空，如果是为null，表示该线程创建是用来处理队列里面的任务的，所以就需要判断队列是否为null
* !workQueue.isEmpty()用来校验队列是否为空，为空，取反结果为false，最外层再次取反，整体结果为true，表示队列没有任务需要处理，也就不在需要创建线程了
* 反之需要创建线程处理队列中的任务
*/
if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
//返回创建失败
return false;
//逻辑到了这，说明需要创建工作线程了
for (;;) {
//获取线程池中的工作线程数量
int wc = workerCountOf(c);
/**
* CAPACITY：线程池最大容量
* wc >= CAPACITY：校验线程池的线程数量是否超过了最大的线程数。如果为true：表示已经超过了，直接返回创建失败，如果为false，进行wc >= (core ? corePoolSize : maximumPoolSize)的判断
* core是方法入参，true：表示需要创建核心线程 false：表示需要创建非核心线程
* wc >= (core ? corePoolSize : maximumPoolSize)：用来校验线程池中的线程数是否超过了核心线程数或者非核心线程数，如果为true，表示已经超过了，返回创建失败
*/
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
//返回创建失败
return false;
//将线程数加1
if (compareAndIncrementWorkerCount(c))
//添加成功后，跳出外层for循环
break retry;
c = ctl.get();
//再次校验线程池状态是否有变化
if (runStateOf(c) != rs)
//如果有变化，本次内循环结束，重新走一次内层for循环
continue retry;
}
}
//标记worker开始状态
boolean workerStarted = false;
//标记worker添加状态
boolean workerAdded = false;
//工作线程
Worker w = null;
try {
//new对象，通过构造函数传入任务firstTask
w = new Worker(firstTask);
//获取Worker中的线程t
final Thread t = w.thread;
//健壮性非空校验
if (t != null) {
//获取ReentrantLock锁对象
final ReentrantLock mainLock = this.mainLock;
//加锁
mainLock.lock();
try {
//获取线程池状态
int rs = runStateOf(ctl.get());
/**
* (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null))
* rs < SHUTDOWN：如果为true，程序断言，后面的逻辑不处理。表示线程池是RUNNING状态
* rs < SHUTDOWN：如果为false，状态是非RUNNING状态，校验(rs == SHUTDOWN && firstTask == null)部分的校验逻辑
* rs == SHUTDOWN && firstTask == null：校验状态是不是为SHUTDOWN，如果为true，任务firstTask是否为null，两者为空的话
* 结合前面的了解，这个线程是用来实例队列里面堆积的任务的
*/
if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
//校验线程t是否存活，存活返回true，反之false
if (t.isAlive())
throw new IllegalThreadStateException(); //如果t是存活状态，说明已经创建了，无需再次创建
//将新创建的工作队列存放到工作队列HashSet集合中
workers.add(w);
//获取工作线程个数，如果数量超过历史最大线程数，更新历史最大线程数的值
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
//将worker添加状态改为true
workerAdded = true;
}
} finally {
//释放锁
mainLock.unlock();
}
//线程成功添加到集合HashSet中的话
if (workerAdded) {
//调用线程的start()方法启动线程，这个线程启动后，会执行Worker的run()方法,然后执行runWorker(this)方法
t.start();
//将worker的开始状态改为true
workerStarted = true;
}
}
} finally {
//如果开始状态未改变，表示线程失败了
if (!workerStarted)
//将刚才添加到工作线程集合HashSet中的Worker从集合中删除
addWorkerFailed(w);
}
//将worker的开始状态返回
return workerStarted;
}
/**
* 将开始失败的Worker从工作集合中删除
* @param w 工作线程
*/
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) // If abrupt, then workerCount wasn't adjusted
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);
}
}
/**
* 获取任务task方法
*/
private Runnable getTask() {
//是否超时的标记
boolean timedOut = false;
for (;;) {
//取clt的值并转为int值
int c = ctl.get();
//获取线程池状态
int rs = runStateOf(c);
//校验线程池状态并检查队列是非为null，整体结果如果为true，返回null，并完成任务次数减1
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
//获取线程池中的工作线程数量
int wc = workerCountOf(c);
//校验是否设置了超时或者 最大线程数是否超过了最大核心线程数
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//判断 线程池线程数量是否大于最大线程数量 或者超时校验和校验队列中任务是否为null
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
//完成次数减1 并返回空任务
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//workQueue.poll：该方法取出元素时，如果队列为空，则阻塞给定的时间，如果存在任务，取出第一个任务
//workQueue.take()：队列中取出任务task
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
//取到任务返回
if (r != null)
return r;
//更新标记值
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
/**
* 运行工作线程
*
* @param w 工作线程
*/
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
//task：任务。接收Worker的任务，如果在SHUTDOWN状态下创建的线程，这个firstTask就是为null
Runnable task = w.firstTask;
//将这个任务置为null？疑问点。线程复用？
w.firstTask = null;
w.unlock(); //允许中断
//表示完成状态
boolean completedAbruptly = true;
try {
/**
* 先校验传入的任务是否为空，如果不为空，线程处理该任务，如果任务为空，通过getTask()获取任务，
* 这里是while循环，会一直查询获取知道拿到任务为止
*/
while (task != null || (task = getTask()) != null) {
//加锁
w.lock();
/**
* runStateAtLeast(ctl.get(), STOP)：校验线程池状态值是否大于等于STOP，为true的话，表示线程池已经停止了，并且终止处理任何任务，在处理中的任务也会终止
* Thread.interrupted()测试当前线程是否被中断，返回一个boolean并清除中断状态。wt.isInterrupted()只测试此线程是否被中断 ，不清除中断状态。wt.interrupt()中断此线程
* 线程池状态校验和线程状态校验
*/
if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted())
wt.interrupt();
try {
//空方法，用于拓展
beforeExecute(wt, task);
Throwable thrown = null;
try {
//执行任务的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，便于线程复用
task = null;
//完成次数累加
w.completedTasks++;
//解锁
w.unlock();
}
}
//如果任务为空，并且阻塞队列中也没有拿到任务，完成状态为false
completedAbruptly = false;
} finally {
//如果completedAbruptly结果为true，那么更新任务完成次数
//如果completedAbruptly结果为false，删除工作队列中的该任务线程，并调用terminated()方法使线程池状态变为TERMINATED结束状态
processWorkerExit(w, completedAbruptly);
}
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
/**
* 核心方法execute详解
* @param command 任务
*/
public void execute(Runnable command) {
//空判断，防止提交null的任务
if (command == null)
throw new NullPointerException();
//获取clt的值并转成int类型，高3位表示状态，后29位表示线程个数
int c = ctl.get();
// workerCountOf：获取工作线程数量
//校验工作线程数量是否 小于 核心线程数
if (workerCountOf(c) < corePoolSize) {
//核心线程数还没到达最大值，创建核心线程
if (addWorker(command, true))
//创建成功，任务结束
return;
//创建失败，重新获取clt的值
c = ctl.get();
}
//逻辑到此表示：工作线程数量 大于 核心线程数
// isRunning()：校验线程池是否处于RUNNING状态
//如果是RUNNING状态，将任务command放入阻塞队列中
if (isRunning(c) && workQueue.offer(command)) {
//逻辑到此：表示任务已经放入阻塞队列中
int recheck = ctl.get();
//再次校验线程池状态是否正常，如果状态是非RUNNING状态，就将刚才添加到阻塞队列的任务删除
if (! isRunning(recheck) && remove(command))
//拒绝任务
reject(command);
else if (workerCountOf(recheck) == 0)
/**
* 逻辑到这存在这么几种情况
* 1. 线程池状态为RUNNING状态
* 2. 线程池状态不为RUNNING状态，但是在执行移除任务方法remove(command)时移除失败
* 出现以上两种中的任何一种，逻辑都会进入else if (workerCountOf(recheck) == 0)
* 判断workerCountOf(recheck) == 0为true时，表示线程池中已经没有工作线程了
* 故而需要创建一个空任务线程来处理队列中的任务，
* 因为在最外层workQueue.offer(command)会将任务放入队列，但是如果线程池正常运行，
* 这段if (! isRunning(recheck) && remove(command))中的remove(command)会被断言无法执行，
* 故而队列中必然还存在任务
*/
addWorker(null, false);
}
//创建非核心工作线程
else if (!addWorker(command, false))
//如果非核心线程创建失败，执行拒绝策略
reject(command);
}
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(STOP);
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
public boolean isShutdown() {
return ! isRunning(ctl.get());
}
public boolean isTerminating() {
int c = ctl.get();
return ! isRunning(c) && runStateLessThan(c, TERMINATED);
}
public boolean isTerminated() {
return runStateAtLeast(ctl.get(), TERMINATED);
}
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (;;) {
if (runStateAtLeast(ctl.get(), TERMINATED))
return true;
if (nanos <= 0)
return false;
nanos = termination.awaitNanos(nanos);
}
} finally {
mainLock.unlock();
}
}
protected void finalize() {
SecurityManager sm = System.getSecurityManager();
if (sm == null || acc == null) {
shutdown();
} else {
PrivilegedAction<Void> pa = () -> { shutdown(); return null; };
AccessController.doPrivileged(pa, acc);
}
}
public void setThreadFactory(ThreadFactory threadFactory) {
if (threadFactory == null)
throw new NullPointerException();
this.threadFactory = threadFactory;
}
public ThreadFactory getThreadFactory() {
return threadFactory;
}
public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
if (handler == null)
throw new NullPointerException();
this.handler = handler;
}
public RejectedExecutionHandler getRejectedExecutionHandler() {
return handler;
}
public void setCorePoolSize(int corePoolSize) {
if (corePoolSize < 0)
throw new IllegalArgumentException();
int delta = corePoolSize - this.corePoolSize;
this.corePoolSize = corePoolSize;
if (workerCountOf(ctl.get()) > corePoolSize)
interruptIdleWorkers();
else if (delta > 0) {
// We don't really know how many new threads are "needed".
// As a heuristic, prestart enough new workers (up to new
// core size) to handle the current number of tasks in
// queue, but stop if queue becomes empty while doing so.
int k = Math.min(delta, workQueue.size());
while (k-- > 0 && addWorker(null, true)) {
if (workQueue.isEmpty())
break;
}
}
}
public int getCorePoolSize() {
return corePoolSize;
}
public boolean prestartCoreThread() {
return workerCountOf(ctl.get()) < corePoolSize &&
addWorker(null, true);
}
void ensurePrestart() {
int wc = workerCountOf(ctl.get());
if (wc < corePoolSize)
addWorker(null, true);
else if (wc == 0)
addWorker(null, false);
}
public int prestartAllCoreThreads() {
int n = 0;
while (addWorker(null, true))
++n;
return n;
}
public boolean allowsCoreThreadTimeOut() {
return allowCoreThreadTimeOut;
}
public void allowCoreThreadTimeOut(boolean value) {
if (value && keepAliveTime <= 0)
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
if (value != allowCoreThreadTimeOut) {
allowCoreThreadTimeOut = value;
if (value)
interruptIdleWorkers();
}
}
public void setMaximumPoolSize(int maximumPoolSize) {
if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
throw new IllegalArgumentException();
this.maximumPoolSize = maximumPoolSize;
if (workerCountOf(ctl.get()) > maximumPoolSize)
interruptIdleWorkers();
}
public int getMaximumPoolSize() {
return maximumPoolSize;
}
public void setKeepAliveTime(long time, TimeUnit unit) {
if (time < 0)
throw new IllegalArgumentException();
if (time == 0 && allowsCoreThreadTimeOut())
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
long keepAliveTime = unit.toNanos(time);
long delta = keepAliveTime - this.keepAliveTime;
this.keepAliveTime = keepAliveTime;
if (delta < 0)
interruptIdleWorkers();
}
public long getKeepAliveTime(TimeUnit unit) {
return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
}
public BlockingQueue<Runnable> getQueue() {
return workQueue;
}
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}
public void purge() {
final BlockingQueue<Runnable> q = workQueue;
try {
Iterator<Runnable> it = q.iterator();
while (it.hasNext()) {
Runnable r = it.next();
if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
it.remove();
}
} catch (ConcurrentModificationException fallThrough) {
// Take slow path if we encounter interference during traversal.
// Make copy for traversal and call remove for cancelled entries.
// The slow path is more likely to be O(N*N).
for (Object r : q.toArray())
if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
q.remove(r);
}
tryTerminate(); // In case SHUTDOWN and now empty
}
public int getPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Remove rare and surprising possibility of
// isTerminated() && getPoolSize() > 0
return runStateAtLeast(ctl.get(), TIDYING) ? 0
: workers.size();
} finally {
mainLock.unlock();
}
}
public int getActiveCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int n = 0;
for (Worker w : workers)
if (w.isLocked())
++n;
return n;
} finally {
mainLock.unlock();
}
}
public int getLargestPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
return largestPoolSize;
} finally {
mainLock.unlock();
}
}
public long getTaskCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
long n = completedTaskCount;
for (Worker w : workers) {
n += w.completedTasks;
if (w.isLocked())
++n;
}
return n + workQueue.size();
} finally {
mainLock.unlock();
}
}
public long getCompletedTaskCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
long n = completedTaskCount;
for (Worker w : workers)
n += w.completedTasks;
return n;
} finally {
mainLock.unlock();
}
}
public String toString() {
long ncompleted;
int nworkers, nactive;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
ncompleted = completedTaskCount;
nactive = 0;
nworkers = workers.size();
for (Worker w : workers) {
ncompleted += w.completedTasks;
if (w.isLocked())
++nactive;
}
} finally {
mainLock.unlock();
}
int c = ctl.get();
String rs = (runStateLessThan(c, SHUTDOWN) ? "Running" :
(runStateAtLeast(c, TERMINATED) ? "Terminated" :
"Shutting down"));
return super.toString() +
"[" + rs +
", pool size = " + nworkers +
", active threads = " + nactive +
", queued tasks = " + workQueue.size() +
", completed tasks = " + ncompleted +
"]";
}
protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }
protected void terminated() { }
public static class CallerRunsPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code CallerRunsPolicy}.
*/
public CallerRunsPolicy() { }
/**
* Executes task r in the caller's thread, unless the executor
* has been shut down, in which case the task is discarded.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
public static class AbortPolicy implements RejectedExecutionHandler {
/**
* Creates an {@code AbortPolicy}.
*/
public AbortPolicy() { }
/**
* Always throws RejectedExecutionException.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
* @throws RejectedExecutionException always
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
public static class DiscardPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardPolicy}.
*/
public DiscardPolicy() { }
/**
* Does nothing, which has the effect of discarding task r.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardOldestPolicy} for the given executor.
*/
public DiscardOldestPolicy() { }
/**
* Obtains and ignores the next task that the executor
* would otherwise execute, if one is immediately available,
* and then retries execution of task r, unless the executor
* is shut down, in which case task r is instead discarded.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
}到这里，线程池的源码阅读就结束了，源码中也存在很多的疑问点。欢迎讨论！！！
857
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
