先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
// 线程数容量，低29位表示有效的线程数, 0001 1111 1111 1111 1111 1111 1111 1111
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
/**
-
大小关系：RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED，
-
源码中频繁使用大小关系来作为条件判断。
-
1110 0000 0000 0000 0000 0000 0000 0000 运行
-
0000 0000 0000 0000 0000 0000 0000 0000 关闭
-
0010 0000 0000 0000 0000 0000 0000 0000 停止
-
0100 0000 0000 0000 0000 0000 0000 0000 整理
-
0110 0000 0000 0000 0000 0000 0000 0000 终止
*/
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; // 终止
/**
-
得到运行状态:入参c为ctl的值，~CAPACITY高3位为1低29位全为0,
-
因此运算结果为ctl的高3位, 也就是运行状态
*/
private static int runStateOf(int c) { return c & ~CAPACITY; }
/**
-
得到有效的线程数:入参c为ctl的值, CAPACITY高3为为0,
-
低29位全为1, 因此运算结果为ctl的低29位, 也就是有效的线程数
*/
private static int workerCountOf(int c) { return c & CAPACITY; }
/**
-
得到ctl的值：高3位的运行状态和低29位的有效线程数进行或运算,
-
组合成一个完成的32位数
*/
private static int ctlOf(int rs, int wc) { return rs | wc; }
// 状态c是否小于s
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;
}
// 使用CAS增加一个有效的线程
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
// 使用CAS减少一个有效的线程
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
// 减少一个有效的线程
private void decrementWorkerCount() {
do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}
// 工作队列
private final BlockingQueue workQueue;
// 锁
private final ReentrantLock mainLock = new ReentrantLock();
// 包含线程池中的所有工作线程,只有在mainLock的情况下才能访问,Worker集合
private final HashSet workers = new HashSet();
private final Condition termination = mainLock.newCondition();
// 跟踪线程池的最大到达大小，仅在mainLock下访问
private int largestPoolSize;
// 总的完成的任务数
private long completedTaskCount;
// 线程工厂，用于创建线程
private volatile ThreadFactory threadFactory;
// 拒绝策略
private volatile RejectedExecutionHandler handler;
/**
-
线程超时时间，当线程数超过corePoolSize时生效,
-
如果有线程空闲时间超过keepAliveTime, 则会被终止
*/
private volatile long keepAliveTime;
// 是否允许核心线程超时，默认false，false情况下核心线程会一直存活。
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”);
/**
- Worker类，每个Worker包含一个线程、一个初始任务、一个任务计算器
*/
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread; // Worker对应的线程
Runnable firstTask; // 运行的初始任务。
volatile long completedTasks; // 每个线程的任务计数器
Worker(Runnable firstTask) {
setState(-1); // 禁止中断，直到runWorker
this.firstTask = firstTask; // 设置为初始任务
// 使用当前线程池的线程工厂创建一个线程
this.thread = getThreadFactory().newThread(this);
}
// 将主运行循环委托给外部runWorker
public void run() {
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
/**
-
通过AQS的同步状态来实现锁机制。state为0时代表锁未被获取（解锁状态），
-
state为1时代表锁已经被获取（加锁状态）。
*/
protected boolean isHeldExclusively() { //
return getState() != 0;
}
protected boolean tryAcquire(int unused) { // 尝试获取锁
if (compareAndSetState(0, 1)) { // 使用CAS尝试将state设置为1，即尝试获取锁
// 成功将state设置为1，则当前线程拥有独占访问权
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) { // 尝试释放锁
setExclusiveOwnerThread(null); // 释放独占访问权：即将独占访问线程设为null
setState(0); // 解锁：将state设置为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) {
}
}
}
}
execute方法
使用线程池的submit方法提交任务时，会走到该方法，该方法也是线程池最重要的方法。
public void execute(Runnable command) {
if (command == null) // 为空校验
throw new NullPointerException();
int c = ctl.get(); // 拿到当前的ctl值
if (workerCountOf© < corePoolSize) { // 如果有效的线程数小于核心线程数
if (addWorker(command, true)) // 则新建一个线程来处理任务（核心线程）
return;
c = ctl.get(); // 拿到当前的ctl值
}
// 走到这里说明有效的线程数已经 >= 核心线程数
if (isRunning© && workQueue.offer(command)) {// 如果当前状态是运行, 尝试将任务放入工作队列
int recheck = ctl.get(); // 再次拿到当前的ctl值
// 如果再次检查状态不是运行, 则将刚才添加到工作队列的任务移除
if (! isRunning(recheck) && remove(command))
reject(command); // 并调用拒绝策略
else if (workerCountOf(recheck) == 0) // 如果再次检查时,有效的线程数为0,
addWorker(null, false); // 则新建一个线程(非核心线程)
}
// 走到这里说明工作队列已满
else if (!addWorker(command, false))//尝试新建一个线程来处理任务(非核心)
reject(command); // 如果失败则调用拒绝策略
}
该方法就是对应上文的线程池的工作流程。主要调用到的方法为addWorker（见下文addWorker方法解读）。
addWorker方法
/**
- 添加一个Worker，Worker包含一个线程和一个任务，由这个线程来执行该任务。
*/
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;😉 {
int c = ctl.get(); // c赋值为ctl
int rs = runStateOf©; // rs赋值为运行状态
/**
-
1.如果池停止或有资格关闭，则此方法返回false；
-
如果线程工厂在被询问时未能创建线程，它也返回false。
-
包括以下5种情况：
-
1).rs为RUNNING，通过校验。
-
2).rs为STOP或TIDYING或TERMINATED，返回false。
-
（STOP、TIDYING、TERMINATED：已经停止进入最后清理终止，不接受任务不处理队列任务）
-
3).rs为SHUTDOWN，提交的任务不为空，返回false。
-
（SHUTDOWN：不接受任务但是处理队列任务，因此任务不为空返回false）
-
4).rs为SHUTDOWN，提交的任务为空，并且工作队列为空，返回false。
-
（状态为SHUTDOWN、提交的任务为空、工作队列为空，则线程池有资格关闭，直接返回false）
-
5).rs为SHUTDOWN，提交的任务为空，并且工作队列不为空，通过校验。
-
（因为SHUTDOWN状态下刚好可以处理队列任务）
*/
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;😉 {
int wc = workerCountOf©; // 拿到有效的线程数
// 校验有效的线程数是否超过阈值
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 使用CAS将workerCount+1, 修改成功则跳出循环，否则进入下面的状态判断
if (compareAndIncrementWorkerCount©)
break retry;
c = ctl.get(); // 重新读取ctl
// 判断当前运行状态，如果不等于上面获取的运行状态rs，
// 说明rs被其他线程修改了，跳到retry重新校验线程池状态
if (runStateOf© != rs)
continue retry;
// 走到这里说明compareAndIncrementWorkerCount失败;
// 重试内部循环（状态没变，则继续内部循环，尝试使用CAS修改workerCount）
}
}
boolean workerStarted = false; // Worker的线程是否启动
boolean workerAdded = false; // Worker是否成功增加
Worker w = null;
try {
w = new Worker(firstTask); // 用firstTask和当前线程创建一个Worker
final Thread t = w.thread; // 拿到Worker对应的线程
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()); // 加锁的情况下重新获取当前的运行状态
// 如果当前的运行状态为RUNNING，
// 或者当前的运行状态为SHUTDOWN并且firstTask为空，则通过校验
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // 预先校验线程是可以启动的
throw new IllegalThreadStateException();
workers.add(w); // 将刚创建的worker添加到工作者列表
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) { // 如果Worker添加成功，则启动线程执行
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted) // 如果Worker的线程没有成功启动
addWorkerFailed(w); // 则进行回滚, 移除之前添加的Worker
}
return workerStarted;
}
该方法主要目的就是使用入参中的firstTask和当前线程添加一个Worker，前面的for循环主要是对当前线程池的运行状态和有效的线程数进行一些校验，校验逻辑比较绕，可以参考注释进行理解。该方法涉及到的其他方法有addWorkerFailed（见下文addWorkerFailed源码解读）；还有就是Worker的线程启动时，会调用Worker里的run方法，执行runWorker(this)方法（见下文runWorker源码解读）。
addWorkerFailed方法
/**
-
Rolls back the worker thread creation.
-
- removes worker from workers, if present
-
- decrements worker count
-
- rechecks for termination, in case the existence of this
-
worker was holding up termination
*/
private void addWorkerFailed(Worker w) { // 回滚Worker的添加，就是将Worker移除
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w); // 移除Worker
decrementWorkerCount(); // 有效线程数-1
tryTerminate(); // 有worker线程移除，可能是最后一个线程退出需要尝试终止线程池
} finally {
mainLock.unlock();
}
}
该方法很简单，就是移除入参中的Worker并将workerCount-1，最后调用tryTerminate尝试终止线程池，tryTerminate见下文对应方法源码解读。
runWorker方法
上文addWork方法里说道，当Worker里的线程启动时，就会调用该方法。
/**
- Worker的线程开始执行任务
*/
final void runWorker(Worker w) {
Thread wt = Thread.currentThread(); // 获取当前线程
Runnable task = w.firstTask; // 拿到Worker的初始任务
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true; // Worker是不是因异常而死亡
try {
while (task != null || (task = getTask()) != null) {// Worker取任务执行
w.lock(); // 加锁
/**如果线程池停止，确保线程中断; 如果不是，确保线程不被中断。
-
在第二种情况下进行重新检查，以便在清除中断的同时处理shutdownNow竞争
-
线程池停止指运行状态为STOP/TIDYING/TERMINATED中的一种
*/
if ((runStateAtLeast(ctl.get(), STOP) || // 判断线程池运行状态
(Thread.interrupted() && // 重新检查
runStateAtLeast(ctl.get(), STOP))) && // 再次判断线程池运行状态
!wt.isInterrupted())// 走到这里代表线程池运行状态为停止,检查wt是否中断
wt.interrupt(); // 线程池的状态为停止并且wt不为中断, 则将wt中断
try {
beforeExecute(wt, task);// 执行beforeExecute（默认空，需要自己重写）
Throwable thrown = null;
try {
task.run(); // 执行任务
} catch (RuntimeException x) {
thrown = x; throw x; //如果抛异常,则completedAbruptly为true
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);// 执行afterExecute（需要自己重写）
}
} finally {
task = null; // 将执行完的任务清空
w.completedTasks++; // Worker完成任务数+1
w.unlock();
}
}
completedAbruptly = false; // 如果执行到这里，则worker是正常退出
} finally {
processWorkerExit(w, completedAbruptly);// 调用processWorkerExit方法
}
}
该方法为Worker线程开始执行任务，首先执行当初创建Worker时的初始任务，接着从工作队列中获取任务执行。主要涉及两个方法：获取任务的方法getTask（见下文getTask源码解读）和执行Worker退出的方法processWorkerExit（见下文processWorkerExit源码解读）。注：processWorkerExit在处理正常Worker退出时，没有对workerCount-1，而是在getTask方法中进行workerCount-1。
getTask方法
private Runnable getTask() { // Worker从工作队列获取任务
boolean timedOut = false; // poll方法取任务是否超时
for (;😉 { // 无线循环
int c = ctl.get(); // ctl
int rs = runStateOf©; // 当前运行状态
// 如果线程池运行状态为停止，或者可以停止（状态为SHUTDOWN并且队列为空）
// 则返回null，代表当前Worker需要移除
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount(); // 将workerCount - 1
// 返回null前将workerCount - 1,
// 因此processWorkerExit中completedAbruptly＝false时无需再减
return null;
}
int wc = workerCountOf©; // 当前的workerCount
// 判断当前Worker是否可以被移除, 即当前Worker是否可以一直等待任务。
// 如果allowCoreThreadTimeOut为true，或者workerCount大于核心线程数，
// 则当前线程是有超时时间的（keepAliveTime），无法一直等待任务。
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 如果wc超过最大线程数 或者 当前线程会超时并且已经超时，
// 并且wc > 1 或者 工作队列为空，则返回null，代表当前Worker需要移除
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) { // 确保有Worker可以移除
if (compareAndDecrementWorkerCount©)
// 返回null前将workerCount - 1，
// 因此processWorkerExit中completedAbruptly＝false时无需再减
return null;
continue;
}
try {
// 根据线程是否会超时调用相应的方法，poll为带超时的获取任务方法
// take()为不带超时的获取任务方法，会一直阻塞直到获取到任务
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true; // 走到这代表当前线程获取任务超时
} catch (InterruptedException retry) {
timedOut = false; // 被中断
}
}
}
Worker从工作队列获取任务，如果allowCoreThreadTimeOut为false并且 workerCount<=corePoolSize，则这些核心线程永远存活，并且一直在尝试获取工作队列的任务；否则，线程会有超时时间（keepAliveTime），当在keepAliveTime时间内获取不到任务，该线程的Worker会被移除。
Worker移除的过程：getTask方法返回null，导致runWorker方法中跳出while循环，调用processWorkerExit方法将Worker移除。注意：在返回null的之前，已经将workerCount-1，因此在processWorkerExit中，completedAbruptly=false的情况（即正常超时退出）不需要再将workerCount-1。
processWorkerExit方法
总结
互联网大厂比较喜欢的人才特点：对技术有热情，强硬的技术基础实力；主动，善于团队协作，善于总结思考。无论是哪家公司，都很重视高并发高可用技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，是不是能真的得到锻炼。其实我写了这么多，只是我自己的总结，并不一定适用于所有人，相信经过一些面试，大家都会有这些感触。
**另外本人还整理收藏了2021年多家公司面试知识点以及各种技术点整理 **
下面有部分截图希望能对大家有所帮助。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
一直在尝试获取工作队列的任务；否则，线程会有超时时间（keepAliveTime），当在keepAliveTime时间内获取不到任务，该线程的Worker会被移除。
Worker移除的过程：getTask方法返回null，导致runWorker方法中跳出while循环，调用processWorkerExit方法将Worker移除。注意：在返回null的之前，已经将workerCount-1，因此在processWorkerExit中，completedAbruptly=false的情况（即正常超时退出）不需要再将workerCount-1。
processWorkerExit方法
总结
互联网大厂比较喜欢的人才特点：对技术有热情，强硬的技术基础实力；主动，善于团队协作，善于总结思考。无论是哪家公司，都很重视高并发高可用技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，是不是能真的得到锻炼。其实我写了这么多，只是我自己的总结，并不一定适用于所有人，相信经过一些面试，大家都会有这些感触。
**另外本人还整理收藏了2021年多家公司面试知识点以及各种技术点整理 **
下面有部分截图希望能对大家有所帮助。
[外链图片转存中…(img-gnY7PPBu-1713624361515)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-quMe2oyZ-1713624361515)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
