面向 5 年经验 Java 开发者,目标岗位 18-22K AI+Java 方向。
每题包含:标准回答 → 追问 → 追问回答 → 面试Tips。
标准回答:
synchronized 是 JVM 层面的关键字,通过 monitorenter/monitorexit 字节码指令实现,支持自动加锁释放;ReentrantLock 是 JDK 层面的 API,基于 AQS 实现,提供可中断、超时、公平锁、多条件变量等高级特性。性能上,JDK 6 之后 synchronized 经过锁升级优化(偏向锁→轻量级锁→重量级锁),两者在低竞争场景差异不大。
追问:synchronized 的锁升级过程是怎样的?
回答:
无锁 → 偏向锁(线程 ID 写入 Mark Word)→ 轻量级锁(CAS 自旋)→ 重量级锁(操作系统互斥量)。偏向锁在竞争时撤销,轻量级锁自旋失败后膨胀为重量级锁。批量重偏向和批量撤销是两个重要的优化阈值(默认 20 次和 40 次)。
Tips: 面试官常追问锁升级细节,建议手画 Mark Word 结构图。提到 JDK 15 默认关闭偏向锁是加分项。
标准回答:
HashMap 线程不安全,允许 null key 和 null value;ConcurrentHashMap 线程安全,不允许 null。JDK 8 的 CHM 摒弃了 Segment 分段锁,改用 CAS + synchronized(锁数组头节点),锁粒度从段级别降到桶级别,并发度大幅提升。两者底层都是数组 + 链表 + 红黑树。
追问:CHM 的 put 流程中,哪些地方用了 CAS,哪些地方用了 synchronized?
回答:
初始化数组用 CAS(sizeCtl 控制);定位到空桶时用 CAS 插入新节点(tabAt + compareAndSwapInt);桶非空时 synchronized 锁住头节点再遍历插入/更新;扩容用 CAS + transferIndex 协调多线程迁移。设计思路是:乐观场景走 CAS 快路径,冲突场景退化为悲观锁。
Tips: 能说清 "CAS 用于空桶、synchronized 用于非空桶" 就够了,不要背源码。
标准回答:
七大核心参数:corePoolSize(核心线程数)、maximumPoolSize(最大线程数)、keepAliveTime(非核心线程空闲存活时间)、unit(时间单位)、workQueue(阻塞队列)、threadFactory(线程工厂)、handler(拒绝策略)。配置原则:CPU 密集型设为 CPU 核心数 +1,IO 密集型设为 CPU 核心数 × 2 或根据 CPU 利用率公式 N_threads = N_cpu × (1 + W/C) 计算。
追问:四种拒绝策略分别是什么?生产环境推荐哪种?
回答:
AbortPolicy(抛异常,默认)、CallerRunsPolicy(由提交线程执行)、DiscardPolicy(静默丢弃)、DiscardOldestPolicy(丢弃队列最老任务)。生产推荐 CallerRunsPolicy 或自定义策略(记录日志 + 持久化到 DB/MQ 后异步重试),不推荐静默丢弃。
ThreadPoolExecutor executor = new ThreadPoolExecutor(
8, 32, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1024),
new ThreadFactoryBuilder().setNameFormat("biz-pool-%d").build(),
(r, e) -> {
log.warn("任务被拒绝: {}", r);
// 持久化到 Redis/DB,后续补偿执行
}
);
Tips: 一定不要用 Executors.newFixedThreadPool(),面试官会追问为什么(无界队列 OOM 风险)。
标准回答:
volatile 保证可见性(修改后立即刷新主内存)和有序性(禁止指令重排),但不保证原子性;synchronized 保证可见性、有序性和原子性。volatile 本质是通过内存屏障实现的,写操作前插入 StoreStore 屏障,读操作后插入 LoadLoad 屏障。
追问:volatile 能保证 i++ 的线程安全吗?为什么?
回答:
不能。i++ 不是原子操作(读取→加1→写回),volatile 只保证读到最新值,但两个线程可能同时读到相同值再各自 +1 写回,结果丢失一次更新。解决方案:AtomicInteger(CAS)、synchronized 或 LongAdder(分段累加,高并发更优)。
// LongAdder 比 AtomicInteger 高并发性能更好
LongAdder counter = new LongAdder();
counter.add(1);
long sum = counter.sum();
Tips: 能提到 LongAdder 的分段 CAS 思路(Cell 数组)是加分项。
标准回答:
四种基础算法:标记-清除(碎片问题)、标记-整理(移动开销)、复制(空间浪费)、分代收集。常见收集器:CMS(低延迟,已废弃)、G1(Region 化,可预测停顿)、ZGC(着色指针,亚毫秒停顿)、Parallel Scavenge(吞吐优先)。JDK 8 默认 Parallel + ParOld,JDK 9+ 默认 G1。
追问:G1 的 Mixed GC 触发条件和回收流程?
回答:
当老年代占用达到 IHOP 阈值(InitiatingHeapOccupancyPercent,默认 45%)时触发。流程:并发标记 → 最终标记 → 筛选回收(选择回收价值高的 Region)。G1 可通过 -XX:MaxGCPauseMillis 设定目标停顿时间,收集器据此选择回收哪些 Region。
Tips: 提到 ZGC 的着色指针(Colored Pointers)和读屏障(Load Barrier)是加分亮点。
标准回答:
AQS(AbstractQueuedSynchronizer)是并发锁的底层框架,核心是一个 volatile int state + CLH 双向等待队列。独占模式(如 ReentrantLock)通过 tryAcquire/tryRelease 操作 state,共享模式(如 Semaphore)通过 tryAcquireShared/tryReleaseShared 操作 state。获取失败时线程封装为 Node 入队,通过 LockSupport.park/unpark 挂起和唤醒。
追问:AQS 的公平锁和非公平锁实现有什么区别?
回答:
非公平锁在 lock() 时先直接 CAS 尝试获取 state(可能插队),失败后再走 acquire() 入队流程;公平锁在 tryAcquire() 中先检查 hasQueuedPredecessors(),队列有前驱节点则直接返回 false 不抢锁。非公平吞吐更高但可能导致饥饿。
// 非公平锁的 lock() —— 先尝试插队
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
// 公平锁的 tryAcquire() —— 先检查队列
protected final boolean tryAcquire(int acquires) {
if (c == 0) {
if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
}
// ...
}
Tips: 能手画 CLH 队列结构(prev/next/nextWaiter/status)会加分。
标准回答:
当元素数量超过 threshold(capacity × loadFactor,默认 16 × 0.75 = 12)时触发扩容。JDK 8 创建新数组(容量翻倍),遍历旧数组每个桶:单节点直接重新 hash 定位;链表拆成高位链和低位链(通过 hash & oldCap == 0 判断);红黑树拆分,节点数 ≤ 6 时退化为链表。
追问:为什么多线程扩容会导致死循环?JDK 8 修复了吗?
回答:
JDK 7 使用头插法,多线程扩容时链表会反转,形成环形链表导致死循环。JDK 8 改用尾插法 + 高低位拆分,不会反转链表,解决了死循环问题。但 HashMap 仍然不是线程安全的(数据覆盖、size 不准确等问题仍存在)。
Tips: 能说出 "高低位拆分用 hash & oldCap 判断" 就是区分度。
标准回答:
Java 8:Lambda 表达式、Stream API、Optional、函数式接口、方法引用、CompletableFuture、新日期 API(java.time)、默认方法。Java 17(LTS):密封类(sealed classes)、模式匹配 instanceof、文本块、switch 表达式、记录类(record)、伪随机数生成器增强。Spring Boot 3.x 要求最低 Java 17。
追问:sealed class 和 final 有什么区别?
回答:
final 类不能被任何类继承;sealed class 通过 permits 关键字显式指定允许继承的子类,子类必须是 final、sealed 或 non-sealed 的。sealed 比-final 更灵活,允许受限的继承层次,配合模式匹配 switch 使用更优雅。
public sealed interface Shape permits Circle, Rectangle, Triangle {}
public record Circle(double radius) implements Shape {}
public record Rectangle(double w, double h) implements Shape {}
public record Triangle(double a, double b, double c) implements Shape {}
// 模式匹配 switch
double area = switch (shape) {
case Circle(var r) -> Math.PI * r * r;
case Rectangle(var w, var h) -> w * h;
case Triangle(var a, var b, var c) -> {
double s = (a + b + c) / 2;
yield Math.sqrt(s * (s-a) * (s-b) * (s-c));
}
};
Tips: 提到 Spring Boot 3 必须 Java 17 说明你关注版本关系。
标准回答:
CompletableFuture 是 Java 8 引入的异步编程工具,实现了 Future 和 CompletionStage 接口。支持链式调用(thenApply/thenAccept)、组合(thenCombine/allOf/anyOf)、异常处理(exceptionally/handle)。底层基于 ForkJoinPool 或指定线程池执行,通过栈(Completion 链)管理回调。
追问:thenApply 和 thenCompose 的区别?
回答:
thenApply 类似 map,接收 Function<T, U>,返回 CompletableFuture<U>;thenCompose 类似 flatMap,接收 Function<T, CompletableFuture<U>>,返回 CompletableFuture<U>(自动展平)。whenComplete 不改变结果类型只做副作用。链式调用时 thenCompose 更适合组合多个异步步骤。
CompletableFuture<String> future = CompletableFuture
.supplyAsync(() -> getUserId())
.thenCompose(id -> getUserInfo(id)) // 返回 CF,自动展平
.thenApply(user -> user.getName())
.exceptionally(ex -> "default");
Tips: 别忘了提线程池指定,默认 ForkJoinPool 在 IO 密集时可能不够用。
标准回答:
五种状态:RUNNING(接收新任务并处理队列任务)、SHUTDOWN(不接收新任务但处理队列任务,调用 shutdown())、STOP(不接收不处理并中断进行中任务,调用 shutdownNow())、TIDYING(所有任务终止,workerCount=0)、TERMINATED(terminated() 方法执行完成)。状态存储在 ctl 高 3 位。
追问:shutdown() 和 shutdownNow() 的区别?
回答:
shutdown() 平滑关闭:拒绝新任务,等待已提交任务和队列任务完成;shutdownNow() 强制关闭:拒绝新任务、中断正在执行的任务、返回队列中未执行的任务列表。生产中推荐先 shutdown(),再 awaitTermination(timeout) 等待,超时后 shutdownNow()。
executor.shutdown();
if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
executor.shutdownNow();
log.warn("线程池未在 30s 内优雅关闭,已强制终止");
}
Tips: 能写出优雅关闭的代码模板是加分项。
标准回答:
CAS(Compare And Swap)是无锁并发的核心操作:比较内存值与预期值,相等则更新为新值,整个过程原子性由 CPU 指令保证(x86 的 CMPXCHG)。ABA 问题是值从 A→B→A 变回原值,CAS 认为没变过。解决方案:AtomicStampedReference(加版本号)或 AtomicMarkableReference(加布尔标记)。
追问:Unsafe 类的 compareAndSwapInt 是如何保证原子性的?
回答:
底层调用 C++ 的 Atomic::cmpxchg,在 x86 架构上对应 LOCK CMPXCHG 指令,LOCK 前缀锁总线(或使用缓存一致性协议 MESI),确保多核下该指令的原子性。JDK 9+ 用 VarHandle 替代了部分 Unsafe 操作。
Tips: 提到 LOCK 前缀和 MESI 协议说明你理解硬件层面。
标准回答:
happens-before 是 JMM 定义的偏序关系,如果 A happens-before B,则 A 的操作结果对 B 可见。核心规则:程序顺序规则、volatile 写先于 volatile 读、synchronized 解锁先于后续加锁、线程 start() 先于其 run() 内容、线程 join() 返回先于后续操作、传递性规则。
追问:volatile 如何利用 happens-before 保证可见性?
回答:
volatile 写操作 happens-before 后续对同一变量的 volatile 读。JMM 通过内存屏障实现:volatile 写前插入 StoreStore 屏障(确保前面的写完成),写后插入 StoreLoad 屏障(确保写对其他线程可见);volatile 读后插入 LoadLoad 和 LoadStore 屏障。这保证了写操作的可见性传播。
Tips: happens-before 不是时间上的先后,而是可见性保证,这个区分很重要。
标准回答:
G1 把堆划分为等大 Region(1-32MB),支持 Mixed GC 回收老年代和新生代,通过 -XX:MaxGCPauseMillis 控制目标停顿。ZGC(JDK 15+ 生产可用)也用 Region 但是动态大小的,通过着色指针(Color Pointers)+ 读屏障(Load Barrier)实现并发整理,停顿时间 < 1ms 且不随堆大小增长。
追问:ZGC 的读屏障是如何工作的?
回答:
对象引用加载时检查指针的 marked 位,如果颜色不对说明对象正在被移动,读屏障会自动修正指针(自愈)并指向新地址。这样 GC 移动对象时不需要 STW 来修正引用,应用线程自己做。代价是每次对象引用读取都多一次判断(约 4% 吞吐下降)。
Tips: 提到 "着色指针" 和 "读屏障自愈" 两个关键词就够了。
标准回答:
三步走:(1) 保留现场:-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/dump.hprof 自动导出堆快照;(2) 分析 dump:用 MAT 或 VisualVM 找到支配树中最大的对象、GC Roots 引用链;(3) 定位代码:结合 Shallow Heap vs Retained Heap 区分大对象本身和它引用的对象总量。常见原因:内存泄漏(ThreadLocal 未清理、静态集合持续增长)、大对象分配(大文件一次性读入)。
追问:如何区分内存泄漏和内存溢出?
回答:
内存溢出是确实需要这么多内存但堆不够,加内存或优化数据结构可解决;内存泄漏是对象不再使用但 GC 无法回收(仍被 GC Roots 引用),加内存只是延缓。排查方法:多次 dump 对比,看某类对象数量持续增长且不回落就是泄漏。用 jmap -histo:live 触发 Full GC 后对比效果更明显。
# 排查命令链
jmap -histo:live <pid> | head -20 # GC后对象统计
jmap -dump:format=b,file=dump.hprof <pid> # 导出堆dump
jstat -gcutil <pid> 1000 10 # GC趋势观察
Tips: 能说清 "泄漏 vs 溢出" 的区别和排查手段,面试官会认可。
标准回答:
类加载五个阶段:加载(找 class 文件)→ 链接(验证、准备、分配默认值)→ 初始化(clinit)。双亲委派:加载器先委托父加载器加载,父加载器找不到再自己加载。保证核心类(如 java.lang.Object)不会被自定义类覆盖。打破双亲委派的场景:SPI(JDBC 用线程上下文类加载器)、Tomcat(每个 WebApp 独立类加载器)、OSGi(网状委托)。
追问:Tomcat 是如何打破双亲委派的?
回答:
Tomcat 的 WebAppClassLoader 先自己加载 WEB-INF/classes 和 WEB-INF/lib 下的类(不走双亲委派),加载不到再委托父加载器。这样不同 Web 应用可以使用同一库的不同版本互不干扰。但核心类(java. 开头)仍然走双亲委派保证安全。
Tips: 能举 SPI 和 Tomcat 两个打破双亲委派的例子足够了。
标准回答:
Java 泛型在编译时进行类型检查,编译后擦除为原始类型(Raw Type),运行时不存在泛型信息。擦除规则:无界擦除为 Object,有界擦除为上界类型。影响:不能 new T()、不能 instanceOf 泛型、不能创建泛型数组。桥方法(Bridge Method)由编译器生成保证多态正确性。
追问:泛型擦除后,运行时还能获取泛型信息吗?
回答:
可以通过反射部分获取:类继承上的泛型信息(getGenericSuperclass / getGenericInterfaces)保留在 Class 文件的 Signature 属性中。Spring 的 ResolvableType、Jackson 的 TypeReference 就是利用这个原理。但局部变量的泛型信息编译后确实丢失。
// 通过匿名子类保留泛型信息
TypeReference<List<String>> type = new TypeReference<>() {};
// type.getType() 运行时仍可获取 List<String>
Tips: 提到 TypeReference 和 Spring 的 ResolvableType 说明实战经验。
标准回答:
ThreadLocalMap 的 Entry 继承 WeakReference<ThreadLocal<?>>,Key 是弱引用会被 GC 回收,但 Value 是强引用。Key 被 GC 后 Value 仍存在,无法被访问也无法被回收(除非线程结束)。线程池场景线程复用,泄漏更严重。解决方案:使用后必须调用 remove(),最好放在 finally 块中。
追问:为什么 Key 设计为弱引用而不是强引用?
回答:
如果 Key 是强引用,即使 ThreadLocal 对象设为 null,Entry 仍然持有它和 Value,两者都无法回收,泄漏更严重。弱引用至少保证 ThreadLocal 对象可以被 GC,然后 Entry 的 Key 变 null。ThreadLocalMap 在 get/set/remove 时会顺带清理 Key 为 null 的 Entry(expungeStaleEntry),但不是及时的,所以必须手动 remove。
// 正确用法
ThreadLocal<Connection> connHolder = new ThreadLocal<>();
try {
connHolder.set(getConnection());
// 业务逻辑
} finally {
connHolder.remove(); // 必须!
}
Tips: 强调 "线程池场景必须 remove()" 是一线经验。
标准回答:
锁粗化(Lock Coarsening):JIT 检测到同一对象连续加锁/解锁,将多次锁操作合并为一次,减少锁开销。锁消除(Lock Elimination):JIT 通过逃逸分析发现锁对象不会逃出方法(不可能被其他线程访问),直接消除锁操作。两者都是 JIT 编译器的自动优化。
追问:逃逸分析还能做哪些优化?
回答:
除了锁消除,逃逸分析还支持:栈上分配(对象不逃出方法则在栈上分配,无需 GC)、标量替换(将对象拆解为基本类型成员直接在栈上使用)。通过 -XX:+DoEscapeAnalysis 开启(默认开启),-XX:+PrintEscapeAnalysis 可查看分析结果。
// 锁消除示例:StringBuffer 不逃出方法
public String concat(String a, String b) {
StringBuffer sb = new StringBuffer(); // 不逃出
sb.append(a);
sb.append(b); // JIT 消除这两次 synchronized
return sb.toString();
}
Tips: 锁粗化/锁消除是 JIT 优化,非 JVM 字节码层面,注意说清楚。
标准回答:
虚拟线程是 JDK 21 正式引入的轻量级线程,由 JVM 而非 OS 管理,创建和调度开销极小(可创建百万级)。底层是用户态的 Fiber,挂起时释放载体线程(Platform Thread),恢复时可能换一个载体线程。适合 IO 密集型场景(如大量 HTTP 调用、数据库查询),大幅提升吞吐量。使用 Executors.newVirtualThreadPerTaskExecutor() 创建。
追问:虚拟线程和协程(Kotlin Coroutines)的区别?
回答:
虚拟线程是 JVM 级别的 M:N 调度(M 个虚拟线程映射到 N 个平台线程),对现有代码几乎透明,不需要 async/await 语法;Kotlin 协程是语言级别的实现,需要 suspend 函数和协程作用域。虚拟线程的优势是与现有阻塞式 API 天然兼容,无需改造代码;劣势是当前不支持 finalizer、不推荐使用 synchronized(会 pin 住载体线程),建议用 ReentrantLock 替代。
// 虚拟线程示例
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
IntStream.range(0, 100_000).forEach(i -> {
executor.submit(() -> {
Thread.sleep(Duration.ofSeconds(1));
return i;
});
});
} // 10万并发,只需少量平台线程
Tips: 提到 "synchronized 会 pin 住载体线程" 说明你了解实际限制。
标准回答:
record 是不可变数据载体类,自动生成 constructor/getter/equals/hashCode/toString,适合做 DTO、Value Object。sealed class 限制继承层次,配合 record 和模式匹配实现代数数据类型(ADT),使类型安全的 exhaustive switch 成为可能。Spring Framework 6 已支持 sealed class 作为配置类。
追问:record 能实现接口吗?能定义实例字段吗?
回答:
record 可以实现接口,但不能继承类(隐式继承 java.lang.Record)。不能定义实例字段(只有组件对应的 private final 字段),但可以定义静态字段和静态方法。可以在 compact constructor 中添加校验逻辑。
// record + sealed 实现类型安全的返回值
public sealed interface Result<T> {
record Success<T>(T data) implements Result<T> {}
record Failure<T>(String code, String msg) implements Result<T> {}
}
// 模式匹配
Result<Order> result = process(order);
switch (result) {
case Success(var data) -> log.info("成功: {}", data);
case Failure(var code, var msg) -> log.error("失败: {} - {}", code, msg);
// 编译器检查穷举性,无需 default
}
Tips: 用 sealed + record + pattern matching 三件套举例最有说服力。
| 考察方向 | 题号 | 核心关键词 |
|---|---|---|
| 锁机制 | Q01, Q04, Q18 | 锁升级、volatile、JIT优化 |
| 并发容器 | Q02, Q07 | CHM、resize、高低位拆分 |
| 线程池 | Q03, Q10 | 七大参数、拒绝策略、生命周期 |
| JUC框架 | Q06, Q11, Q12 | AQS、CAS、happens-before |
| GC | Q05, Q13 | G1 Mixed GC、ZGC着色指针 |
| JVM诊断 | Q14, Q15 | OOM排查、双亲委派 |
| 类型系统 | Q16, Q17, Q20 | 泛型擦除、ThreadLocal、sealed |
| 新特性 | Q08, Q09, Q19 | CompletableFuture、虚拟线程、record |