01.4 阶段 3 并发编程
所属:全栈开发面试题库 / 学习路径 / 01 Java 与 Spring 全栈
本页目录
一、阶段定位
阶段 2 让你知道一个线程有自己的栈、对象在堆上共享。本阶段解决"多个线程同时读写同一份数据时会发生什么、怎么保证正确"。因为从阶段 5 Spring MVC 开始,每个请求就是一个线程,Service 单例被并发调用、缓存被并发读写、数据库连接被并发获取——不掌握并发,写出来的服务在压测下就会出现偶现的金额错、库存超卖、接口超时。
不掌握本阶段会卡在:(1) 用 i++ 在多线程下计数,结果总是少一点,不知道是可见性还是原子性;(2) 线程池参数凭感觉填 new ThreadPoolExecutor(0, Integer.MAX_VALUE, ...),上线后OOM;(3) 用 ConcurrentHashMap 但说不出它怎么保证线程安全;(4) ThreadLocal 在 Tomcat 线程池下出现"上一个请求的数据串到下一个请求";(5) 不知道 Java 21 虚拟线程什么时候能用、什么时候反而更慢。
本阶段原有"卡点"落到现象:(1) 问你 happens-before 是什么,你只能背"可见性、有序性、原子性"三个词,举不出 volatile 怎么保证可见性;(2) 让你配置一个 CPU 密集任务的线程池,你答"CPU 核数"或"越大越好";(3) 让你解释 ConcurrentHashMap 在 Java 7 与 Java 8 的区别,答不上分段锁。出现任一现象,补齐再进 阶段 4 构建、测试与工程化。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能写出一段有可见性/原子性问题的代码并复现 | 多线程计数复现结果少算 |
| 能说清 volatile 能做什么、不能做什么 | 用它修一个停止标志可见性问题 |
| 能解释 synchronized 锁升级过程 | 能说清偏向/轻量/重量 |
| 能正确配置线程池并说清每个参数 | 给 CPU 与 IO 密集任务分别给参数 |
| 能说出 ConcurrentHashMap 的并发手段 | 对比 Java 7/8 实现 |
| 能用 CompletableFuture 编排 3 个依赖调用 | 写出串行+并行+异常处理 |
| 能说清 ThreadLocal 为什么要 remove | 解释线程池下的串数据问题 |
建议学时:
- 全职:2 周,约 55 小时。JMM 10、锁 15、线程池 12、并发容器 8、CompletableFuture/ThreadLocal/虚拟线程 10。
- 在职:4–5 周,约 60 小时。
学时分配:JMM 与 volatile 15%、synchronized/锁升级 15%、CAS/AQS 15%、线程池 25%、并发容器 10%、异步编排 10%、ThreadLocal 与虚拟线程 10%。线程池是最高频考点。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 线程基础 | 会 Thread.start()、理解 run 与 start 区别 |
01.2 阶段 1 |
| JVM 内存 | 知道堆共享、栈私有 | 01.3 阶段 2 |
| 集合基础 | 知道 HashMap 非线程安全 | 01.2 阶段 1 |
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| JMM | 主内存/工作内存、可见性/有序性/原子性、happens-before | 能讲清原理 | 04.1 Java |
| volatile | 可见性、禁止重排、不保证原子性 | 能讲清原理 | 04.1 Java |
| synchronized | 对象锁/类锁、锁升级、等待/通知 | 能讲清原理 | 04.1 Java |
| CAS 与原子类 | CAS、ABA、AtomicInteger、LongAdder | 会用 | 04.1 Java |
| AQS | state、同步队列、ReentrantLock、Condition | 了解 | 04.1 Java |
| 线程池 | 7 参数、拒绝策略、线程数依据、动态调参 | 能讲清原理 | 09.1 高并发基础 |
| 并发容器 | ConcurrentHashMap、CopyOnWriteArrayList、BlockingQueue | 能讲清原理 | 04.1 Java |
| 异步编排 | CompletableFuture、异常处理、线程切换 | 会用 | 04.1 Java |
| ThreadLocal/虚拟线程 | 父子线程、remove、Loom 边界 | 会用 | 04.1 Java |
进度建议:JMM、synchronized、线程池、ConcurrentHashMap 四项必须"能讲清原理"。
五、分模块精讲
5.1 JMM、happens-before 与 volatile
为什么需要它:不理解 JMM,就解释不了"为什么一个线程改了标志位另一个线程看不到""为什么双重检查锁定要加 volatile"。
核心机制:
- JMM 把内存抽象为主内存与工作内存:线程读写的是自己的工作内存(CPU 缓存/寄存器),何时刷回主内存由 JMM 决定。
- 三大问题:可见性(一个线程改了另一线程看不到)、原子性(
i++是读-改-写三步)、有序性(编译器/CPU 重排指令)。 - happens-before:前一个操作的结果对后一个操作可见。常用规则:程序顺序规则、
volatile写先行于读、锁的解锁先行于加锁、Thread.start()先行于线程内操作、传递性。 volatile:保证可见性与禁止重排(内存屏障),但不保证原子性;适合做状态标志,不适合做计数器。
最小可运行示例:
public class VolatileDemo {
// 不加 volatile:另一个线程可能永远看不到 running=false
private static volatile boolean running = true;
public static void main(String[] args) throws Exception {
new Thread(() -> {
while (running) { // 没有 volatile 时,可能死循环
// 业务
}
System.out.println("stopped");
}).start();
Thread.sleep(1000);
running = false; // 写 volatile
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 标志位改了线程不停 | 缺 volatile 可见性 | 加 volatile |
| volatile 计数仍不准 | volatile 不保证原子性 | 用 AtomicInteger 或 synchronized |
| 双重检查锁定单例偶发 NPE | 对象引用半初始化被重排 | 实例字段加 volatile |
面试考法:必问"volatile 能保证原子性吗""happens-before""双重检查锁定为什么要 volatile"。
5.2 synchronized 与锁升级
为什么需要它:synchronized 是最基础的互斥手段。它的锁升级过程是 Java 6 后优化的重点,也是高频考点。
核心机制:
- 锁对象:普通方法锁 this(对象锁);静态方法锁 Class 对象(类锁);同步代码块锁括号里的对象。
- 锁升级(无必须反向):无锁 → 偏向锁(线程 ID 记录在对象头,无竞争时几乎零开销)→ 轻量级锁(CAS 自旋,交替执行)→ 重量级锁(操作系统互斥量,线程阻塞)。Java 15 起偏向锁默认关闭。
- 同步队列与等待队列:
wait/notify必须在 synchronized 块内;wait 释放锁进入等待队列,notify 唤醒一个到同步队列竞争。 - 可重入:同一线程可重复进入同一把锁。
最小可运行示例:
public class SyncDemo {
private int count = 0;
private final Object lock = new Object();
public void inc() {
synchronized (lock) { count++; } // 锁 lock 对象
}
public synchronized static void staticMethod() {
// 锁 SyncDemo.class
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 加了 synchronized 还是并发改坏 | 锁的对象不是同一个 | 锁同一个 monitor,注意锁 this vs 锁 Class |
IllegalMonitorStateException |
wait/notify 不在锁内 | 放进 synchronized 块 |
| 死锁 | 交叉持锁 | 统一加锁顺序,或用 tryLock 超时 |
面试考法:问"synchronized 与 Lock 区别""锁升级过程""sleep 与 wait 区别"。要点:synchronized 自动释放、Lock 手动;sleep 不释放锁、wait 释放。
5.3 CAS、原子类与 ABA
为什么需要它:无锁并发的基石。AtomicInteger、LongAdder、AQS、ConcurrentHashMap 都建立在 CAS 上。
核心机制:
- CAS(Compare And Swap):三个操作数——内存位置 V、预期值 A、新值 B;V==A 时才把 V 改成 B,原子完成。
- 问题:ABA(值从 A 改成 B 又改回 A,CAS 以为没变);解决用版本号
AtomicStampedReference。 AtomicInteger:compareAndSet、incrementAndGet;高并发计数用LongAdder(分段 Cell,减少热点)。
最小可运行示例:
import java.util.concurrent.atomic.*;
public class CasDemo {
private static final AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws Exception {
Thread[] ts = new Thread[10];
for (int i = 0; i < 10; i++) {
ts[i] = new Thread(() -> {
for (int j = 0; j < 1000; j++) count.incrementAndGet();
});
ts[i].start();
}
for (Thread t : ts) t.join();
System.out.println(count.get()); // 10000
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 高并发下 AtomicLong 吞吐低 | 单节点热点 CAS | 换 LongAdder |
| ABA 导致逻辑错误 | 只比较值 | 用 AtomicStampedReference |
面试考法:问"CAS 原理""ABA 是什么""LongAdder 为什么快"。
5.4 AQS 与 ReentrantLock
为什么需要它:ReentrantLock、CountDownLatch、Semaphore、ReentrantReadWriteLock 都基于 AQS。理解它才能解释"为什么 Lock 能公平/非公平"。
核心机制:
- AQS:一个
volatile int state表示同步状态 + 一个 FIFO 等待队列。子类通过tryAcquire/tryRelease定义 state 语义。 - ReentrantLock:state 表示持有次数;非公平(默认)新线程直接抢,公平按队列顺序。
Condition:await/signal替代 wait/notify,一个锁可有多个等待队列。tryLock(timeout)可超时,避免死锁。
最小可运行示例:
import java.util.concurrent.locks.*;
public class LockDemo {
private final ReentrantLock lock = new ReentrantLock();
private final Condition notEmpty = lock.newCondition();
public void take() throws InterruptedException {
lock.lock();
try {
while (empty) notEmpty.await();
// 取数据
} finally {
lock.unlock(); // 必须 finally 释放
}
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 加锁后异常没释放锁 | 没放 finally | finally 中 unlock |
| 公平锁吞吐低 | 按队列入队 | 非公平,除非业务要求 |
面试考法:问"AQS 原理""ReentrantLock 与 synchronized 区别"。
5.5 线程池
为什么需要它:这是 Java 后端面试出现频率最高的并发题。Spring 的 Tomcat 线程池、@Async 线程池、批量任务线程池,都靠它。配错了要么 OOM,要么吞吐上不去。
核心机制:
- 7 参数:
corePoolSize核心线程数、maximumPoolSize最大线程数、keepAliveTime空闲回收、unit、workQueue工作队列、threadFactory线程工厂、handler拒绝策略。 - 执行流程:核心线程未满→建核心;满了→入队列;队列满→建到最大;最大也满→拒绝策略。
- 拒绝策略:AbortPolicy(抛异常,默认)、CallerRunsPolicy(调用者线程跑)、DiscardPolicy(静默丢)、DiscardOldestPolicy(丢最老的)。
- 线程数依据:CPU 密集 ≈ 核数 + 1;IO 密集 ≈ 核数 * (1 + 等待/计算),公式只是起点,要压测校准。
- 不要用
Executors.newXXX:Fixed/Single 队列无界会 OOM,Cached 线程数无界会 OOM;用ThreadPoolExecutor显式构造。
最小可运行示例:
import java.util.concurrent.*;
public class PoolDemo {
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
4, 8, 60L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(200),
r -> { Thread t = new Thread(r, "order-worker"); t.setDaemon(false); return t; },
new ThreadPoolExecutor.CallerRunsPolicy() // 队列满让调用者跑,形成背压
);
for (int i = 0; i < 1000; i++) {
int id = i;
pool.submit(() -> System.out.println("处理 " + id + " by " + Thread.currentThread().getName()));
}
pool.shutdown();
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
RejectedExecutionException |
队列+最大都满 | 调大队列/最大,或换拒绝策略 |
| 内存持续涨 | LinkedBlockingQueue 无界 | 用有界队列 |
| 任务被静默丢弃 | DiscardPolicy | 换 Abort 并打日志 |
| 线程名无法排查 | 默认线程名 pool-1-thread-x | 自定义 ThreadFactory 命名 |
面试考法:必问"7 个参数""执行流程""为什么不用 Executors""CPU/IO 密集线程数怎么定"。
5.6 并发容器
为什么需要它:业务缓存、计数器、观察者列表都要用并发容器。用错容器或用对容器但不懂原理,会在压测时翻车。
核心机制:
ConcurrentHashMap:Java 7 分段锁 Segment(默认 16 段,并发度 16);Java 8 改为数组 + CAS + synchronized 锁桶头,粒度更细,并发度更高;不允许 null 键值。CopyOnWriteArrayList:写时复制整个数组,读无锁;适合读多写少(如监听器列表),写少时数据最终一致。BlockingQueue:ArrayBlockingQueue(有界数组)、LinkedBlockingQueue(可选界)、SynchronousQueue(不存储,直接交递,Cached 线程池用)、DelayQueue(延迟获取)。
最小可运行示例:
import java.util.concurrent.*;
public class QueueDemo {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
// 生产者
new Thread(() -> { try { queue.put("order-1"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start();
// 消费者:take 会阻塞直到有数据
String item = queue.take();
System.out.println(item);
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 写多读少时 CopyOnWrite 占用高 | 每次写复制全数组 | 换 ConcurrentLinkedQueue |
| 用 HashMap 在并发下死循环(Java 7) | 扩容头插法成环 | 升级 Java 8+ 或换 ConcurrentHashMap |
| 队列无界导致 OOM | LinkedBlockingQueue 默认 Integer.MAX_VALUE | 设容量 |
面试考法:问"ConcurrentHashMap 1.7 与 1.8 区别""CopyOnWrite 适用场景""BlockingQueue 实现"。
5.7 CompletableFuture、ThreadLocal 与虚拟线程
为什么需要它:微服务下一个接口要调多个下游,串行等太慢;ThreadLocal 是透传用户上下文的常见手段(但也是泄漏重灾区);Java 21 虚拟线程改变 IO 密集并发的写法。
核心机制:
- CompletableFuture:
supplyAsync异步、thenApply串行转换、thenCombine合并两个、allOf等全部、exceptionally异常处理;默认用 ForkJoinPool.commonPool。 - ThreadLocal:每个线程一个独立副本;线程池复用线程时必须
remove(),否则串数据与泄漏。父子线程传递用InheritableThreadLocal,跨线程池用 TransmittableThreadLocal。 - 虚拟线程(Java 21 正式):由 JVM 调度而非 OS,IO 阻塞时不占平台线程;适合 IO 密集、大量阻塞调用;不适合 CPU 密集、
synchronized大块临界区(pin 住载体线程,Java 21 已修复 synchronized pin,仍建议用 ReentrantLock)。
最小可运行示例:
import java.util.concurrent.*;
public class AsyncDemo {
public static void main(String[] args) throws Exception {
// 并行调两个接口再合并
CompletableFuture<String> user = CompletableFuture.supplyAsync(() -> { sleep(100); return "user"; });
CompletableFuture<String> order = CompletableFuture.supplyAsync(() -> { sleep(200); return "order"; });
CompletableFuture<String> combined = user.thenCombine(order, (u, o) -> u + "+" + o);
System.out.println(combined.get()); // 约 200ms,不是 300ms
}
static void sleep(long ms) { try { Thread.sleep(ms); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 异步任务用公共池被阻塞任务拖慢 | 默认 ForkJoinPool | 传自定义线程池 |
| 请求间用户信息串了 | ThreadLocal 没 remove | finally 中 remove |
| 虚拟线程吞吐没提升 | 任务是 CPU 密集或 synchronized pin | 换平台线程/ReentrantLock |
面试考法:问"CompletableFuture 怎么异常处理""ThreadLocal 泄漏""虚拟线程与平台线程区别、适用边界"。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 复现计数少算 | 多线程 i++ 与 AtomicInteger 对比 | 能复现并说原因 | 1 小时 |
| 复现可见性问题 | 不加 volatile 的停止标志死循环 | 加 volatile 后正常停止 | 1 小时 |
| 线程池拒绝 | 满队列触发 CallerRuns | 能看到调用者线程执行 | 1 小时 |
| CompletableFuture 并行 | 两个异步调用合并 | 耗时 = max 而非 sum | 1 小时 |
| ThreadLocal 串数据 | 线程池下不 remove | 复现串数据,加 remove 修复 | 1 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 把 newFixedThreadPool 改为显式 ThreadPoolExecutor | 有界队列+命名工厂 | 不再无界队列 | 1 小时 |
| 把 synchronized 计数改为 LongAdder | 压测对比吞吐 | LongAdder 更高 | 2 小时 |
| 给 CompletableFuture 加异常处理 | 下游抛异常能被 exceptionally 捕获 | 不吞异常 | 1 小时 |
| ThreadLocal 改 TTL | 跨线程池透传上下文 | 异步任务能读到 | 2 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 批量导出线程池 | 分页查库 + 导出,背压 | 不 OOM、拒绝可观测 | 4 小时 |
| 接口聚合 | 调 3 个下游并行聚合 | 总耗时 = 最慢下游,异常可降级 | 5 小时 |
| 延迟任务队列 | 用 DelayQueue 实现订单超时取消 | 到期任务被处理 | 4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| 多线程计数偏小 | 非原子操作 | 去掉同步复现 | 换 Atomic/LongAdder |
| 标志位改了线程不停 | 可见性问题 | 加 volatile | 加 volatile |
RejectedExecutionException |
队列+最大满 | 看队列长度与活跃线程 | 调参/换拒绝策略 |
| 线程数暴涨 OOM | Cached/newXXX 无界 | jstack 数线程 | 显式 ThreadPoolExecutor |
| 请求间数据串 | ThreadLocal 没 remove | 看是否在线程池复用 | finally remove |
| 死锁 | 交叉持锁 | jstack 找 deadlock 提示 | 统一加锁顺序 |
| 异步任务被公共池拖慢 | ForkJoinPool 被阻塞 | 看线程名 | 传独立线程池 |
| 虚拟线程没提速 | CPU 密集/pin | 看载体线程 | 换平台线程 |
八、出口条件
全部勾选后进入 阶段 4 构建、测试与工程化。
- [ ] 能复现并解释可见性、原子性两类问题
- [ ] 能说清 volatile 的边界与锁升级过程
- [ ] 能讲出线程池 7 参数与执行流程,拒绝 newXXX
- [ ] 能对比 ConcurrentHashMap 1.7/1.8
- [ ] 能用 CompletableFuture 写出并行聚合与异常处理
- [ ] 能解释 ThreadLocal 为什么必须 remove
- [ ] 能说清虚拟线程的适用边界
自测题:
- volatile 能保证原子性吗?为什么?
- 要点:不能,
i++是读-改-写三步,volatile 只保证可见与有序。
- 要点:不能,
- 线程池执行任务的完整流程?
- 要点:核心→队列→最大→拒绝。
- 为什么不推荐 Executors.newFixedThreadPool?
- 要点:LinkedBlockingQueue 无界,任务堆积 OOM。
- ConcurrentHashMap 在 Java 8 怎么保证线程安全?
- 要点:CAS + synchronized 锁桶头节点,放弃分段锁。
- ThreadLocal 内存泄漏的根因?
- 要点:Entry key 弱引用被回收,value 强引用,线程池线程不销毁。
- 虚拟线程为什么不适合 CPU 密集?
- 要点:OS 线程仍是稀缺资源,虚拟线程优势在阻塞不占载体。