面试速查:Java 并发一页纸

面试速查:Java 并发一页纸

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


面向岗位:大型加密货币交易所 Senior Backend Developer - Risk 考察目标:Java 多线程与并发是 Senior Backend 面试的必考项,占比通常在 30%-40%。本文档覆盖手写代码、核心原理、场景应用,要求能在白板上 15-20 分钟内写出线程安全的代码,并能说清 JMM、AQS、锁升级等底层原理。


目录

  1. 面试核心速查表
  2. 手写代码精讲(6 大必考场景)
  3. 高频面试题库(Q&A + 易错点)
  4. 面试现场建议
  5. 常见追问应对

1. 面试核心速查表

1.1 JMM 内存模型速查

特性volatilesynchronizedAtomicfinal
可见性✅ 立即可见✅ 解锁前刷回主存✅ 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 条规则

  1. 程序次序规则:同一个线程内,书写在前面的操作 happen-before 后面的
  2. 监视器锁规则:unlock happen-before 后面对同锁的 lock
  3. volatile 规则:volatile 写 happen-before 后面对该变量的读
  4. 线程启动规则:Thread.start() happen-before 线程内所有操作
  5. 线程终止规则:线程内所有操作 happen-before 对该线程的 Thread.join() 返回
  6. 线程中断规则:interrupt() happen-before 检测到中断事件
  7. 对象终结规则:构造函数执行 happen-before finalize()
  8. 传递性规则:A happen-before B,B happen-before C → A happen-before C

2. 手写代码精讲(6 大必考场景)

2.1 手写线程池

题目

实现一个简易线程池,支持 execute(Runnable) 和 shutdown(),使用阻塞队列存放任务。

核心思路

  1. 维护一个任务队列(BlockingQueue)和工作线程集合
  2. 初始化时启动 corePoolSize 个线程,每个线程循环 take() 队列中的任务
  3. execute() 提交任务到队列
  4. 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.");
    }
}

复杂度分析

OperationTimeSpace
executeO(1)O(queue size)
take (worker)O(1)O(queue size)
shutdownO(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,缓冲区满时生产者等待,空时消费者等待。

核心思路

  1. notFull Condition:缓冲区满时,生产者 await()
  2. notEmpty Condition:缓冲区空时,消费者 await()
  3. 用 ReentrantLock 保护 count 和数组索引
  4. 为什么要用两个 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!");
    }
}

复杂度分析

OperationTimeSpace
produceO(1)O(capacity)
consumeO(1)O(capacity)

易错点

  • 必须用 while 而不是 if:await() 被唤醒后,条件可能已经不满足了(虚假唤醒或其他线程抢先),需要重新检查
  • 先修改状态再 signal:保证唤醒的线程看到的状态是正确的
  • signal() vs signalAll():单生产者单消费者用 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
    }
}

复杂度分析

OperationTimeSpace
每轮打印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 问题。

核心思路

  1. AtomicReference<Thread> 表示当前持有锁的线程
  2. lock():CAS 将 null 替换为当前线程,失败则自旋
  3. unlock():CAS 将当前线程替换为 null,只有持有线程才能解锁
  4. 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)");
    }
}

复杂度分析

OperationTimeSpace
lock (无竞争)O(1)O(1)
lock (高竞争)O(自旋次数),最坏无界O(1)
unlockO(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):

  1. 第一次检查(无锁):避免每次调用都加锁
  2. synchronized:保证只有一个线程进入初始化
  3. 第二次检查(加锁内):防止多个线程排队进入后重复初始化
  4. volatile:禁止指令重排序,保证 new 的happens-before 关系

为什么需要 volatile?instance = new Singleton() 实际分三步:

  1. 分配内存
  2. 初始化对象
  3. 引用指向内存地址 没有 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);
    }
}

复杂度分析

OperationTimeSpace
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,超过时间自动清理。

核心思路

  1. 封装 ThreadLocal<Map<K, ValueHolder<V>>>,每个 ValueHolder 包含 value 和过期时间戳
  2. get() 时检查是否过期,过期则清理
  3. 提供 remove() 手动清理
  4. 附带定时清理任务(简化版:每次 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.");
    }
}

复杂度分析

OperationTimeSpace
setO(1)O(keys per thread)
getO(keys) 含清理O(keys per thread)
removeAllO(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 只能保证:

  1. 可见性:一个线程修改后,其他线程立即可见
  2. 有序性:禁止指令重排序

要保证 i++ 的原子性,用 AtomicInteger 或 synchronized。

易错点:

  • 不要说 "volatile 保证线程安全",这是错的。
  • 例外:volatile boolean flag = true; flag = false; 是原子的(boolean 赋值是单条字节码)。

Q2: synchronized 锁升级的具体过程?什么情况下会膨胀为重量级锁?

标准答案:

Java 6 引入锁升级优化,减少无竞争时的锁开销:

  1. 无锁:对象头记录 hashCode
  2. 偏向锁:第一个线程获取时,对象头的 mark word 用 CAS 替换为 Thread ID。之后该线程进入无需 CAS。
  3. 轻量级锁:第二个线程竞争时,偏向锁撤销,线程栈创建 Lock Record,用 CAS 将 mark word 替换为指向 Lock Record 的指针。竞争线程自旋等待。
  4. 重量级锁:自旋超过阈值(默认 10 次或自适应),升级为 monitor,线程进入 EntryList 阻塞。

重量级锁膨胀后不会降级。

易错点:

  • 偏向锁默认延迟 4 秒开启(JVM 启动时有很多单线程操作,没必要偏向)。面试时写测试代码发现无偏向锁,要提到这个参数。
  • hashCode() 被调用后,偏向锁会永久撤销(因为 mark word 没位置同时存 hashCode 和 Thread ID)。

Q3: AQS(AbstractQueuedSynchronizer)的核心设计是什么?

标准答案:

AQS 是 JUC 包的基石,ReentrantLock、CountDownLatch、Semaphore 都基于它。

核心设计:

  1. state(volatile int):表示同步状态。ReentrantLock 中 state=0 表示未锁定,>0 表示重入次数。
  2. FIFO 双向队列(CLH 变体):获取锁失败的线程包装为 Node 入队,排队等待。
  3. CAS 操作:入队、出队、修改 state 都用 CAS 保证原子性。
  4. LockSupport.park/unpark:阻塞/唤醒线程,避免自旋消耗 CPU。
  5. 独占 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 永远不会被清理。

解决办法:

  1. 用完调用 threadLocal.remove()
  2. 在线程池场景下,使用 TransmittableThreadLocal(阿里开源)或手动清理

易错点:

  • 不要说 "弱引用解决了 ThreadLocal 内存泄漏",它只是缓解了 Key 的泄漏,Value 的泄漏还在。
  • ThreadLocalMap 的 expungeStaleEntry 会在 set/get/remove 时清理部分过期 Entry,但不彻底。

Q5: ConcurrentHashMap 1.7 和 1.8 的区别?

标准答案:

维度JDK 1.7JDK 1.8
数据结构Segment[] + HashEntry[](分段锁)Node[] + 链表/红黑树
锁粒度Segment 级别(默认 16 个 Segment)Node 级别(synchronized 或 CAS)
并发度默认 16(Segment 数)理论无限(桶级别)
Hash 冲突链表链表 -> 红黑树(长度 >= 8)
size 计算三次统计,不一致则加锁全表baseCount + CounterCell[](类似 LongAdder)
读取UNSAFE get VolatileUNSAFE get Volatile

JDK 1.8 核心改进:

  1. 取消 Segment,直接用 Node[] 数组,锁粒度降到单个桶
  2. 链表长度 >= 8 且数组长度 >= 64 时转红黑树,查询从 O(n) 降到 O(log n)
  3. put:桶为空用 CAS,桶非空用 synchronized(锁头节点)
  4. 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()  // 或自定义:记录日志 + 丢弃
);

关键原则:

  1. 队列必须有界(ArrayBlockingQueue),LinkedBlockingQueue 默认 Integer.MAX_VALUE 会 OOM
  2. 线程名要自定义,方便问题排查
  3. 监控 activeCount、queueSize、completedTaskCount

易错点:

  • 不要用 Executors.newFixedThreadPool() 和 newCachedThreadPool(),它们的队列要么无界要么允许无限创建线程,生产环境极易 OOM。
  • CallerRunsPolicy 在异步场景(如 @Async)下会变成同步执行,可能阻塞主流程。

Q7: synchronized 和 ReentrantLock 的区别?

标准答案:

维度synchronizedReentrantLock
实现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% 怎么排查?

标准答案:

四步排查法:

  1. 定位进程:top 找到 PID(如 1234)
  2. 定位线程:top -Hp 1234 找到消耗 CPU 最高的线程 TID(如 5678)
  3. 转十六进制:printf "%x\n" 5678 -> 162e
  4. 看堆栈: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等待全部/任意完成

thenCompose vs thenApply:

  • 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)
写 consume3 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:

分场景:

  1. 单 JVM:用 LongAdder(Java 8)。它把计数分散到多个 Cell 上,每个线程操作不同的 Cell,最后 sum() 汇总。比 AtomicLong 的单一 CAS 竞争小得多。
  2. 分布式:用 Redis INCR + 滑动窗口,或每个节点本地用 LongAdder 统计后定时上报到 Redis / StarRocks。
  3. 更高性能:用 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内容
无锁010hashCode + 分代年龄
偏向锁011Thread 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 的链表:

  1. 入队:CAS 更新 tail.next 为新节点,再 CAS 移动 tail
  2. 出队:CAS 移动 head 到 head.next
  3. ABA 问题:用 AtomicStampedReference 或 AtomicMarkableReference 解决(带版本号)

Java 中的 ConcurrentLinkedQueue 就是基于 Michael-Scott 算法。

在 大型加密货币交易所 场景中,Disruptor 的 RingBuffer 是更优的无锁方案:

  • 数组 + 序列号(sequence),生产者 CAS 抢序列号,消费者按序读取
  • 没有链表节点的分配开销,GC 压力极小
  • 适合风控事件的高吞吐低延迟处理

Q4: 线程池中的线程抛出异常后,线程池会怎么处理?

Model Answer:

  1. 如果是 submit() 提交:异常被包装在 Future.get() 中,线程不会死,会继续从队列取任务执行。
  2. 如果是 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 抢一次,抢不到再排队。允许插队。

为什么默认非公平?

  1. 吞吐更高:插队成功时,省去了线程唤醒/阻塞的开销(约 100ms 量级)
  2. CPU 缓存更友好:刚释放锁的线程 CPU 缓存还是热的,新线程立刻获取缓存命中率高
  3. 饥饿可控:虽然有理论饥饿可能,但实际中锁持有时间短的场景下很少出现

什么时候用公平锁? 锁持有时间长、线程数多、要求严格按序执行(如交易撮合的订单队列)。


Q6: Fork/Join 框架的原理?和线程池的区别?

Model Answer:

Fork/Join 是分治任务的专用线程池,核心类 ForkJoinPool + RecursiveTask/RecursiveAction。

核心机制:

  1. 任务窃取(Work Stealing):每个线程有一个双端队列。自己产生的子任务放队尾,从队尾取。空闲线程从其他线程的队头偷任务,减少竞争。
  2. Fork:将大任务拆分为小任务,提交到队列
  3. Join:等待子任务完成,合并结果

与 ThreadPoolExecutor 区别:

维度ThreadPoolExecutorForkJoinPool
任务类型独立任务分治/递归任务
队列外部共享队列每个线程独立双端队列
空闲线程阻塞等待窃取其他线程任务
适用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)**频繁失效,性能暴跌。

解决办法:

  1. Padding:在变量前后填充 7 个 long(56 字节),保证变量独占一个 cache line
    class PaddedLong {
        public long value;
        public long p1, p2, p3, p4, p5, p6, p7; // padding
    }
  2. @Contended(Java 8,需加 -XX:-RestrictContended):
    @Contended
    private volatile long value;
  3. 数组下标错位:LongAdder 的 Cell[] 用 @Contended 注解,且数组大小是 2 的幂,通过 hash 分散到不同 cache line

效果:解决伪共享后,LongAdder 比 AtomicLong 在高并发下快 5-10 倍。


Q8: 如何排查线上死锁?

Model Answer:

发现:应用无响应、部分 API 超时、线程数不下降。

定位:

  1. jstack <pid> 查找 "Found one Java-level deadlock:"
  2. 输出会精确列出:
    • 死锁的线程名
    • 每个线程持有的锁(locked <xxx>)
    • 每个线程等待的锁(waiting to lock <xxx>)
  3. 结合代码找到交叉加锁的顺序

解决:

  1. 统一加锁顺序:所有线程按固定顺序获取锁(如按对象 hashCode 排序)
  2. 超时获取:tryLock(timeout),超时后释放已持有的锁并重试
  3. 无锁化:用 CAS 替代锁

大型加密货币交易所 Risk 场景:风控规则引擎中,两个规则同时更新用户余额和冻结金额,如果加锁顺序不一致会导致死锁。解决方案:按 userId 排序后加锁,或用一个全局的 userId 级 ReentrantLock。


Last Updated: 2026-05-14 Target Position: 大型加密货币交易所 Senior Backend Developer - Risk Study Tip: 手写代码重点背 生产者-消费者 和 DCL 单例(考频最高),原理重点背 AQS + 锁升级 + ThreadLocal 泄漏。面试时主动提 LongAdder、Disruptor、@Contended 等关键词加分。