largestPoolSize = s;
// 新增工作线程成功
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 看到亲切迷人的start方法了!
// 这并非线程池的execute 的command 参数指向的线程
t.start();
workerStarted = true;
}
}
} finally {
// 线程启动失败,把刚才第3处加,上的工作线程计数再减-回去
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
第1处
配合循环语句出现的标签,类似于goto语法作用。label 定义时,必须把标签和冒号的组合语句紧紧相邻定义在循环体之前,否则编译报错。目的是在实现多重循环时能够快速退出到任何一层。出发点似乎非常贴心,但在大型软件项目中,滥用标签行跳转的后果将是无法维护的!
在 workerCount 加1成功后,直接退出两层循环。
第2处,这样的表达式不利于阅读,应如是
第3处
与第1处的标签呼应,AtomicInteger
对象的加1操作是原子性的。break retry
表 直接跳出与retry
相邻的这个循环体
第4处
此continue
跳转至标签处,继续执行循环.
如果条件为false,则说明线程池还处于运行状态,即继续在for(;)
循环内执行.
第5处
compareAndIncrementWorkerCount
方法执行失败的概率非常低.
即使失败,再次执行时成功的概率也是极高的,类似于自旋原理.
这里是先加1,创建失败再减1,这是轻量处理并发创建线程的方式;
如果先创建线程,成功再加1,当发现超出限制后再销毁线程,那么这样的处理方式明显比前者代价要大.
第6处
Worker
对象是工作线程的核心类实现。它实现了Runnable
接口,并把本对象作为参数输入给run()
中的runWorker (this)
。所以内部属性线程thread
在start
的时候,即会调用runWorker
。
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/**
-
This class will never be serialized, but we provide a
-
serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
/**
-
Creates with given first task and thread from ThreadFactory.
-
@param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1); // 直到调用runWorker前,禁止被中断
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** 将主线程的 run 循环委托给外部的 runWorker 执行 */
public void run() {
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
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) {
}
}
}
}
setState(-1)是为何
设置个简单的状态,检查状态以防止中断。在调用停止线程池时会判断state 字段,决定是否中断之。
t 到底是谁?
===================================================================
/**
-
检查是否可以根据当前池状态和给定的边界(核心或最大)
-
添加新工作线程。如果是这样,工作线程数量会相应调整,如果可能的话,一个新的工作线程创建并启动
-
将firstTask作为其运行的第一项任务。
-
如果池已停止此方法返回false
-
如果线程工厂在被访问时未能创建线程,也返回false
-
如果线程创建失败,或者是由于线程工厂返回null,或者由于异常(通常是在调用Thread.start()后的OOM)),我们干净地回滚。
*/
private boolean addWorker(Runnable firstTask, boolean core) {
/**
-
Check if queue empty only if necessary.
-
如果线程池已关闭,并满足以下条件之一,那么不创建新的 worker:
-
1. 线程池状态大于 SHUTDOWN,也就是 STOP, TIDYING, 或 TERMINATED
-
2. firstTask != null
-
3. workQueue.isEmpty()
-
简单分析下:
-
状态控制的问题,当线程池处于 SHUTDOWN ,不允许提交任务,但是已有任务继续执行
-
当状态大于 SHUTDOWN ,不允许提交任务,且中断正在执行任务
-
多说一句:若线程池处于 SHUTDOWN,但 firstTask 为 null,且 workQueue 非空,是允许创建 worker 的
*/
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;😉 {
int wc = workerCountOf©;
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 如果成功,那么就是所有创建线程前的条件校验都满足了,准备创建线程执行任务
// 这里失败的话,说明有其他线程也在尝试往线程池中创建线程
if (compareAndIncrementWorkerCount©)
break retry;
// 由于有并发,重新再读取一下 ctl
c = ctl.get(); // Re-read ctl
// 正常如果是 CAS 失败的话,进到下一个里层的for循环就可以了
// 可如果是因为其他线程的操作,导致线程池的状态发生了变更,如有其他线程关闭了这个线程池
// 那么需要回到外层的for循环
if (runStateOf© != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
/* *
- 到这里,我们认为在当前这个时刻,可以开始创建线程来执行任务
*/
// worker 是否已经启动
boolean workerStarted = false;
// 是否已将这个 worker 添加到 workers 这个 HashSet 中
boolean workerAdded = false;
Worker w = null;
try {
// 把 firstTask 传给 worker 的构造方法
w = new Worker(firstTask);
// 取 worker 中的线程对象,Worker的构造方法会调用 ThreadFactory 来创建一个新的线程
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());
// 小于 SHUTTDOWN 即 RUNNING
// 如果等于 SHUTDOWN,不接受新的任务,但是会继续执行等待队列中的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// worker 里面的 thread 不能是已启动的
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 加到 workers 这个 HashSet 中
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 若添加成功
if (workerAdded) {
// 启动线程
t.start();
workerStarted = true;
}
}
} finally {
// 若线程没有启动,做一些清理工作,若前面 workCount 加了 1,将其减掉
if (! workerStarted)
addWorkerFailed(w);
}
// 返回线程是否启动成功
return workerStarted;
}
看下 addWorkFailed
记录 workers 中的个数的最大值,因为 workers 是不断增加减少的,通过该值可知线程池的大小的历史峰值。只有拿到主锁才能访问。
private int largestPoolSize;
runWorker
// worker 线程启动后调用
// worker 初始化时,可指定 firstTask,那么第一个任务也就可以不需要从队列中获取
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
// 该线程的第一个任务(若有)
Runnable task = w.firstTask;
w.firstTask = null;
// 允许中断
w.unlock();
boolean completedAbruptly = true;
try {
// 自旋,不断从等待队列获取任务,执行之
// 循环调用 getTask 获取任务
while (task != null || (task = getTask()) != null) {
w.lock();
// 若线程池状态大于等于 STOP,那么意味着该线程也要中断
/**
-
若线程池STOP,请确保线程 已被中断
-
如果没有,请确保线程未被中断
-
这需要在第二种情况下进行重新检查,以便在关中断时处理shutdownNow竞争
*/
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) {
// 这里不允许抛出 Throwable,所以转换为 Error
thrown = x; throw new Error(x);
} finally {
// 也是一个钩子方法,将 task 和异常作为参数,留给需要的子类实现
afterExecute(task, thrown);
}
} finally {
// 置空 task,准备 getTask 下一个任务
task = null;
// 累加完成的任务数
w.completedTasks++;
// 释放掉 worker 的独占锁
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 到这里,需要执行线程关闭
// 1. 说明 getTask 返回 null,也就是说,这个 worker 的使命结束了,执行关闭
// 2. 任务执行过程中发生了异常
// 第一种情况,已经在代码处理了将 workCount 减 1,这个在 getTask 方法分析中说
// 第二种情况,workCount 没有进行处理,所以需要在 processWorkerExit 中处理
processWorkerExit(w, completedAbruptly);
}
}
看看
getTask()
// 此方法有三种可能
// 1. 阻塞直到获取到任务返回。默认 corePoolSize 之内的线程是不会被回收的,它们会一直等待任务
// 2. 超时退出。keepAliveTime 起作用的时候,也就是如果这么多时间内都没有任务,那么应该执行关闭
// 3. 如果发生了以下条件,须返回 null
// 池中有大于 maximumPoolSize 个 workers 存在(通过调用 setMaximumPoolSize 进行设置)
// 线程池处于 SHUTDOWN,而且 workQueue 是空的,前面说了,这种不再接受新的任务
// 线程池处于 STOP,不仅不接受新的线程,连 workQueue 中的线程也不再执行
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;😉 {
// 允许核心线程数内的线程回收,或当前线程数超过了核心线程数,那么有可能发生超时关闭
// 这里 break,是为了不往下执行后一个 if (compareAndDecrementWorkerCount©)
// 两个 if 一起看:如果当前线程数 wc > maximumPoolSize,或者超时,都返回 null
// 那这里的问题来了,wc > maximumPoolSize 的情况,为什么要返回 null?
// 换句话说,返回 null 意味着关闭线程。
// 那是因为有可能开发者调用了 setMaximumPoolSize 将线程池的 maximumPoolSize 调小了
// 如果此 worker 发生了中断,采取的方案是重试
// 解释下为什么会发生中断,这个读者要去看 setMaximumPoolSize 方法,
// 如果开发者将 maximumPoolSize 调小了,导致其小于当前的 workers 数量,
// 那么意味着超出的部分线程要被关闭。重新进入 for 循环,自然会有部分线程会返回 null
int c = ctl.get();
int rs = runStateOf©;
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// CAS 操作,减少工作线程数
decrementWorkerCount();
return null;
}
int wc = workerCountOf©;
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount©)
先自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《Java开发全套学习资料》送给大家,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助,可以扫码领取!
如何快速更新自己的技术积累?
- 在现有的项目里,深挖技术,比如用到netty可以把相关底层代码和要点都看起来。
- 如果不知道目前的努力方向,就看自己的领导或公司里技术强的人在学什么。
- 知道努力方向后不知道该怎么学,就到处去找相关资料然后练习。
- 学习以后不知道有没有学成,则可以通过面试去检验。
我个人觉得面试也像是一场全新的征程,失败和胜利都是平常之事。所以,劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜,等待你的将是更美好的未来,继续加油!
以上面试专题的答小编案整理成面试文档了,文档里有答案详解,以及其他一些大厂面试题目
够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。**
[外链图片转存中…(img-TnqzyCcr-1711479814228)]
[外链图片转存中…(img-dDNoZVen-1711479814229)]
[外链图片转存中…(img-9Kbj5nVi-1711479814229)]
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助,可以扫码领取!
如何快速更新自己的技术积累?
- 在现有的项目里,深挖技术,比如用到netty可以把相关底层代码和要点都看起来。
- 如果不知道目前的努力方向,就看自己的领导或公司里技术强的人在学什么。
- 知道努力方向后不知道该怎么学,就到处去找相关资料然后练习。
- 学习以后不知道有没有学成,则可以通过面试去检验。
我个人觉得面试也像是一场全新的征程,失败和胜利都是平常之事。所以,劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜,等待你的将是更美好的未来,继续加油!
以上面试专题的答小编案整理成面试文档了,文档里有答案详解,以及其他一些大厂面试题目
[外链图片转存中…(img-Rbcm01B2-1711479814229)]
[外链图片转存中…(img-3aCUBH4z-1711479814230)]
需要更多Java资料的小伙伴可以帮忙点赞+关注,点击传送门,即可免费领取!