并发编程高频 20 题详解

2026-11-01

面试最卷的方向之一。每道题按「考察点 → 答案 → 手写代码 / 画图」展开,建议配合 并发编程面试题.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:#e6f7e6

2. 线程的生命周期与状态转换

考察点: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 锁的能力差异。

区别synchronizedReentrantLock
实现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 可见。主要规则:

  1. 程序次序:同一线程内,前面的操作 happens-before 后面的。
  2. 监视器锁:unlock happens-before 后续的 lock。
  3. volatile:写 happens-before 后续的读。
  4. 传递性:A → B,B → C,则 A → C。
  5. 线程 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 读 flag

8. 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。

版本实现锁粒度
JDK7Segment 数组 + 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() 分为三步:

  1. 分配内存空间。
  2. 初始化对象(调用构造器)。
  3. 将 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 年经验总结):

  1. 优先用并发容器和原子类,而不是自己加锁,减少出错。
  2. 线程池必须自定义参数 + 有界队列 + 明确拒绝策略,别用 Executors 快捷方法。
  3. 锁粒度尽量小,能用读写锁就别用独占锁,能用无锁(CAS)就少加锁。
  4. 计数器场景优先 LongAdder。
  5. ThreadLocal 用完 remove,防止内存泄漏。
  6. 避免在锁内做耗时 IO,减少锁持有时间。
  7. 上线前用 jstack/Arthas 检查是否有线程泄漏、死锁、线程池打满。