| Files | Last commit | Last update |
|---|---|---|
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago | ||
| 1 month ago |
Java 并发编程专题导航
一句话定位:从线程、JMM 内存模型到 JUC 工具箱与并发集合,覆盖 Java 并发编程完整知识图谱与学习路径。
从底层原语到现代并发模型,全面掌握 Java 并发编程体系。
引言:学习路径
Java 并发编程专题导航 是一个学习专题,由 N 个子主题构成。
本篇是入口导航——先扫一眼目录定目标,再按路径顺序读,每个子主题都给出'为什么学 / 学到什么 / 怎么用'。
一、专题概述
Java 并发编程是 Java 平台的核心能力之一,涵盖了从线程创建、同步控制、内存模型到高级并发抽象的全套机制。理解并发编程是编写高性能、高可靠服务端程序的前提。
1.1 为什么需要并发编程
┌─────────────────────────────────────────────────────────┐
│ 并发编程解决的问题 │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 性能提升 │ │ 资源利用率 │ │ 用户体验 │ │
│ │ │ │ │ │ │ │
│ │ 多核 CPU │→ │ 充分调度 │→ │ 快速响应 │ │
│ │ 并行计算 │ │ 避免空闲 │ │ 不阻塞 UI │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 架构简化 │ │ 业务模型 │ │ 系统吞吐 │ │
│ │ │ │ │ │ │ │
│ │ 事件驱动 │→ │ 自然映射 │→ │ 并发处理 │ │
│ │ 异步编排 │ │ 真实世界 │ │ 提升 QPS │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────┘
并发编程的核心目标:在保证正确性(数据一致、无竞态)的前提下,最大化吞吐量和响应速度。
1.2 并发编程解决的核心问题
| 问题维度 | 具体表现 |
|---|---|
| 正确性 | 多线程对共享资源的读写导致数据不一致 |
| 活性 | 死锁、饥饿、活锁导致任务无法推进 |
| 性能 | 线程创建/切换开销、锁竞争导致吞吐量下降 |
| 复杂性 | 异步回调嵌套、错误传播困难、调试困难 |
1.3 并发 vs 并行
| 概念 | 定义 | 关注点 | 示例 |
|---|---|---|---|
| 并发 (Concurrency) | 多个任务在同一时间段内交替执行 | 任务调度与资源复用 | 单核 CPU 上运行多个线程 |
| 并行 (Parallelism) | 多个任务在同一时刻真正同时执行 | 充分利用多核 | 多核 CPU 上每个核各跑一个线程 |
// 并发示例:单核 CPU 上两个线程交替执行
// Thread-A: |██░░░░░░░░|██░░░░░░░░|██░░░░░░░░|
// Thread-B: ░░|██░░░░░░|██░░░░░░|██░░░░░░|
// 交替切换,同一时刻只有一个在运行
// 并行示例:双核 CPU 上两个线程同时执行
// Core-1: |████████████████████████████|
// Core-2: |████████████████████████████|
// 真正同时运行
1.4 并发与并行深度展开(Rob Pike 详解 + Java 实战)
1.4.1 Rob Pike 一句话定义
Concurrency is about dealing with many things at once.
Parallelism is about doing many things at once.
—— Rob Pike, "Concurrency is not Parallelism"
并发是「结构」(deal with):同一时间段处理多个任务的能力
并行是「执行」(do):同一时刻多个任务真在跑的事实
1.4.2 咖啡店比喻(高频考点)
[Concurrent] 1 个咖啡师轮流做 5 杯 [Parallel] 5 个咖啡师各做 1 杯
单核 × 5 任务(交替) 多核 × 1 任务/核(真同时)
→ 提高 CPU 利用率 → 减少总执行时间
1.4.3 4 维度对比表
| 维度 | 并发 (Concurrency) | 并行 (Parallelism) |
|---|---|---|
| 核心问题 | 任务调度 | 任务执行 |
| 硬件要求 | 单核即可 | 必须多核 |
| 提速原理 | 利用 IO 等待时间切换 | 真分核并行 |
| Java 实战 | CompletableFuture / NIO | parallelStream / ForkJoinPool |
| 依赖中间件 | event loop / Netty | multiprocessing / OpenMP |
1.4.4 6 大常见误区
| # | 误区 | 真相 |
|---|---|---|
| 1 | ❌ "多线程 = 并行" | 单核多线程只是并发,OS 时间片切换 |
| 2 | ❌ "并发 = 性能更好" | CPU 密集型需要并行才能榨干多核 |
| 3 | ❌ "异步 ≠ 并发" | 错!异步是并发的一种实现(Node.js / coroutine) |
| 4 | ❌ "并行一定更快" | Amdahl 定律:加速比上限 = 1/(1-p) |
| 5 | ❌ "Goroutine 一定是并行" | GOMAXPROCS=1 时只并发 |
| 6 | ❌ "SIMD 是并行" | 是,但与应用层线程并行不同层级 |
1.4.5 CPU-bound vs IO-bound 选型(实战核心)
| 任务类型 | 推荐模型 | 反模式 |
|---|---|---|
| IO 密集(网络/磁盘) | 并发:CompletableFuture / NIO / Netty reactor | 用 ForkJoinPool = 浪费线程切换 |
| CPU 密集(计算/加密) | 并行:parallelStream / ForkJoinPool / multiprocessing | 用单线程 reactor = 浪费多核 |
| 高并发低延迟(10 万 QPS) | 异步 + 单线程 reactor | 用 1 线程 = 1 请求 |
| CPU 极高吞吐(离线批处理) | 并行 + ForkJoin | 用串行 = 浪费 N-1 核 |
// IO 密集:用并发
CompletableFuture<String> u = CompletableFuture.supplyAsync(() -> fetchUser());
CompletableFuture<String> o = CompletableFuture.supplyAsync(() -> fetchOrders());
String user = u.join(); String order = o.join();
// CPU 密集:用并行
List<Integer> result = hugeList.parallelStream()
.map(this::heavyCompute)
.collect(Collectors.toList());
// 反例:把 IO 密集丢进 ForkJoinPool
// → 100 线程都在等 IO,全部阻塞 → 无并发提升
// 反例:把 CPU 密集扔给 NIO 单线程 reactor
// → 1 核满载,其余 N-1 核空转
1.4.6 5 大语言模型对照
| 语言 | 并发实现 | 并行实现 | 默认 |
|---|---|---|---|
| Java | Thread / Executor / CompletableFuture | parallelStream / ForkJoinPool | 多线程 |
| Go | goroutine + channel | GOMAXPROCS 决定 | NumCPU(自动) |
| Erlang | process | 多调度器 | 自动并行 |
| Node.js | async/await 事件循环 | worker_threads / cluster | 单线程 |
| Rust | tokio async | rayon | 单线程 |
| Python | asyncio | multiprocessing | GIL 限制 |
金句:先识别任务类型(IO/CPU),再选并发模型——这是架构师的核心能力。
二、Java 并发演进历程
Java 并发能力经历了从底层原语到高级抽象的完整演进:
| 阶段 | Java 版本 | 核心特性 | 编程模型 |
|---|---|---|---|
| 第一阶段 | Java 1-4 | Thread、synchronized、volatile、wait/notify |
手动管理线程,底层同步原语 |
| 第二阶段 | Java 5-7 | java.util.concurrent、线程池、Fork/Join、并发集合 |
库级抽象,结构化并发工具 |
| 第三阶段 | Java 8-16 | CompletableFuture、StampedLock、VarHandle |
异步编排,无锁编程 |
| 第四阶段 | Java 19-26 | 虚拟线程、结构化并发、作用域值 | 现代轻量并发模型 |
// === 第一阶段:手动管理线程(Java 1)===
new Thread(() -> {
synchronized (lock) {
doWork();
}
}).start();
// === 第二阶段:线程池(Java 5)===
ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> doWork());
// === 第三阶段:异步编排(Java 8)===
CompletableFuture.supplyAsync(() -> fetchData())
.thenApply(data -> transform(data))
.thenAccept(System.out::println);
// === 第四阶段:虚拟线程(Java 21)===
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
executor.submit(() -> blockingIoCall()); // 同步写法,异步性能
}
三、专题导航
以下是 Java 并发编程的核心子专题,按知识依赖关系排列:
| 序号 | 专题 | 说明 | 链接 |
|---|---|---|---|
| 一 | Java 内存模型 (JMM) | happens-before 原则、内存屏障、指令重排序、可见性与有序性 | jmm |
| 二 | volatile 关键字 | volatile 语义、可见性保证、禁止重排序、适用场景与局限 | volatile |
| 三 | synchronized 关键字 | 内置锁原理、Monitor 对象、锁升级过程(偏向锁→轻量级锁→重量级锁) | synchronized |
| 四 | ThreadLocal 线程局部变量 | 线程封闭技术、内存泄漏问题、InheritableThreadLocal、TransmittableThreadLocal | threadlocal |
| 五 | 原子类与 CAS 操作 | AtomicInteger、LongAdder、AtomicReference、Unsafe、CAS 原理与 ABA 问题 |
atomic |
| 六 | CompletableFuture 异步编程 | 异步编排、组合、异常处理、虚拟线程集成、与线程池对比 | completablefuture |
| 七 | 线程协作(3 线程按顺序执行) | T1/T2/T3 顺序执行 3 语义 + 8 方案对比(join/CountDownLatch/CompletableFuture/Semaphore…) | thread-basics/sequential-execution |
| 八 | 🆕 虚拟线程(Java 21+) | carrier thread / mount-unmount / pinning / ScopedValue / 结构化并发 | virtual-threads |
| 九 | Java 锁机制 | synchronized 原理、锁升级、ReentrantLock、StampedLock、CAS、AQS | java-locks |
| 十 | 线程池 | ThreadPoolExecutor 参数详解、工作队列、拒绝策略、ForkJoinPool | thread-pool |
| 十一 | Java 线程基础 | 线程创建、生命周期、start/run 区别、interrupt 机制 | thread-basics |
| 十二 | JUC 锁体系 | AQS、ReentrantLock / ReentrantReadWriteLock / StampedLock、Condition | juc-locks |
| 十三 | 并发工具类 | CountDownLatch、CyclicBarrier、Semaphore、Phaser、Exchanger | utilities |
| 十四 | 🆕 大数据量 Excel 导出 OOM | 4 大解决方案(流式写入 / 分批查询 / 多线程分片 / 内存优化)+ 性能对比 | excel-export-oom |
四、专题详解
一、Java 内存模型 (JMM)
Java 内存模型(Java Memory Model)是并发编程的理论基础,定义了线程如何与主内存和工作内存交互。
核心概念:
- 主内存:所有线程共享的变量存储区域
- 工作内存:每个线程私有的变量副本区域
- happens-before 原则:判断数据是否存在竞争的核心规则
┌─────────────────────────────────────────────┐
│ Java 内存模型 │
│ │
│ ┌─────────┐ │
│ │ 主 内 存 │ ← 所有共享变量 │
│ │ (RAM) │ │
│ └────┬────┘ │
│ │ 读/写 │
│ ┌────────┼────────┐ │
│ ▼ ▼ ▼ │
│ ┌────────┐┌────────┐┌────────┐ │
│ │线程 A ││线程 B ││线程 C │ │
│ │工作内存││工作内存││工作内存│ │
│ │ 副本x ││ 副本x ││ 副本x │ │
│ └────────┘└────────┘└────────┘ │
│ │
│ 问题:线程 A 修改 x,线程 B 何时能看到? │
│ 答案:由 JMM 的 happens-before 规则保证 │
└─────────────────────────────────────────────┘
happens-before 八大规则:
| 规则 | 说明 |
|---|---|
| 程序顺序规则 | 单线程内,前面的操作 happens-before 后面的操作 |
| 锁规则 | 解锁 happens-before 后续加锁 |
| volatile 规则 | volatile 写 happens-before 后续 volatile 读 |
| 传递规则 | A happens-before B,B happens-before C,则 A happens-before C |
| 线程启动规则 | Thread.start() happens-before 该线程的任何操作 |
| 线程终止规则 | 线程的所有操作 happens-before Thread.join() 返回 |
| 线程中断规则 | Thread.interrupt() happens-before 被中断线程检测到中断 |
| 对象终结规则 | 对象构造完成 happens-before finalize() 方法调用 |
// happens-before 示例
class Example {
int a = 0;
volatile boolean flag = false;
// 线程 A 执行
void writer() {
a = 42; // (1)
flag = true; // (2) -- volatile 写
}
// 线程 B 执行
void reader() {
if (flag) { // (3) -- volatile 读
System.out.println(a); // (4) 一定输出 42
}
}
}
// 推导:(1) -> (2) [程序顺序]
// (2) -> (3) [volatile 规则]
// (3) -> (4) [程序顺序]
// 传递性:(1) -> (4),所以 (4) 一定能看到 a = 42
详细内容见:jmm 专题
二、volatile 关键字
volatile 是 Java 提供的最轻量级的同步机制,保证变量的可见性和禁止指令重排序。
核心特性:
| 特性 | 说明 | 对比 synchronized |
|---|---|---|
| 可见性 | 一个线程修改 volatile 变量,其他线程立即可见 | synchronized 也保证可见性 |
| 禁止重排序 | 编译器和 CPU 不会对 volatile 操作重排序 | synchronized 也禁止重排序 |
| 原子性 | 不保证复合操作的原子性(如 count++) |
synchronized 保证原子性 |
// volatile 正确用法:状态标志
class Worker {
private volatile boolean running = true;
public void stop() {
running = false; // 写 volatile,其他线程立即可见
}
public void run() {
while (running) { // 读 volatile,一定能看到最新值
doWork();
}
}
}
// volatile 错误用法:复合操作不保证原子性
class BadCounter {
private volatile int count = 0;
public void increment() {
count++; // 问题:读-改-写三步,volatile 只保证单步可见性
// 两个线程同时调用,可能丢失计数
}
}
详细内容见:volatile 专题
三、synchronized 关键字
synchronized 是 Java 最基础的同步机制,基于 JVM 内部的 Monitor 对象实现。
锁升级过程(重点):
无锁 → 偏向锁 → 轻量级锁(自旋) → 重量级锁(阻塞)
┌──────────────────────────────────────────────────────────┐
│ synchronized 锁升级 │
│ │
│ 阶段 1: 无锁 │
│ ┌─────────────────────────────┐ │
│ │ Mark Word: 无锁状态标识 │ │
│ └─────────────────────────────┘ │
│ │
│ 阶段 2: 偏向锁(仅一个线程访问时) │
│ ┌─────────────────────────────┐ │
│ │ Mark Word: 偏向线程ID + Epoch│ ← 无锁竞争,无开销 │
│ └─────────────────────────────┘ │
│ │
│ 阶段 3: 轻量级锁(少量竞争,自旋等待) │
│ ┌─────────────────────────────┐ │
│ │ Mark Word: 指向 Lock Record │ ← CAS 竞争,自旋 │
│ └─────────────────────────────┘ │
│ │
│ 阶段 4: 重量级锁(竞争激烈,阻塞等待) │
│ ┌─────────────────────────────┐ │
│ │ Mark Word: 指向 Monitor │ ← OS 互斥锁,阻塞 │
│ └─────────────────────────────┘ │
└──────────────────────────────────────────────────────────┘
// 基本用法
class Counter {
private int count = 0;
// 同步实例方法 → 锁 this
public synchronized void increment() {
count++;
}
// 同步静态方法 → 锁 Counter.class
public static synchronized void staticIncrement() {
// ...
}
// 同步代码块 → 锁指定对象
public void add() {
synchronized (this) {
count++;
}
}
}
详细内容见:synchronized 专题
四、ThreadLocal 线程局部变量
ThreadLocal 提供线程局部变量,实现线程封闭,每个线程拥有独立的变量副本,无需加锁即可保证线程安全。
数据结构:
ThreadLocal 原理图
Thread-1 Thread-2
┌──────────────┐ ┌──────────────┐
│ threadLocals │ │ threadLocals │
│ (Entry[]) │ │ (Entry[]) │
├──────────────┤ ├──────────────┤
│ TL-A → Val1 │ │ TL-A → Val2 │ ← 同一个 ThreadLocal,不同值
│ TL-B → Val3 │ │ TL-B → Val4 │
└──────────────┘ └──────────────┘
▲ ▲
└──────────┬───────────────┘
│
┌───────────────┐
│ ThreadLocal<A>│ ← 弱引用 key
│ ThreadLocal<B>│
└───────────────┘
内存泄漏问题:
// ThreadLocal 的 key 是弱引用,value 是强引用
// 如果 ThreadLocal 对象被 GC 回收,Entry 的 key 变为 null
// 但 value 仍然强引用,导致内存泄漏
// 解决方案:使用完毕后务必调用 remove()
public class ThreadLocalDemo {
private static final ThreadLocal<UserContext> USER_CONTEXT =
ThreadLocal.withInitial(UserContext::new);
public void process() {
try {
UserContext ctx = USER_CONTEXT.get();
ctx.setUserId(123);
doBusiness();
} finally {
USER_CONTEXT.remove(); // 必须清理,防止内存泄漏!
}
}
}
详细内容见:threadlocal 专题
五、原子类与 CAS 操作
原子类基于 CAS(Compare-And-Swap)无锁算法实现线程安全的单变量操作,性能优于加锁方案。
CAS 原理:
┌───────────────────────────────────────────────────────┐
│ CAS 操作原理 │
│ │
│ CAS(预期值, 新值) → 成功/失败 │
│ │
│ 伪代码: │
│ boolean CAS(int* addr, int expected, int newValue) { │
│ if (*addr == expected) { │
│ *addr = newValue; │
│ return true; │
│ } │
│ return false; │
│ } │
│ │
│ CPU 指令支持:x86 的 CMPXCHG / ARM 的 LDREX/STREX │
└───────────────────────────────────────────────────────┘
原子类家族:
| 类别 | 类名 | 说明 |
|---|---|---|
| 基本类型 | AtomicInteger、AtomicLong、AtomicBoolean |
单变量原子操作 |
| 数组类型 | AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray |
数组元素的原子操作 |
| 引用类型 | AtomicReference、AtomicStampedReference(解决 ABA) |
对象引用的原子操作 |
| 字段更新器 | AtomicIntegerFieldUpdater、AtomicLongFieldUpdater |
指定类的 volatile 字段 |
| 累加器 | LongAdder、DoubleAdder(高并发更优) |
分段累加,减少 CAS 竞争 |
// AtomicInteger 用法
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet(); // 原子自增,返回新值
counter.getAndIncrement(); // 原子自增,返回旧值
counter.compareAndSet(5, 10);// CAS: 期望值为 5,更新为 10
// LongAdder(高并发场景推荐)
LongAdder longAdder = new LongAdder();
longAdder.increment(); // 分段累加
long sum = longAdder.sum(); // 获取总和
详细内容见:atomic 专题
六、CompletableFuture 异步编程
CompletableFuture(Java 8 引入)提供了强大的异步编排能力,支持链式调用、组合、异常处理,是回调地狱的终结者。
核心能力:
// 1. 创建异步任务
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
return fetchDataFromRemote();
});
// 2. 链式变换
future
.thenApply(data -> parse(data)) // 转换结果
.thenAccept(result -> System.out.println(result)) // 消费结果
.exceptionally(ex -> { // 异常处理
log.error("Failed", ex);
return "fallback";
});
// 3. 组合多个异步任务
CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> callA());
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> callB());
// 等待两个都完成
CompletableFuture.allOf(f1, f2).join();
String result = f1.join() + f2.join();
// 任一完成即可
CompletableFuture.anyOf(f1, f2).join();
// 4. 超时控制
String result = future.orTimeout(5, TimeUnit.SECONDS).join();
// 5. 虚拟线程集成(Java 21+)
// 默认使用 ForkJoinPool.commonPool()
// 可指定使用虚拟线程的执行器
CompletableFuture.supplyAsync(() -> blockingIoCall(),
Executors.newVirtualThreadPerTaskExecutor());
CompletableFuture vs 虚拟线程对比:
| 维度 | CompletableFuture | 虚拟线程(Java 21+) |
|---|---|---|
| 编程风格 | 异步回调链 | 同步写法 |
| 可读性 | 中等(链式调用) | 高(线性逻辑) |
| 异常处理 | .exceptionally() |
标准 try-catch |
| 适用场景 | 非阻塞 I/O、流式处理 | 阻塞 I/O、高并发 |
| 学习曲线 | 较陡 | 低 |
详细内容见:completablefuture 专题
五、并发工具类速查
| 工具类 | 用途 | 典型场景 |
|---|---|---|
| CountDownLatch | 等待多个操作完成 | 主线程等待 N 个子任务完成 |
| CyclicBarrier | 多线程 barrier 同步点 | 多线程计算后合并结果 |
| Semaphore | 信号量控制并发访问数 | 限制同时访问资源的线程数 |
| Phaser | 灵活的分阶段同步 | 多阶段并行计算 |
| Exchanger | 线程间数据交换 | 生产者-消费者数据传递 |
六、并发集合速查
| 集合类 | 说明 | 适用场景 |
|---|---|---|
| ConcurrentHashMap | 分段锁 / CAS + synchronized | 高并发 key-value 存储 |
| CopyOnWriteArrayList | 写时复制的线程安全 List | 读多写少场景 |
| BlockingQueue | 阻塞队列 | 生产者-消费者模式 |
| ConcurrentLinkedQueue | 无锁并发队列 | 高性能无锁场景 |
七、并发编程知识体系全景
┌────────────────────────────────────────────────────────────────┐
│ Java 并发编程知识体系 │
│ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 理论基础 │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────────────┐ │ │
│ │ │ JMM 模型 │ │ volatile │ │ happens-before 原则 │ │ │
│ │ │ 主/工作内存│ │ 可见性/有序│ │ 八大规则 │ │ │
│ │ └────────────┘ └────────────┘ └────────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────┼────────────────────────────────┐ │
│ │ 同步机制 │ │
│ │ ┌────────────────┐ ┌────────────────┐ ┌──────────┐ │ │
│ │ │ synchronized │ │ 显式锁(JUC) │ │ 原子类 │ │ │
│ │ │ 锁升级/Monitor │ │ ReentrantLock │ │ CAS/ABA │ │ │
│ │ │ 偏向→轻量→重量 │ │ StampedLock │ │ LongAdder│ │ │
│ │ └────────────────┘ └────────────────┘ └──────────┘ │ │
│ └───────────────────────┼────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────┼────────────────────────────────┐ │
│ │ 线程管理 │ │
│ │ ┌────────────────┐ ┌────────────────┐ ┌──────────┐ │ │
│ │ │ ThreadLocal │ │ 线程池 │ │ 虚拟线程 │ │ │
│ │ │ 线程封闭 │ │ ThreadPoolExec │ │ Java 21+ │ │ │
│ │ │ 内存泄漏防护 │ │ ForkJoinPool │ │ 轻量调度 │ │ │
│ │ └────────────────┘ └────────────────┘ └──────────┘ │ │
│ └───────────────────────┼────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────┼────────────────────────────────┐ │
│ │ 异步编排 │ │
│ │ ┌────────────────┐ ┌────────────────┐ ┌──────────┐ │ │
│ │ │ Future/Callable│ │ CompletableFuture│ │ 结构化并 │ │ │
│ │ │ Java 5-7 │ │ Java 8+ │ │ 发(预览) │ │ │
│ │ │ 阻塞等待 │ │ 链式组合 │ │ Java 25+ │ │ │
│ │ └────────────────┘ └────────────────┘ └──────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────────┘
八、常见并发问题速查
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 竞态条件 | 多线程对共享变量的执行顺序不确定 | 加锁、原子操作、不可变对象 |
| 死锁 | 循环等待对方持有的锁 | 锁排序、tryLock 超时、死锁检测 |
| 饥饿 | 某些线程长期得不到 CPU 或锁 | 公平锁、调整优先级 |
| 活锁 | 线程不断重试但始终无法推进 | 引入随机退避 |
| 内存可见性 | 一个线程的修改对其他线程不可见 | volatile、synchronized、final |
| 指令重排序 | 编译器/CPU 优化导致执行顺序变化 | volatile、内存屏障 |
| ThreadLocal 泄漏 | Entry 的 value 强引用未被清理 | finally 块中 remove() |
| CAS ABA 问题 | 值被修改后恢复为原值,CAS 无法感知 | AtomicStampedReference |
九、最佳实践原则
- 优先使用并发库:
java.util.concurrent提供的工具类,而非手动管理线程 - 最小化共享状态:不可变对象 > 线程封闭(ThreadLocal) > 同步访问
- 锁的范围尽量小:缩小临界区,减少锁持有时间
- 避免在锁内执行耗时操作:如 I/O、网络调用
- I/O 密集型使用虚拟线程(Java 21+),CPU 密集型使用固定线程池
- 始终为线程池设置合理参数:根据任务类型选择核心线程数
- 正确处理中断:响应
InterruptedException,不吞掉中断信号 - ThreadLocal 用完必清:
finally块中调用remove()防止泄漏
十、专题目录结构
concurrency/
├── README.md ← 本文件,专题导航
├── jmm/ ← Java 内存模型
│ └── README.md
├── volatile/ ← volatile 关键字
│ └── README.md
├── synchronized/ ← synchronized 关键字与锁机制
│ └── README.md
├── threadlocal/ ← ThreadLocal 线程局部变量
│ └── README.md
├── atomic/ ← 原子类与 CAS 操作
│ └── README.md
├── completablefuture/ ← CompletableFuture 异步编程
│ └── README.md
├── virtual-threads/ ← 🆕 虚拟线程(Java 21+)
│ └── README.md
├── java-locks/ ← Java 锁机制(synchronized / ReentrantLock / CAS / AQS)
│ └── README.md
└── thread-pool/ ← 线程池(ThreadPoolExecutor / ForkJoinPool)
└── README.md
总结:Java 并发编程从
synchronized+Thread演进到虚拟线程 + 结构化并发的现代模型。 本专题覆盖了并发编程的基础知识体系——从 JMM 理论到 volatile/synchronized 同步原语, 从 ThreadLocal 线程封闭到 CAS 无锁编程,再到 CompletableFuture 异步编排。 掌握这些内容是进一步学习线程池、虚拟线程、结构化并发等高级主题的基础。
📊 本节统计
| 统计维度 | 数值 | 口径 |
|---|---|---|
| 分类主题数 | 13 | jmm / volatile / synchronized / threadlocal / atomic / completablefuture / 🆕 virtual-threads / java-locks / thread-pool + juc-locks / thread-basics / utilities / concurrent-collections(含 3 子专题) |
| 子 README 数 | 16 | 含 concurrent-collections(3 子目录)+ virtual-threads / java-locks / thread-pool 等深层 leaf |
| 含 frontmatter 的 README | 17 / 17 | 100% 覆盖(2026-07-16) |
统计时间戳:2026-07-01