
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
面向岗位:大型加密货币交易所 Senior Backend Developer - Risk 考察目标:Java 多线程与并发是 Senior Backend 面试的必考项,占比通常在 30%-40%。本文档覆盖手写代码、核心原理、场景应用,要求能在白板上 15-20 分钟内写出线程安全的代码,并能说清 JMM、AQS、锁升级等底层原理。
目录
- 面试核心速查表
- 手写代码精讲(6 大必考场景)
- 2.1 手写线程池
- 2.2 手写生产者-消费者
- 2.3 手写交替打印 ABC
- 2.4 手写 CAS 自旋锁
- 2.5 手写并发安全单例(DCL)
- 2.6 手写带 TTL 的 ThreadLocal 包装器
- 高频面试题库(Q&A + 易错点)
- 面试现场建议
- 常见追问应对
1. 面试核心速查表
1.1 JMM 内存模型速查
| 特性 | volatile | synchronized | Atomic | final |
|---|---|---|---|---|
| 可见性 | ✅ 立即可见 | ✅ 解锁前刷回主存 | ✅ CAS 保证 | ✅ 构造函数不逃逸 |
| 原子性 | ❌ i++ 不保证 | ✅ 代码块原子 | ✅ 单操作原子 | ✅ 引用赋值原子 |
| 有序性 | ✅ 内存屏障 | ✅ 串行化 | ✅ happen-before | ✅ 初始化顺序 |
背诵口诀:volatile 只保证可见性 + 有序性,不保证原子性。
1.2 synchronized 锁升级流程
无锁(对象头 mark word 记录 hashCode)
↓ 第一个线程获取
偏向锁(mark word 记录 Thread ID,CAS 替换)
↓ 第二个线程竞争
轻量级锁(线程栈创建 Lock Record,CAS 替换 mark word 为指针)
↓ CAS 自旋失败(默认 10 次或自适应)
重量级锁(monitor 关联,线程进入 EntryList 阻塞)
关键数字:
- 偏向锁延迟开启:4 秒(
-XX:BiasedLockingStartupDelay=4000) - 轻量级锁自旋次数:默认 10 次(
-XX:PreBlockSpin=10),Java 6+ 自适应自旋 - 锁升级后不可逆(重量级锁不会降级,偏向锁可以批量撤销)
1.3 线程池 7 大参数 + 4 大拒绝策略
public ThreadPoolExecutor(
int corePoolSize, // 核心线程数:即使空闲也保留
int maximumPoolSize, // 最大线程数:队列满后扩容上限
long keepAliveTime, // 非核心线程空闲存活时间
TimeUnit unit, // keepAliveTime 单位
BlockingQueue<Runnable> workQueue, // 任务等待队列
ThreadFactory threadFactory, // 线程创建工厂(建议自定义命名)
RejectedExecutionHandler handler // 拒绝策略
)| 拒绝策略 | 行为 |
|---|---|
AbortPolicy | 默认,抛异常 RejectedExecutionException |
CallerRunsPolicy | 由调用线程(提交任务的线程)自己执行 |
DiscardPolicy | 静默丢弃任务 |
DiscardOldestPolicy | 丢弃队列最老的任务,重试提交 |
易错点:CallerRunsPolicy 不是让线程池自己运行,而是让调用者线程(通常是主线程或 Servlet 线程)执行,这会阻塞调用方,起到负反馈效果。
1.4 AQS 核心结构
AbstractQueuedSynchronizer
├── state (volatile int) —— 资源状态
├── head (Node) —— CLH 变体队列头(虚节点)
├── tail (Node) —— 队列尾
└── exclusiveOwnerThread —— 独占模式:当前持有线程
Node 结构:
├── waitStatus: CANCELLED(1) | SIGNAL(-1) | CONDITION(-2) | PROPAGATE(-3)
├── prev / next —— 双向链表(方便取消时 O(1) 删除)
├── thread —— 等待线程
└── nextWaiter —— 共享/独占模式标识
1.5 Happens-Before 8 条规则
- 程序次序规则:同一个线程内,书写在前面的操作 happen-before 后面的
- 监视器锁规则:
unlockhappen-before 后面对同锁的lock - volatile 规则:
volatile写 happen-before 后面对该变量的读 - 线程启动规则:
Thread.start()happen-before 线程内所有操作 - 线程终止规则:线程内所有操作 happen-before 对该线程的
Thread.join()返回 - 线程中断规则:
interrupt()happen-before 检测到中断事件 - 对象终结规则:构造函数执行 happen-before
finalize() - 传递性规则:A happen-before B,B happen-before C → A happen-before C
2. 手写代码精讲(6 大必考场景)
2.1 手写线程池
题目
实现一个简易线程池,支持 execute(Runnable) 和 shutdown(),使用阻塞队列存放任务。
核心思路
- 维护一个任务队列(
BlockingQueue)和工作线程集合 - 初始化时启动
corePoolSize个线程,每个线程循环take()队列中的任务 execute()提交任务到队列shutdown()发中断信号,等所有线程结束
Java 实现
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
* 简易线程池实现。
* 生产环境请直接用 ThreadPoolExecutor,本实现用于展示原理。
*/
public class SimpleThreadPool {
private final int corePoolSize;
private final BlockingQueue<Runnable> taskQueue;
private final List<Worker> workers;
private volatile boolean isShutdown = false;
public SimpleThreadPool(int corePoolSize) {
this.corePoolSize = corePoolSize;
this.taskQueue = new LinkedBlockingQueue<>();
this.workers = new ArrayList<>();
for (int i = 0; i < corePoolSize; i++) {
Worker worker = new Worker();
workers.add(worker);
worker.start();
}
}
public void execute(Runnable task) {
if (isShutdown) {
throw new IllegalStateException("Thread pool is shutdown");
}
taskQueue.offer(task);
}
public void shutdown() {
isShutdown = true;
for (Worker worker : workers) {
worker.interrupt();
}
}
public void awaitTermination() throws InterruptedException {
for (Worker worker : workers) {
worker.join();
}
}
private class Worker extends Thread {
@Override
public void run() {
while (!isShutdown || !taskQueue.isEmpty()) {
try {
Runnable task = taskQueue.take();
task.run();
} catch (InterruptedException e) {
// 收到中断信号,检查是否 shutdown
if (isShutdown) {
break;
}
}
}
}
}
// ===================== 测试代码 =====================
public static void main(String[] args) throws InterruptedException {
SimpleThreadPool pool = new SimpleThreadPool(3);
for (int i = 0; i < 10; i++) {
final int taskId = i;
pool.execute(() -> {
System.out.println("Task " + taskId + " running on " + Thread.currentThread().getName());
try {
Thread.sleep(100);
} catch (InterruptedException ignored) {}
});
}
Thread.sleep(500);
pool.shutdown();
pool.awaitTermination();
System.out.println("All tasks completed.");
}
}复杂度分析
| Operation | Time | Space |
|---|---|---|
execute | O(1) | O(queue size) |
take (worker) | O(1) | O(queue size) |
shutdown | O(n) n=worker 数 | O(n) |
大型加密货币交易所 / Risk 实际应用
- 风控规则批处理引擎:异步批量执行 Hive/StarRocks 查询的线程池,core=4, max=8,队列用
ArrayBlockingQueue(capacity=100)+CallerRunsPolicy防止雪崩。 - 交易对账任务调度:每日凌晨执行百万级订单对账,线程池处理分页查询结果。
- Kafka 消费线程:自定义 consumer 的线程池模型,每个 partition 分配一个 worker thread。
2.2 手写生产者-消费者
题目
用 ReentrantLock + Condition 实现一个固定容量的缓冲区,支持 produce 和 consume,缓冲区满时生产者等待,空时消费者等待。
核心思路
notFullCondition:缓冲区满时,生产者await()notEmptyCondition:缓冲区空时,消费者await()- 用
ReentrantLock保护count和数组索引 - 为什么要用两个 Condition?因为
Object.wait()只能有一个等待队列,用 Condition 可以精准唤醒对应类型的线程,减少虚假唤醒竞争
Java 实现
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* 生产者-消费者:ReentrantLock + Condition 实现。
* 相比 synchronized + wait/notify,优势是可以精准唤醒(notFull / notEmpty)。
*/
public class BoundedBuffer<T> {
private final Object[] items;
private final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
private int count = 0;
private int putIndex = 0;
private int takeIndex = 0;
public BoundedBuffer(int capacity) {
this.items = new Object[capacity];
}
public void produce(T item) throws InterruptedException {
lock.lock();
try {
while (count == items.length) {
notFull.await(); // 满了,生产者等待
}
items[putIndex] = item;
putIndex = (putIndex + 1) % items.length;
count++;
notEmpty.signal(); // 通知消费者
} finally {
lock.unlock();
}
}
@SuppressWarnings("unchecked")
public T consume() throws InterruptedException {
lock.lock();
try {
while (count == 0) {
notEmpty.await(); // 空了,消费者等待
}
T item = (T) items[takeIndex];
items[takeIndex] = null; // 帮助 GC
takeIndex = (takeIndex + 1) % items.length;
count--;
notFull.signal(); // 通知生产者
return item;
} finally {
lock.unlock();
}
}
// ===================== 测试代码 =====================
public static void main(String[] args) throws InterruptedException {
BoundedBuffer<Integer> buffer = new BoundedBuffer<>(5);
Thread producer = new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
buffer.produce(i);
System.out.println("Produced: " + i);
Thread.sleep(50);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
Thread consumer = new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
Integer item = buffer.consume();
System.out.println("Consumed: " + item);
Thread.sleep(100);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
producer.start();
consumer.start();
producer.join();
consumer.join();
System.out.println("Done!");
}
}复杂度分析
| Operation | Time | Space |
|---|---|---|
produce | O(1) | O(capacity) |
consume | O(1) | O(capacity) |
易错点
- 必须用
while而不是if:await()被唤醒后,条件可能已经不满足了(虚假唤醒或其他线程抢先),需要重新检查 - 先修改状态再
signal:保证唤醒的线程看到的状态是正确的 signal()vssignalAll():单生产者单消费者用signal()即可;多生产者多消费者建议signalAll(),否则可能唤醒同类线程导致死锁
大型加密货币交易所 / Risk 实际应用
- 风控事件队列:交易产生的 risk event(登录异常、大额转账)放入 bounded buffer,消费者线程批量写入 Kafka。
- 制裁名单查询缓冲:OFAC API 查询结果缓冲,生产者 = 查询线程,消费者 = 缓存更新线程。
- 日志异步输出:应用线程生产日志,后台线程消费写入磁盘/ES。
2.3 手写交替打印 ABC
题目
三个线程分别打印 A、B、C,要求按 ABCABC... 的顺序交替打印,共打印 N 轮。
核心思路
用 ReentrantLock + Condition,三个 Condition 分别对应三个线程。线程 A 打印后唤醒 B,B 打印后唤醒 C,C 打印后唤醒 A。
Java 实现
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* 三个线程交替打印 ABC。
* 考察线程通信、Condition 的精准唤醒。
*/
public class AlternateABC {
private final ReentrantLock lock = new ReentrantLock();
private final Condition conditionA = lock.newCondition();
private final Condition conditionB = lock.newCondition();
private final Condition conditionC = lock.newCondition();
private int state = 0; // 0=A, 1=B, 2=C
public void printA(int times) throws InterruptedException {
print("A", 0, 1, conditionA, conditionB, times);
}
public void printB(int times) throws InterruptedException {
print("B", 1, 2, conditionB, conditionC, times);
}
public void printC(int times) throws InterruptedException {
print("C", 2, 0, conditionC, conditionA, times);
}
private void print(String letter, int expectedState, int nextState,
Condition self, Condition next, int times) throws InterruptedException {
lock.lock();
try {
for (int i = 0; i < times; i++) {
while (state != expectedState) {
self.await();
}
System.out.print(letter);
state = nextState;
next.signal();
}
} finally {
lock.unlock();
}
}
// ===================== 测试代码 =====================
public static void main(String[] args) {
AlternateABC printer = new AlternateABC();
int rounds = 5;
Thread tA = new Thread(() -> {
try { printer.printA(rounds); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
});
Thread tB = new Thread(() -> {
try { printer.printB(rounds); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
});
Thread tC = new Thread(() -> {
try { printer.printC(rounds); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
});
tA.start();
tB.start();
tC.start();
try {
tA.join();
tB.join();
tC.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println(); // newline
}
}复杂度分析
| Operation | Time | Space |
|---|---|---|
| 每轮打印 | O(1) | O(1) |
| 总计 N 轮 | O(N) | O(1) |
其他实现方式对比
| 方式 | 代码量 | 适用场景 |
|---|---|---|
Lock + Condition | 中等 | 推荐,精准唤醒,性能最好 |
synchronized + wait/notify | 少 | 基础考察,但只能用一个 wait set |
Semaphore | 少 | 控制并发数量,交替打印也适用 |
AtomicInteger + CAS | 少 | 无锁实现,忙等待,CPU 占用高 |
大型加密货币交易所 / Risk 实际应用
- 三阶段风控流水线:阶段 A(数据采集)-> 阶段 B(规则计算)-> 阶段 C(动作执行),每个阶段一个线程池,通过 BlockingQueue 串联。本题的线程通信原理是理解流水线的基础。
- 数据库 binlog 解析:多线程按表名 hash 分区,但需要保证同一主键的操作顺序,用到类似的顺序控制。
2.4 手写 CAS 自旋锁
题目
用 AtomicReference 实现一个自旋锁(SpinLock),支持 lock() 和 unlock()。要求能处理 ABA 问题。
核心思路
AtomicReference<Thread>表示当前持有锁的线程lock():CAS 将null替换为当前线程,失败则自旋unlock():CAS 将当前线程替换为null,只有持有线程才能解锁- ABA 问题:本场景下 ABA 不影响正确性(因为锁被释放后,下一个线程获得锁,这是预期行为),但可以提及
AtomicStampedReference作为扩展
Java 实现
import java.util.concurrent.atomic.AtomicReference;
/**
* CAS 自旋锁实现。
* 优点:无阻塞,线程不会挂起;缺点:竞争激烈时 CPU 空转。
*/
public class SpinLock {
private final AtomicReference<Thread> owner = new AtomicReference<>();
public void lock() {
Thread current = Thread.currentThread();
// CAS: 如果 owner 是 null,就设为 current,否则自旋
while (!owner.compareAndSet(null, current)) {
// 自旋:可选 Thread.yield() 或 LockSupport.parkNanos() 减少 CPU 消耗
Thread.yield();
}
}
public void unlock() {
Thread current = Thread.currentThread();
// 只有持有锁的线程才能解锁
if (!owner.compareAndSet(current, null)) {
throw new IllegalMonitorStateException("Current thread does not hold the lock");
}
}
public boolean isLocked() {
return owner.get() != null;
}
// ===================== 测试代码 =====================
private int counter = 0;
public static void main(String[] args) throws InterruptedException {
SpinLock lock = new SpinLock();
int[] counter = {0};
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 1000; j++) {
lock.lock();
try {
counter[0]++;
} finally {
lock.unlock();
}
}
});
threads[i].start();
}
for (Thread t : threads) {
t.join();
}
System.out.println("Counter = " + counter[0] + " (expected 10000)");
}
}复杂度分析
| Operation | Time | Space |
|---|---|---|
lock (无竞争) | O(1) | O(1) |
lock (高竞争) | O(自旋次数),最坏无界 | O(1) |
unlock | O(1) | O(1) |
易错点
- ABA 问题:
AtomicReference的 CAS 不感知中间变化。如果owner从 A -> B -> A,CAS 会认为没有变化。在本锁场景下不影响(锁被正确释放再获取),但在栈/队列的 pop/push 场景会导致数据丢失。 - 自旋 vs 阻塞:自旋适合锁持有时间极短(<1ms),否则应使用
ReentrantLock的 park/unpark。
大型加密货币交易所 / Risk 实际应用
- 高并发计数器:风控中的 QPS 统计、在线用户数统计,CAS 自旋比重量级锁快 10 倍以上。
- 交易对账的乐观锁:数据库行锁升级为 CAS 版本号控制,减少 DB 压力。
- Java 8
LongAdder:本质就是分段 CAS,比AtomicLong的单一 CAS 竞争更小。
2.5 手写并发安全单例(DCL)
题目
手写一个线程安全的单例模式,要求懒加载且高性能。
核心思路
双重检查锁定(Double-Checked Locking):
- 第一次检查(无锁):避免每次调用都加锁
synchronized:保证只有一个线程进入初始化- 第二次检查(加锁内):防止多个线程排队进入后重复初始化
volatile:禁止指令重排序,保证new的happens-before 关系
为什么需要
volatile?instance = new Singleton()实际分三步:
- 分配内存
- 初始化对象
- 引用指向内存地址 没有 volatile,步骤 2 和 3 可能重排序。另一个线程可能拿到未完全初始化的对象。
Java 实现
/**
* 双重检查锁定(DCL)单例。
* 面试最高频,必须能手写且讲清 volatile 的必要性。
*/
public class SingletonDCL {
// volatile 禁止指令重排序,保证可见性
private static volatile SingletonDCL instance;
private SingletonDCL() {
// 防止反射攻击
if (instance != null) {
throw new IllegalStateException("Singleton already initialized");
}
}
public static SingletonDCL getInstance() {
// 第一次检查:无锁,快速路径
if (instance == null) {
synchronized (SingletonDCL.class) {
// 第二次检查:加锁内,防止重复初始化
if (instance == null) {
instance = new SingletonDCL();
}
}
}
return instance;
}
// 防止反序列化创建新实例
protected Object readResolve() {
return getInstance();
}
// ===================== 测试代码 =====================
public static void main(String[] args) throws InterruptedException {
final int THREADS = 100;
Thread[] threads = new Thread[THREADS];
SingletonDCL[] results = new SingletonDCL[THREADS];
for (int i = 0; i < THREADS; i++) {
final int idx = i;
threads[i] = new Thread(() -> {
results[idx] = SingletonDCL.getInstance();
});
threads[i].start();
}
for (Thread t : threads) {
t.join();
}
SingletonDCL first = results[0];
boolean allSame = true;
for (SingletonDCL r : results) {
if (r != first) {
allSame = false;
break;
}
}
System.out.println("All instances same? " + allSame);
}
}复杂度分析
| Operation | Time | Space |
|---|---|---|
getInstance (已初始化) | O(1) | O(1) |
getInstance (首次) | O(1) | O(1) |
其他实现方式对比
| 方式 | 线程安全 | 懒加载 | 性能 | 评价 |
|---|---|---|---|---|
饿汉式 static final | ✅ | ❌ | 最好 | 简单场景首选 |
| DCL + volatile | ✅ | ✅ | 好 | 面试标准答案 |
| 静态内部类 | ✅ | ✅ | 好 | 比 DCL 更优雅,无锁 |
Enum | ✅ | ❌ | 最好 | Joshua Bloch 推荐,防反射/序列化 |
静态内部类写法(推荐生产环境):
public class Singleton {
private Singleton() {}
private static class Holder {
static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() { return Holder.INSTANCE; }
}大型加密货币交易所 / Risk 实际应用
- 风控规则引擎实例:规则引擎是重量对象(加载数万条规则),全局单例避免重复初始化。
- Kafka Producer 实例:Producer 线程安全但创建昂贵,通常包装为单例。
- Sanctions API 客户端:连接池包装为单例,避免重复建立 HTTP 连接。
2.6 手写带 TTL 的 ThreadLocal 包装器
题目
ThreadLocal 在风控场景中用于存储请求上下文(如 userId、traceId),但存在内存泄漏风险。实现一个带**过期时间(TTL)**的 ThreadLocal,超过时间自动清理。
核心思路
- 封装
ThreadLocal<Map<K, ValueHolder<V>>>,每个 ValueHolder 包含 value 和过期时间戳 get()时检查是否过期,过期则清理- 提供
remove()手动清理 - 附带定时清理任务(简化版:每次 get 时顺带清理当前线程的过期项)
Java 实现
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
* 带 TTL 的 ThreadLocal 包装器。
* 解决 ThreadLocal 内存泄漏问题,适用于风控请求上下文存储。
*/
public class TtlThreadLocal<T> {
private final long ttlMillis;
private final ThreadLocal<Map<String, ValueHolder<T>>> threadLocal =
ThreadLocal.withInitial(HashMap::new);
public TtlThreadLocal(long ttlMillis) {
this.ttlMillis = ttlMillis;
}
public void set(String key, T value) {
Map<String, ValueHolder<T>> map = threadLocal.get();
map.put(key, new ValueHolder<>(value, System.currentTimeMillis() + ttlMillis));
}
public T get(String key) {
Map<String, ValueHolder<T>> map = threadLocal.get();
cleanExpired(map); // 顺带清理过期项
ValueHolder<T> holder = map.get(key);
if (holder == null || holder.isExpired()) {
map.remove(key);
return null;
}
return holder.value;
}
public void remove(String key) {
Map<String, ValueHolder<T>> map = threadLocal.get();
if (map != null) {
map.remove(key);
}
}
public void removeAll() {
threadLocal.remove(); // 彻底清理当前线程的 map
}
private void cleanExpired(Map<String, ValueHolder<T>> map) {
long now = System.currentTimeMillis();
Iterator<Map.Entry<String, ValueHolder<T>>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, ValueHolder<T>> entry = it.next();
if (entry.getValue().isExpired()) {
it.remove();
}
}
}
private static class ValueHolder<T> {
final T value;
final long expireAt;
ValueHolder(T value, long expireAt) {
this.value = value;
this.expireAt = expireAt;
}
boolean isExpired() {
return System.currentTimeMillis() > expireAt;
}
}
// ===================== 测试代码 =====================
public static void main(String[] args) throws InterruptedException {
TtlThreadLocal<String> context = new TtlThreadLocal<>(100); // 100ms TTL
context.set("userId", "U12345");
context.set("traceId", "T-abc-123");
System.out.println("userId: " + context.get("userId"));
System.out.println("traceId: " + context.get("traceId"));
Thread.sleep(150); // 超过 TTL
System.out.println("After TTL, userId: " + context.get("userId")); // null
System.out.println("After TTL, traceId: " + context.get("traceId")); // null
context.removeAll();
System.out.println("Cleaned up.");
}
}复杂度分析
| Operation | Time | Space |
|---|---|---|
set | O(1) | O(keys per thread) |
get | O(keys) 含清理 | O(keys per thread) |
removeAll | O(1) | O(1) |
易错点
- ThreadLocal 内存泄漏原因:Thread -> ThreadLocalMap -> Entry -> Value,如果 Thread 是线程池中的长期存活线程,且
remove()没被调用,Value 永远不被回收。 - 弱引用设计:JDK 的
ThreadLocalMap中 Key 是WeakReference<ThreadLocal>,但 Value 是强引用。Key 被 GC 后,Value 还存在,直到下一次set/get/remove时才会被清理(expungeStaleEntry)。 - 最佳实践:在
finally块中调用threadLocal.remove(),如 Servlet 的Filter。
大型加密货币交易所 / Risk 实际应用
- 风控请求上下文:
ThreadLocal<RiskContext>存储当前请求的 userId、ip、deviceId、startTime,规则引擎各组件通过 ThreadLocal 获取,请求结束后remove()。 - 链路追踪 Trace ID:MDC / ThreadLocal 传递 traceId,跨线程时(如线程池)需要手动传递或使用
TransmittableThreadLocal。 - 数据库连接上下文:Spring 的
TransactionSynchronizationManager内部用 ThreadLocal 存 Connection。
3. 高频面试题库(Q&A + 易错点)
Q1: volatile 能保证原子性吗?volatile int i = 0; i++; 线程安全吗?
标准答案:
volatile不能保证原子性。i++是三个操作:读 i、加 1、写回。两个线程同时执行,可能都读到 0,都加 1,结果写入 1(期望是 2)。
volatile只能保证:
- 可见性:一个线程修改后,其他线程立即可见
- 有序性:禁止指令重排序
要保证
i++的原子性,用AtomicInteger或synchronized。
易错点:
- 不要说 "volatile 保证线程安全",这是错的。
- 例外:
volatile boolean flag = true; flag = false;是原子的(boolean 赋值是单条字节码)。
Q2: synchronized 锁升级的具体过程?什么情况下会膨胀为重量级锁?
标准答案:
Java 6 引入锁升级优化,减少无竞争时的锁开销:
- 无锁:对象头记录 hashCode
- 偏向锁:第一个线程获取时,对象头的 mark word 用 CAS 替换为 Thread ID。之后该线程进入无需 CAS。
- 轻量级锁:第二个线程竞争时,偏向锁撤销,线程栈创建 Lock Record,用 CAS 将 mark word 替换为指向 Lock Record 的指针。竞争线程自旋等待。
- 重量级锁:自旋超过阈值(默认 10 次或自适应),升级为 monitor,线程进入
EntryList阻塞。重量级锁膨胀后不会降级。
易错点:
- 偏向锁默认延迟 4 秒开启(JVM 启动时有很多单线程操作,没必要偏向)。面试时写测试代码发现无偏向锁,要提到这个参数。
hashCode()被调用后,偏向锁会永久撤销(因为 mark word 没位置同时存 hashCode 和 Thread ID)。
Q3: AQS(AbstractQueuedSynchronizer)的核心设计是什么?
标准答案:
AQS 是 JUC 包的基石,
ReentrantLock、CountDownLatch、Semaphore都基于它。核心设计:
- state(volatile int):表示同步状态。ReentrantLock 中 state=0 表示未锁定,>0 表示重入次数。
- FIFO 双向队列(CLH 变体):获取锁失败的线程包装为 Node 入队,排队等待。
- CAS 操作:入队、出队、修改 state 都用 CAS 保证原子性。
- LockSupport.park/unpark:阻塞/唤醒线程,避免自旋消耗 CPU。
- 独占 vs 共享模式:ReentrantLock 是独占(exclusive),Semaphore/CountDownLatch 是共享(shared)。
易错点:
- AQS 的队列是双向链表,不是单向。因为取消节点时需要 O(1) 修改前后指针。
shouldParkAfterFailedAcquire方法将前驱节点的 waitStatus 设为SIGNAL(-1),保证前驱释放锁时会唤醒后继。
Q4: ThreadLocal 为什么用弱引用(WeakReference)?还会有内存泄漏吗?
标准答案:
ThreadLocalMap的 Key 是WeakReference<ThreadLocal>,Value 是强引用。为什么 Key 用弱引用? 如果 Key 是强引用,即使 ThreadLocal 变量被置为 null,ThreadLocalMap 仍然持有 ThreadLocal 的引用,导致 ThreadLocal 无法被 GC。 用弱引用后,ThreadLocal 外部引用消失时,Key 会被 GC 回收,Entry 变成
(null, Value)。为什么还会内存泄漏? Key 被 GC 后,Entry 变成
(null, Value),但 Value 仍是强引用。如果 Thread 是线程池中的长期线程,这些(null, Value)Entry 永远不会被清理。解决办法:
- 用完调用
threadLocal.remove()- 在线程池场景下,使用
TransmittableThreadLocal(阿里开源)或手动清理
易错点:
- 不要说 "弱引用解决了 ThreadLocal 内存泄漏",它只是缓解了 Key 的泄漏,Value 的泄漏还在。
ThreadLocalMap的expungeStaleEntry会在set/get/remove时清理部分过期 Entry,但不彻底。
Q5: ConcurrentHashMap 1.7 和 1.8 的区别?
标准答案:
| 维度 | JDK 1.7 | JDK 1.8 |
|---|---|---|
| 数据结构 | Segment[] + HashEntry[](分段锁) | Node[] + 链表/红黑树 |
| 锁粒度 | Segment 级别(默认 16 个 Segment) | Node 级别(synchronized 或 CAS) |
| 并发度 | 默认 16(Segment 数) | 理论无限(桶级别) |
| Hash 冲突 | 链表 | 链表 -> 红黑树(长度 >= 8) |
| size 计算 | 三次统计,不一致则加锁全表 | baseCount + CounterCell[](类似 LongAdder) |
| 读取 | UNSAFE get Volatile | UNSAFE get Volatile |
JDK 1.8 核心改进:
- 取消 Segment,直接用
Node[]数组,锁粒度降到单个桶- 链表长度 >= 8 且数组长度 >= 64 时转红黑树,查询从 O(n) 降到 O(log n)
put:桶为空用 CAS,桶非空用synchronized(锁头节点)size:用CounterCell[]分段计数,避免全局竞争
易错点:
- 1.8 的锁不是 CAS,而是 synchronized(锁头节点)。因为 synchronized 在 Java 6+ 优化后,锁头节点的开销极低(偏向锁/轻量级锁)。
- 红黑树阈值是 8,退树阈值是 6(避免频繁树化/退树)。
size()返回的是近似值,不是精确值(因为 CounterCell 的更新不是原子的)。
Q6: 线程池的 CallerRunsPolicy 有什么坑?生产环境怎么配置?
标准答案:
CallerRunsPolicy不是线程池自己运行任务,而是让提交任务的线程(Caller)来执行。坑:如果 Caller 是主线程 / Servlet 线程,执行
CallerRunsPolicy会阻塞调用方,导致请求处理变慢。这起到一种负反馈效果:线程池和队列都满时,系统主动降速。生产环境配置建议(大型加密货币交易所 Risk 场景):
new ThreadPoolExecutor( 4, // corePoolSize: CPU 密集型 = CPU 核心数 8, // maximumPoolSize: IO 密集型可设 2*CPU 60L, TimeUnit.SECONDS, // keepAliveTime new ArrayBlockingQueue<>(100), // 有界队列!防止 OOM new ThreadFactoryBuilder().setNameFormat("risk-pool-%d").build(), new ThreadPoolExecutor.CallerRunsPolicy() // 或自定义:记录日志 + 丢弃 );关键原则:
- 队列必须有界(
ArrayBlockingQueue),LinkedBlockingQueue默认 Integer.MAX_VALUE 会 OOM- 线程名要自定义,方便问题排查
- 监控
activeCount、queueSize、completedTaskCount
易错点:
- 不要用
Executors.newFixedThreadPool()和newCachedThreadPool(),它们的队列要么无界要么允许无限创建线程,生产环境极易 OOM。 CallerRunsPolicy在异步场景(如@Async)下会变成同步执行,可能阻塞主流程。
Q7: synchronized 和 ReentrantLock 的区别?
标准答案:
| 维度 | synchronized | ReentrantLock |
|---|---|---|
| 实现 | JVM 层面(monitor) | API 层面(AQS) |
| 自动释放 | ✅ 代码块结束自动释放 | ❌ 必须手动 unlock() |
| 可中断 | ❌ 不可 | ✅ lockInterruptibly() |
| 超时获取 | ❌ 不可 | ✅ tryLock(timeout) |
| 公平锁 | ❌ 非公平 | ✅ 可选公平/非公平 |
| 条件队列 | 一个(wait/notify) | 多个(Condition) |
| 性能 | Java 6+ 优化后接近 | 略高(API 调用开销) |
| 代码量 | 少 | 多(try-finally) |
选择建议:
- 简单同步场景用
synchronized,代码简洁,JVM 持续优化- 需要中断、超时、公平、多条件时用
ReentrantLock
易错点:
ReentrantLock必须在finally中unlock(),否则死锁。ReentrantLock的lock()不可中断,但lockInterruptibly()可以。ReadWriteLock(读写锁)只有ReentrantReadWriteLock提供,synchronized没有读写分离能力。
Q8: CountDownLatch、CyclicBarrier、Semaphore 的区别?
标准答案:
| 工具类 | 作用 | 场景 |
|---|---|---|
| CountDownLatch | 一个/多个线程等待其他线程完成 | 主线程等待 10 个 worker 完成(不可复用) |
| CyclicBarrier | 多个线程互相等待,到达屏障后一起继续 | 分阶段计算:10 个线程先算部分结果,汇总后再算下一步(可复用) |
| Semaphore | 控制同时访问某资源的线程数量 | 限流:最多 100 个线程同时访问数据库 |
核心区别:
- CountDownLatch:计数器只能减到 0,不可复用
- CyclicBarrier:计数器减到 0 后自动重置,可复用,且支持
barrierAction(到达屏障时执行的回调)- Semaphore:维护许可(permit),acquire 减 1,release 加 1,可动态调整
易错点:
CountDownLatch的countDown()不会阻塞,只是减计数;await()才会阻塞等待。CyclicBarrier如果某个线程中断或超时,会触发BrokenBarrierException,所有等待线程都会收到异常。Semaphore的release()不要求必须先acquire(),可以凭空释放许可(可能导致许可数超过初始值)。
Q9: 线上 CPU 100% 怎么排查?
标准答案:
四步排查法:
- 定位进程:
top找到 PID(如 1234)- 定位线程:
top -Hp 1234找到消耗 CPU 最高的线程 TID(如 5678)- 转十六进制:
printf "%x\n" 5678->162e- 看堆栈:
jstack 1234 | grep -A 30 "162e"常见原因:
- 死循环:while(true) 没有 sleep
- 频繁 GC:
jstat -gcutil 1234 1000看 GC 频率- 正则回溯:
Pattern.compile("(a+)+b")灾难性回溯- 大量线程竞争:锁竞争导致线程频繁上下文切换
大型加密货币交易所 Risk 实战:
- 风控规则引擎的 NFA 正则匹配(如制裁名单模糊匹配)出现灾难性回溯
- Kafka consumer 的 poll loop 中没有 backoff,空转 CPU 100%
易错点:
jstack输出中线程 ID 是十六进制,而top -Hp输出的是十进制,必须转换。jstack需要与 Java 进程同用户,否则报错 "Unable to open socket file"。- 容器环境中,
top -Hp可能看到的是宿主机的 TID,需要用ps -eLo pid,tid,comm,pcpu | grep 1234。
Q10: CompletableFuture 和 Future 的区别?什么时候用 thenCompose?
标准答案:
Future(Java 5)只能被动get()阻塞获取结果,无法链式组合。CompletableFuture(Java 8)支持函数式异步编排:
方法 作用 thenApply对结果做转换(T -> U) thenAccept消费结果,无返回值(T -> void) thenRun不依赖结果,执行 Runnable thenCompose结果作为参数返回新的 CompletableFuture(扁平化,避免嵌套) thenCombine两个 CF 都完成后合并结果 exceptionally异常处理 allOf / anyOf等待全部/任意完成
thenComposevsthenApply:
thenApply(cf -> fetchOrder(cf.getOrderId()))-> 返回CompletableFuture<CompletableFuture<Order>>(嵌套)thenCompose(cf -> fetchOrder(cf.getOrderId()))-> 返回CompletableFuture<Order>(扁平化)
易错点:
CompletableFuture默认用ForkJoinPool.commonPool()(线程数 = CPU 核心数 - 1),IO 密集型任务会阻塞所有线程。应自定义线程池:supplyAsync(() -> ..., customExecutor)exceptionally只能捕获当前阶段的异常,前面阶段的异常不会传播到后面(除非用whenComplete或handle)。
4. 面试现场建议
4.1 并发题思考框架(5 步法)
面试中遇到并发编程题,按以下顺序思考:
Step 1: 识别共享变量 —— 哪些数据会被多个线程读写?
Step 2: 确定竞态条件 —— 哪些操作不是原子的?(读-改-写?检查-执行?)
Step 3: 选择同步机制 —— CAS?synchronized?Lock?并发容器?
Step 4: 考虑性能 —— 锁粒度够小吗?有没有无锁方案?
Step 5: 边界和清理 —— 异常时锁会释放吗?ThreadLocal 会清理吗?线程会泄漏吗?
4.2 手写代码书写顺序建议
15 分钟白板 LRU 式的时间分配(以生产者-消费者为例):
| 阶段 | 时间 | 做什么 |
|---|---|---|
| 理解题意 | 1 min | 确认容量、线程数、是否需要精准唤醒 |
| 设计数据结构 | 2 min | 画类图:Buffer、Lock、两个 Condition、count |
| 写核心逻辑 | 8 min | 先写 produce()(lock -> while await -> put -> signal -> unlock) |
| 写 consume | 3 min | 对称逻辑 |
| 测试走查 | 1 min | 口头走:buf 满时 produce 进 await,consume 后 signal 唤醒 |
4.3 加分项(主动提及)
| 话题 | 一句话表达 |
|---|---|
| 伪共享(False Sharing) | "volatile long 旁边加 7 个 long padding,避免 CPU cache line 竞争,Java 8 用 @Contended" |
| VarHandle | "Java 9 的 VarHandle 比 Unsafe 更安全,也能做 CAS 和内存屏障" |
| Loom 虚拟线程 | "Java 21 的 Virtual Thread 让百万级并发更简单,但 CPU 密集型任务还是用平台线程" |
| Disruptor | "大型加密货币交易所 风控流水线可以用 Disruptor 替代 BlockingQueue,无锁环状缓冲区,延迟低一个数量级" |
| TransmittableThreadLocal | "线程池场景下 TTL 解决 ThreadLocal 跨线程传递问题,阿里的开源方案" |
4.4 避免的坑
- 不要写
if (count == 0) wait():生产者-消费者必须用while,因为wait()被唤醒后条件可能已变 - 不要在
lock()和unlock()之间抛异常不处理:用try-finally保证解锁 - 不要滥用
synchronized(this):锁对象暴露给外部可能被恶意synchronized导致死锁 - 不要在线程池任务里抛未捕获异常:用
Thread.setDefaultUncaughtExceptionHandler或包装 Runnable - 不要混淆
volatile和Atomic:volatile不保证原子性,AtomicInteger才保证
5. 常见追问应对
Q1: 如果让你设计一个高并发的计数器(如风控 QPS 统计),你会怎么设计?
Model Answer:
分场景:
- 单 JVM:用
LongAdder(Java 8)。它把计数分散到多个Cell上,每个线程操作不同的 Cell,最后sum()汇总。比AtomicLong的单一 CAS 竞争小得多。- 分布式:用 Redis
INCR+ 滑动窗口,或每个节点本地用LongAdder统计后定时上报到 Redis / StarRocks。- 更高性能:用 Disruptor 的
Sequence,单个线程写,多个线程读,无锁。大型加密货币交易所 Risk 场景:交易风控的实时 QPS 统计,每节点本地
LongAdder,每 1 秒聚合写入 Redis HyperLogLog 或 StarRocks,既保证实时性又降低 Redis 压力。
Q2: synchronized 在对象头里是怎么存储的?mark word 的结构?
Model Answer:
对象头(Object Header)分两部分:
- Mark Word(32 位 JVM 占 4 字节,64 位占 8 字节):存储 hashCode、GC 年龄、锁状态
- Klass Pointer(32 位 4 字节,64 位开启压缩指针后 4 字节):指向类元数据
64 位 JVM 的 Mark Word 布局(无压缩):
| unused:25 | hashCode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |
锁状态 lock 标记 biased_lock 内容 无锁 01 0 hashCode + 分代年龄 偏向锁 01 1 Thread ID + Epoch + 分代年龄 轻量级锁 00 - 指向栈中 Lock Record 的指针 重量级锁 10 - 指向 Monitor 的指针 GC 标记 11 - 空(GC 时使用) 追问:如果对象已经计算过 hashCode,就不能进入偏向锁(因为 hashCode 占用了偏向锁的 Thread ID 位置)。调用
hashCode()后,偏向锁会永久撤销。
Q3: 如何设计一个无锁队列(Lock-Free Queue)?
Model Answer:
经典实现是 Michael-Scott Queue,基于 CAS 的链表:
- 入队:CAS 更新 tail.next 为新节点,再 CAS 移动 tail
- 出队:CAS 移动 head 到 head.next
- ABA 问题:用
AtomicStampedReference或AtomicMarkableReference解决(带版本号)Java 中的
ConcurrentLinkedQueue就是基于 Michael-Scott 算法。在 大型加密货币交易所 场景中,Disruptor 的 RingBuffer 是更优的无锁方案:
- 数组 + 序列号(sequence),生产者 CAS 抢序列号,消费者按序读取
- 没有链表节点的分配开销,GC 压力极小
- 适合风控事件的高吞吐低延迟处理
Q4: 线程池中的线程抛出异常后,线程池会怎么处理?
Model Answer:
- 如果是
submit()提交:异常被包装在Future.get()中,线程不会死,会继续从队列取任务执行。- 如果是
execute()提交:异常会传播到ThreadPoolExecutor.afterExecute(),默认实现为空。如果没有自定义afterExecute,异常会打印到 stderr,线程会终止,线程池会创建新线程替换(只要当前线程数 < maxPoolSize)。正确做法:
new ThreadPoolExecutor(...) { @Override protected void afterExecute(Runnable r, Throwable t) { super.afterExecute(r, t); if (t != null) { logger.error("Task failed", t); // 记录日志 // 上报监控系统 } } };或者包装 Runnable,在
run()里加try-catch。
Q5: 公平锁和非公平锁的区别?为什么 ReentrantLock 默认是非公平的?
Model Answer:
- 公平锁:线程按请求锁的顺序获取。AQS 的队列是 FIFO,新线程来了先排队,唤醒 head 的后继。
- 非公平锁:新线程来了先 CAS 抢一次,抢不到再排队。允许插队。
为什么默认非公平?
- 吞吐更高:插队成功时,省去了线程唤醒/阻塞的开销(约 100ms 量级)
- CPU 缓存更友好:刚释放锁的线程 CPU 缓存还是热的,新线程立刻获取缓存命中率高
- 饥饿可控:虽然有理论饥饿可能,但实际中锁持有时间短的场景下很少出现
什么时候用公平锁? 锁持有时间长、线程数多、要求严格按序执行(如交易撮合的订单队列)。
Q6: Fork/Join 框架的原理?和线程池的区别?
Model Answer:
Fork/Join 是分治任务的专用线程池,核心类
ForkJoinPool+RecursiveTask/RecursiveAction。核心机制:
- 任务窃取(Work Stealing):每个线程有一个双端队列。自己产生的子任务放队尾,从队尾取。空闲线程从其他线程的队头偷任务,减少竞争。
- Fork:将大任务拆分为小任务,提交到队列
- Join:等待子任务完成,合并结果
与 ThreadPoolExecutor 区别:
维度 ThreadPoolExecutor ForkJoinPool 任务类型 独立任务 分治/递归任务 队列 外部共享队列 每个线程独立双端队列 空闲线程 阻塞等待 窃取其他线程任务 适用 IO 密集型、异步任务 CPU 密集型、大数据计算 大型加密货币交易所 场景:风控规则的并行评估(如 1000 条规则分成 10 组并行计算),用 Fork/Join 比纯线程池更高效。
Q7: 什么是伪共享(False Sharing)?怎么解决?
Model Answer:
伪共享:CPU 缓存以 cache line(通常 64 字节)为单位加载。两个
volatile long变量如果紧挨着(共占 16 字节),会被加载到同一个 cache line。线程 A 修改变量 1,线程 B 修改变量 2,虽然逻辑上不共享,但物理上共享 cache line,导致**缓存一致性协议(MESI)**频繁失效,性能暴跌。解决办法:
- Padding:在变量前后填充 7 个
long(56 字节),保证变量独占一个 cache lineclass PaddedLong { public long value; public long p1, p2, p3, p4, p5, p6, p7; // padding }@Contended(Java 8,需加-XX:-RestrictContended):@Contended private volatile long value;- 数组下标错位:
LongAdder的Cell[]用@Contended注解,且数组大小是 2 的幂,通过 hash 分散到不同 cache line效果:解决伪共享后,
LongAdder比AtomicLong在高并发下快 5-10 倍。
Q8: 如何排查线上死锁?
Model Answer:
发现:应用无响应、部分 API 超时、线程数不下降。
定位:
jstack <pid>查找"Found one Java-level deadlock:"- 输出会精确列出:
- 死锁的线程名
- 每个线程持有的锁(
locked <xxx>)- 每个线程等待的锁(
waiting to lock <xxx>)- 结合代码找到交叉加锁的顺序
解决:
- 统一加锁顺序:所有线程按固定顺序获取锁(如按对象 hashCode 排序)
- 超时获取:
tryLock(timeout),超时后释放已持有的锁并重试- 无锁化:用 CAS 替代锁
大型加密货币交易所 Risk 场景:风控规则引擎中,两个规则同时更新用户余额和冻结金额,如果加锁顺序不一致会导致死锁。解决方案:按
userId排序后加锁,或用一个全局的userId级 ReentrantLock。
Last Updated: 2026-05-14 Target Position: 大型加密货币交易所 Senior Backend Developer - Risk Study Tip: 手写代码重点背 生产者-消费者 和 DCL 单例(考频最高),原理重点背 AQS + 锁升级 + ThreadLocal 泄漏。面试时主动提 LongAdder、Disruptor、@Contended 等关键词加分。