Java 并发
本文面向 Java 服务端面试与并发问题分析,覆盖线程与协作、Java 内存模型、原子操作、锁与同步器、并发集合、线程池、异步编排、线程上下文和故障定位。回答问题时,应先说清共享状态、正确性条件和生命周期,再解释实现与性能取舍。
版本范围以 JDK 8、17、21 为主。JMM 和公开 API 契约与 HotSpot 的某一版实现不同;文中涉及对象头、AQS 节点、哈希桶和工作队列时,会标明它们是实现细节。JDK 21 正式引入虚拟线程;JDK 24 对监视器相关的虚拟线程固定问题又有改进,不能把某一版本的限制推广到全部后续版本。示例默认使用标准 JDK API;标为 JDK 21 的代码不能直接用于 JDK 8/17。代码用于说明语义,不代表已在生产环境或特定硬件上验证过性能。
并发基础与线程生命周期
易 · 并发、并行、异步分别描述什么?为什么需要多线程?
| 概念 | 描述的关系 | 示例与边界 |
|---|---|---|
| 并发 | 多个任务的执行时间区间重叠 | 单核也可以通过交替调度实现并发 |
| 并行 | 多个任务在同一时刻实际执行 | 通常需要多个执行核心;任务之间仍可能竞争内存 |
| 异步 | 发起操作与获取完成结果分离 | 提交任务后继续工作,稍后通过回调或 Future 获取结果;不必每个任务创建一个线程 |
多线程可以在一个任务等待 I/O 时执行其他任务,也可以让可拆分的计算使用多个核心。收益受可并行比例、调度、同步、缓存竞争和下游容量限制。创建更多线程不会让单个 CPU 核心执行更多计算,反而可能增加切换与排队。
并发错误不宜简单归因为“CPU 缓存导致可见性、操作系统导致原子性、编译器导致有序性”。这些是理解硬件的切入点;Java 程序应依据 JMM 推导跨线程的合法行为,而不能依赖某台机器的缓存表现。
追问:局部变量一定线程安全吗? 局部变量本身通常在线程私有栈帧中,但它指向的对象可能被其他线程共享。List<?> local = sharedList 不会因为引用是局部变量,就让该集合变成线程私有。
易 · Java 线程有哪些状态?BLOCKED 等于所有阻塞吗?
Thread.State 是 JVM 提供的六种状态,并不是操作系统线程状态的一一映射。
| 状态 | 含义 | 典型触发或退出方式 |
|---|---|---|
| NEW | 已创建,尚未成功启动 | 调用 start() 后离开 |
| RUNNABLE | 可运行或正在运行 | 可能等待 CPU,也可能正在本地调用中等待系统资源 |
| BLOCKED | 等待进入某个 Java 对象监视器 | 竞争 synchronized;其他线程释放监视器后仍需竞争 |
| WAITING | 无指定时限地等待其他动作 | Object.wait()、无超时 join()、LockSupport.park() |
| TIMED_WAITING | 带时间约束的等待 | sleep、带超时 wait/join、parkNanos/parkUntil |
| TERMINATED | run() 正常返回或因未捕获异常结束 | 不能再次启动 |
ReentrantLock 的竞争者通常通过 park 等待,在线程转储中常见 WAITING,而不是 BLOCKED。Socket 读取也可能显示为 RUNNABLE。因此,“RUNNABLE 很多”不能单独证明 CPU 忙,“WAITING 很多”也不必然说明故障。
wait() 被通知后需要重新获得原监视器,竞争期间可能处于 BLOCKED。超时与通知只让线程有资格继续,不能保证立即得到 CPU 或锁。状态查询是瞬时快照,不能用作可靠的线程协调协议。
易 · Runnable、Callable、Thread 和 Executor 是什么关系?
| 类型 | 角色 | 返回值与异常 |
|---|---|---|
Runnable | 无结果的任务描述 | run() 无返回值,不能声明受检异常 |
Callable<V> | 有结果的任务描述 | call() 返回 V,可以声明受检异常 |
Thread | 一次线程执行的载体 | start() 触发新线程执行,run() 直接调用只是在当前线程执行普通方法 |
Executor | 决定任务如何执行的接口 | 甚至可以在调用线程内同步执行;接口本身不承诺一定建线程 |
ExecutorService | 带生命周期和 Future 的执行服务 | 支持提交、关闭、批量等待 |
实现 Runnable 或 Callable 不等于创建线程。通常把任务与执行策略分开,比继承 Thread 更便于复用、测试和控制资源。同一个 Thread 只能成功启动一次;同一个任务对象若被多次提交,其字段可能由多个线程同时访问。
线程的未捕获异常不会沿创建线程时的调用栈自动抛回父线程。要通过 Future.get()、结果队列或明确的回调传递结果与失败。
中 · sleep、yield、join、守护线程各有什么边界?
Thread.sleep休眠的是当前线程,不释放已持有的监视器或显式锁;到期只表示可以重新调度。用 sleep 猜测另一个线程“应该执行完了”不是同步。Thread.yield()只是调度提示,不保证切换、不保证公平,也不具有同步语义。线程优先级同样不能用于实现业务先后关系。target.join()等待目标线程终止;成功确认其终止后,可以看到该线程在终止前的动作。带超时 join 返回时目标可能仍活着,需要继续判断。- 对尚未启动的线程调用 join 不会等待它未来的启动。因此先启动 B、让 B 对尚未启动的 A 调用 join,不能保证 A 先输出。应先
a.start(),再启动等待 A 的 B。 - 平台线程可在启动前设置 daemon。当 JVM 只剩守护线程时,可开始退出;守护线程的 finally 不保证因此执行完。不要把关键数据落盘完全托付给守护线程。
线程池的标准平台线程工厂通常创建非守护线程;ForkJoin 公共池与虚拟线程的生命周期不同。JDK 21 虚拟线程总是守护线程,不能仅靠启动一个虚拟线程让进程持续存活,应由主流程 join 或管理执行服务。
中 · 线程安全有哪些实现思路?如何选择?
线程安全是指:在约定的并发调用条件下,程序仍满足其不变式与 API 契约。先定义“不允许出现什么”,再选机制。
| 思路 | 适合场景 | 主要边界 |
|---|---|---|
| 不共享可变状态 | 不可变对象、消息传递、单线程所有权 | 引用传递后必须明确谁可以修改 |
| 线程封闭 | 局部对象、按线程独立的解析器 | 不能让内部可变对象逃逸给其他线程 |
| 互斥同步 | 多字段不变式、复合更新 | 所有相关访问遵守同一锁协议,避免锁内慢调用 |
| 原子操作 | 单位置状态转换、不可变快照替换 | 不自动保证多步业务原子性;重试有成本 |
| 并发容器与同步工具 | 生产消费、缓存映射、限流和阶段等待 | 单个方法线程安全不等于业务组合线程安全 |
不可变对象需要字段与所引用状态共同不可变,并且正确构造。final List<T> 仅限制引用重新赋值,不能阻止 add。一个线程安全 Map 的 get 后 put 也不自动组成原子操作。
Java 内存模型与安全发布
中 · JMM 解决什么问题?如何区分原子性、可见性和有序性?
JMM 是 Java 对共享内存访问的规范,定义哪些执行结果合法,以及同步动作怎样建立跨线程的可见性与顺序保证。它不是“堆内存布局”,也不是要求每个线程必须有一块与物理缓存一一对应的“工作内存”。
| 性质 | 要回答的问题 | 常见误区 |
|---|---|---|
| 原子性 | 操作是否可能以中间状态被并发观察或插入? | volatile int 的 count++ 仍是读、改、写的组合 |
| 可见性 | 一个线程的写,另一线程何时有依据看到? | 经过一段时间、执行日志或睡眠不能替代同步协议 |
| 有序性 | 哪些操作必须以某种先后关系被观察? | 单线程语义不变,不代表另一线程观察到所有源代码顺序 |
普通引用、int 等单次读写是原子的;long/double 的普通非 volatile 读写在 JLS 中允许拆分,不能把某种常见 JVM 的实现当作跨平台保证。volatile long/double 的单次读写保证原子性。
y = x 包含读 x、写 y 两个动作,不能把整句视为对两个位置的原子事务。x++ 也不是一个不可分割的更新。锁可以保护一个业务临界区,但只有所有参与者遵循锁协议时才成立。
难 · happens-before 是什么?与真实时间先后有何区别?
如果 A happens-before B,A 的相关效果对 B 有规定的可见性与顺序保证。它是偏序关系,不要求所有动作都排成唯一时间线,也不要求底层严格照源代码顺序逐条执行;优化只要不产生规范禁止的可观察结果即可。
常用推导规则如下:
| 规则 | 可以建立的关系 | 必须注意的条件 |
|---|---|---|
| 程序顺序 | 同一线程中,前面的动作 HB 后面的动作 | 不能直接跨线程套用 |
| 监视器 | 同一监视器的解锁 HB 后续加锁 | 锁不同对象不成立 |
| volatile | 对某 volatile 变量的写 HB 后续对它的读 | 不等于其他线程立刻执行到读,也不等于复合操作互斥 |
| 启动 | Thread.start() HB 被启动线程中的动作 | 在 start 之后才进行的父线程写不由这条规则覆盖 |
| 终止 | 线程中的动作 HB 另一线程成功检测到其终止 | 如正常完成的 join;超时返回未必确认终止 |
| 中断 | 调用 interrupt HB 另一线程检测到中断 | 中断是协作信号,不是强制停止 |
| 传递 | A HB B,B HB C,则 A HB C | 安全发布经常依赖它 |
JUC 还在公开契约中给出高层的内存一致性效果:提交任务之前的动作 HB 任务执行;异步计算的动作 HB 通过对应 Future.get() 获取结果后的动作;把对象放入并发集合前的动作 HB 另一线程随后访问或移除该对象的动作。应读具体 API 的契约,不要仅凭“线程安全”四个字推导一切。
例:发布一份普通数据。
final class Publication {
private int answer;
private volatile boolean ready;
void publish() { // 假设只发布一次
answer = 42; // A
ready = true; // B:volatile 写
}
int readOrDefault() {
if (ready) { // C:若读到发布的 true
return answer; // D
}
return -1;
}
}A → B 是程序顺序,B → C 是 volatile 同步,C → D 是程序顺序,通过传递性保证 D 看到已发布的 42。若用普通 boolean,没有这条发布链,即使“发布线程早已运行完”,读线程也没有相同保证。
追问:没有 HB 就一定读到旧值吗? 不是。含数据竞争的程序可能多次恰好给出预期结果,也可能出现规范允许的其他结果;一次运行成功不能证明安全。正确同步的、没有数据竞争的程序可按顺序一致的交错模型理解,而不是逐一猜测 CPU 指令。
中 · volatile 能做什么?为什么不能实现 i++?
volatile 为该字段的访问提供可见性和规定的顺序语义,同时保证该字段单次读写的原子性。它不提供互斥。
两个线程都可能读取 count=0,各算出 1,再各写入 1。两次 volatile 写都合法,结果仍只增加 1。应使用 AtomicInteger.incrementAndGet() 或在同一把锁下执行整个读改写。
典型用途包括独立状态标记和不可变配置快照的整体替换:
final class Config {
final String endpoint;
final int timeoutMillis;
Config(String endpoint, int timeoutMillis) {
this.endpoint = endpoint;
this.timeoutMillis = timeoutMillis;
}
}
final class ConfigStore {
private volatile Config current = new Config("https://example.invalid", 1000);
Config snapshot() {
return current;
}
void replace(Config next) {
current = java.util.Objects.requireNonNull(next);
}
}一次请求先读一次 snapshot,后续使用同一快照,避免两次读到不同配置版本。多个独立 volatile 字段不能保证组合一致:分别更新 endpoint 和 timeout 时,读者可能看到新旧混合的状态。把数组引用声明为 volatile 也不会使数组每个元素自动具有 volatile 语义。
“写操作不依赖旧值”是判断 volatile 是否足够的常用经验,但不是绝对语法限制。即使只有一个写线程,也要检查是否存在多字段不变式和对象后续可变行为。
难 · volatile 的实现一定是“每次读主内存”和“加一条屏障”吗?
这些说法是教学近似,不是实现契约。JVM 编译器结合 CPU 内存模型,选择指令、屏障与优化限制来满足 JMM。某种平台上可以省去的屏障,在另一平台上可能必需;底层可能使用带顺序约束的指令,而不表现为一条独立的 fence。
理解 StoreStore、StoreLoad、LoadLoad、LoadStore 有助于读实现:它们描述哪两类访问不能跨越某个边界发生不允许的重排。但不能据此声称 Java 源代码中每个 volatile 必然生成固定四条屏障。volatile 也不意味着禁用 CPU 缓存,缓存一致性协议仍参与实现。
JDK 9 起 VarHandle 为普通、opaque、acquire/release、volatile 等访问模式及 CAS 提供标准 API。较弱的访问模式适合对内存顺序有完整证明的底层组件,不应为了“更快”随意替换 volatile。release/acquire 的配对约束、volatile 的同步顺序和单纯原子更新不是同一个层次的概念。
难 · 双重检查单例为什么需要 volatile?还有更简单的方案吗?
DCL 的外层无锁读取需要安全发布,volatile 保证读者不会通过这条发布路径看到未完整构造的状态。它不是修复构造函数中 this 逃逸的万能手段。
public final class Singleton {
private static volatile Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
Singleton result = instance;
if (result == null) {
synchronized (Singleton.class) { // 稳定、非空的锁对象
result = instance;
if (result == null) {
result = new Singleton();
instance = result;
}
}
}
return result;
}
}外层检查减少初始化后的加锁,内层检查防止多个初次访问者重复创建,volatile 负责无锁路径的安全发布。不能用尚为 null 的 instance 当锁,也不能写成 synchronized(instance.class)。
若没有额外初始化控制需求,静态内部类利用类初始化保证更简单:
public final class Service {
private Service() {
}
private static class Holder {
static final Service INSTANCE = new Service();
}
public static Service getInstance() {
return Holder.INSTANCE;
}
}枚举也是常用方案,并具有对应的序列化语义。选择还要考虑依赖注入、反射、类加载器边界以及初始化失败后的行为,而不是只背“线程安全单例”的代码形状。
中 · final 的初始化安全性与普通安全发布有什么不同?
构造函数结束时,final 字段具有特殊的初始化安全语义。在对象被正确构造、构造期间没有让 this 逃逸等前提下,另一个线程即使通过存在数据竞争的路径拿到该引用,对 final 字段仍有专门保证;对构造期通过 final 引用可达的初始化状态也有相应规则。它不把任意其他普通字段都变成可见,更不保护之后的修改。
例如 final int[] values 在构造期间填好数组且不逃逸,具有初始化安全意义;构造后并发执行 values[0]++ 仍是数据竞争。不要把 final 规则解释为“字段访问会在未获取对象引用前真实执行”,更适合从规范允许哪些观察结果理解。
安全发布对象的常用方式包括静态初始化、volatile 引用、锁保护、并发容器、线程启动前传递以及通过任务提交与 Future 返回。工程代码仍应采用明确的发布方式,不应主动依赖一个存在数据竞争的引用传播路径。
常见 this 逃逸:在构造函数内启动线程、把自身注册到可被其他线程调用的监听器、调用可覆盖方法导致子类的未初始化状态暴露。final 无法补救这些设计问题。
易 · final、编译期常量、private 方法与不可变类有什么区别?
- final 变量只能按语言规则赋值一次;只有以常量表达式初始化的基本类型或 String 常量变量,才属于编译期常量。例如
final int n = readConfig()不是编译期常量。 - final 实例方法不能被重写,但可以重载;final 类不能被继承,可通过组合与委托扩展使用方式,例如在包装类中保存 String 并调用其方法。这更准确地说是组合,而不必统一称为某种设计模式。
- private 方法对子类不可见,不参与通常的继承重写。子类声明一个同名同参数方法是新的方法,不是覆盖父类 private 方法。“private 隐式 final”只是旧教材的类比,并非需要添加 final 的理由。
- 不可变类还需封装可变成员、按需防御性复制、不暴露可修改内部状态,并在正确构造后发布。仅把类标成 final 并不足够。
中断、等待与线程协作
中 · interrupt 为什么是协作式取消?三个中断 API 有什么差别?
interrupt() 发出中断请求。被请求线程需要在可中断阻塞操作中响应,或者主动检查状态。它不会无条件把任意代码强行停止。
| API | 作用 | 是否清除中断状态 |
|---|---|---|
thread.interrupt() | 请求中断目标线程;具体效果取决于其当前操作 | 不按“读后清除”的方式工作 |
thread.isInterrupted() | 查询目标线程中断状态 | 否 |
Thread.interrupted() | 查询当前线程中断状态 | 是 |
sleep、wait、join、BlockingQueue.take/put、lockInterruptibly 等可抛出 InterruptedException,抛出时通常清除中断状态。LockSupport.park 会因中断返回,不抛这个异常,也不清除标记。进入 synchronized 时的锁竞争不可中断;线程已经持有锁也不会因中断自动释放它。
I/O 不能一概说“都可中断”或“都不可中断”。某些 NIO 可中断通道会关闭通道并抛出对应异常;平台线程的某些传统阻塞 I/O 不会仅靠 interrupt 退出;JDK 21 虚拟线程在相关网络 I/O 上有额外的中断支持。应按具体 API 确认取消、关闭、超时的行为。
中 · 捕获 InterruptedException 后应该怎么做?
有三种常见策略:
- 方法允许声明中断时,向上抛出,让知道任务生命周期的调用者决定。
- Runnable 等不能抛受检异常的边界,执行必要清理,恢复中断状态并结束当前任务。
- 只有明确拥有取消策略的最外层任务,可以把它解释为正常退出并消费信号;理由必须清晰。
import java.util.concurrent.BlockingQueue;
final class QueueWorker implements Runnable {
private final BlockingQueue<Runnable> queue;
QueueWorker(BlockingQueue<Runnable> queue) {
this.queue = queue;
}
@Override
public void run() {
try {
while (!Thread.currentThread().isInterrupted()) {
Runnable job = queue.take();
job.run();
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
// 仅在这里释放本工作线程拥有的资源。
}
}
}这里的 job 仍须自行遵循中断协议;若 job 无限循环且从不检查中断,外层无法及时接管。运行时异常的报告策略也应由任务边界定义,不能悄悄当成中断吞掉。
追问:恢复中断后继续循环执行 take 会怎样? 下一次可中断操作可能马上再次抛异常,导致忙循环。恢复标记通常用于向外传播取消意图,之后应返回或交给上层,而不是无条件重试同一操作。
Thread.stop/suspend/resume 是不安全的历史 API。强制停止可能破坏受锁保护的不变式,挂起时保留锁可能造成永久等待;应改用中断、状态协议和资源关闭。
中 · wait/notify 怎样写才不会丢失条件变化?
正确对象是“受锁保护的条件”,通知只是提示条件可能改变。条件检查、条件修改和通知必须遵循同一监视器协议。
final class OneShotBox<T> {
private T value;
private boolean ready;
synchronized void put(T next) {
if (ready) {
throw new IllegalStateException("already published");
}
value = next;
ready = true;
notifyAll();
}
synchronized T await() throws InterruptedException {
while (!ready) {
wait();
}
return value;
}
}这段协议不要求读线程先 wait:若 put 先执行,后来的读线程检查 ready 后直接返回。真正危险的是把 notify 当作可累计事件,不保存条件状态。
必须使用 while,原因包括虚假唤醒、多个等待者竞争,以及唤醒后条件可能再次被其他线程改变。wait() 释放当前对象的监视器,返回或抛出 InterruptedException 前会重新获得它;不会释放当前线程持有的其他锁。notify/notifyAll 本身不释放监视器,等待者要等通知者退出临界区后再竞争。
notify() 任意选择一个等待者。当不同条件共用一个等待集时,可能唤醒无法推进的线程;notifyAll() 配合条件循环更容易保证正确性,但也可能增加竞争。若需多个独立等待集,可考虑 Condition。
中 · Condition 如何支持多个条件?signal 是否把锁交给等待者?
Condition 通常与一把 ReentrantLock 关联,每个 Condition 有独立的等待队列。典型有界缓冲区分别用 notEmpty 和 notFull,避免把生产者和消费者混在一个等待集中。
调用常见的 AQS Condition 的 await() 时,当前线程必须持有对应独占锁;它进入条件队列并完全释放这把锁,返回前再恢复先前的重入持有状态。signal() 把候选等待者转移到同步获取流程,不直接交出锁,也不意味着其等待条件必然已经满足。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
final class IntSlot {
private final ReentrantLock lock = new ReentrantLock();
private final Condition notEmpty = lock.newCondition();
private final Condition notFull = lock.newCondition();
private int value;
private boolean full;
void put(int next) throws InterruptedException {
lock.lockInterruptibly();
try {
while (full) {
notFull.await();
}
value = next;
full = true;
notEmpty.signal();
} finally {
lock.unlock();
}
}
int take() throws InterruptedException {
lock.lockInterruptibly();
try {
while (!full) {
notEmpty.await();
}
int result = value;
full = false;
notFull.signal();
return result;
} finally {
lock.unlock();
}
}
}该例展示一个槽位的协议,工程中一般直接用 BlockingQueue。超时等待要计算总剩余时间并循环,不能每次虚假唤醒后重新给完整超时,从而突破调用者的总时间预算。
难 · park/unpark 与 wait/notify 有何不同?为什么仍需要条件循环?
LockSupport 为每个线程维护至多一个许可。unpark 先发生时,可以让随后一次 park 消费许可直接返回;多次 unpark 不会累计多个许可。它不要求调用者持有某个监视器,也不会释放当前线程持有的锁。
park 可以因许可、中断或虚假唤醒返回;parkNanos/parkUntil 还可以因时间条件返回。返回不代表业务条件已经成立,因此典型协议是“检查条件 → park → 再检查条件”。条件本身仍需 volatile、原子类或其他同步协议保证可见性,不能把 park 单独当作数据发布机制。
import java.util.concurrent.locks.LockSupport;
final class OneShotGate {
private volatile boolean open;
private volatile Thread waiter; // 此例仅支持一个等待者
void await() throws InterruptedException {
waiter = Thread.currentThread();
try {
while (!open) {
if (Thread.interrupted()) {
throw new InterruptedException();
}
LockSupport.park(this);
}
} finally {
waiter = null;
}
}
void open() {
open = true;
LockSupport.unpark(waiter); // 对 null 调用无效果
}
}若 open 在 waiter 注册前发生,等待者通过检查 open 跳过 park;若 open 在检查后、park 前发生,许可覆盖该窗口。此例演示协议,实际一次性门闩应使用 CountDownLatch。手写底层组件还要考虑类初始化和其他 park 消费许可等因素。
park(blocker) 中的 blocker 用于诊断,getBlocker() 是快照,不能用于同步决策。unpark 不保证目标立即运行,也不保证下一条业务语句先于其他线程执行。
| 方法 | 是否需要持锁 | 等待期间释放什么锁 | 中断响应 |
|---|---|---|---|
sleep | 否 | 不释放锁 | 抛 InterruptedException,清除标记 |
Object.wait | 当前对象监视器 | 该监视器 | 抛 InterruptedException,重新持锁后返回异常 |
Condition.await | 通常为关联独占锁 | 该关联锁 | 常用实现支持抛 InterruptedException |
LockSupport.park | 否 | 不释放锁 | 返回并保留中断标记 |
synchronized、显式锁与 AQS
中 · synchronized 锁住什么?字节码如何表达?
| 写法 | 对应的监视器 |
|---|---|
synchronized void f() | 当前实例 this |
static synchronized void f() | 声明该方法的 Class 对象 |
synchronized (lock) | 表达式求值得到的对象 |
实例同步方法与静态同步方法通常不是同一把锁;两个不同实例的同步方法也不互斥。“对象锁、方法锁、类锁”是使用层面的简称,并不是三套互不相干的底层机制。
同步代码块通常以 monitorenter/monitorexit 表达,编译器生成异常路径以确保退出监视器。同步方法以 ACC_SYNCHRONIZED 标记表达,由 JVM 在调用和退出时处理,不要求方法字节码内显式出现这两个指令。
synchronized 支持重入:同一线程再次获取同一监视器可以继续执行,退出时与进入层数匹配,最后一次退出才真正释放。先退出一个代码块、再调用同锁方法不是重入示例;在尚未释放时再次进入才是。
正常退出与异常退出都会释放对应监视器,但数据可能已经部分更新,所以异常安全仍要设计。自动释放锁不等于不会死锁;线程也可能在持锁期间等待另一个锁形成环路。
中 · synchronized 与 ReentrantLock 如何选?
| 维度 | synchronized | ReentrantLock |
|---|---|---|
| 释放方式 | 语言结构自动释放 | 必须在 finally 中解锁 |
| 重入 | 支持 | 支持,获取与释放次数匹配 |
| 竞争中断 | 获取监视器不响应中断退出 | lockInterruptibly()、带超时 tryLock 支持 |
| 尝试与超时 | 无对应语法 | tryLock()、带超时 tryLock |
| 公平选项 | 不承诺 FIFO 公平 | 构造时可选公平,默认非公平 |
| 等待条件 | 一个监视器等待集 | 可创建多个 Condition |
| 适合场景 | 词法范围清晰、普通互斥 | 需要定时获取、可取消获取或多个条件队列 |
lock() 本身也不是可中断获取方式。“Lock 能中断持锁线程”不准确:可中断的是等待获取锁的调用,持锁线程仍必须协作取消。Lock 是接口,不保证所有实现都可重入、公平或支持 Condition。
java.util.concurrent.locks.ReentrantLock lock =
new java.util.concurrent.locks.ReentrantLock();
if (lock.tryLock(200, java.util.concurrent.TimeUnit.MILLISECONDS)) {
try {
// 只在成功获取锁后访问受保护状态。
} finally {
lock.unlock();
}
} else {
// 明确处理本次超时,例如把失败返回给调用者。
}这段代码所在方法需传播或处理 InterruptedException。不能在 tryLock 失败后执行 unlock,也不要把不可中断的 lock 放进一个 finally 无条件解锁的宽泛结构中。
性能没有“少量同步用 synchronized,大量同步必用 Lock”的固定分界。临界区长度、竞争程度、吞吐与尾延迟、硬件、JDK 版本都影响结果,应先按语义选择,再针对真实负载测量。
难 · HotSpot 的锁优化有哪些?为什么不能再背固定升级路线?
传统材料常介绍偏向、轻量级、重量级及自旋,但这些是特定年代 HotSpot 的实现,不是 Java 语言规定的固定状态机。
| 技术 | 目标与机制 | 边界 |
|---|---|---|
| 锁消除 | 编译器证明对象不逃逸等情况下消除不必要同步 | 不是程序员可依赖的语义,不保证每次都发生 |
| 锁粗化 | 合并邻近同步区域,减少反复获取释放 | 扩大临界区也可能减少并行度 |
| 自旋 | 短暂等待锁,避免立即挂起的开销 | 占用 CPU;持锁者长期阻塞时不适合持续自旋 |
| 轻量级路径 | 在无竞争或低竞争时减少昂贵操作 | 具体对象头与栈记录设计随版本演变 |
| 监视器膨胀 | 为竞争、等待等情况提供监视器管理 | 不等于每次进入 synchronized 都切换内核态 |
偏向锁在 JDK 15 起默认禁用并被废弃相关选项,JDK 17 不应按“默认开启偏向锁”解释。后续版本的轻量级锁实现继续变化,不能把 JDK 8 对象头位图原样当作 JDK 21+ 的统一事实。
逃逸分析可支持标量替换等优化,不能直接断言 HotSpot 会把所有不逃逸对象“分配到栈上”。优化的首要前提仍是正确程序;不能拿锁消除解释业务数据竞争。
难 · AQS 的职责是什么?所有 JUC 工具都基于 AQS 吗?
AbstractQueuedSynchronizer 是构建同步器的模板框架:管理一个 volatile int 同步状态、获取失败后的等待队列、挂起唤醒、取消与超时等。子类定义“何时允许获取”和“释放意味着什么”。AbstractQueuedLongSynchronizer 提供类似的 long 状态版本;AbstractOwnableSynchronizer 提供独占持有者信息,信息本身不会自动实现互斥。
核心扩展点如下:
| 方法 | 子类负责解释的含义 |
|---|---|
tryAcquire / tryRelease | 独占获取、释放;释放返回值表示是否可以推进等待者 |
tryAcquireShared | 负数为失败,非负为成功,正值表示后继共享获取可能成功 |
tryReleaseShared | 共享释放是否需要推进等待者 |
isHeldExclusively | 当前线程是否独占持有,支持条件等检查 |
AQS 同步队列是受 CLH 思路启发的 FIFO 等待队列,但不能等同于经典纯自旋 CLH 锁。等待线程主要可被 park,队列还要处理取消、中断和超时。JDK 8 与后续版本的节点状态字段和流程有变化,面试应先说明协议,再按指定版本展开源码。
获取流程可概括为:尝试获取 → 失败则排队 → 在适当时机重试或挂起 → 被唤醒后再次尝试。释放使状态变化并推动后继执行;被唤醒不等于已经得到资源。
ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch 使用 AQS。CyclicBarrier 使用 ReentrantLock 与 Condition 协调;JDK 8/17/21 的 FutureTask、SynchronousQueue、Phaser 不能笼统归为“直接继承 AQS 实现”。Condition 队列也不是每个 AQS 同步器必有:CountDownLatch 和 Semaphore 不需要它。
难 · ReentrantLock 的重入、公平和非公平分别如何实现?
ReentrantLock 内部组合一个继承 AQS 的同步器;并不是 ReentrantLock 本身必须继承 AQS。典型实现中 state 表示重入次数:
- state 为 0 时竞争获取,并记录独占持有线程。
- 若当前线程已是持有者,可增加计数;其他线程不能通过该路径。
- unlock 由持有者递减计数,减到 0 时清理持有者并释放,其他等待者才有机会获取。
非公平模式允许新到线程在某些路径直接尝试抢占,提高吞吐但可能增加某些等待者的延迟。公平模式在一般获取路径检查是否存在排在前面的等待者,尽量按等待顺序授予;这不等于操作系统调度公平,也不保证绝对无饥饿。
即使公平 ReentrantLock,无参 tryLock() 也允许插队;带超时 tryLock 则遵守该锁的公平设置。重入不需要排在自己的等待者之后。不能用单次 isLocked() 快照判断“下一步我一定能获取”。
中 · ReentrantReadWriteLock 的状态与升降级如何理解?
读写锁允许多个读者并发,写者排他。写线程可重入写锁,也可以在持有写锁时获取读锁。读操作必须确实不修改共享结构;在“读锁”下惰性初始化缓存、更新统计或修改访问顺序,仍可能破坏状态。
在 JDK 8/17/21 的经典实现中,AQS int state 的高 16 位表示读持有总数,低 16 位表示写重入数,对应计数上限为 65535。每线程读持有次数还通过首读者优化和线程本地计数等机制记录。这个数量是实现约束,不是选择线程规模的目标,也不能无条件外推所有后续 JDK。
- 降级:持写锁 → 获取读锁 → 释放写锁 → 继续持读锁。这样从写完到读阶段不会出现没有保护的窗口。
- 升级:持读锁时直接等待写锁不受支持。即使只有当前读者,也可能一直无法满足写锁获取条件;多个读者都升级更会互相等待。
- 需要读后写时,先释放读锁,再获取写锁,随后重新验证条件,因为中间其他线程可能改变状态。
读写锁只有读多、临界区有一定工作量且竞争模式合适时才可能有收益;读锁计数与缓存一致性也有成本。写锁支持 Condition,读锁不支持创建 Condition。
难 · StampedLock 的乐观读如何保证正确?
JDK 8 引入的 StampedLock 提供写锁、读锁和乐观读票据,不具有 ReentrantLock 那样的可重入语义。乐观读不排斥写者;必须先读到局部变量,再验证 stamp,失败后退回真正读锁。
import java.util.concurrent.locks.StampedLock;
final class Point {
private final StampedLock lock = new StampedLock();
private double x;
private double y;
void move(double dx, double dy) {
long stamp = lock.writeLock();
try {
x += dx;
y += dy;
} finally {
lock.unlockWrite(stamp);
}
}
double distance() {
long stamp = lock.tryOptimisticRead();
double localX = x;
double localY = y;
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
localX = x;
localY = y;
} finally {
lock.unlockRead(stamp);
}
}
return Math.hypot(localX, localY);
}
}validate 成功后应使用已经读入的局部值,而不是重新无锁读取字段。复杂对象图在乐观读期间可能不一致,甚至在 validate 前就触发异常;不能仅在最后补一个 validate 就认定任意遍历安全。读锁转换为写锁可以通过 tryConvertToWriteLock 尝试,失败时仍需正确释放已有票据并重新获取、重新检查条件。
CAS、原子类与非阻塞算法
中 · CAS 提供什么保证?AtomicInteger 如何使用?
CAS 比较当前位置是否等于预期值,匹配才原子地写入新值,并报告成功或失败。比较与更新是不可分割的,但“读取旧值、计算、CAS 重试”的整个循环并不是一次不可被其他线程插入的操作。
import java.util.concurrent.atomic.AtomicInteger;
final class Quota {
private final AtomicInteger remaining;
Quota(int initial) {
if (initial < 0) {
throw new IllegalArgumentException("negative quota");
}
remaining = new AtomicInteger(initial);
}
boolean tryTake() {
for (;;) {
int old = remaining.get();
if (old == 0) {
return false;
}
if (remaining.compareAndSet(old, old - 1)) {
return true;
}
}
}
}成功 CAS 是这里扣减的线性化点。incrementAndGet() 返回更新后的值,getAndIncrement() 返回旧值,不能在示例替换时忽略区别。AtomicInteger 依赖具有相应内存语义的访问与原子指令;JDK 不同版本可能通过 Unsafe、VarHandle 或 intrinsic 路径实现,不应将公开 API 固定等同于某个私有字段布局。
追问:updateAndGet 的函数可以发消息吗? 不应如此。竞争导致函数可能重复执行,应尽量使用无副作用函数。先发消息、再 CAS 失败重试,可能产生多次外部副作用。
难 · CAS 有哪些局限?什么是 lock-free 和 wait-free?
- 竞争激烈时多次重试会消耗 CPU,并造成缓存行反复争用。退避或
Thread.onSpinWait()等提示只能影响等待成本,不能自动修复算法正确性。 - 单个位置的原子更新不自动保护多字段不变式。可将完整不可变状态放入 AtomicReference 整体替换,或者使用锁;若对象内部仍并发可变,原子引用也无能为力。
- CAS 比较值,不记录完整历史,因此可能有 ABA。
- 原子操作本身不等于整段算法无锁。算法中若另有阻塞、无限等待或外部调用,其整体进展保证需单独分析。
lock-free 通常指系统整体持续有操作取得进展,不保证某个线程不会饿死;wait-free 要求每个操作在有界步骤内完成,是更强的保证。锁保护的临界区与 CAS 循环都可能在某些负载下更快,不能说“乐观一定比悲观高效”。
难 · ABA 为什么可能造成错误?AtomicStampedReference 会自动加版本吗?
假设线程 T1 读取链式结构头节点 A 及其后继 B,准备把头从 A 改为 B。T2 把 A 移除、改变链,再把同一个 A 放回。T1 的 CAS 仍可能看到头为 A,但旧的后继假设已经失效。Java GC 防止普通对象引用悬空,不会自动排除同一对象被重新挂回的逻辑 ABA。
AtomicStampedReference 将引用与 int stamp 作为一个原子状态比较。stamp 由调用者维护,不会自动递增。获取时要读取一致的一对值:
import java.util.concurrent.atomic.AtomicStampedReference;
final class VersionedValue<T> {
private final AtomicStampedReference<T> state;
VersionedValue(T initial) {
state = new AtomicStampedReference<>(initial, 0);
}
boolean replace(T expected, T next) {
int[] stamp = new int[1];
T current = state.get(stamp);
if (current != expected) {
return false;
}
return state.compareAndSet(current, next, stamp[0], stamp[0] + 1);
}
}如果并发更新在读取 stamp 后发生,只要每次更新遵守版本协议,本次 CAS 就会失败。若分别调用 getReference() 和 getStamp(),中间可能已有更新,得到的不是同一快照。版本计数会溢出;有严格历史要求时需评估环回窗口,不能只说“加版本号就永久解决”。
AtomicMarkableReference 维护一个布尔标记,适合逻辑删除等状态,不能替代通用的递增版本。纯计数场景中从 A 到 B 再到 A 往往不影响业务;ABA 只有在算法依赖“期间从未改变”时才构成问题。
中 · 原子类有哪些类别?LongAdder 可以替代 AtomicLong 吗?
| 类别 | 代表 API | 语义与场景 |
|---|---|---|
| 基本值 | AtomicBoolean、AtomicInteger、AtomicLong | 单个状态、序号、CAS 更新 |
| 引用 | AtomicReference | 不可变状态快照原子替换,比较引用身份而非 equals |
| 数组元素 | AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray | 每个元素的原子访问,不是整个数组的事务 |
| 字段更新器 | AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater | 在访问限制内更新指定 volatile 字段,减少每个对象单独包装的需要 |
| 引用与标记 | AtomicStampedReference、AtomicMarkableReference | 版本或逻辑标记与引用共同更新 |
| 分散计数 | LongAdder、DoubleAdder、LongAccumulator 等 | 降低高竞争统计更新的热点 |
不存在标准的 AtomicStampedFieldUpdater。字段更新器有类型、volatile 和可访问性要求;若同一个字段还通过不遵守协议的普通复合操作修改,就会破坏业务原子性。JDK 9+ 的 VarHandle 是可考虑的标准底层访问工具。
LongAdder 通过分散更新到不同计数单元降低热点竞争,读取时汇总。sum() 不是与所有并发更新构成单个原子快照,sumThenReset() 也不适合与并发更新一起当成严格结算事务。适合请求量统计,不适合要求精确比较并扣减的库存、唯一序号或账户余额;这些通常需要 AtomicLong、锁或数据库事务。
中 · Unsafe 与伪共享需要了解到什么程度?
Unsafe 是历史上 JDK 内部广泛使用的低层接口,涉及对象字段与数组访问、原子操作、线程停驻、直接内存等。它绕过部分语言安全约束,属于非标准接口;模块封装与后续演进会限制或替代部分用法。业务代码应优先选择 JUC、VarHandle 和所需版本支持的标准内存 API,而不是反射获取 Unsafe。
伪共享指不同线程更新逻辑独立的变量,但变量位于同一缓存一致性单元,导致缓存行争用。它影响性能,不会凭空提供业务原子性,也不能通过“互不共享同一个 Java 变量”完全排除。常见缓存行大小为 64 字节,但不是 Java 规范常量。
LongAdder 的布局、JDK 内部 @Contended 等可以减少某些热点;注解的使用限制与 JVM 参数有关,不能在业务类上随便标注就保证生效。先从热点数据和并行访问模式证明瓶颈,再考虑填充布局,避免为没有依据的猜测牺牲大量内存。
并发集合与队列
易 · JUC 提供哪些工具?如何避免把类名当作答案?
| 需求 | 常用工具 | 首先确认的问题 |
|---|---|---|
| 单位置原子状态 | atomic 包、VarHandle | 是否涉及复合不变式或 ABA? |
| 排他或读写访问 | ReentrantLock、读写锁、StampedLock | 是否要可中断获取、条件队列或重入? |
| 等待任务完成与阶段协调 | CountDownLatch、CyclicBarrier、Phaser | 是一次性事件还是可重复阶段? |
| 限制同时访问数量 | Semaphore | 许可与真正资源的关系是什么? |
| 并发映射、列表与集合 | ConcurrentHashMap、COW、SkipList | 是否需要顺序、快照、复合操作? |
| 任务交接与背压 | BlockingQueue、TransferQueue | 容量、超时与关闭协议是什么? |
| 执行与结果管理 | ExecutorService、Future、CompletableFuture | 谁拥有执行器、谁处理失败和取消? |
这些类别是使用视角,不是完整继承关系图。选择类时必须说出容量、等待、原子操作和生命周期契约。
中 · Hashtable、同步包装与 ConcurrentHashMap 有什么区别?
Hashtable 的许多方法在整个对象上同步,不允许 null 键值。Collections.synchronizedMap 使用统一互斥机制保护单次调用;遍历时通常还需按照包装类文档在包装对象上同步。它们并非已被语言“废除”,在低并发或需要统一外部锁协议时仍有用途。
ConcurrentHashMap 的读取一般无需获取全表互斥锁,更新尽量局部协调,并提供 putIfAbsent/compute/merge 等复合操作。不支持 null 键值,使“查不到”的 null 具有明确含义。
线程安全方法之间的组合仍需设计:
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.LongAdder;
final class FrequencyTable {
private final ConcurrentHashMap<String, LongAdder> counts =
new ConcurrentHashMap<>();
void record(String key) {
counts.computeIfAbsent(key, ignored -> new LongAdder()).increment();
}
long approximateCount(String key) {
LongAdder value = counts.get(key);
return value == null ? 0L : value.sum();
}
}这里假设不并发移除或替换已有计数器;若同时删除 key,已经取得旧 LongAdder 的线程仍可能更新已脱离 Map 的对象。计数是统计语义,不是精确结算。computeIfAbsent 的函数应短小,避免阻塞调用及递归修改相同映射,不能在里面直接执行很慢的远程服务然后认为“其他 key 完全不受影响”。
难 · ConcurrentHashMap 在 JDK 7 与 JDK 8+ 的实现如何变化?
| 维度 | JDK 7 经典实现 | JDK 8/17/21 经典实现 |
|---|---|---|
| 主要组织 | Segment 数组,每段管理自己的哈希表 | Node 数组,桶内为链表或树 |
| 更新协调 | 段级 ReentrantLock | 空桶插入使用 CAS,冲突更新使用桶级同步等机制 |
| 扩容 | 各 Segment 内部表扩容;Segment 数量不随它扩容 | 整体表迁移,线程可协助处理分区 |
| 并发度参数 | concurrencyLevel 影响初始段数,默认常见为 16 | 主要作为初始化容量提示,不能解释为“只有 16 把锁” |
JDK 7 的 put 先定位段,再在段内定位桶并更新;段内表可扩容,但不能由此推导“整个 Map 最多只允许 16 个线程执行任意操作”。读取、不同段更新、同段冲突的行为不同。
JDK 8+ 对空桶以 CAS 插入,非空桶更新需要处理链表、树及并发迁移;读者通过受内存语义保障的节点与字段访问看到状态。不能简化成“只有 CAS,没有锁”,更不能在读代码中看到没有 synchronized 就声称没有同步协议。
扩容如何迁移? 通过协作分配迁移范围,将旧桶拆分到新表位置,并在旧桶设置转发标记。遇到迁移状态的操作会遵循相应转发或协助逻辑,不是暂停整个世界逐个复制。读者和更新者都必须正确识别中间状态。
为什么常说 8 与 64? 在这些版本的典型实现中,树化阈值涉及桶长度 8,表容量不足最小树化容量 64 时通常先尝试扩容;退化还受不同路径的判定影响。8 是综合冲突概率、节点成本和树操作收益的工程选择,不是树节点达到 8 就在所有操作中无条件树化的 API 承诺。
难 · ConcurrentHashMap 的一致性边界在哪里?
对某个 key 的已完成更新,与随后返回该更新值的非空读取之间,有相应 HB 保证。但它没有全表事务:
put(a, x)与put(b, y)不是一次原子提交。读者可能只看到其中一个更新。- size、isEmpty、containsValue 与聚合结果在并发修改时可反映中间状态,不适合用“size 小于阈值再 put”实现严格容量上限。
- 遍历通常是弱一致的,不抛 ConcurrentModificationException,不代表获得了某一时刻的完整快照。
- Map 保证映射结构的并发访问,不会使其 value 内部的 ArrayList、日期格式化器等自动线程安全。
需要跨多个 key 保持业务约束时,可用外部锁、把相关状态合并为一个不可变值、单线程所有权或事务存储。仅多加几个 concurrent 容器不能替代事务设计。
ConcurrentSkipListMap/Set 提供并发有序访问与范围操作,使用跳表,不能称为“有序哈希表”。是否需要排序和范围查询,比背出树或跳表名称更决定选型。
中 · fail-fast、弱一致与快照迭代有什么区别?
| 迭代语义 | 代表 | 能保证什么 |
|---|---|---|
| fail-fast | ArrayList/HashMap 的常见迭代器 | 尽力检测不允许的结构修改并抛异常;不构成线程安全机制 |
| 弱一致 | ConcurrentHashMap、ConcurrentLinkedQueue 等 | 可与修改并发执行,不要求反映单一时刻的完整集合 |
| 快照 | CopyOnWriteArrayList 迭代器 | 持有创建迭代器时的数组,之后结构变化不反映到该迭代器 |
没有抛 ConcurrentModificationException 不能证明程序没有数据竞争。COW 的快照与 CHM 的弱一致也不能混为一谈。CopyOnWriteArrayList 只快照数组中的引用,被引用的可变元素仍可能变化。
中 · CopyOnWriteArrayList 为什么适合读多写少?有哪些成本?
写操作在互斥保护下构造新的数组,并通过具有相应可见性语义的数组引用发布;读操作通常使用当前数组,无需与写者争抢同一把锁。旧迭代器继续使用旧数组,避免结构变化干扰。
成本是写时复制 O(n)、短期同时保留新旧数组,以及被长生命周期迭代器延长的旧数组存活。频繁写入或大型列表会增加内存、复制和 GC 压力。适合小规模、变化少、遍历频繁的监听器列表或规则快照。
不要说“set 已返回但之后的所有新读仍只能最终看到新值”。一次操作获取当前数组具有发布保证;旧迭代器看旧数组是快照契约,分开多次 get 则可能跨越不同数组版本。需要一致遍历时应使用同一个迭代器或快照。
JDK 8 常见源码使用 ReentrantLock,后续版本内部锁实现有变化,不影响公开契约。不能将某版 Unsafe 的反序列化辅助代码当成每次写操作的核心流程。CopyOnWriteArraySet 基于类似的 COW 列表思路,适合小型集合,去重与写入同样有扫描和复制成本。
Vector 单次同步方法与 COW 代表不同取舍,Vector 并未因为较老就等于“不可使用”。if (list.size() > i) list.remove(i) 在两者上都不能仅靠两个方法分别线程安全就获得整体原子性。
难 · ConcurrentLinkedQueue 怎样在不使用互斥锁的情况下工作?
它是基于链式节点的无界非阻塞队列,以 CAS 等原子操作推进插入、逻辑删除与辅助指针。offer 发布节点,poll 成功取得并移除元素;返回 null 表示本次没有取得元素,不能推导未来一定仍为空。它不接受 null 元素。
head/tail 是辅助定位指针,可能落后于当前有效头尾;操作会沿链接查找并在适当时机协助推进。删除可能先把 item 逻辑置空,再推进 head。某些版本采用减少指针 CAS 的跳跃更新策略,但“HOPS 永远固定隔一个节点”不是公开契约,也不是所有版本通用公式。
无锁不等于无成本:重试、链式节点分配、缓存局部性、GC 与空轮询都可能成为瓶颈。它适合不需要阻塞等待、且外部已有事件通知或调度机制的场景;若消费者没有任务就应休眠,BlockingQueue 通常更直接。
size 通常需要遍历,在并发修改时也不适合作为精确决策依据。不要写 if (!queue.isEmpty()) queue.poll() 并假定 poll 必定非 null,应直接处理 poll 的结果。
中 · BlockingQueue 四组 API 如何选择?
| 操作 | 失败时抛异常 | 立即返回特殊值 | 等待直至可执行 | 最多等待指定时间 |
|---|---|---|---|---|
| 插入 | add(e) | offer(e) 返回 false | put(e) | offer(e, timeout, unit) |
| 移除队首 | remove() | poll() 返回 null | take() | poll(timeout, unit) |
| 查看队首 | element() | peek() 返回 null | 无 | 无 |
阻塞与限时等待可响应中断。队列不允许 null,正好让 null 表达没有取得元素。并非所有 BlockingQueue 都有实用容量上限,也不是所有实现都按 FIFO 排序。
放入对象之前的动作,对另一线程随后访问或移除该对象之后的动作具有相应 HB 效果。但生产者在 put 之后继续修改同一对象的字段,仍可能与消费者产生竞争。常见协议是将对象所有权交给消费者,之后生产者不再修改。
中 · 阻塞队列家族如何选?SynchronousQueue 为什么容量为零仍有用?
| 队列 | 容量与顺序 | 适合场景和代价 |
|---|---|---|
| ArrayBlockingQueue | 固定容量,FIFO,可选等待公平性 | 数组存储、容量明确;典型实现一把锁与两个条件 |
| LinkedBlockingQueue | 可指定容量,默认上限为 Integer.MAX_VALUE,FIFO | 链式节点;典型实现分离入队与出队锁,但仍有协调和分配成本 |
| LinkedBlockingDeque | 可指定容量,双端 | 两端生产消费、需要前后插入的调度;通过 Queue 接口使用时尾入首出 |
| PriorityBlockingQueue | 逻辑上无界,按比较顺序取出 | 优先级调度;同优先级不保证 FIFO,必须另设计防饥饿与容量限制 |
| DelayQueue | 逻辑上无界,仅到期元素可取出 | 到期任务;有元素但未到期时 take 仍会等待 |
| SynchronousQueue | 不存储元素,生产消费直接配对 | 直接交接;可选公平模式,offer 无接收者时失败,put 等待配对 |
| LinkedTransferQueue | 无界,提供 transfer 等交接操作 | transfer 等待元素被消费者接收,普通 offer 不等价于等待消费 |
“无界”是容量策略,不代表内存无限。PriorityBlockingQueue 的比较器还必须满足排序契约;DelayQueue 元素要正确实现 Delayed,延时计算通常基于单调时间,避免墙上时钟调整影响相对等待。
SynchronousQueue 的 put 可能等待,但 ThreadPoolExecutor 通常通过非阻塞 offer 判断是否能交接;交接失败后按扩线程或拒绝策略处理,不会让提交者自动执行 put 无限等待。
BlockingDeque 的 put/offer/add 对应尾部操作,take/poll/remove 对应头部操作;也可明确使用 First/Last 方法。自行在两端取任务不等于自动实现了 ForkJoinPool 的工作窃取协议。
难 · 怎样设计有界生产消费与退出协议?
BlockingQueue 没有通用 close 方法。需要选择中断、外部生命周期控制,或双方约定的终止消息;多消费者时终止消息数量与顺序也要设计。
以下完整例子使用单生产者、单消费者,以及一个显式终止标记。生产者由 main 执行,消费者异常或外部中断会退出;finally 保证 main 不因异常留下长期等待的工作线程。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public final class QueuePipeline {
private static final Object END = new Object();
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Object> queue = new ArrayBlockingQueue<>(4);
Thread consumer = new Thread(() -> {
try {
for (;;) {
Object item = queue.take();
if (item == END) {
return;
}
System.out.println((Integer) item);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "consumer");
consumer.start();
try {
for (int i = 1; i <= 3; i++) {
queue.put(i);
}
queue.put(END);
consumer.join();
} finally {
consumer.interrupt();
}
}
}这个有限示例的消费逻辑不会主动抛业务异常。实际流水线如果消费者可能失败,生产者不能无限 put:应有失败传播与总超时,否则消费者已退出时生产者可能永久等待。多生产者还要确保全部生产结束后再发终止标记,不能让某个生产者过早终止其他人的消费。
队列长度只是一个指标,还需考虑元素大小、生产速率、消费速率、最坏排队时间和下游失败。背压意味着把资源紧张反馈到上游,而不是把积压悄悄搬到另一个无界队列。
Future、线程池与调度
中 · FutureTask 解决什么问题?状态如何保证结果只完成一次?
FutureTask 实现 RunnableFuture,因此既能被 Thread/Executor 执行,也能作为 Future 等待结果。它把一次计算的执行、正常结果、异常、取消和等待者唤醒封装起来。
在 JDK 8/17/21 的典型实现中,通过原子状态转换选定执行者与完成者,并配合结果字段发布、等待节点和 park/unpark。不能只说“靠 CAS 就线程安全”,因为结果可见性、取消与执行者之间的竞争同样重要;也不能把它概括为基于 AQS 的阻塞锁。
| 操作 | 正常或异常行为 |
|---|---|
get() | 等待完成,正常返回值,失败抛 ExecutionException,取消抛 CancellationException,可被中断 |
get(timeout, unit) | 超时抛 TimeoutException,任务仍可能继续执行 |
cancel(false) | 成功时进入取消状态,不请求中断执行线程 |
cancel(true) | 成功时可尝试中断执行线程,依赖任务协作退出 |
isDone() | 正常、失败、取消都可能为 true,不表示成功 |
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public final class FutureTaskExample {
public static void main(String[] args) throws Exception {
FutureTask<Long> task = new FutureTask<>(() -> {
long sum = 0;
for (int i = 1; i <= 100_000; i++) {
if (Thread.currentThread().isInterrupted()) {
throw new InterruptedException();
}
sum += i;
}
return sum;
});
Thread worker = new Thread(task, "sum-worker");
worker.start();
try {
System.out.println(task.get(1, TimeUnit.SECONDS));
} catch (TimeoutException e) {
task.cancel(true);
throw e;
} finally {
task.cancel(true);
}
}
}finally 的 cancel 对已完成任务无效果,但覆盖了等待者被中断等提前退出路径。取消成功与底层计算已停止是两件事;若计算不检查中断,Future 可能已取消而线程仍在运行。runAndReset 是供特殊可重复执行封装使用的受保护能力,不代表普通 FutureTask 完成后可随意重启。
中 · 为什么使用线程池?ThreadPoolExecutor 的提交顺序是什么?
平台线程池复用工作线程,限制资源,集中管理任务、失败和关闭。它不能自动让共享任务互不干扰,也不是把“线程对象放进队列”,通常队列中放的是 Runnable 任务。
简化后的 execute 决策顺序:
- 若 worker 数小于 corePoolSize,尝试创建一个 worker 直接执行本任务。
- 否则在运行状态允许时,尝试用 offer 入队。
- 入队成功后重新检查运行状态与 worker 数,处理关闭竞态,必要时启动 worker 防止任务无人消费。
- 无法入队时,尝试在 maximumPoolSize 范围内创建 worker 执行本任务。
- 若仍不能接纳,调用拒绝策略。
因此不是“先扩到 maximum,再入队”。未满的无界队列会让池通常不再扩到 core 以上,maximumPoolSize 基本失去调节作用。corePoolSize 也不是“创建执行器时立即创建的线程数”,通常按提交惰性创建,可使用 prestart 方法提前启动。
worker 执行首个任务后,循环从队列取任务;无任务时通过阻塞等待而非忙循环。线程池还要维护运行状态、worker 数、worker 集合及退出替补等协议,不等于仅有一个队列和一个 HashSet。
中 · 七个线程池参数如何影响容量与延迟?
| 参数 | 作用 | 面试应说明的边界 |
|---|---|---|
| corePoolSize | 常规 worker 数的基准 | 不是保证永久存在的专属线程身份 |
| maximumPoolSize | worker 数上限 | 队列满或无法交接后才通常发挥作用 |
| keepAliveTime | 空闲 worker 的回收等待 | 默认主要作用于超出核心数的 worker |
| unit | 上述时间单位 | 不要混用毫秒与秒 |
| workQueue | 待执行任务缓冲 | 容量、元素大小、顺序决定内存和排队上限 |
| threadFactory | 创建工作线程 | 命名、属性、未捕获异常处理;工厂也可能无法成功创建 |
| handler | 无法接纳时的行为 | 包括过载与关闭后提交,不仅是“队列满” |
allowCoreThreadTimeOut(true) 可使核心线程也按空闲时间退出,要求有效的非零 keepAliveTime。核心线程不是一组永远固定的 Thread 实例;异常退出、回收和替补都可能改变实例。
下面是显式容量、命名和拒绝行为的配置示例,参数仅用于展示,不代表通用生产推荐值:
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
final class Pools {
static ThreadPoolExecutor newIoPool() {
AtomicInteger sequence = new AtomicInteger();
ThreadFactory factory = task -> {
Thread thread = new Thread(task, "io-worker-" + sequence.incrementAndGet());
thread.setUncaughtExceptionHandler((t, error) -> error.printStackTrace());
return thread;
};
return new ThreadPoolExecutor(
4, 8, 30, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(100), factory,
new ThreadPoolExecutor.AbortPolicy());
}
}该异常处理器只覆盖真正逃出线程的异常,不会自动看到被 Future 捕获的业务异常。生产系统可接入自己的日志与监控,但无需为了命名线程强制引入第三方依赖。
难 · 四种拒绝策略会怎样影响调用者与 Future?
| 策略 | 行为 | 风险与适用边界 |
|---|---|---|
| AbortPolicy | 抛 RejectedExecutionException,默认策略 | 调用方必须处理失败;通常最容易让过载显性化 |
| CallerRunsPolicy | 未关闭时由提交线程执行 | 形成一定反馈,但阻塞提交者;关闭后静默不执行 |
| DiscardPolicy | 不执行也不报告 | 只有业务明确允许丢弃且有观测时才可考虑 |
| DiscardOldestPolicy | 未关闭时移除队头并重试提交 | 丢的是队头,不必然是业务最旧;优先队列可能丢最高优先级任务 |
CallerRunsPolicy 的调用者可能是 HTTP 线程、事件循环、持锁线程,未必是 main。它会改变执行上下文、延迟与重入行为,不适合不允许阻塞的事件循环。与持锁提交组合时,也可能引入新的锁顺序问题。
submit() 通常先把任务包装为 FutureTask 再调用 execute。若拒绝处理器只是打印日志或静默丢弃,submit 可能返回一个永不完成的 Future,导致 get 一直等。自定义拒绝处理器应明确抛出失败、取消被拒绝的 Future,或实现可追踪的可靠转交;不能“记一行日志就算处理了”。DiscardOldest 移除的旧任务也有类似 Future 悬空问题。
在业务层重试拒绝任务时,要有总时间预算、幂等约束和容量依据。立即无限重试只会加剧过载;无界放入另一个队列也没有解决资源约束。
难 · execute 与 submit 的异常到哪里去了?afterExecute 能拿到所有异常吗?
| 提交方式 | 异常通常在哪里 | worker 是否受影响 |
|---|---|---|
execute 执行普通 Runnable,异常逃出 run | 进入线程池钩子及线程未捕获异常处理机制 | worker 可异常退出,池视需要补充 |
submit 包装成 FutureTask | Future 保存异常,get 抛 ExecutionException | 业务异常通常不会逃出 FutureTask.run,worker 可继续 |
| 周期调度任务 | ScheduledFuture 保存失败,后续周期通常被抑制 | 线程本身未必死亡 |
ThreadPoolExecutor 的 afterExecute(r, t) 中 t 可能为 null,因为 RunnableFuture 已经捕获异常。若用该钩子统一观测,可在确认任务已完成且是 Future 时调用 get,分别处理 ExecutionException、CancellationException 和中断;不能不加判断就等待一个尚未完成的周期 Future。
更简单的业务边界是:要么持有并检查 Future,要么在顶层任务包装中显式记录失败,要么使用有清晰异常通道的编排方式。不能靠轮询 isDone() 判断业务成功,更不能只 catch Exception 后打印日志并返回伪造默认结果。
中 · Executors 工厂有什么资源风险?是否必须禁用全部工厂?
| 工厂 | 典型策略 | 主要风险 |
|---|---|---|
| newFixedThreadPool | 固定 worker 数,默认无界 LinkedBlockingQueue | 积压导致内存与延迟持续增加 |
| newSingleThreadExecutor | 单 worker 顺序执行,默认无界队列,异常时可替补 | 吞吐受一个 worker 限制,不能阻止队列膨胀 |
| newCachedThreadPool | SynchronousQueue,线程上限很高,空闲回收 | 高并发慢任务可能创建过多平台线程 |
| newScheduledThreadPool | 固定核心规模,无界延迟工作队列 | 大量延迟任务积压;不是主要依靠无限扩 worker 执行任务 |
| newWorkStealingPool | ForkJoin 风格工作窃取 | 不承诺提交顺序,需关注公共资源和阻塞任务 |
无界队列的池仍可能在关闭后拒绝;因此“FixedThreadPool 永远不拒绝”是错误说法。ScheduledThreadPoolExecutor 的 maximumPoolSize 虽然大,但无界延迟队列使它不按普通过载策略扩张到该上限;其核心风险应准确描述为任务积压与核心处理能力不足。
显式构造 ThreadPoolExecutor 有助于把资源策略写清楚,但“所有 Executors API 都危险”也是过度归纳。选择取决于负载、边界和生命周期管理。Spring 等框架只是配置入口,最终仍要理解队列容量、拒绝、异常和关闭策略,不能靠一个 Bean 名称绕开这些问题。
难 · 线程池大小怎样估算?如何监控过载?
CPU 密集任务通常从接近可用 CPU 并行度开始,而不是机械设置“核心数加一”。容器配额、超线程、任务可拆分性、GC 和其他线程都影响可用计算能力。
对独立、可并行的平台线程任务,可用近似模型 线程数 ≈ CPU 数 × 目标利用率 × (1 + 等待时间 / 计算时间) 作为起点。它假设等待与计算比例相对稳定,不考虑所有下游限制;数据库连接数、外部限额和内存往往先成为约束。2 × CPU 不是 I/O 密集任务通用答案。
至少观察:
- 活跃线程、当前线程数、历史峰值、队列长度与剩余容量。
- 提交、完成、拒绝速率,以及排队等待和执行耗时的分位数。
- 超时、取消、业务失败率,以及下游连接池、CPU、GC、文件描述符。
getTaskCount/getCompletedTaskCount/getActiveCount 等通常是近似指标,不能作为严格账本。队列持续增长而 worker 全忙,说明进入系统的速率超过当前处理能力;worker 大量等待下游时,增加线程可能只把下游压得更慢。
Little 定律 L = λW 可在稳定条件下连接系统平均在途数、吞吐与平均停留时间。要先明确统计边界与单位;瞬时过载、重试风暴与不稳定队列不能靠这个平均公式直接保证尾延迟。
难 · shutdown、shutdownNow 与 awaitTermination 有什么区别?
| 操作 | 是否继续接收新任务 | 已排队与正在运行的任务 | 是否等待终止 |
|---|---|---|---|
| shutdown | 否 | 通常继续完成已接纳任务,唤醒空闲 worker 参与退出 | 否 |
| shutdownNow | 否 | 尝试中断运行任务,并返回尚未开始的任务列表 | 否,任务可能忽略中断 |
| awaitTermination | 不改变接收策略 | 等待池终止、超时或调用者中断 | 是,有时间上限 |
这是线程池的运行状态,不是把每个 Thread 的状态设为名为 SHUTDOWN 的 Thread.State。isShutdown() 不等于 isTerminated(),后者要求不再有执行和等待任务等终止条件。
JDK 8 兼容的关闭辅助方法可以采用:
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
final class Shutdowns {
static boolean close(ExecutorService pool) throws InterruptedException {
pool.shutdown();
try {
if (pool.awaitTermination(5, TimeUnit.SECONDS)) {
return true;
}
cancelNeverStarted(pool.shutdownNow());
return pool.awaitTermination(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
cancelNeverStarted(pool.shutdownNow());
throw e;
}
}
private static void cancelNeverStarted(List<Runnable> tasks) {
for (Runnable task : tasks) {
if (task instanceof Future<?>) {
((Future<?>) task).cancel(false);
}
}
}
}返回 false 表示仍未确认终止,调用者必须决定如何报告并处理资源。未开始任务需要按业务决定重新投递、持久化或失败,不能仅拿到列表就当任务已执行。取消其中的 Future 是避免永久等待的一部分,不代替业务恢复。
ExecutorService 从较新 JDK 开始支持 AutoCloseable;本文 JDK 21 示例可使用 try-with-resources,JDK 8/17 不可以照搬。close 可能等待任务结束,不是一个任意时限内返回的强制关闭按钮。
中 · ScheduledThreadPoolExecutor 如何实现延迟与周期任务?
ScheduledThreadPoolExecutor 使用能记录截止时间、周期与完成状态的调度任务,并通过无界延迟工作队列组织。典型内部队列是堆结构,并采用等待最早任务到期的策略;不能简单称为普通 DelayQueue 的实例。
| 方法 | 下一次调度依据 | 若某次执行耗时超过间隔 |
|---|---|---|
| schedule | 延迟后执行一次 | 到期只是具备执行资格 |
| scheduleAtFixedRate | 以初始计划时间加周期计算 | 后续可能接连执行以追赶计划,但同一周期任务不会与自身重叠 |
| scheduleWithFixedDelay | 上一次执行结束后再等固定延迟 | 周期随执行耗时拉长,不追赶之前计划 |
同一周期任务的相邻执行不重叠,前一次执行的效果 HB 后一次执行,即使可能由不同 worker 执行。不同任务仍可并行。
周期任务某次抛出未处理异常,会抑制后续执行;这不是“线程池会自动补线程所以任务继续”。如果业务允许周期继续,应在任务边界明确记录并处理预期异常;未知严重错误不宜一概吞掉。
常见配置:
setRemoveOnCancelPolicy(true)可使已取消任务及时从队列移除,减少到期前的保留。setContinueExistingPeriodicTasksAfterShutdownPolicy控制 shutdown 后是否继续已有周期任务,默认 false。setExecuteExistingDelayedTasksAfterShutdownPolicy控制 shutdown 后是否执行已有延迟任务,默认 true。
它通常按 corePoolSize 提供执行能力,调整 maximumPoolSize 没有普通有界队列池的同等效果。不宜随意把核心规模设为 0 或允许核心超时。Timer 是较早的单线程调度方案,一个慢任务会延迟其他任务,TimerTask 的未捕获异常可能终止调度线程;新代码通常优先使用调度执行器。
Fork/Join 与 CompletableFuture
中 · ForkJoinPool 的工作窃取解决什么问题?
Fork/Join 从 JDK 7 起提供,适合可拆分为独立子任务、可在内存中计算并合并结果的工作。核心角色是 ForkJoinTask、ForkJoinWorkerThread 与 ForkJoinPool;RecursiveTask 返回结果,RecursiveAction 无结果,CountedCompleter 支持基于完成计数的依赖组织。
典型工作队列为双端结构。默认本地执行偏向 LIFO,利于深度优先和局部性;其他 worker 从另一端窃取,通常取得更早、更粗的任务。异步模式可改变本地调度策略;不应将一个版本的队列索引方向当作 API 保证。
阻塞地等待普通 I/O、数据库或外部 Future,可能占住 worker,使本应可运行的子任务缺少执行机会。ManagedBlocker 可在特定场景让池感知阻塞并作补偿,但不是无限线程或下游容量保证。并行流与一些异步 API 会共享 commonPool,阻塞任务可能互相影响。
JDK 的 Arrays.parallelSort、并行流,以及 ConcurrentHashMap 的部分并行聚合操作会用到相关机制。公共池不是每个组件私有资源,不能因为一个方法名带 parallel 就认为一定更快。
难 · 如何写正确的 Fork/Join 求和?阈值和数值范围为何重要?
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public final class ParallelSum {
static final class SumTask extends RecursiveTask<Long> {
private static final int THRESHOLD = 1_000;
private final int from;
private final int to; // 闭区间;本例限定正数且范围较小
SumTask(int from, int to) {
this.from = from;
this.to = to;
}
@Override
protected Long compute() {
if (to - from <= THRESHOLD) {
long sum = 0;
for (int i = from; i <= to; i++) {
sum += i;
}
return sum;
}
int middle = from + (to - from) / 2;
SumTask left = new SumTask(from, middle);
SumTask right = new SumTask(middle + 1, to);
left.fork();
long rightResult = right.compute();
return left.join() + rightResult;
}
}
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();
try {
System.out.println(pool.invoke(new SumTask(1, 100_000)));
} finally {
pool.shutdown();
}
}
}数学结果为 5,000,050,000,超出 int 上限,所以任务结果和局部累加都使用 long。这是根据公式得出的预期值,不是某次运行的输出记录。区间划分不重叠且不遗漏,使用“fork 一半、当前线程计算一半、join”减少无谓排队。
阈值过小会让任务创建、调度和装箱成本超过实际计算,过大又可能并行不足。此求和直接用等差公式更简单,示例只是展示分治机制。斐波那契的朴素递归具有大量重复计算,即使能并行也不是高效算法;先选算法再并行化。
若 fork 多个任务,通常逆序 join 有利于本地执行与减少等待;这是常用性能建议,不是“其他 join 顺序一定算错”的语义规则。invokeAll 可简化对子任务的组织,但仍要检查异常、取消和任务间是否形成循环依赖。
中 · CompletableFuture 比 Future 多解决了什么问题?
JDK 8 的 CompletableFuture 同时实现 Future 与 CompletionStage,把“完成后的动作”表示为依赖图,避免调用者必须手工阻塞 get 并继续提交任务。它支持正常与异常完成、组合、转换和手动完成。
| 方法族 | 输入输出关系 | 适用情形 |
|---|---|---|
| thenApply | T → U | 同步转换一个结果 |
| thenCompose | T -> CompletionStage<U>,展平结果 | 后续异步调用依赖前一步返回值 |
| thenAccept / thenRun | 消费结果 / 无需输入,无返回结果 | 终端副作用,仍需观察失败 |
| thenCombine | 等待两个阶段,合成结果 | 独立请求并发执行后汇总 |
| allOf | 等待所有阶段完成,结果类型为 Void | 批量汇合,结果需要从各子 Future 取出 |
| anyOf | 任意一个阶段先完成,结果为 Object | 先完成者可能是失败,不是“首个成功” |
allOf 中某个任务失败不会自动取消其余任务,也不是可靠的立即失败并停止所有工作的机制。依赖图表达顺序,不自动替代底层资源的超时、取消与容量控制。
难 · Async 后缀是否保证独立线程?怎样避免公共池被阻塞?
非 Async 的依赖动作可能在完成前置阶段的线程执行,也可能在注册动作的调用线程执行,取决于完成时机。Async 通常把动作交给执行器;没有显式指定执行器时,标准 CompletableFuture 常用 commonPool,特定并行度不足时还有其他处理。不要依赖具体线程名或固定执行顺序。
提供自定义 Executor 时,其 execute 本身可能在调用线程执行,例如 CallerRunsPolicy。因此 Async 不是“保证某个新线程”的同义词。慢 I/O 应使用适合其资源边界的执行器,或在 JDK 21 中结合虚拟线程;CPU 任务与慢 I/O 混用 commonPool 可能相互拖慢。
以下 JDK 8 兼容例子用独立、受容量限制的执行器组合两项计算,并在汇合时显式取得异常:
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public final class FutureComposition {
public static void main(String[] args) throws Exception {
ThreadPoolExecutor pool = new ThreadPoolExecutor(
2, 2, 0L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(16),
new ThreadPoolExecutor.AbortPolicy());
try {
CompletableFuture<Integer> first =
CompletableFuture.supplyAsync(() -> 20, pool);
CompletableFuture<Integer> second =
CompletableFuture.supplyAsync(() -> 22, pool);
CompletableFuture<Integer> total = first.thenCombine(second, Integer::sum);
System.out.println(total.get(1, TimeUnit.SECONDS));
} finally {
pool.shutdownNow();
}
}
}这里的计算有限且不阻塞,所以清理逻辑简单。若替换成真实 RPC,必须给每个调用设置连接、读取及总截止时间,并定义组合失败时如何取消仍在进行的请求。只给最终 get 设置 1 秒,不会自动让底层调用在 1 秒时停止。
难 · CompletableFuture 的异常、超时与取消如何传播?
| API | 作用 | 容易误解的边界 |
|---|---|---|
| exceptionally | 从异常转换为一个正常值或再次抛出 | 返回默认值意味着业务已接受降级,应有明确依据 |
| handle | 同时接收正常值与异常,可转换结果 | 会改变后续阶段的完成状态 |
| whenComplete | 观察正常结果或异常,通常用于记录 | 若观察逻辑再抛异常,也可能影响返回阶段 |
| get | 等待结果,可中断,异常包装为 ExecutionException | 超时不取消任务 |
| join | 等待结果,异常通常包装为 CompletionException | 不以抛 InterruptedException 的方式支持中断等待 |
| orTimeout | JDK 9+,超时使该 Future 异常完成 | 不是对底层任务执行线程的硬取消 |
| completeOnTimeout | JDK 9+,超时以指定值完成 | 返回该值不表示实际计算已成功 |
CompletableFuture 的 cancel(true) 中 mayInterruptIfRunning 对该实现不具有中断底层计算的控制效果,不能照搬 FutureTask 的执行线程取消语义。它主要把 Future 置为取消完成,并影响依赖阶段;要停止真实任务,需要其执行句柄、资源取消 API 或共享的协作式取消协议。
超时操作通常改变被调用的那个 CompletableFuture;若多个调用方共享同一个实例,一个调用方施加的超时可能影响其他观察者。设计公共异步接口时应区分共享计算与每个订阅者自己的等待预算。
追问:为什么不在每个阶段都 exceptionally 返回 null? 这会把错误变成合法完成,后面可能出现难定位的空指针或不完整业务结果。应在知道如何恢复的边界恢复,其余情况保留失败原因。处理 CompletionException/ExecutionException 时应追踪 cause,不应丢失原始异常链。
同步工具与阶段协调
中 · CountDownLatch 与 CyclicBarrier 如何选择?
| 维度 | CountDownLatch | CyclicBarrier |
|---|---|---|
| 模型 | 等待计数降为零的一次性事件 | 固定参与数在每代屏障集合 |
| 是否可复用 | 不可重置 | 一代成功后可进入下一代,也可显式 reset |
| 等待者与完成者 | 可以是不同线程,也可以有多个等待者 | 通常由参与各阶段的线程调用 await |
| 失败影响 | 某线程不 countDown,其他等待者可能持续等待 | 中断、超时或屏障动作失败可使本代 broken |
| 常见用途 | 多个初始化任务完成后开放服务 | 迭代计算每轮对齐后继续 |
不能把差别概括为“Latch 减、Barrier 加”,CyclicBarrier 内部同样可以用递减的剩余计数。也不能规定“Latch 的下一步只能由主线程做”,任意等待线程都可以继续。
CountDownLatch 基于 AQS 共享获取:计数未归零时等待,归零后释放等待者,后来的 await 也直接通过。它没有必须使用的 Condition 队列。countDown 之前的动作 HB 另一线程成功 await 返回之后的动作。
任务无论成功失败都需要完成通知时,通常在 finally 中 countDown,同时另行保存失败。归零只表示计数协议完成,不等于全部业务成功;任务提交被拒绝也要纳入协议,否则初始计数可能永远无法归零。
CyclicBarrier 的 barrierAction 由抵达屏障的某个线程执行。参与者数量超过实际可调度 worker 数时,例如在两线程池中提交四个都等待四方到齐的任务,可能产生线程饥饿;屏障并不会自动增加 worker。
难 · 容器添加到第五个元素时通知另一线程,怎样区分“曾达到”与“恰好停在五个”?
若只要求“达到五个后发出一次通知”,一个 latch 即可表达事件。但观察者真正被调度时,生产者可能已添加到十个。若要求观察者提示时容器必须仍恰好有五个,还需第二次握手暂停生产者。
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
public final class FifthElement {
public static void main(String[] args) throws InterruptedException {
List<Integer> values = new ArrayList<>();
CountDownLatch reachedFive = new CountDownLatch(1);
CountDownLatch observedFive = new CountDownLatch(1);
Thread observer = new Thread(() -> {
try {
reachedFive.await();
System.out.println("size = " + values.size());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
observedFive.countDown();
}
}, "observer");
Thread producer = new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
values.add(i);
if (values.size() == 5) {
reachedFive.countDown();
observedFive.await();
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "producer");
observer.start();
producer.start();
try {
producer.join();
observer.join();
} finally {
producer.interrupt();
observer.interrupt();
}
}
}在没有外部取消的正常流程中,第一个 latch 发布前五次写,第二个 latch 让观察完成前不再有后续写,所以这一特定访问协议允许使用 ArrayList。它并不把 ArrayList 普遍变成线程安全容器,也不能支持未遵循协议的第三个读写者。
此有限例子假定生产阶段除中断外不失败。若是可能异常的生产任务,还需向观察者传播失败并结束其等待,例如通过 CompletableFuture 的正常/异常完成表达事件。不要把 volatile List 当成修复措施:volatile 修饰引用并不保护列表内部结构。
中 · Semaphore 是锁还是资源池?release 能否超过初始许可数?
Semaphore 管理许可数量,可用于限制同时进行的操作。acquire 原子地扣除许可,不足时等待;tryAcquire 可立即或限时尝试;release 增加许可,可能释放等待者。它不自动管理真实资源对象,也不记录每个许可属于哪个线程。
因此:
- 初始 10 个许可,11 个线程各 acquire 一次,若都尚未 release,至多 10 个通过,另一个等待。
- 同一线程连续 acquire 11 次也会在许可耗尽时等待,Semaphore 没有“同线程自动重入不扣许可”的语义。
- 初始 1 个,acquire 一次后 release 两次,许可可变为 2;初始 2 个时直接 release 一次,再 acquire(3) 可以成功。初始数量不是上限。
java.util.concurrent.Semaphore permits = new java.util.concurrent.Semaphore(10);
permits.acquire();
try {
// 已获得一个许可后才调用受限制的资源。
} finally {
permits.release();
}acquire 应放在 try-finally 结构之前,防止未获取成功就 release。若使用 tryAcquire,只有返回 true 才能执行对应 release。实际资源池还要管理资源借还、健康检查和关闭,不能只用信号量替代连接池。
公平 Semaphore 可减少插队,但无参 tryAcquire 等路径有自己的公平性边界,应按 API 文档确认。Semaphore 不提供互斥锁那样的所有者检查,因此一个线程也能释放另一个线程对应的许可;这是能力,也是重复释放导致限流失效的风险。
难 · Phaser 为什么适合动态多阶段任务?如何处理取消?
Phaser 从 JDK 7 起提供动态注册、抵达、等待阶段推进与注销。核心计数包括已注册参与数、当前未抵达数和 phase;全部参与者抵达后推进 phase。
| 方法 | 含义 |
|---|---|
| register / bulkRegister | 增加后续需参与抵达的注册数 |
| arrive | 抵达本阶段但不等待,返回本次阶段号 |
| arriveAndAwaitAdvance | 抵达并等阶段推进,等待不以抛 InterruptedException 退出 |
| arriveAndDeregister | 抵达并注销,减少后续参与数 |
| awaitAdvanceInterruptibly | 等指定阶段发生变化,可中断或限时 |
| forceTermination | 强制进入终止状态,释放相关等待者;不停止实际任务 |
注册只是计数,不绑定线程身份,程序必须自行保证“注册一次、每阶段抵达一次、最终正确注销”。漏注册、重复抵达或异常路径遗漏注销都可能破坏阶段协议。
import java.util.concurrent.Phaser;
public final class DynamicPhase {
public static void main(String[] args) throws InterruptedException {
Phaser phaser = new Phaser(1); // 协调者先占一个注册名额
for (int i = 0; i < 3; i++) {
phaser.register();
new Thread(() -> {
try {
System.out.println(Thread.currentThread().getName() + " completed");
} finally {
phaser.arriveAndDeregister();
}
}, "phase-worker-" + i).start();
}
int phase = phaser.arriveAndDeregister();
phaser.awaitAdvanceInterruptibly(phase);
}
}协调者的初始注册防止子任务过早全部注销导致 phaser 在提交尚未完成时终止。此例没有跨多轮保留参与者;多轮场景应在每一阶段抵达,最终再注销。任务创建或提交失败时,还要撤销已注册但不会执行的名额。
默认 onAdvance 在注册数降到 0 时终止,终止后等待方法可返回负值。可通过重写 onAdvance 定义阶段动作与终止规则,但该动作应短小。大量参与者可使用父子 Phaser 分层,降低单点竞争;监控方法是快照,不应拿它们替代同步协议。
中 · Exchanger 与 SynchronousQueue 的差别是什么?
Exchanger 是两方数据交换点:双方各提交一个对象,配对成功后各自取得对方对象。SynchronousQueue 是单向直接交接,一个生产者把对象交给消费者。Exchanger 适合双缓冲、生产消费双方互换已填充与空闲缓冲区。
exchange 支持中断及超时。可以有多于两个线程使用同一个 Exchanger,但每次交换只形成一对,配对不绑定固定线程身份;若业务要求固定生产者和消费者对应关系,需自行设计实例与生命周期。
交换对象前的动作,在成功交换后对对方有对应的可见性保证;双方要把所有权真正交换,不能一边交换完继续修改已交给对方的缓冲区。若一方少交换一次或提前失败,另一方可能持续等待,因此应采用一致轮数、终止消息或超时取消协议,不能靠 System.exit 强行结束示例。
旧实现曾从单槽发展为支持多交换槽的竞争分散机制;这些是实现演进,不是选型时必须背诵的版本数字。优先解释配对、所有权与退出,再按面试要求分析指定 JDK 的 arena/slot 实现。
ThreadLocal、上下文与资源生命周期
中 · ThreadLocal 的数据到底保存在哪里?会自动复制对象吗?
ThreadLocal 是访问入口,数据典型地存于每个 Thread 的 ThreadLocalMap 中,以 ThreadLocal 为键寻找当前线程的值。initialValue 或 withInitial 在该线程首次需要初始化时产生值,remove 后再次 get 可重新初始化。
它不会自动深拷贝对象。如果多个线程都执行 local.set(sharedMutableObject),各线程的槽位虽然不同,仍然指向同一个共享对象。线程隔离要求值的实际所有权也被隔离。
适合按线程使用、生命周期明确的状态,例如部分旧式非线程安全解析器。对请求用户身份、追踪信息等,作用域通常是“请求”,线程池却会复用线程,所以必须显式安装和清理。
难 · ThreadLocalMap 的弱键为什么仍可能留住内存?
典型实现中 Entry 的 key 为弱引用,value 为强引用。长期存活的线程通过自己的 map 保持 Entry,Entry 又保持 value:
存活线程 → ThreadLocalMap → Entry → value
- 若 ThreadLocal 本身已不可达,GC 可清除弱 key,但不会因此自动同步清除 value;后续某些 get/set/remove 会顺便清理陈旧条目,不保证立刻或覆盖所有闲置场景。
- 若 ThreadLocal 是 static final 并一直可达,key 不会因弱引用而消失,value 也会一直保留到 remove、替换或线程结束。这可以是预期缓存,也可能是超出请求生命周期的保留。
- 泄漏大小不能统一写成“核心线程数乘最后一个对象”。多个键、陈旧条目、对象引用图、线程变化和类加载器保留都影响实际大小。
public final class RequestContext {
private static final ThreadLocal<String> USER_ID = new ThreadLocal<>();
public static void handle(String userId, Runnable action) {
USER_ID.set(userId);
try {
action.run();
} finally {
USER_ID.remove();
}
}
public static String currentUserId() {
return USER_ID.get();
}
}该写法假定 handle 是最外层请求边界。如果允许嵌套作用域,内层 remove 会删除外层上下文,应保存旧值并在 finally 恢复;还要根据协议区分“没有值”和合法 null。清理不仅防内存保留,也防线程复用后把上个请求的身份误用于下个请求。
难 · InheritableThreadLocal 为什么不等于线程池上下文传播?
InheritableThreadLocal 通常在线程创建时从父线程继承初始值,并非每次提交任务时继承。线程池 worker 可能早已创建,因此执行时看到的不是提交者当前上下文;值若是可变对象,还可能被父子线程共享。
可靠传播应在提交时捕获需要的信息,执行时安装,在 finally 清理或恢复 worker 原上下文。只传播必要且可安全共享的值,避免把完整请求对象、数据库连接等长引用链带到后台任务。CompletableFuture 切换执行线程时也没有通用的 ThreadLocal 自动传播保证。
可以用框架的任务装饰器或经过验证的上下文传播组件,但必须理解取消、嵌套调用和异常路径。日志 MDC 或链路追踪“看起来能传”也不能推导所有业务 ThreadLocal 都会自动传。
中 · ThreadLocal 能否解决数据库连接与日期格式化问题?
ThreadLocal 只能帮助把连接绑定到当前线程,不能代替连接池、事务边界和关闭。每个长期 worker 永久持有一个真实连接,会占尽数据库资源;虚拟线程数量多时更危险。常规服务应从 DataSource 按操作或事务借连接,并在边界归还;框架可能内部用 ThreadLocal 绑定事务资源,但它还实现了完整的生命周期管理。
旧式 SimpleDateFormat/DateFormat 不是通用线程安全对象,可按线程隔离或局部创建。JDK 8 起 java.time 的 DateTimeFormatter 不可变且线程安全,通常优先共享它:
java.time.format.DateTimeFormatter formatter =
java.time.format.DateTimeFormatter.ISO_LOCAL_DATE;
String text = java.time.LocalDate.of(2026, 1, 2).format(formatter);要检查时区、历法和业务格式,不能仅替换类名就假设所有历史解析行为相同。按线程缓存重对象是否划算,也依赖线程规模;平台线程池的少量缓存经验不能直接用于每请求一个虚拟线程。
虚拟线程与 JDK 版本边界
中 · JDK 21 虚拟线程解决什么问题?是不是更快的线程池?
虚拟线程在 JDK 21 通过 JEP 444 正式交付。它是由 JDK 调度、可在合适阻塞点卸载的轻量线程,可让大量主要等待 I/O 的任务使用直观的顺序阻塞代码,而不必为每个并发任务长期占用一个平台线程。
虚拟线程运行时需要承载的平台线程。卸载后承载线程可运行其他虚拟线程;这不增加 CPU 核心,也不缩短远程服务本身的耗时。CPU 密集循环不会因为切到虚拟线程而自动更快。
// JDK 21
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public final class VirtualTasks {
public static void main(String[] args) throws Exception {
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
Future<String> result = executor.submit(() -> {
Thread.sleep(10);
return Thread.currentThread().isVirtual() ? "virtual" : "platform";
});
System.out.println(result.get());
}
}
}这是每任务创建虚拟线程的执行器,不能解释成“固定数量虚拟线程复用的池”。虚拟线程通常不需要像昂贵平台线程那样池化,但仍要用 Semaphore、连接池或入口容量限制保护下游。没有队列上限的虚拟任务创建仍会保留请求状态、缓冲区和等待对象,并非零内存成本。
难 · 固定、ThreadLocal 和 native 调用在不同 JDK 中有什么边界?
| 维度 | JDK 8/17 | JDK 21 | JDK 24 起的相关改进 |
|---|---|---|---|
| 正式虚拟线程 API | 无 | 正式提供 | 继续演进 |
| synchronized 中的阻塞 | 使用平台线程机制 | 可能导致虚拟线程固定在承载线程上 | JEP 491 消除监视器相关的主要固定场景 |
| native/外部函数相关边界 | 依具体调用行为分析 | 某些调用会阻塞或固定承载线程 | 不能由 JEP 491 推导全部 native 阻塞问题消失 |
| ThreadLocal | 与线程数量和寿命相关 | 支持,但每任务一线程使大型缓存代价显著 | 仍需按作用域与规模设计 |
在 JDK 21,长时间持有 synchronized 并执行阻塞 I/O 值得特别分析;必要时考虑缩短临界区或使用适合的显式锁。不要因此无条件把全部 synchronized 替换成 ReentrantLock:短暂内存临界区可能完全合理,JDK 24 的行为也不同。
诊断应结合目标 JDK 的虚拟线程转储、JFR 事件和文档。JDK 21 可关注 jdk.VirtualThreadPinned 等事件,支持时用 -Djdk.tracePinnedThreads=full 辅助定位;这个选项的适用性与价值随实现变化,不能机械用于所有后续版本。
JDK 21 的结构化并发与 ScopedValue 仍属于预览 API,不是 JDK 21 无需预览开关的稳定标准。它们与虚拟线程的稳定性状态不同;如果项目采用,应按所用具体版本重新确认 API、预览标志和生命周期语义。不要把某篇“Java 21 新特性”列表整体当作稳定生产接口契约。
死锁、饥饿与并发故障定位
中 · 死锁、活锁、饥饿分别是什么?哪些情况线程转储不一定报告死锁?
| 现象 | 含义 | 典型例子 |
|---|---|---|
| 死锁 | 多个执行者互相等待,所需条件由环中其他执行者掌握 | A 持锁 X 等 Y,B 持 Y 等 X |
| 活锁 | 执行者不断变化或重试,但业务没有进展 | 双方不断释放与重抢,持续相互避让 |
| 饥饿 | 某任务长期得不到所需执行机会或资源 | 非公平竞争、低优先级任务持续被高优先级任务压制 |
| 线程池饥饿 | 池内任务占住 worker 等待同池排队任务 | 单线程池中父任务 submit 子任务再 get |
经典资源死锁常用互斥、持有并等待、不可抢占、循环等待四个条件分析。破坏其中一个条件可以避免对应模型中的死锁,但实际系统还会涉及数据库锁、远程调用和消息协议,不能只检查两把 Java 锁。
JVM 可识别部分监视器和 ownable synchronizer 的锁环;无法据此发现所有 Future 依赖环、数据库等待或分布式死锁。“未发现 Java 级死锁”不等于系统没有死锁。
难 · 怎样从设计上避免死锁?tryLock 为什么不是自动免疫?
- 为多资源获取定义全局稳定顺序,并让所有路径遵循。若用业务 ID 排序,要有稳定唯一规则;identityHashCode 可能冲突,不能忽略同序号的处理。
- 缩小锁保护范围,避免持锁执行外部回调、慢 I/O 和无法控制的代码;但不能为了缩小锁把业务不变式拆坏。
- 对允许失败的获取使用超时与中断,失败时释放已持资源并按业务返回。所有重试还需总截止时间和退避策略,防止活锁。
- 避免在受限池中同步等待同池的后续任务,优先以异步依赖组合或调整所有权、执行策略。
ReentrantLock 仅提供工具;若始终用 lock 并形成相反的多锁顺序,仍会死锁。tryLock 获取第二把锁失败后若不释放第一把锁,或者立即无限重试,也无法解决问题。
数据库事务与 Java 锁相互嵌套时,JVM 单方无法给出完整等待图。设计中应统一事务边界、超时和重试幂等,而不能只靠在某个位置加 synchronized。
难 · 线上请求卡住时,怎样建立有证据的诊断链?
先确认现象边界:全部接口还是某个租户、吞吐下降还是尾延迟上升、CPU 高还是低、是否与变更或下游故障相关。再收集与该假设对应的数据,不要先认定“锁导致”。
- 保留时间与进程信息。 记录目标 PID、JDK 版本、容器配额和故障窗口,确保工具连接的是同一个进程。
- 在间隔采样中比较线程栈。 平台线程常用
jcmd <pid> Thread.print -l或jstack -l <pid>;JDK 21 大量虚拟线程可按工具帮助使用jcmd <pid> Thread.dump_to_file <path>等适合的转储方式。命令权限、输出位置和支持参数随运行环境确认。 - 追踪等待关系。 BLOCKED 在哪个对象上,谁持有它;park 等待哪种同步器;业务线程是否在 Future.get、连接借用、Socket 读取或队列 put 上停留。栈顶只有 park 不足以判断原因,要向下看业务帧。
- 关联容量与进展。 同时看线程池活跃数、队列与拒绝,数据库连接池活跃/等待,吞吐、错误和下游超时。连续栈不变且完成速率为零,比一次快照更能说明无进展。
- CPU 高时用采样定位热点。 JFR 或合适 profiler 可分辨 CAS 重试、忙轮询、锁竞争、分配与 GC;不要把 RUNNABLE 数量等同于 CPU 用量。
- 用最小因果假设解释证据。 例如“全部 worker 在等连接、连接占用在慢 SQL、入口队列持续增长”,修复点可能是 SQL 与并发限制,而非把 worker 加倍。
以上是排障方法与命令示意,不是本项目已发生或已完成的线上验证。采样和转储有开销,大型进程应采用适合当前环境的诊断方式,并保护转储中的业务信息。
难 · 常见并发故障怎样从症状追到根因?
| 症状 | 优先检查 | 可能的根因与处理方向 |
|---|---|---|
| CPU 高、业务完成率低 | 重试热点、空 poll、自旋、中断后循环 | 缺少阻塞等待、竞争失控、吞掉取消后持续重试 |
| CPU 低、请求堆积 | worker 栈、连接池、锁持有者 | 下游慢、持锁 I/O、线程池依赖等待 |
| submit 后 get 永不返回 | 拒绝策略、任务是否真正执行、Future 状态 | 静默丢弃、未启动任务未取消、业务无限等待 |
| 周期任务不再执行 | ScheduledFuture 异常、任务日志 | 未处理异常抑制后续周期;不是必然线程死亡 |
| 请求串用户或链路串号 | ThreadLocal/MDC 的安装与清理 | 线程复用污染、错误使用继承上下文 |
| 堆被上下文对象长期占用 | 长寿线程到 ThreadLocalMap 的引用链 | 未 remove、陈旧弱键条目、值引用大型对象图 |
| 虚拟线程吞吐受限 | 承载线程、固定事件、下游并发与 CPU | 版本相关固定、native 阻塞、资源限额或纯计算瓶颈 |
| 结果偶发错乱 | 发布链与复合不变式 | 共享可变对象、不一致锁、volatile 被误当事务 |
并发验证要区分“有同步语义的证明”和“测试未发现反例”。sleep、反复打印、某次压力下正常都不能证明数据竞争不存在。业务代码优先使用成熟组件;确需开发底层并发算法时,可结合专用内存模型测试工具与针对性的负载测试,但它们也不能替代完整的正确性推导。
参考资料
易 · 应优先查哪些官方规范与 API?
以下资料用于确认语言与 API 契约;阅读源码时应切换到项目实际使用的 JDK 分支,不要把实现细节当成跨版本保证。
- JLS 17:线程、锁、内存模型与 final 字段语义
- JLS 12.4:类与接口初始化
- JVMS:monitorenter / monitorexit 指令
- JDK 8 java.util.concurrent 包及内存一致性说明
- JDK 17 java.util.concurrent 包
- JDK 21 Thread
- JDK 21 LockSupport
- JDK 21 AbstractQueuedSynchronizer
- JDK 21 ReentrantLock
- JDK 21 ReentrantReadWriteLock
- JDK 21 StampedLock
- JDK 21 atomic 包
- JDK 21 ConcurrentHashMap
- JDK 21 CopyOnWriteArrayList
- JDK 21 BlockingQueue
- JDK 21 ThreadPoolExecutor
- JDK 21 ScheduledThreadPoolExecutor
- JDK 21 FutureTask
- JDK 21 CompletableFuture
- JDK 21 ForkJoinPool
- JDK 21 CountDownLatch
- JDK 21 CyclicBarrier
- JDK 21 Semaphore
- JDK 21 Phaser
- JDK 21 Exchanger
- JDK 21 ThreadLocal
- JDK 21 jcmd 工具
- JEP 193:VarHandles
- JEP 374:默认禁用并废弃偏向锁
- JEP 444:虚拟线程
- JEP 491:同步代码中不固定虚拟线程
- JEP 453:JDK 21 结构化并发预览
- JEP 446:JDK 21 Scoped Values 预览
原文大量问题与分类参考了 pdai Java 并发知识体系。该系列可作为进一步阅读材料;涉及版本实现与 API 行为时,以官方规范、目标 JDK 文档和对应版本源码为准。