并发编程高频 20 题详解
面试最卷的方向之一。每道题按「考察点 → 答案 → 手写代码 / 画图」展开,建议配合
并发编程面试题.md(速查版)一起复习。
1. 进程、线程、协程的区别
考察点:对并发执行单元层次的理解。
- 进程:操作系统资源分配的最小单位,拥有独立的内存空间和资源,进程间通过 IPC 通信,切换开销大。
- 线程:CPU 调度的最小单位,是进程内的执行单元,共享进程的堆和方法区,各自拥有栈,切换开销小于进程。
- 协程:用户态轻量线程,由程序自己调度(非 OS 调度),切换开销极小,适合高并发 IO 场景。Java 的虚拟线程(JDK21,Project Loom)本质就是协程。
graph TD
A[进程] --> B[线程 1]
A --> C[线程 2]
A --> D[线程 3]
B --> E[协程 a]
B --> F[协程 b]
style A fill:#e8f4fd
style B fill:#fff3cd
style C fill:#fff3cd
style D fill:#fff3cd
style E fill:#e6f7e6
style F fill:#e6f7e62. 线程的生命周期与状态转换
考察点:6 种线程状态的准确定义,以及 sleep/wait/join/lock 对状态的影响。
Java 线程共 6 种状态:NEW → RUNNABLE → BLOCKED / WAITING / TIMED_WAITING → TERMINATED。
stateDiagram-v2
[*] --> NEW
NEW --> RUNNABLE: start()
RUNNABLE --> BLOCKED: 竞争锁失败
BLOCKED --> RUNNABLE: 获取到锁
RUNNABLE --> WAITING: wait()/join()/park()
WAITING --> RUNNABLE: notify()/unpark()
RUNNABLE --> TIMED_WAITING: sleep()/wait(ms)
TIMED_WAITING --> RUNNABLE: 超时/唤醒
RUNNABLE --> TERMINATED: 执行完毕
TERMINATED --> [*]易错点:
sleep()是Thread的静态方法,不释放锁,进入 TIMED_WAITING。wait()是Object的方法,释放锁,需在同步块中调用,进入 WAITING。yield()只是让出 CPU 提示,不保证切换,状态仍为 RUNNABLE。
3. synchronized 底层实现与锁升级
考察点:对象头 Mark Word、Monitor、锁升级过程。
synchronized 锁信息存在对象头的 Mark Word 中,经历了从无锁到重量级锁的升级:
graph LR
A[无锁] -->|偏向锁开启, 首个线程| B[偏向锁]
B -->|出现竞争| C[轻量级锁]
C -->|自旋失败/竞争激烈| D[重量级锁]
style A fill:#e6f7e6
style D fill:#fce4e4- 偏向锁:无竞争时,锁偏向第一个访问的线程,记录线程 ID,再次进入无需 CAS。
- 轻量级锁:竞争不激烈时,用 CAS 把锁记录指针写入 Mark Word,失败则自旋。
- 重量级锁:自旋仍失败,升级为 Monitor(依赖操作系统互斥量),线程挂起进入等待队列,
monitorenter/monitorexit指令。
锁只升级不降级(偏向锁可被批量撤销,但正常不降级)。
4. synchronized 与 ReentrantLock 的区别
考察点:语法糖 vs JDK 锁的能力差异。
| 区别 | synchronized | ReentrantLock |
|---|---|---|
| 实现 | JVM 关键字,C++ 实现 | JDK 类,Java 实现 |
| 释放 | 自动释放 | 必须 finally 中 unlock |
| 公平锁 | 非公平 | 可选公平/非公平 |
| 中断 | 不可中断 | lockInterruptibly() 可中断 |
| 多条件 | 一个 wait/notify | 多个 Condition |
| 尝试锁 | 无 | tryLock() 可非阻塞获取 |
// synchronized 用法
public synchronized void method1() { ... }
public void method2() {
synchronized (this) { ... }
}
// ReentrantLock 用法
private final ReentrantLock lock = new ReentrantLock();
public void method3() {
lock.lock();
try {
// 业务逻辑
} finally {
lock.unlock(); // 必须释放
}
}5. JMM 内存模型与三大特性
考察点:主内存/工作内存、原子性/可见性/有序性。
JMM(Java Memory Model)抽象了主内存和工作内存的关系:所有共享变量存在主内存,每个线程有自己的工作内存,操作变量需先 copy 到工作内存,再刷回主内存。
graph LR
M[主内存<br/>共享变量] ---|read/load| T1[工作内存1<br/>线程A]
T1 ---|store/write| M
M ---|read/load| T2[工作内存2<br/>线程B]
T2 ---|store/write| M
style M fill:#e8f4fd三大特性:
- 原子性:操作不可分割(synchronized、Lock、原子类保证)。
- 可见性:一个线程的修改对其他线程可见(volatile、synchronized、final)。
- 有序性:指令按序执行,禁止重排序(volatile 内存屏障、happens-before)。
6. volatile 的可见性与有序性原理
考察点:内存屏障、与 synchronized 的对比。
volatile 通过内存屏障实现:
- 可见性:写 volatile 变量后,强制把工作内存刷回主内存(Store 屏障);读 volatile 前,强制从主内存读最新值(Load 屏障)。
- 有序性:禁止 volatile 前后指令重排序。
- 不保证原子性:
i++是「读-改-写」三步,多线程下仍会丢更新,需用 AtomicInteger 或加锁。
// volatile 保证可见性示例
public class VolatileDemo {
private static volatile boolean flag = false;
public static void main(String[] args) {
new Thread(() -> {
while (!flag) { } // 不加 volatile,可能死循环
System.out.println("退出");
}).start();
try { Thread.sleep(1000); } catch (InterruptedException e) {}
flag = true; // 主线程修改,子线程立即可见
}
}7. happens-before 规则
考察点:判断两个操作是否可见的规则。
happens-before 是 JMM 的核心,若 A happens-before B,则 A 的结果对 B 可见。主要规则:
- 程序次序:同一线程内,前面的操作 happens-before 后面的。
- 监视器锁:unlock happens-before 后续的 lock。
- volatile:写 happens-before 后续的读。
- 传递性:A → B,B → C,则 A → C。
- 线程 start/join:start 前的操作对线程可见;线程执行完对 join 返回后可见。
// 传递性示例:写 flag 前先写了 count
int count = 0;
volatile boolean flag = false;
// 线程A:count = 42; flag = true;
// 线程B:if (flag) 读 count == 42
// 因为 count 写在 volatile 写之前,volatile 写 happens-before 读 flag8. CAS 原理、优缺点与 ABA 问题
考察点:原子操作的底层原理,ABA 及解决。
CAS(Compare And Swap)是乐观锁的核心,底层依赖 CPU 的 cmpxchg 原子指令,Unsafe 类封装。
// AtomicInteger 的 CAS 自旋
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
// unsafe.getAndAddInt 内部:
// do { var5 = getIntVolatile(o, offset); }
// while (!compareAndSwapInt(o, offset, var5, var5 + 1));优点:无锁、性能高、非阻塞。 缺点:ABA 问题、自旋 CPU 开销、只能保证单变量原子。
ABA 问题:值从 A → B → A,CAS 无法感知中间变化。解决:带版本号 AtomicStampedReference:
AtomicStampedReference<Integer> ref =
new AtomicStampedReference<>(100, 0);
int stamp = ref.getStamp();
// CAS 同时比较值和版本号
boolean success = ref.compareAndSet(100, 200, stamp, stamp + 1);9. AQS 原理
考察点:AbstractQueuedSynchronizer 是 JUC 锁的基石。
AQS 维护一个 volatile int state 同步状态 + 一个 CLH 变体的双向等待队列。线程抢不到锁就包装成 Node 入队,阻塞等待;前驱释放锁后唤醒后继。
graph LR
H[head 哨兵] --> N1[Node1<br/>持有锁线程]
N1 --> N2[Node2<br/>等待线程]
N2 --> N3[Node3<br/>等待线程]
N3 --> N4[...]
style N1 fill:#e6f7e6
style N2 fill:#fff3cd
style N3 fill:#fff3cd核心方法(模板方法模式,子类实现):
- 独占式:
tryAcquire/tryRelease(ReentrantLock)。 - 共享式:
tryAcquireShared/tryReleaseShared(Semaphore、CountDownLatch)。
手写一个极简互斥锁(基于 AQS):
public class MyLock {
private static class Sync extends AbstractQueuedSynchronizer {
@Override
protected boolean tryAcquire(int arg) {
return compareAndSetState(0, 1); // 抢锁成功返回 true
}
@Override
protected boolean tryRelease(int arg) {
setState(0);
return true;
}
}
private final Sync sync = new Sync();
public void lock() { sync.acquire(1); }
public void unlock() { sync.release(1); }
}10. ReentrantLock 可重入与公平锁实现
考察点:state 计数、公平/非公平的 CAS 差异。
可重入:state 记录重入次数。同一线程重复加锁 state++,释放 state--,为 0 才真正释放:
// 简化版可重入逻辑
protected boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
} else if (current == getExclusiveOwnerThread()) {
setState(c + acquires); // 重入
return true;
}
return false;
}公平 vs 非公平:
- 非公平锁(默认):直接 CAS 抢锁,抢不到再排队。
- 公平锁:加锁前先检查队列是否有等待线程,有则排队
hasQueuedPredecessors()。
// 公平锁的额外判断
if (c == 0) {
if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}11. 线程池核心参数与执行流程
考察点:7 个参数、任务提交流程、拒绝策略。
graph TD
A[提交任务] --> B{核心线程未满?}
B -->|是| C[创建核心线程执行]
B -->|否| D{队列未满?}
D -->|是| E[入队等待]
D -->|否| F{达到最大线程数?}
F -->|否| G[创建非核心线程执行]
F -->|是| H[执行拒绝策略]
style H fill:#fce4e4核心参数:corePoolSize、maximumPoolSize、keepAliveTime、workQueue、threadFactory、handler。
手写一个线程池(简化核心逻辑):
ThreadPoolExecutor pool = new ThreadPoolExecutor(
4, // 核心线程数
8, // 最大线程数
60, TimeUnit.SECONDS, // 空闲存活时间
new ArrayBlockingQueue<>(100), // 有界队列
new ThreadFactoryBuilder().setNameFormat("biz-%d").build(),
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);为什么不用 Executors:Fixed/Single 用无界队列可能 OOM,Cached 线程数无限可能 OOM。
12. ThreadLocal 原理与内存泄漏
考察点:ThreadLocalMap、弱引用 key、泄漏原因与解决。
每个 Thread 内部有一个 ThreadLocalMap,key 是 ThreadLocal 的弱引用,value 是强引用。
graph LR
T[Thread] --> M[ThreadLocalMap]
M --> E[Entry]
E --> K[ThreadLocal 弱引用]
E --> V[value 强引用]
style K fill:#fce4e4
style V fill:#e6f7e6内存泄漏原因:key 是弱引用会被 GC 回收(key 变 null),但 value 是强引用,且 Entry 还引用着它,无法被回收,造成泄漏。
解决:用完必须调用 remove():
private static final ThreadLocal<String> tl = new ThreadLocal<>();
try {
tl.set("data");
// 使用
} finally {
tl.remove(); // 必须清理
}应用:链路追踪 traceId 透传、数据库连接、SimpleDateFormat 线程隔离。
13. ConcurrentHashMap 线程安全原理
考察点:JDK7 分段锁 vs JDK8 CAS+synchronized。
| 版本 | 实现 | 锁粒度 |
|---|---|---|
| JDK7 | Segment 数组 + HashEntry,Segment 继承 ReentrantLock | 段级 |
| JDK8 | 数组 + 链表/红黑树,CAS + synchronized 锁桶头节点 | 桶级 |
JDK8 关键点:
- 初始化:CAS 保证只初始化一次。
- put:桶为空时 CAS 插入;有冲突时 synchronized 锁头节点。
- size:baseCount + CounterCell 分段计数,避免全表加锁。
- 扩容:多线程协助扩容(transfer)。
// JDK8 put 简化示意
// 1. 空桶 CAS 插入
if (tabAt(tab, i) == null) {
if (casTabAt(tab, i, null, new Node<>(hash, key, value))) {
break;
}
}
// 2. 有冲突 synchronized 锁头节点
synchronized (f) { ... }14. CountDownLatch / CyclicBarrier / Semaphore
考察点:三个同步工具类的区别与用法。
// 1. CountDownLatch:一个线程等 N 个线程完成,不可复用
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
new Thread(() -> { doWork(); latch.countDown(); }).start();
}
latch.await(); // 主线程等待
// 2. CyclicBarrier:一组线程互相等待到齐,可复用
CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("全部到齐"));
for (int i = 0; i < 3; i++) {
new Thread(() -> { doWork(); barrier.await(); }).start();
}
// 3. Semaphore:控制并发访问数(限流)
Semaphore semaphore = new Semaphore(5); // 最多 5 个并发
semaphore.acquire();
try { doWork(); } finally { semaphore.release(); }15. 死锁的产生与排查
考察点:四个必要条件、手写死锁、jstack 定位。
四个必要条件:互斥、请求与保持、不可剥夺、循环等待。破坏任意一个即可预防。
手写死锁:
public class DeadLock {
private static final Object A = new Object();
private static final Object B = new Object();
public static void main(String[] args) {
new Thread(() -> {
synchronized (A) {
sleep(100);
synchronized (B) { System.out.println("t1"); }
}
}).start();
new Thread(() -> {
synchronized (B) {
sleep(100);
synchronized (A) { System.out.println("t2"); }
}
}).start();
}
}排查:jstack <pid> 找到 Found one Java-level deadlock,会列出互相等待的线程和锁。
16. 生产者消费者多种实现
考察点:从低级到高级的演进。
方式一:synchronized + wait/notify
public class PCSync {
private final Object lock = new Object();
private int count = 0;
private static final int MAX = 10;
public void produce() throws InterruptedException {
synchronized (lock) {
while (count == MAX) lock.wait(); // 用 while 防止虚假唤醒
count++;
lock.notifyAll();
}
}
public void consume() throws InterruptedException {
synchronized (lock) {
while (count == 0) lock.wait();
count--;
lock.notifyAll();
}
}
}方式二:ReentrantLock + Condition(支持定向唤醒)
public class PCLock {
private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
private int count = 0;
private static final int MAX = 10;
public void produce() {
lock.lock();
try {
while (count == MAX) notFull.await();
count++;
notEmpty.signal(); // 定向唤醒消费者
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
}
// consume 类似
}方式三:BlockingQueue(推荐)
BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
// 生产者
queue.put(1); // 满了阻塞
// 消费者
Integer v = queue.take(); // 空了阻塞17. 双重检查单例为什么加 volatile
考察点:指令重排序导致的半初始化对象。
public class Singleton {
private static volatile Singleton instance; // volatile 关键
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) { // 第一次检查
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查
instance = new Singleton();
}
}
}
return instance;
}
}new Singleton() 分为三步:
- 分配内存空间。
- 初始化对象(调用构造器)。
- 将 instance 指向内存地址。
若 2、3 重排序,线程 B 第一次检查时发现 instance 非 null,返回的是未初始化完成的对象,导致 NPE 或拿到错误状态。volatile 禁止该重排序。
18. 手写一个阻塞队列
考察点:结合锁 + 条件变量实现数据结构。
public class MyBlockingQueue {
private final Object[] items;
private int putIdx, takeIdx, count;
private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
public MyBlockingQueue(int capacity) {
this.items = new Object[capacity];
}
public void put(Object o) throws InterruptedException {
lock.lock();
try {
while (count == items.length) notFull.await();
items[putIdx] = o;
if (++putIdx == items.length) putIdx = 0;
count++;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0) notEmpty.await();
Object o = items[takeIdx];
if (++takeIdx == items.length) takeIdx = 0;
count--;
notFull.signal();
return o;
} finally {
lock.unlock();
}
}
}19. CompletableFuture 异步编排
考察点:异步编程、组合多个任务。
// 异步执行 + 串行
CompletableFuture.supplyAsync(() -> queryA())
.thenApply(a -> a + process(a)) // 有返回值串行
.thenAccept(System.out::println); // 无返回值消费
// 两个任务并行,都完成后组合
CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "A");
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> "B");
f1.thenCombine(f2, (a, b) -> a + b).thenAccept(System.out::println);
// 任一完成即返回
f1.applyToEither(f2, r -> r).thenAccept(System.out::println);
// 全部完成
CompletableFuture.allOf(f1, f2).join();需要指定线程池时传入自定义 Executor,避免都用公共 ForkJoinPool。
20. 并发工具类与容器总结 + 实战建议
考察点:整体知识地图 + 工程经验。
锁与同步:synchronized、ReentrantLock、ReentrantReadWriteLock(读写分离)、StampedLock、Semaphore、CountDownLatch、CyclicBarrier、Phaser。
原子类:AtomicInteger/Long/Reference、LongAdder(高并发计数优于 AtomicLong,分 Cell 累加)、AtomicStampedReference。
并发容器:ConcurrentHashMap、CopyOnWriteArrayList(读多写少)、ConcurrentLinkedQueue、BlockingQueue 系列(Array/Linked/Priority/Synchronous)。
线程池:ThreadPoolExecutor、ScheduledThreadPoolExecutor、ForkJoinPool(分治)、CompletableFuture。
实战建议(8 年经验总结):
- 优先用并发容器和原子类,而不是自己加锁,减少出错。
- 线程池必须自定义参数 + 有界队列 + 明确拒绝策略,别用 Executors 快捷方法。
- 锁粒度尽量小,能用读写锁就别用独占锁,能用无锁(CAS)就少加锁。
- 计数器场景优先
LongAdder。 - ThreadLocal 用完
remove,防止内存泄漏。 - 避免在锁内做耗时 IO,减少锁持有时间。
- 上线前用
jstack/Arthas 检查是否有线程泄漏、死锁、线程池打满。