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

通识对照:Java 线程池七参数:常备、排队、扩容与拒绝——再谈快慢路径隔离

面试题集锦: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 = 临时工多久没活就辞退。拒绝策略 = 排队区也满了怎么办。

线程池执行流程

interview java concurrency qa · 图 1
interview java concurrency qa · 图 1 · 点击查看 SVG 原图

四种拒绝策略

策略行为
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 消费线程)从传送带上批量收集卡片,攒够一批就提交。传送带满了 → 卡片掉地上(丢弃/降采样)。

架构

interview java concurrency qa · 图 2
interview java concurrency qa · 图 2 · 点击查看 SVG 原图

关键设计点

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

CountDownLatchCyclicBarrierPhaser
核心一次性倒计时可重置屏障动态注册 + 多阶段
参与方固定数量固定数量可变(随时增删)
可重用❌✅✅
阶段单阶段单阶段多阶段
// 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 题)