ThreadPoolExecutor属性
//高3位:当前线程池运行状态 低位:当前线程池中的线程数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//COUNT_BITS:29,ctl中表示线程池中的线程数量的位数
private static final int COUNT_BITS = Integer.SIZE - 3;
//ctl低29位能表示的最大数值:线程池能拥有的线程最大数量
//0001 1111 1111 1111 1111 1111 1111 1111
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
//1110 0000 0000 0000 0000 0000 0000 0000
private static final int RUNNING = -1 << COUNT_BITS;
//0000 0000 0000 0000 0000 0000 0000 0000
private static final int SHUTDOWN = 0 << COUNT_BITS;
//0010 0000 0000 0000 0000 0000 0000 0000
private static final int STOP = 1 << COUNT_BITS;
//0100 0000 0000 0000 0000 0000 0000 0000
private static final int TIDYING = 2 << COUNT_BITS;
//0110 0000 0000 0000 0000 0000 0000 0000
private static final int TERMINATED = 3 << COUNT_BITS;
//通过c获取线程池运行状态
//例如c = ctl = 1110 0000 0000 0000 0000 0000 0000 0011
// ~CAPACITY = 1110 0000 0000 0000 0000 0000 0000 0000
// 结果 = 111:状态为RUNNING
private static int runStateOf(int c) { return c & ~CAPACITY; }
//通过c获取线程池运行状态
//例如c = ctl = 1110 0000 0000 0000 0000 0000 0000 0011
// CAPACITY = 0001 1111 1111 1111 1111 1111 1111 1111
// 结果 = 011:当前线程池有3个线程
private static int workerCountOf(int c) { return c & CAPACITY; }
//计算ctl
//rs:线程池状态 wc:当前线程池中的线程数量
//例如 rs:111 000000000000000000
// wc:000 000000000000000111
// 结果:111 000000000000000111
private static int ctlOf(int rs, int wc) { return rs | wc; }
//比较线程池状态c,是否小于状态s
//任何情况下,RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
//比较线程池状态c,是否大于等于状态s
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
//通过c获取线程池是否是RUNNING状态
//任何情况下,小于SHUTDOWN的是RUNNING
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
//ctl值+1,就是线程数量加一
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
//ctl值-1,就是线程数量减一
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
//ctl值-1,重试到成功为止
private void decrementWorkerCount() {
do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}
//任务队列:线程池中的线程数达到corePoolSize时,提交的任务暂存入任务队列
private final BlockingQueue workQueue;
//线程池全局锁ReentrantLock:具体见AQS源码阅读(一)
//向线程池中增加线程,改变线程池状态等操作必须加锁
private final ReentrantLock mainLock = new ReentrantLock();
//Worker:线程池中封装线程的类,具体后面会写
private final HashSet workers = new HashSet();
//全局锁的condition队列:具体见AQS源码阅读(二)
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();
public ThreadPoolExecutor(int corePoolSize,//核心线程数量限制
int maximumPoolSize,//最大线程数量限制
long keepAliveTime,//空闲线程存活时间
TimeUnit unit,//时间单位
BlockingQueue 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;
}
Worker属性
-
Worker中封装了工作线程,线程池通过HashSet保存Worker,进而实现保存工作线程
-
Worker实现了Runnable,线程工厂生产工作线程时Worker作为参数传入,当工作线程启动时执行的是Worker的run()方法
-
Worker继承了AQS,使用了AQS的独占模式,当Worker中的工作线程执行任务时需要先设置独占锁,这样线程池可以通过Worker的锁状态来判断工作线程的状态
private final class Worker extends AbstractQueuedSynchronizer implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
//工作线程
final Thread thread;
//初始任务:可以在构造函数中设置,可以设置为null
Runnable firstTask;
//当前Worker完成任务的数量
volatile long completedTasks;
Worker(Runnable firstTask) {
//将AQS中state设置为-1,此时锁无法被占有
setState(-1);
this.firstTask = firstTask;
//使用线程工厂创建线程:当前Worker对象作为Runnable传入,当线程启动时,执行的是Worker对象中的run()方法
this.thread = getThreadFactory().newThread(this);
}
//当Worker内的线程启动时,会执行run()
public void run() {
//runWorker会执行firstTask,执行完毕或者firstTask为空就会从任务队列中取任务执行,具体后面会写
runWorker(this);
}
//重写的AQS的isHeldExclusively()方法
//当前锁是否被占用
protected boolean isHeldExclusively() {
return getState() != 0;
}
//重写的AQS的tryAcquire()方法
//lock() -> acquire() -> tryAcquire()
protected boolean tryAcquire(int unused) {
//CAS操作修改AQS中的state:修改成功即线程抢占锁成功
if (compareAndSetState(0, 1)) {
//设置持有锁的线程为当前线程
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
//重写的AQS的tryRelease方法unlock
//unlock ->release() ->tryRelease()
protected boolean tryRelease(int unused) {
//设置持有锁线程为空,把state值改回0
setExclusiveOwnerThread(null);
setState(0);
return true;
}
//加锁:如果失败会阻塞当前线程
public void lock() { acquire(1); }
//尝试加锁:如果失败时会直接返回false
public boolean tryLock() { return tryAcquire(1); }
//解锁:将state值设为0,将持有锁线程设置为空
public void unlock() { release(1); }
//当前Worker对象的锁是否被占用
public boolean isLocked() { return isHeldExclusively(); }
//给Worker中的工作线程一个中断信号
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
解析execute()
- execute():根据当前线程池情况决定command去向
//command:提交的任务
public void execute(Runnable command) {
//任务不能为空
if (command == null)
throw new NullPointerException();
//ctl的最新值
int c = ctl.get();
//情况一:当前线程数量未达到corePoolSize,addWorker():具体后面会写
if (workerCountOf(c) < corePoolSize) {
//addWorker():创建Worker对象,直接执行任务
//参数true:此时先采用corePoolSize限制线程数量
if (addWorker(command, true))
return;
//addWorker()失败:
//1.线程数量已经达到corePoolSize,可能有多个线程同时addWorker()使线程数量增加
//2.线程池状态已经改变
c = ctl.get();
}
//1.当前线程数量已达到corePoolSize
//2.addWorker()失败
//情况二:将任务加入阻塞队列
if (isRunning(c) && workQueue.offer(command)) {
//ctl的最新值
int recheck = ctl.get();
// !isRunning(recheck) == true:任务加入阻塞队列后,线程池状态改变
//remove(command) :将任务移出阻塞队列
if (! isRunning(recheck) && remove(command))
//当前线程池状态不是RUNNING状态,把任务出队成功,然后拒绝
reject(command);
//1.当前线程池是RUNNING状态
//2.线程池状态不是RUNNING状态,remove()失败
//为什么会remove()失败? 任务提交后被空闲线程取走执行了
//为什么不是RUNNING状态,空闲线程还能取走任务执行呢? SHUTDOWN状态下不能提交任务,但空闲的线程会继续取任务执行
//当前线程池是RUNNING状态,而线程池没有存活线程,addWorker()去增加一个线程工作
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//1.当前线程池不是RUNNING状态
//2.offer()失败,当前阻塞队列已满
//情况三:再次addWorker(),此时采用maximumPoolSize作线程数量限制
else if (!addWorker(command, false))
//addWorker()失败,拒绝任务
reject(command);
}
解析addWorker()
-
参数firstTask:Worker启动后直接执行的任务,如果为空,Worker会去阻塞队列获取任务执行
-
参数core == true:线程数量限制使用corePoolSize,否则使用maximumPoolSize
-
返回true:创建worker成功,工作线程启动
-
返回false:1.线程池状态rs > SHUTDOWN 2.线程池状态rs = SHUTDOWN,队列中已经没有任务了 || 队列有任务,但是firstTask != null
-
3.线程池数量达到限制(coprePoolSize 或 maximumPoolSIze) 4.ThreadFactory创建的线程是null
private boolean addWorker(Runnable firstTask, boolean core) {
//自旋
retry:
for (;;) {
//ctl的最新值
int c = ctl.get();
//线程池运行状态
int rs = runStateOf(c);
//rs >= SHUTDOWN:当前线程池状态不是RUNNING状态
//rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty():线程池是SHUTDOWN状态 && 提交的任务为空 && 任务队列不是空
//排除这种情况,因为线程池是SHUTDOWN状态,但是任务队列里面还有任务,此时允许添加Worker
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
//1.线程池状态 rs > SHUTDOWN
//2.rs == SHUTDOWN,队列中已经没有任务了
//3.rs == SHUTDOWN,firstTask != null,SHUTDOWN状态不能提交任务
return false;
//自旋
for (;;) {
//线程池中的线程数量
int wc = workerCountOf(c);
//wc >= CAPACITY:线程池中的线程数量已经达到最大值
//wc >= (core ? corePoolSize : maximumPoolSize):线程池中的线程数量是否达到设定的数量限制
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//compareAndIncrementWorkerCount() == true:CAS增加成功
// false:其他线程更改了ctl,可能是更改线程数量,也可能是更改线程池状态
if (compareAndIncrementWorkerCount(c))
//跳出外层自旋:去创建Worker
break retry;
//ctl的最新值
c = ctl.get(); // Re-read ctl
//线程池状态发生是否发生变化
if (runStateOf(c) != rs)
//跳出内层自旋:到外层自旋去判断线程池状态
continue retry;
}
}
//表示创建的Worker中的工作线程是否启动
boolean workerStarted = false;
//表示创建的Worker是否添加HashSet中
boolean workerAdded = false;
//创建Worker引用
Worker w = null;
try {
//创建Worker
w = new Worker(firstTask);
//Worker中的工作线程
final Thread t = w.thread;
//防止ThreadFactory产生null
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
//加锁
mainLock.lock();
try {
//线程池运行状态
int rs = runStateOf(ctl.get());
//rs < SHUTDOWN：当前线程池为RUNNING状态
//(rs == SHUTDOWN && firstTask == null):当前线程池为SHUTDOWN状态 && firstTask为空
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
//工作线程已经启动过了,抛出异常
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//将创建的Worker添加到线程池中
workers.add(w);
//线程池中的线程数量
int s = workers.size();
//更新largestPoolSize
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
//解锁
mainLock.unlock();
}
//添加Worker成功
if (workerAdded) {
//线程启动
t.start();
workerStarted = true;
}
}
} finally {
//线程启动失败
if (! workerStarted)
//将当前创建的Woker移除线程池
addWorkerFailed(w);
}
return workerStarted;
}
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//从线程池中移除w
if (w != null)
workers.remove(w);
//工作线程数减一
decrementWorkerCount();
//尝试结束线程池,具体后面会写
//为什么要结束线程池？ 进入这个方法是因为添加Woker失败,此时线程池已经不是RUNNING状态了
tryTerminate();
} finally {
mainLock.unlock();
}
}
解析runWorker()
-
addWorker()创建Worker后,就会启动工作线程,此时执行的时Worker对象中的run()方法,就是调用了runWorker()
-
runWorker()会首先执行firstTask,如果firstTask为空再去任务队列中取任务执行
-
取任务的方法getTask()在任务队列为空时会阻塞线程,具体后面会写
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
//Worker中的任务:firstTask
Runnable task = w.firstTask;
w.firstTask = null;
//为什么先unlock()? 因为Worker对象创建时会把state设为-1,unlock()会将state设为0,持有锁线程设为null,相当于初始化锁状态
w.unlock(); // allow interrupts
//true;产生了异常,需要进行后续处理
boolean completedAbruptly = true;
try {
//task != null:第一次执行时firstTask不是null,先执行firstTask
//(task = getTask()) != null:firstTask已经被执行过了,或者firstTask为空,去任务队列中取任务,getTask()后面会写
while (task != null || (task = getTask()) != null) {
//加锁?
//为什么要加锁? 后面要执行任务了,线程池会根据Worker的锁是否被持有判断是否正在执行任务
w.lock();
//当前线程的中断标记什么时候为true ? 1.shutdownNow()会给所有的工作线程一个中断信号 2.执行任务期间线程给了自己一个中断信号
//Thread.interrupted():返回当前中断标记并设置中断标记为false,为什么这么做？ 因为有可能在执行上一次任务时,线程的把自己中断标记置为true,这里刷新中断标记,不再影响这次任务执行
//if条件为true的情况
//情况一:(runStateAtLeast(ctl.get(), STOP) && !wt.isInterrupted():线程池至少是STOP状态,但中断标记为false,需要给自己一个中断信号
//情况二:(Thread.interrupted() && runStateAtLeast(ctl.get(), STOP)) && !wt.isInterrupted():线程在第一次(runStateAtLeast(ctl.get(), STOP)为false,第二次却为true ?
//有可能是第一次判断线程池状态时还未有线程执行shutdownNow(),第二次判断时,此时已经线程执行shutdownNow()了,此时前面的Thread.interrupted()刷新了中断标记,需要给自己一个中断信号
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;
//更新当前Worker对象完成的任务数量
w.completedTasks++;
//解锁,1.正常情况下会再getTask()获取任务
// 2.task.run()时出现异常
w.unlock();
}
}
//getTask() == null,当前线程准备退出
completedAbruptly = false;
} finally {
//正常退出: completedAbruptly == false
//异常退出: task.run()执行时抛出异常,解锁后来执行此方法,此时completedAbruptly = true
processWorkerExit(w, completedAbruptly);
}
}
//如果是正常退出,线程数减一这个操作发生在getTask()中
//异常退出,线程数减一发生这个方法中
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
completedTaskCount += w.completedTasks;
//将w从线程池移除
workers.remove(w);
} finally {
mainLock.unlock();
}
//尝试结束线程池,具体后面会写
//为什么要结束线程池呢？如果这是最后一个退出的线程,需要它去这个方法中结束线程池
tryTerminate();
//最新ctl值
int c = ctl.get();
//线程池状态为RUNNING或SHUTDOWN
if (runStateLessThan(c, STOP)) {
//正常退出
if (!completedAbruptly) {
//min:线程池最低的线程数量
//allowCoreThreadTimeOut == true :核心线程数内的线程超时后会被回收
//allowCoreThreadTimeOut == false: min == corePoolSize
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
//此时线程池状态为RUNNING或SHUTDOWN,如果任务队列还有任务,至少保留一个线程
if (min == 0 && ! workQueue.isEmpty())
min = 1;
//当前线程数量已经超过min,直接返回
if (workerCountOf(c) >= min)
return; // replacement not needed
}
//1.线程为异常退出,需要创建一个线程作为补充
//2.任务队列中还有任务,而此时workerCountOf(c)为0,最少留一个线程
addWorker(null, false);
}
}
解析getTask()
-
getTask():去任务队列中获取任务,如果返回null,工作线程将正常退出
-
对于获取任务,有两个操作,一个是poll():支持超时,在限定时间内没有任务就会返回null;一个是take():没有任务就会阻塞
-
getTask()返回null后,runWorker()就会执行退出processWorkerExit(),即实现了线程的回收
private Runnable getTask() {
//从任务队列poll()是否超时
boolean timedOut = false; // Did the last poll() time out?
//自旋
for (;;) {
//ctl的最新值
int c = ctl.get();
//线程池运行状态
int rs = runStateOf(c);
//rs >= SHUTDOWN:线程池状态不是RUNNING状态
//1.rs >= STOP:线程池状态最低是STOP状态,不能再获取任务了
//2.workQueue.isEmpty():线程池状态不是RUNNING 且 任务队列已空,不能再获取任务了
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
//线程池中的线程数量减一
decrementWorkerCount();
return null;
}
//1.线程池是RUNNING状态
//2.线程池是SHUTDOWN状态,但是任务队列还未空
//线程池中线程数量
int wc = workerCountOf(c);
//timed == true 当前线程从阻塞队列获取任务时使用poll():获取超时之后,会把timedOut置为true
//timed == false 当前线程从阻塞队列获取任务时使用take():获取不到任务就阻塞
//allowCoreThreadTimeOut == true:无论此时线程数量多少,都使用poll()操作,即使当前线程池中的线程数量小于corePoolSize
//wc > corePoolSize: 当前线程池中的线程数量大于corePoolSize,使用poll()操作
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//wc > maximumPoolSize:线程数量已经超过maximumPoolSize
//为什么会超过？setMaximumPoolSize()方法可以把maximumPoolSize设置成更小
//(timed && timedOut):当前线程使用poll()获取任务 && 获取任务超时
//(wc > 1 || workQueue.isEmpty()):线程池中还有其他线程 || 任务队列已空
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
//线程池中的线程数量减一
if (compareAndDecrementWorkerCount(c))
return null;
//CAS操作失败:再次去自旋
//为什么失败? 1.其他线程也在执行此操作 2.线程池状态改变了
continue;
}
try {
//获取任务: 按照上面计算出的timed决定使用poll()还是take()
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
//返回任务
if (r != null)
return r;
//获取任务超时
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
解析shutdown()和shutdownNow()
-
shutdown()会先把线程池状态设为SHUTDOWN,然后中断空闲线程,任务队列中如果有任务就会被取出执行
-
shutdownNow()会先把线程池状态设为SHUTDOWN,然后中断所有线程,把任务队列中的任务导出并作为结果返回
-
这两个都会调用tryTerminate()方法尝试结束线程池,最终由最后一个退出线程池的线程结束线程池
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
//设置线程池状态为SHUTDOWN
advanceRunState(SHUTDOWN);
//中断空闲线程:如果线程正在被阻塞在getTask()方法就会被唤醒,醒来发现线程池状态改变,getTask()返回null,线程就会去退出
interruptIdleWorkers();
//钩子方法
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
//将线程池状态设置为targetState
private void advanceRunState(int targetState) {
//自旋
for (;;) {
int c = ctl.get();
//线程池状态已经是targetState,返回
//线程池状态已经不是targetState,将线程池状态设置为targetState
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
private void interruptIdleWorkers() {
interruptIdleWorkers(false);
}
//onlyOne == true:中断一个线程 false:中断所有线程
//中断的线程必须是空闲状态:通过Worker的锁状态来判断
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
//Worker中的工作线程
Thread t = w.thread;
//!t.isInterrupted() == true:这个工作线程尚未中断
//w.tryLock():尝试获取锁,获取成功即表明工作线程处于空闲状态
if (!t.isInterrupted() && w.tryLock()) {
try {
//给Worker中的工作线程一个中断信号,如果此时工作线程阻塞在getTask()方法中就会被唤醒,继续自旋发现线程池状态改变返回null
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
final void tryTerminate() {
//自旋
for (;;) {
//ctl的最新值
int c = ctl.get();
//isRunning(c):线程池状态正常直接返回
//runStateAtLeast(c, TIDYING):线程池状态已经被其他线程设置为TIDYING,当前线程返回由其他线程继续停止线程池
//(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()):SHUTDOWN状态下,要等待任务队列为空才能停止线程池
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
？
//1.线程池状态至少是STOP
//2.线程池状态是SHUTDOWN,任务队列为空
//线程池中还有其他线程
if (workerCountOf(c) != 0) { // Eligible to terminate
//中断一个空闲线程,空闲线程在做什么？
//在getTask()中poll()或者take(),正在阻塞
//1.唤醒后的线程,在getTask()中返回null,线程会在runWorker()中退出执行processWorkerExit()
//2.执行processWorkerExit()的线程会执行tryTerminate()方法,也来到这里继续中断空闲线程
interruptIdleWorkers(ONLY_ONE);
return;
}
//此时workerCountOf(c) == 0,当前线程是最后一个退出的线程
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//设置线程池状态为TIDYING
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
//钩子方法
terminated();
} finally {
//设置线程池状态为TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
//唤醒调用awaitTermination()的线程
//awaitTermination():会使线程一直阻塞,直到线程状态为TERMINATED或者超时
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
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)
//Worker中的方法:给Worker中的工作线程一个中断信号
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
