面试题集锦:Java 并发(ConcurrentHashMap、线程池、JMM)

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:10 题
交叉参考:Q2 → B3 Q18、Q7 → B3 Q16/Q17、Q8 → B3 Q15
Q1:ConcurrentHashMap 原理
TL;DR
JDK 7 = Segment 分段锁(16 个 Segment,每个一把 ReentrantLock,并发度 16)。JDK 8 = CAS + synchronized(无锁化 + 链表/红黑树)。sizeCtl 控制初始化和扩容状态。扩容多线程协同(每个线程认领一段搬运)。
类比
🏢 写字楼楼层管理:JDK7 = 每层楼一个门禁(Segment 锁),不同楼层的人可以同时进出,同一楼层排队。JDK8 = 每个房间一个门禁(CAS+synchronized),粒度更细,效率更高。
JDK7 → JDK8 核心变化
// JDK 7:Segment 数组,每个 Segment 管一段
final Segment<K,V>[] segments; // 默认 16 个,每段独立锁
// JDK 8:Node 数组 + CAS,细粒度锁
transient volatile Node<K,V>[] table; // 直接操作数组
// put 时:数组位置为空 → CAS 插入;冲突 → synchronized 锁链表头节点sizeCtl 状态机
负数:正在初始化或扩容
-1:正在初始化
-(1+n):n 个线程正在协助扩容(高 16 位标识)
正数:
未初始化 = 初始容量
已初始化 = 下次扩容的阈值(0.75 × table.length)
扩容协作
1. 第一个线程触发扩容 → 创建新表(2x)→ 划分迁移区间(步长=16)
2. 其他线程 put 时发现正在扩容 → 帮助迁移(认领一个区间)
3. 迁移时用 ForwardingNode 占位("我正在搬,你等我")
4. 最后一个线程迁移 → 检查所有区间完成 → 替换表
记忆锚
"JDK7 分段锁 16 并发,JDK8 CAS+synchronized 细粒度,扩容多线程协同搬"
Q2:synchronized 锁升级 → 详见 B3 Q18
此处给精简版:
无锁(001)→ 偏向锁(101,单线程免 CAS)→ 轻量级锁(00,CAS 自旋)
→ 重量级锁(10,OS mutex 阻塞)
锁消除:JIT 发现不会竞争 → 去掉锁
锁粗化:连续加锁 → 合并成一个大锁
Q3:AQS(AbstractQueuedSynchronizer)源码级理解
TL;DR
AQS = Java 并发包的基类。核心:state(int,同步状态)+ CLH 变种队列(FIFO 等待队列)+ acquire/release 模板方法。ReentrantLock、CountDownLatch、Semaphore 全部基于 AQS。
类比
🎫 医院叫号系统:state = 当前叫到的号码。CLH 队列 = 候诊区排队的人。acquire = 取号等待。release = 叫下一个号。公平锁 = 严格按取号顺序。
核心三要素
public abstract class AbstractQueuedSynchronizer {
// 1. state:同步状态(volatile)
private volatile int state;
// 2. CLH 队列:双向链表,存等待线程
static final class Node {
volatile Node prev, next;
volatile Thread thread;
volatile int waitStatus; // SIGNAL/CANCELLED/CONDITION
}
// 3. 模板方法:子类只需实现 tryAcquire/tryRelease
protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); }
protected boolean tryRelease(int arg) { throw new UnsupportedOperationException(); }
}ReentrantLock 公平锁流程
// acquire → tryAcquire(抢锁)→ 失败 → addWaiter(入队)→ acquireQueued(自旋+阻塞)
// 公平锁 tryAcquire:检查队列前面有没有人
final boolean tryAcquire(int acquires) {
if (state == 0) {
if (!hasQueuedPredecessors() && // ← 公平!前面没人我才抢
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 可重入检查...
}记忆锚
"state 管状态,CLH 排等待,子类实现 tryXxx——AQS 是并发包之母"
Q4:线程池 7 参数 + 状态机 + 拒绝策略
TL;DR
ThreadPoolExecutor 7 参数:corePoolSize(核心线程)→ maximumPoolSize(最大线程)→ keepAliveTime(空闲回收时间)→ unit → workQueue(阻塞队列)→ threadFactory → rejectedExecutionHandler(拒绝策略)。
类比
🍔 快餐店排班:corePoolSize = 常驻员工(3 人,平时够用)。workQueue = 等餐队列(20 人容量)。maximumPoolSize = 最大员工数(高峰期可临时招到 10 人)。keepAliveTime = 临时工多久没活就辞退。拒绝策略 = 排队区也满了怎么办。
线程池执行流程
四种拒绝策略
| 策略 | 行为 |
|---|---|
| AbortPolicy(默认) | 抛 RejectedExecutionException |
| CallerRunsPolicy | 由调用者线程自己执行(慢但不会丢) |
| DiscardPolicy | 静默丢弃(不推荐) |
| DiscardOldestPolicy | 丢弃队列中最旧的任务 |
记忆锚
"核心→队列→最大→拒绝,四步判断。拒绝策略选 CallerRuns 保不丢"
Q5:CAS 原理 + ABA 问题 + LongAdder
TL;DR
CAS = Compare-And-Swap,CPU 原子指令(cmpxchg)。ABA 问题 = 值从 A→B→A,CAS 检测不到变化。解决:版本号(AtomicStampedReference)。LongAdder = 分段 CAS(Cell 数组),高并发下吞吐比 AtomicLong 高。
类比
🔢 银行排号机:CAS = 你看屏幕是 100,走上前按"确认"→ 如果屏幕还是 100 就取号成功,如果变成 101 就重试。ABA 问题 = 号从 100→101→100,你第二次看还是 100,以为没人取过——但中间的 101 被取走了。版本号 = 屏幕上不仅显示号,还显示"第 N 轮"。
CAS 原理
// AtomicInteger.incrementAndGet()
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
// Unsafe.getAndAddInt(自旋 CAS)
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta)); // ← 失败就重试
return v;
}ABA 解决方案
// AtomicStampedReference:带版本号的 CAS
AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(100, 0);
int[] stamp = new int[1];
int value = ref.get(stamp); // value=100, stamp[0]=0
ref.compareAndSet(100, 200, stamp[0], stamp[0] + 1); // 版本号也变LongAdder(分段 CAS)
AtomicLong:所有线程 CAS 同一个变量 → 竞争激烈时自旋浪费 CPU
LongAdder:内部 Cell[] 数组,每个线程 CAS 自己的 Cell → 无竞争
sum() 时才遍历所有 Cell 求和
适用:高并发计数(QPS 计数),不需要实时精确值
不适用:需要 CAS 返回值的场景(如分布式锁)
记忆锚
"CAS 原子指令自旋重试,ABA 用版本号,高并发计数用 LongAdder 分段"
Q6:CompletableFuture 异步编排
TL;DR
CompletableFuture = 异步任务编排器。核心能力:thenApply(转换结果)→ thenCompose(串联异步)→ thenCombine(合并两个结果)→ allOf(等待全部完成)→ exceptionally(异常处理)。底层 ForkJoinPool。
类比
🍳 做早餐:烤面包(异步 1)+ 煎蛋(异步 2)+ 煮咖啡(异步 3)。然后等全部完成(allOf)→ 摆盘上桌。面包烤焦了(异常)→ 重新烤一片(exceptionally)。
常用 API
// 1. 单个异步任务
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
return queryRiskScore(userId); // 耗时 200ms
});
// 2. 链式转换
future.thenApply(score -> "风险等级: " + score); // 不阻塞,异步转换
// 3. 串联异步(thenCompose 解决 thenApply 返回 Future 的嵌套问题)
CompletableFuture<User> user = getUserAsync(userId);
user.thenCompose(u -> getRiskScoreAsync(u)); // 扁平化
// 4. 并行 + 合并
CompletableFuture<Integer> score1 = getScoreAsync("rule");
CompletableFuture<Integer> score2 = getScoreAsync("ml");
score1.thenCombine(score2, (s1, s2) -> s1 + s2); // 等两个都完成→合并
// 5. 等待全部
CompletableFuture.allOf(future1, future2, future3).join();
// 6. 异常处理
future.exceptionally(ex -> {
log.error("风控评分失败", ex);
return 0; // 降级默认值
});选择线程池
// 不传线程池 → ForkJoinPool.commonPool()(默认)
CompletableFuture.supplyAsync(() -> heavyWork());
// ✅ 传自定义线程池(生产推荐)
Executor executor = new ThreadPoolExecutor(10, 20, ...);
CompletableFuture.supplyAsync(() -> heavyWork(), executor);记忆锚
"supplyAsync 异步起,thenApply 转换,thenCombine 合并,allOf 等全部,传自定义线程池"
Q7:ThreadLocal 原理 + 内存泄漏 → 详见 B3 Q16/Q17
精简版:
Thread.threadLocals(ThreadLocalMap)→ key(弱引用) → value(强引用)
线程池复用 → key 被 GC 但 value 永不回收 → 内存泄漏
解决:finally { threadLocal.remove(); }
Q8:JMM + happens-before + volatile → 详见 B3 Q15
精简版:
JMM:主内存 + 工作内存模型,定义线程间可见性规则
volatile:可见性(写后立即可见)+ 有序性(禁止重排序),不保证原子性
happens-before:unlock→lock / volatile写→读 / Thread.start→run
Q9:线程池在可观测性 Agent 中的配置
TL;DR
Agent 线程池特点:不能拖累业务应用。核心原则:corePoolSize 极小(1-2 个)、Queue 有界且偏大、CallerRunsPolicy 拒绝策略防止丢数据。业务线程和 Agent 线程隔离。
配置
ThreadPoolExecutor agentExecutor = new ThreadPoolExecutor(
1, // corePoolSize:只占 1 个线程(最小化资源)
2, // maxPoolSize:最多 2 个
30, TimeUnit.SECONDS, // 30s 空闲回收
new LinkedBlockingQueue<>(10000), // 大队列缓冲(允许积压)
new ThreadFactoryBuilder().setNameFormat("agent-%d").setDaemon(true).build(),
new ThreadPoolExecutor.CallerRunsPolicy() // 满了让业务线程自己发(不丢数据)
);设计要点
1. 线程数极小(不要和业务抢 CPU)
2. Daemon 线程(应用退出时 Agent 自动退出)
3. 大缓冲队列(允许短暂积压但不丢数据)
4. CallerRunsPolicy(队列满了由业务线程执行,确保数据不丢)
5. 隔离:Agent 和业务用不同线程池,Agent 慢不影响业务
记忆锚
"极小核心(1)+大缓冲队列+CallerRuns 不丢数据+Daemon 自动退"
Q10:高吞吐低延迟埋点 SDK 设计
TL;DR
埋点 SDK 核心:无锁数据结构(Disruptor RingBuffer)+ 批量发送(攒 100 条或 100ms 发一次)+ 异步非阻塞(发日志不阻塞业务线程)+ 采样(减少数据量)。Java 用 Disruptor,Go 用 channel pipeline。
类比
🏭 工厂流水线质检:Disruptor RingBuffer = 传送带。业务线程把"质检卡片"放上传送带就回去干活(异步非阻塞)。质检员(Agent 消费线程)从传送带上批量收集卡片,攒够一批就提交。传送带满了 → 卡片掉地上(丢弃/降采样)。
架构
关键设计点
1. 无锁写入:生产端 CAS 抢占 RingBuffer slot(< 100ns)
2. 批量发送:攒够 100 条 或 100ms 发一次(减少网络开销)
3. 异步非阻塞:业务线程写完 RingBuffer 立刻返回
4. 背压处理:RingBuffer 满了 → 丢弃(采样)或限速
5. 采样策略:正常 1% 采样 + 错误 100% 采样
6. 序列化高效:Protobuf(比 JSON 小 5 倍,解析快 10 倍)
与 Go 对比
Java:Disruptor RingBuffer(预分配+无锁CAS+内存屏障),纳秒级写入
Go:buffered channel(天然 ring buffer),或直接用 sync.Pool + atomic
→ Go 实现更简单(channel 内置),Java 调优空间更大(Disruptor 极致)
记忆锚
"RingBuffer 无锁写 + 批量发 + 异步不阻塞 + 采样降量 + Protobuf 序列化"
总结
CHM → JDK8 CAS+synchronized + 多线程协同扩容
AQS → state+CLH 队列+模板方法,并发包之母
线程池 → 核心→队列→最大→拒绝,CallerRuns 保不丢
CAS → 原子自旋 + ABA 用版本号 + LongAdder 分段
CF → supplyAsync 异步 + thenCombine 合并 + 自定义池
Agent → 极小核心+大缓冲+CallerRuns+Daemon
SDK → RingBuffer 无锁 + 批量 + 异步 + 采样 + Protobuf
B13 补充:并发追问(Q11-Q16)
来自
questions.md:Phaser、CAS、线程池规范、任务防丢失。
Q11:Phaser vs CountDownLatch vs CyclicBarrier
| CountDownLatch | CyclicBarrier | Phaser | |
|---|---|---|---|
| 核心 | 一次性倒计时 | 可重置屏障 | 动态注册 + 多阶段 |
| 参与方 | 固定数量 | 固定数量 | 可变(随时增删) |
| 可重用 | ❌ | ✅ | ✅ |
| 阶段 | 单阶段 | 单阶段 | 多阶段 |
// Phaser 例子:3 阶段流水线
Phaser phaser = new Phaser(3); // 3 个 worker
for (int i = 0; i < 3; i++) {
new Thread(() -> {
doPhase1(); phaser.arriveAndAwaitAdvance(); // 等所有人完成阶段1
doPhase2(); phaser.arriveAndAwaitAdvance(); // 等所有人完成阶段2
doPhase3(); phaser.arriveAndAwaitAdvance(); // 等所有人完成阶段3
}).start();
}记忆锚
"Latch 一次性的门,Barrier 可重复的门,Phaser 可动态加人 + 多阶段的门"
Q12:CAS 什么时候用?
✅ 适合 CAS:
- 简单计数器(AtomicInteger/LongAdder)
- 无锁队列(ConcurrentLinkedQueue)
- 状态切换(0→1,一次性状态变更)
- 乐观锁(版本号校验)
❌ 不适合 CAS:
- 复杂多变量同时更新(AtomicReference 只能管一个变量)
- 竞争极激烈(CAS 自旋浪费 CPU → 用 synchronized/LongAdder)
- 长操作(CAS 不适合保护耗时长的临界区 → 用锁)
Q13:阿里线程池应用规范
1. 线程池必须显式创建,禁止用 Executors(newFixed/newCached 无界队列→OOM)
2. 必须自定义 ThreadFactory(给线程起有意义的名字,方便排查)
3. 队列必须有界(LinkedBlockingQueue 要指定容量)
4. 拒绝策略推荐 CallerRunsPolicy(让调用者线程执行,减慢而非丢弃)
5. 线程池不再使用时必须 shutdown(否则 JVM 不退出)
Q14:如何避免线程池任务因服务异常遗失?
// 方案:持久化 + 补偿
// 提交任务前先写入 DB
@Service
public class ReliableTaskService {
public void submitTask(Task task) {
// 1. 先把任务持久化到 DB(状态=PENDING)
taskRepo.save(task);
// 2. 再提交到线程池
executor.submit(() -> {
task.setStatus("RUNNING"); taskRepo.save(task);
try {
doWork(task);
task.setStatus("COMPLETED"); taskRepo.save(task);
} catch (Exception e) {
task.setStatus("FAILED"); taskRepo.save(task);
// 3. 定时任务扫 FAILED 重试
}
});
}
}
// 启动时恢复 PENDING/RUNNING 状态的遗留任务
// 定时任务扫 FAILED 重试 + 告警记忆锚
"任务持久化(DB)+ 启动恢复 + 失败重试,线程池只负责执行不负责可靠性"
Q15:volatile 深入
TL;DR
volatile = 保证可见性(一个线程改了,其他线程立刻看到)+ 有序性(禁止指令重排序)。不保证原子性(i++ 仍需要 CAS 或 synchronized)。
// volatile 保证可见性的原理:
// 写 volatile 变量 → JVM 插入 StoreStore + StoreLoad 屏障 → 强制刷回主内存
// 读 volatile 变量 → JVM 插入 LoadLoad + LoadStore 屏障 → 强制从主内存读
// ✅ volatile 适用
volatile boolean running = true; // 标志位:一个线程改,其他线程看
// ❌ volatile 不适用
volatile int count = 0;
count++; // 三个操作(读-改-写),不是原子的!Q16:synchronized 锁升级回顾 → 详见 B3 Q18
总结
Phaser → 动态参与者 + 多阶段屏障
CAS → 简单计数器/标志位/乐观锁 OK,高竞争/长操作 NO
线程池规范 → 显式创建 + 有界队列 + 命名 + CallerRuns + shutdown
任务防丢失 → DB 持久化 + 启动恢复 + 失败重试
volatile → 可见性+有序性,不保证原子性(i++ 不行)
下一篇:B14 可观测性(18 题)