第一个模块：先搞定“并发基础源码”，别一上来就啃Netty
我见过最多的误区就是“上来就啃热门框架源码”——去年带的实习生小杨，入职第一天就问我“要不要先看Netty的Reactor模式？”，我让他先写个“并发抢票程序”，结果他用synchronized写了个死循环，连ReentrantLock的tryLock()都不会用，更别说理解AQS的同步队列了。高并发源码的地基，是JUC包下的基础类，这些类是所有框架的“底层积木”，没搞懂它们，看框架源码就是“看天书”。
那基础源码该怎么学？我 了一个“三步法”，亲测有效：
第一步：先“用熟”再“看源码”。比如学ReentrantLock，先写10个不同的并发场景（比如抢票、秒杀、多线程统计），把公平锁、非公平锁、可重入性都测一遍——你得先知道“它能解决什么问题”，再去看“它是怎么解决的”。我自己学的时候，写了个“家庭群抢红包”的程序，用ReentrantLock的公平锁让每个人按顺序抢，debug的时候看线程怎么排队，state变量怎么从0变成1，再变成0，慢慢就摸透了它的核心逻辑。 第二步：“拆方法”比“看整体”更重要。比如AQS（AbstractQueuedSynchronizer）是JUC的核心，但你别一开始就看整个类，先拆它的核心方法：acquire()（获取锁）、release()（释放锁）、hasQueuedPredecessors()（公平锁的判断）。我学的时候，把acquire()方法拆成3步：tryAcquire()（尝试获取锁）→ addWaiter()（加入等待队列）→ acquireQueued()（队列中等待），每一步都打日志，看线程怎么从“运行中”变成“等待中”，队列里的节点怎么排序。 第三步：用“小实验”验证源码逻辑。比如学ThreadPoolExecutor，别光看参数说明，写个“图片上传”的程序，把核心线程数设为2，最大线程数设为4，任务队列用LinkedBlockingQueue（容量10），然后提交20个任务，debug看线程池的状态：什么时候创建核心线程？什么时候创建非核心线程？队列满了之后拒绝策略怎么触发？我之前做这个实验的时候，发现当任务队列满了，才会创建非核心线程——这就是为什么很多人配置线程池时，把队列设得太大，导致非核心线程永远不会被创建的原因。
为了帮你省时间，我整理了一份“高并发基础源码学习清单”，直接照着做就行：
| 模块 | 核心类 | 学习重点 | 验证方法 |
|---|---|---|---|
| 并发锁 | ReentrantLock、ReadWriteLock | AQS同步队列、公平/非公平策略、可重入性 | 写“并发抢票程序”，debug看线程排队顺序 |
| 线程池 | ThreadPoolExecutor、ScheduledThreadPoolExecutor | 核心/非核心线程、任务队列、拒绝策略 | 写“图片上传程序”，测试不同参数下的线程状态 |
| 并发工具 | CountDownLatch、CyclicBarrier、Semaphore | 同步逻辑、计数器机制 | 写“多线程数据同步程序”，比如统计多个文件的行数 |
记住：基础源码不是“知识点”，是“思维方式”——比如学了AQS，你再看Netty的EventLoop，就能看懂它的“任务队列”是怎么实现的；学了ThreadPoolExecutor，看Dubbo的线程池设计，就能明白“为什么Dubbo要分IO线程和业务线程”。
第二个模块：拆解“热门框架核心并发逻辑”，从“能用”到“懂原理”
等你把基础源码啃透，就可以开始看热门框架了——但别“全量看”，要“抓核心”。框架的高并发能力，往往藏在“线程模型”“IO处理”“任务调度”这三个地方，你只要把这三个部分的源码拆解清楚，框架的核心逻辑就懂了80%。
我以“Netty”为例，讲怎么拆解它的核心并发逻辑：
第一步：先搞懂“它的核心问题是什么”。Netty是做“高并发网络通信”的，它要解决的问题是“如何用最少的线程处理最多的连接”——所以它的核心是“Reactor模式”（反应式IO模型）。 第二步：找“核心类”。Netty的Reactor模式，核心类是EventLoopGroup（线程组）、NioEventLoop（单个线程）、Channel（连接通道）。我学的时候，先看EventLoopGroup的创建：比如new NioEventLoopGroup(4)，就是创建4个NioEventLoop线程；然后看NioEventLoop的run()方法，它的核心是一个无限循环：先处理Selector的IO事件（比如accept、read），再处理任务队列里的任务（比如用户提交的Runnable）。 第三步：“联系基础源码”。Netty的EventLoop其实用到了ThreadPoolExecutor的核心思想——“线程复用”，但它做了优化：每个NioEventLoop绑定一个Selector，处理多个Channel的事件，避免了线程上下文切换的开销。我之前帮朋友排查过Netty的“线程阻塞”问题：他用Netty做网关，把“数据库查询”放到了IO线程里，结果IO线程被阻塞，导致新连接无法处理。我让他看NioEventLoop的run()方法，发现IO线程的任务队列是“单线程执行”的，耗时任务必须放到自定义线程池里——这就是源码知识的实战价值。
再比如“Redis”的高并发逻辑，核心是“单线程+多路复用”。你看Redis的源码，核心文件是ae.c（事件驱动框架），里面的aeEventLoop结构体，包含一个Selector（用epoll或kqueue实现）和一个任务队列。Redis的main()函数，就是启动一个aeEventLoop循环：先处理IO事件（比如客户端的连接、命令），再处理定时任务（比如过期键删除）。为什么Redis用单线程？因为它的瓶颈是“内存访问”而不是“CPU”，单线程避免了线程切换的开销——你要是能在面试里提到“aeEventLoop的epoll_wait调用”和“任务队列的处理顺序”，比只说“单线程快”要加分10倍。
这里给你一个“框架核心并发逻辑拆解清单”，可以直接套用：
| 框架 | 核心问题 | 核心类/文件 | 关键逻辑 |
|---|---|---|---|
| Netty | 高并发网络通信 | EventLoopGroup、NioEventLoop | Reactor模式、IO线程与任务线程分离 |
| Redis | 高并发内存数据库 | ae.c、aeEventLoop | 单线程+多路复用、任务队列调度 |
| Dubbo | 高并发RPC调用 | ThreadPool、Dispatcher | IO线程（处理网络请求）、业务线程（处理逻辑）分离 |
重点提醒：看框架源码的时候，别纠结“细枝末节”——比如Netty的ByteBuf有100个方法，你不用全看，只要搞懂“它是怎么高效管理内存的”（比如池化、零拷贝）就行；Redis的string类型有很多操作，你不用全看，只要搞懂“它的IO线程怎么处理命令”就行。框架源码的价值，是让你学会“用基础积木搭高楼”——比如你能把JUC的ThreadPoolExecutor和Netty的EventLoop结合起来，就能设计出一个“高并发的网关系统”。
第三个模块：把“源码知识”对接“面试+实战”，避免“学了白学”
我见过很多人，源码学了一堆，面试的时候说不清楚，实战的时候用不上——问题出在“没把源码和场景挂钩”。源码知识要“活”，必须对接“面试题”和“实战场景”，你得知道“这个源码知识点，在面试里怎么问？在实战中怎么用？”
先讲“面试”：面试官问高并发源码，本质是问“你能不能用源码知识解决问题”。比如常问的“Redis为什么能支持高并发？”，普通回答是“单线程+多路复用”，但如果你能讲：“Redis的aeEventLoop用epoll_wait监听多个客户端连接，每个连接的命令放到任务队列里，单线程顺序执行，避免了线程切换的开销——我看ae.c的源码时，发现它的事件循环是‘先处理IO事件，再处理定时任务’，这样保证了命令的低延迟”，面试官肯定对你刮目相看。
再比如“Netty的线程模型为什么高效？”，你可以讲：“Netty的EventLoopGroup用了Reactor模式，每个NioEventLoop绑定一个Selector，处理多个Channel的事件——我之前用Netty做过网关，遇到过IO线程阻塞的问题，后来看了NioEventLoop的run()方法，把耗时任务放到了业务线程池里，吞吐量提升了3倍”——用“实战案例+源码细节”回答，比“背 ”管用100倍。
再讲“实战”：源码知识的价值，是帮你“解决复杂问题”。比如我之前做“电商秒杀系统”，遇到“订单超卖”的问题，用synchronized锁不住，后来用ReentrantLock的公平锁+双重检查：
private ReentrantLock lock = new ReentrantLock(true); // 公平锁
public boolean seckill(Long productId) {
lock.lock();
try {
Product product = productDao.get(productId);
if (product.getStock() > 0) {
product.setStock(product.getStock()
1);
productDao.update(product);
return true;
}
return false;
} finally {
lock.unlock();
}
}
为什么用公平锁？因为公平锁会让线程按顺序获取锁，避免“饥饿线程”（有的线程永远抢不到锁）——这就是ReentrantLock源码里的hasQueuedPredecessors()方法的作用：判断队列里有没有比当前线程更早的线程，如果有，当前线程就排队。后来上线后，超卖问题解决了，TPS（每秒交易数）从500提升到了2000。
再比如做“高并发接口测试”，用CountDownLatch做并发模拟：
public void testConcurrentRequest() throws InterruptedException {
int threadCount = 100;
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
try {
startLatch.await(); // 等待所有线程准备好
// 调用高并发接口
ResponseEntity response = restTemplate.getForEntity("/api/seckill/1", String.class);
System.out.println(response.getBody());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
endLatch.countDown(); // 标记线程完成
}
}).start();
}
startLatch.countDown(); // 开始执行
endLatch.await(); // 等待所有线程完成
System.out.println("所有请求完成");
}
这个程序用CountDownLatch模拟了100个并发请求，帮我找出了接口的“瓶颈点”——比如数据库的行锁竞争，后来优化了SQL，把行锁改成了页锁，接口的响应时间从500ms降到了100ms。
最后想说：学高并发源码，不是为了“背源码”，是为了“拥有解决高并发问题的思维”——当你遇到“线程阻塞”“并发超卖”“连接积压”这些问题时，能立刻想到“我之前学过的哪个源码知识点能解决这个问题？”。我带的实习生里，最快上手的那个，就是把“基础源码”和“框架逻辑”都对接了实战场景，现在他做高并发接口，能直接用JUC的类解决问题，面试的时候也能讲出“源码+场景”的例子，去年拿到了阿里的offer。
如果你按这3个模块学，不管是面试还是实战，都能“心里有底”——要是你在学的过程中遇到问题，比如“Netty的EventLoop怎么调试？”“Redis的aeEventLoop怎么看？”，欢迎回来找我，我帮你一起拆源码！
本文常见问题（FAQ）
为什么不能一上来就啃Netty这类热门框架的源码？
我见过很多人刚学高并发源码就盯着Netty、Redis这类框架，其实特别容易踩坑。比如去年带的实习生小杨，入职第一天就问要不要看Netty的Reactor模式，我让他先写个并发抢票程序，结果他用synchronized写了个死循环，连ReentrantLock的tryLock()都不会用，更别说理解AQS的同步队列了。
高并发源码的地基是JUC包下的基础类，比如ReentrantLock、ThreadPoolExecutor这些，它们是所有框架的“底层积木”。没搞懂这些基础，看框架源码就像没学过拼音直接读课文，根本摸不清逻辑——框架里的并发逻辑全是基础类的组合，基础不牢，框架源码就是“天书”。
学高并发基础源码时，“先‘用熟’再‘看源码’”具体怎么操作？
比如学ReentrantLock，别着急打开源码文件，先找10个不同的并发场景练手——像抢票、秒杀、多线程统计数据这些，把公平锁、非公平锁、可重入性都测一遍。你得先知道这个类能解决什么问题，比如用公平锁让抢票的人按顺序排队，用非公平锁提高效率，这些实际场景用多了，再看源码才会有共鸣。
我自己学ReentrantLock的时候，写了个家庭群抢红包的程序，用公平锁让家里人按发消息的顺序抢，debug的时候盯着state变量看——从0变成1是锁被拿走，再变回0是锁释放，还能看到等待队列里的线程怎么排序，慢慢就把“可重入性”“同步队列”这些概念吃透了，比光看注释管用多了。
拆解框架核心并发逻辑时，要重点抓哪些部分？
框架的高并发能力一般藏在“线程模型”“IO处理”“任务调度”这三个地方，比如Netty是做高并发网络通信的，核心就是Reactor模式——你要找EventLoopGroup（线程组）、NioEventLoop（单个线程）这些核心类，看它们怎么用最少的线程处理最多的连接。
再比如Redis的高并发逻辑是“单线程+多路复用”，核心文件是ae.c里的aeEventLoop结构体，你要盯紧它的事件循环：先处理Selector的IO事件（比如客户端连接、命令），再处理任务队列里的定时任务（比如过期键删除）。抓准这三个核心点，框架的并发逻辑就懂了80%，不用纠结那些细枝末节的方法。
面试时讲高并发源码，怎么说才能让回答更加分？
面试官问源码不是要你背方法名，而是看你能不能用源码知识解决问题。比如被问“Redis为什么能支持高并发？”，别只说“单线程+多路复用”，要讲源码细节：“Redis的核心是ae.c里的aeEventLoop结构体，它用epoll_wait监听多个客户端连接，单线程顺序处理IO事件和任务队列，避免了线程切换的开销——我看源码时发现，它的事件循环是先处理IO事件再处理定时任务，这样保证了命令的低延迟。”
更加分的是结合实战场景，比如“我之前用Netty做网关时，把数据库查询放到了IO线程里，导致线程阻塞，后来看了NioEventLoop的run()方法，发现IO线程是单线程处理任务队列的，于是把耗时任务放到业务线程池，吞吐量一下提升了3倍”——用“源码细节+实战问题解决”的例子，比背 管用100倍。
