罗罗编程学习记录
本页内容 展开查看

01.4 阶段 3 并发编程

所属:全栈开发面试题库 / 学习路径 / 01 Java 与 Spring 全栈

本页目录

一、阶段定位

阶段 2 让你知道一个线程有自己的栈、对象在堆上共享。本阶段解决"多个线程同时读写同一份数据时会发生什么、怎么保证正确"。因为从阶段 5 Spring MVC 开始,每个请求就是一个线程,Service 单例被并发调用、缓存被并发读写、数据库连接被并发获取——不掌握并发,写出来的服务在压测下就会出现偶现的金额错、库存超卖、接口超时。

不掌握本阶段会卡在:(1) 用 i++ 在多线程下计数,结果总是少一点,不知道是可见性还是原子性;(2) 线程池参数凭感觉填 new ThreadPoolExecutor(0, Integer.MAX_VALUE, ...),上线后OOM;(3) 用 ConcurrentHashMap 但说不出它怎么保证线程安全;(4) ThreadLocal 在 Tomcat 线程池下出现"上一个请求的数据串到下一个请求";(5) 不知道 Java 21 虚拟线程什么时候能用、什么时候反而更慢。

本阶段原有"卡点"落到现象:(1) 问你 happens-before 是什么,你只能背"可见性、有序性、原子性"三个词,举不出 volatile 怎么保证可见性;(2) 让你配置一个 CPU 密集任务的线程池,你答"CPU 核数"或"越大越好";(3) 让你解释 ConcurrentHashMap 在 Java 7 与 Java 8 的区别,答不上分段锁。出现任一现象,补齐再进 阶段 4 构建、测试与工程化。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能写出一段有可见性/原子性问题的代码并复现 多线程计数复现结果少算
能说清 volatile 能做什么、不能做什么 用它修一个停止标志可见性问题
能解释 synchronized 锁升级过程 能说清偏向/轻量/重量
能正确配置线程池并说清每个参数 给 CPU 与 IO 密集任务分别给参数
能说出 ConcurrentHashMap 的并发手段 对比 Java 7/8 实现
能用 CompletableFuture 编排 3 个依赖调用 写出串行+并行+异常处理
能说清 ThreadLocal 为什么要 remove 解释线程池下的串数据问题

建议学时:

  • 全职:2 周,约 55 小时。JMM 10、锁 15、线程池 12、并发容器 8、CompletableFuture/ThreadLocal/虚拟线程 10。
  • 在职:4–5 周,约 60 小时。

学时分配:JMM 与 volatile 15%、synchronized/锁升级 15%、CAS/AQS 15%、线程池 25%、并发容器 10%、异步编排 10%、ThreadLocal 与虚拟线程 10%。线程池是最高频考点。

三、先修自检

先修项 合格标准 不合格时回到
线程基础 会 Thread.start()、理解 run 与 start 区别 01.2 阶段 1
JVM 内存 知道堆共享、栈私有 01.3 阶段 2
集合基础 知道 HashMap 非线程安全 01.2 阶段 1

四、知识地图

模块 知识点 掌握程度 对应题库章节
JMM 主内存/工作内存、可见性/有序性/原子性、happens-before 能讲清原理 04.1 Java
volatile 可见性、禁止重排、不保证原子性 能讲清原理 04.1 Java
synchronized 对象锁/类锁、锁升级、等待/通知 能讲清原理 04.1 Java
CAS 与原子类 CAS、ABA、AtomicInteger、LongAdder 会用 04.1 Java
AQS state、同步队列、ReentrantLock、Condition 了解 04.1 Java
线程池 7 参数、拒绝策略、线程数依据、动态调参 能讲清原理 09.1 高并发基础
并发容器 ConcurrentHashMap、CopyOnWriteArrayList、BlockingQueue 能讲清原理 04.1 Java
异步编排 CompletableFuture、异常处理、线程切换 会用 04.1 Java
ThreadLocal/虚拟线程 父子线程、remove、Loom 边界 会用 04.1 Java

进度建议:JMM、synchronized、线程池、ConcurrentHashMap 四项必须"能讲清原理"。

五、分模块精讲

5.1 JMM、happens-before 与 volatile

为什么需要它:不理解 JMM,就解释不了"为什么一个线程改了标志位另一个线程看不到""为什么双重检查锁定要加 volatile"。

核心机制:

  • JMM 把内存抽象为主内存与工作内存:线程读写的是自己的工作内存(CPU 缓存/寄存器),何时刷回主内存由 JMM 决定。
  • 三大问题:可见性(一个线程改了另一线程看不到)、原子性(i++ 是读-改-写三步)、有序性(编译器/CPU 重排指令)。
  • happens-before:前一个操作的结果对后一个操作可见。常用规则:程序顺序规则、volatile 写先行于读、锁的解锁先行于加锁、Thread.start() 先行于线程内操作、传递性。
  • volatile:保证可见性与禁止重排(内存屏障),但不保证原子性;适合做状态标志,不适合做计数器。

最小可运行示例:

public class VolatileDemo {
    // 不加 volatile:另一个线程可能永远看不到 running=false
    private static volatile boolean running = true;

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            while (running) { // 没有 volatile 时,可能死循环
                // 业务
            }
            System.out.println("stopped");
        }).start();
        Thread.sleep(1000);
        running = false; // 写 volatile
    }
}

常见坑:

现象 原因 修法
标志位改了线程不停 缺 volatile 可见性 加 volatile
volatile 计数仍不准 volatile 不保证原子性 用 AtomicInteger 或 synchronized
双重检查锁定单例偶发 NPE 对象引用半初始化被重排 实例字段加 volatile

面试考法:必问"volatile 能保证原子性吗""happens-before""双重检查锁定为什么要 volatile"。

5.2 synchronized 与锁升级

为什么需要它:synchronized 是最基础的互斥手段。它的锁升级过程是 Java 6 后优化的重点,也是高频考点。

核心机制:

  • 锁对象:普通方法锁 this(对象锁);静态方法锁 Class 对象(类锁);同步代码块锁括号里的对象。
  • 锁升级(无必须反向):无锁 → 偏向锁(线程 ID 记录在对象头,无竞争时几乎零开销)→ 轻量级锁(CAS 自旋,交替执行)→ 重量级锁(操作系统互斥量,线程阻塞)。Java 15 起偏向锁默认关闭。
  • 同步队列与等待队列:wait/notify 必须在 synchronized 块内;wait 释放锁进入等待队列,notify 唤醒一个到同步队列竞争。
  • 可重入:同一线程可重复进入同一把锁。

最小可运行示例:

public class SyncDemo {
    private int count = 0;
    private final Object lock = new Object();

    public void inc() {
        synchronized (lock) { count++; } // 锁 lock 对象
    }

    public synchronized static void staticMethod() {
        // 锁 SyncDemo.class
    }
}

常见坑:

现象 原因 修法
加了 synchronized 还是并发改坏 锁的对象不是同一个 锁同一个 monitor,注意锁 this vs 锁 Class
IllegalMonitorStateException wait/notify 不在锁内 放进 synchronized 块
死锁 交叉持锁 统一加锁顺序,或用 tryLock 超时

面试考法:问"synchronized 与 Lock 区别""锁升级过程""sleep 与 wait 区别"。要点:synchronized 自动释放、Lock 手动;sleep 不释放锁、wait 释放。

5.3 CAS、原子类与 ABA

为什么需要它:无锁并发的基石。AtomicInteger、LongAdder、AQS、ConcurrentHashMap 都建立在 CAS 上。

核心机制:

  • CAS(Compare And Swap):三个操作数——内存位置 V、预期值 A、新值 B;V==A 时才把 V 改成 B,原子完成。
  • 问题:ABA(值从 A 改成 B 又改回 A,CAS 以为没变);解决用版本号 AtomicStampedReference。
  • AtomicInteger:compareAndSet、incrementAndGet;高并发计数用 LongAdder(分段 Cell,减少热点)。

最小可运行示例:

import java.util.concurrent.atomic.*;

public class CasDemo {
    private static final AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws Exception {
        Thread[] ts = new Thread[10];
        for (int i = 0; i < 10; i++) {
            ts[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) count.incrementAndGet();
            });
            ts[i].start();
        }
        for (Thread t : ts) t.join();
        System.out.println(count.get()); // 10000
    }
}

常见坑:

现象 原因 修法
高并发下 AtomicLong 吞吐低 单节点热点 CAS 换 LongAdder
ABA 导致逻辑错误 只比较值 用 AtomicStampedReference

面试考法:问"CAS 原理""ABA 是什么""LongAdder 为什么快"。

5.4 AQS 与 ReentrantLock

为什么需要它:ReentrantLock、CountDownLatch、Semaphore、ReentrantReadWriteLock 都基于 AQS。理解它才能解释"为什么 Lock 能公平/非公平"。

核心机制:

  • AQS:一个 volatile int state 表示同步状态 + 一个 FIFO 等待队列。子类通过 tryAcquire/tryRelease 定义 state 语义。
  • ReentrantLock:state 表示持有次数;非公平(默认)新线程直接抢,公平按队列顺序。
  • Condition:await/signal 替代 wait/notify,一个锁可有多个等待队列。
  • tryLock(timeout) 可超时,避免死锁。

最小可运行示例:

import java.util.concurrent.locks.*;

public class LockDemo {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notEmpty = lock.newCondition();

    public void take() throws InterruptedException {
        lock.lock();
        try {
            while (empty) notEmpty.await();
            // 取数据
        } finally {
            lock.unlock(); // 必须 finally 释放
        }
    }
}

常见坑:

现象 原因 修法
加锁后异常没释放锁 没放 finally finally 中 unlock
公平锁吞吐低 按队列入队 非公平,除非业务要求

面试考法:问"AQS 原理""ReentrantLock 与 synchronized 区别"。

5.5 线程池

为什么需要它:这是 Java 后端面试出现频率最高的并发题。Spring 的 Tomcat 线程池、@Async 线程池、批量任务线程池,都靠它。配错了要么 OOM,要么吞吐上不去。

核心机制:

  • 7 参数:corePoolSize 核心线程数、maximumPoolSize 最大线程数、keepAliveTime 空闲回收、unit、workQueue 工作队列、threadFactory 线程工厂、handler 拒绝策略。
  • 执行流程:核心线程未满→建核心;满了→入队列;队列满→建到最大;最大也满→拒绝策略。
  • 拒绝策略:AbortPolicy(抛异常,默认)、CallerRunsPolicy(调用者线程跑)、DiscardPolicy(静默丢)、DiscardOldestPolicy(丢最老的)。
  • 线程数依据:CPU 密集 ≈ 核数 + 1;IO 密集 ≈ 核数 * (1 + 等待/计算),公式只是起点,要压测校准。
  • 不要用 Executors.newXXX:Fixed/Single 队列无界会 OOM,Cached 线程数无界会 OOM;用 ThreadPoolExecutor 显式构造。

最小可运行示例:

import java.util.concurrent.*;

public class PoolDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
            4, 8, 60L, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(200),
            r -> { Thread t = new Thread(r, "order-worker"); t.setDaemon(false); return t; },
            new ThreadPoolExecutor.CallerRunsPolicy() // 队列满让调用者跑,形成背压
        );
        for (int i = 0; i < 1000; i++) {
            int id = i;
            pool.submit(() -> System.out.println("处理 " + id + " by " + Thread.currentThread().getName()));
        }
        pool.shutdown();
    }
}

常见坑:

现象 原因 修法
RejectedExecutionException 队列+最大都满 调大队列/最大,或换拒绝策略
内存持续涨 LinkedBlockingQueue 无界 用有界队列
任务被静默丢弃 DiscardPolicy 换 Abort 并打日志
线程名无法排查 默认线程名 pool-1-thread-x 自定义 ThreadFactory 命名

面试考法:必问"7 个参数""执行流程""为什么不用 Executors""CPU/IO 密集线程数怎么定"。

5.6 并发容器

为什么需要它:业务缓存、计数器、观察者列表都要用并发容器。用错容器或用对容器但不懂原理,会在压测时翻车。

核心机制:

  • ConcurrentHashMap:Java 7 分段锁 Segment(默认 16 段,并发度 16);Java 8 改为数组 + CAS + synchronized 锁桶头,粒度更细,并发度更高;不允许 null 键值。
  • CopyOnWriteArrayList:写时复制整个数组,读无锁;适合读多写少(如监听器列表),写少时数据最终一致。
  • BlockingQueue:ArrayBlockingQueue(有界数组)、LinkedBlockingQueue(可选界)、SynchronousQueue(不存储,直接交递,Cached 线程池用)、DelayQueue(延迟获取)。

最小可运行示例:

import java.util.concurrent.*;

public class QueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
        // 生产者
        new Thread(() -> { try { queue.put("order-1"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start();
        // 消费者:take 会阻塞直到有数据
        String item = queue.take();
        System.out.println(item);
    }
}

常见坑:

现象 原因 修法
写多读少时 CopyOnWrite 占用高 每次写复制全数组 换 ConcurrentLinkedQueue
用 HashMap 在并发下死循环(Java 7) 扩容头插法成环 升级 Java 8+ 或换 ConcurrentHashMap
队列无界导致 OOM LinkedBlockingQueue 默认 Integer.MAX_VALUE 设容量

面试考法:问"ConcurrentHashMap 1.7 与 1.8 区别""CopyOnWrite 适用场景""BlockingQueue 实现"。

5.7 CompletableFuture、ThreadLocal 与虚拟线程

为什么需要它:微服务下一个接口要调多个下游,串行等太慢;ThreadLocal 是透传用户上下文的常见手段(但也是泄漏重灾区);Java 21 虚拟线程改变 IO 密集并发的写法。

核心机制:

  • CompletableFuture:supplyAsync 异步、thenApply 串行转换、thenCombine 合并两个、allOf 等全部、exceptionally 异常处理;默认用 ForkJoinPool.commonPool。
  • ThreadLocal:每个线程一个独立副本;线程池复用线程时必须 remove(),否则串数据与泄漏。父子线程传递用 InheritableThreadLocal,跨线程池用 TransmittableThreadLocal。
  • 虚拟线程(Java 21 正式):由 JVM 调度而非 OS,IO 阻塞时不占平台线程;适合 IO 密集、大量阻塞调用;不适合 CPU 密集、synchronized 大块临界区(pin 住载体线程,Java 21 已修复 synchronized pin,仍建议用 ReentrantLock)。

最小可运行示例:

import java.util.concurrent.*;

public class AsyncDemo {
    public static void main(String[] args) throws Exception {
        // 并行调两个接口再合并
        CompletableFuture<String> user = CompletableFuture.supplyAsync(() -> { sleep(100); return "user"; });
        CompletableFuture<String> order = CompletableFuture.supplyAsync(() -> { sleep(200); return "order"; });
        CompletableFuture<String> combined = user.thenCombine(order, (u, o) -> u + "+" + o);
        System.out.println(combined.get()); // 约 200ms,不是 300ms
    }
    static void sleep(long ms) { try { Thread.sleep(ms); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }
}

常见坑:

现象 原因 修法
异步任务用公共池被阻塞任务拖慢 默认 ForkJoinPool 传自定义线程池
请求间用户信息串了 ThreadLocal 没 remove finally 中 remove
虚拟线程吞吐没提升 任务是 CPU 密集或 synchronized pin 换平台线程/ReentrantLock

面试考法:问"CompletableFuture 怎么异常处理""ThreadLocal 泄漏""虚拟线程与平台线程区别、适用边界"。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
复现计数少算 多线程 i++ 与 AtomicInteger 对比 能复现并说原因 1 小时
复现可见性问题 不加 volatile 的停止标志死循环 加 volatile 后正常停止 1 小时
线程池拒绝 满队列触发 CallerRuns 能看到调用者线程执行 1 小时
CompletableFuture 并行 两个异步调用合并 耗时 = max 而非 sum 1 小时
ThreadLocal 串数据 线程池下不 remove 复现串数据,加 remove 修复 1 小时

6.2 改造型

练习 要求 验收标准 预计耗时
把 newFixedThreadPool 改为显式 ThreadPoolExecutor 有界队列+命名工厂 不再无界队列 1 小时
把 synchronized 计数改为 LongAdder 压测对比吞吐 LongAdder 更高 2 小时
给 CompletableFuture 加异常处理 下游抛异常能被 exceptionally 捕获 不吞异常 1 小时
ThreadLocal 改 TTL 跨线程池透传上下文 异步任务能读到 2 小时

6.3 设计型

练习 要求 验收标准 预计耗时
批量导出线程池 分页查库 + 导出,背压 不 OOM、拒绝可观测 4 小时
接口聚合 调 3 个下游并行聚合 总耗时 = 最慢下游,异常可降级 5 小时
延迟任务队列 用 DelayQueue 实现订单超时取消 到期任务被处理 4 小时

七、排障表

现象 可能原因 排查步骤 解决办法
多线程计数偏小 非原子操作 去掉同步复现 换 Atomic/LongAdder
标志位改了线程不停 可见性问题 加 volatile 加 volatile
RejectedExecutionException 队列+最大满 看队列长度与活跃线程 调参/换拒绝策略
线程数暴涨 OOM Cached/newXXX 无界 jstack 数线程 显式 ThreadPoolExecutor
请求间数据串 ThreadLocal 没 remove 看是否在线程池复用 finally remove
死锁 交叉持锁 jstack 找 deadlock 提示 统一加锁顺序
异步任务被公共池拖慢 ForkJoinPool 被阻塞 看线程名 传独立线程池
虚拟线程没提速 CPU 密集/pin 看载体线程 换平台线程

八、出口条件

全部勾选后进入 阶段 4 构建、测试与工程化。

  • [ ] 能复现并解释可见性、原子性两类问题
  • [ ] 能说清 volatile 的边界与锁升级过程
  • [ ] 能讲出线程池 7 参数与执行流程,拒绝 newXXX
  • [ ] 能对比 ConcurrentHashMap 1.7/1.8
  • [ ] 能用 CompletableFuture 写出并行聚合与异常处理
  • [ ] 能解释 ThreadLocal 为什么必须 remove
  • [ ] 能说清虚拟线程的适用边界

自测题:

  1. volatile 能保证原子性吗?为什么?
    • 要点:不能,i++ 是读-改-写三步,volatile 只保证可见与有序。
  2. 线程池执行任务的完整流程?
    • 要点:核心→队列→最大→拒绝。
  3. 为什么不推荐 Executors.newFixedThreadPool?
    • 要点:LinkedBlockingQueue 无界,任务堆积 OOM。
  4. ConcurrentHashMap 在 Java 8 怎么保证线程安全?
    • 要点:CAS + synchronized 锁桶头节点,放弃分段锁。
  5. ThreadLocal 内存泄漏的根因?
    • 要点:Entry key 弱引用被回收,value 强引用,线程池线程不销毁。
  6. 虚拟线程为什么不适合 CPU 密集?
    • 要点:OS 线程仍是稀缺资源,虚拟线程优势在阻塞不占载体。