面试题集锦:JVM 内存、GC 与调优问答

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:20 题
重点:Q11(Virtual Threads 补课)、Q9-Q10(结合线上故障排查思路的教学案例)、Q13-Q14(Virtual Threads vs Go)
Q1:JVM 内存区域划分 + 元空间
TL;DR
JVM 运行时数据区 = 堆(对象实例)+ 方法区/元空间(类信息、常量)+ 栈(方法调用、局部变量)+ 程序计数器(当前执行位置)+ 本地方法栈(Native 方法)。JDK 8 元空间替代永久代,用本地内存而非堆内存。
类比
🏢 办公楼:堆 = 仓库(所有人共享,放货/GC 就是清理仓库),栈 = 每人独立工位(方法调用压栈,结束出栈),元空间 = 公司档案室(存类定义和常量,不是货也不是工位)。
区域划分
| 区域 | 存储内容 | 线程 | GC | 异常 |
|---|---|---|---|---|
| 堆 | 对象实例、数组 | 共享 | ✅ | OOM: Java heap space |
| 元空间 | 类元数据、方法信息、常量池 | 共享 | ✅ | OOM: Metaspace |
| 栈 | 局部变量、操作数栈、帧数据 | 私有 | ❌ | StackOverflowError |
| 程序计数器 | 当前字节码行号 | 私有 | ❌ | — |
| 本地方法栈 | Native 方法 | 私有 | ❌ | StackOverflowError |
元空间 vs 永久代
| 永久代 (JDK ≤7) | 元空间 (JDK ≥8) | |
|---|---|---|
| 存储位置 | 堆内 | 本地内存(堆外) |
| 大小 | -XX:MaxPermSize 固定 | 默认无上限,受物理内存限制 |
| OOM 风险 | 容易 PermGen OOM | 需大量动态生成类才会 OOM |
| 字符串常量池 | 在永久代 | 移到堆中 |
记忆锚
"堆放对象,栈管调用,元空间存类信息——JDK8 搬家到堆外"
Q2:GC 算法对比
TL;DR
三种基础 GC 算法:标记-清除(有碎片)→ 标记-复制(无碎片但浪费一半)→ 标记-整理(无碎片但慢)。JVM 分代收集:新生代用复制(对象朝生夕死),老年代用整理(对象长期存活)。
类比
🗑️ 三种倒垃圾方式:
- 标记-清除 = 把垃圾袋挑出来扔掉 → 留下空隙,再放新东西要挪来挪去
- 标记-复制 = 把有用的搬到隔壁屋,整间屋清空 → 干净但需要两间屋
- 标记-整理 = 把有用的推到屋子一头,垃圾推到另一头扔掉 → 整齐但费力气
三种算法对比
| 算法 | 碎片 | 速度 | 空间 | 适用 |
|---|---|---|---|---|
| 标记-清除 | ❌ 有碎片 | 快(只标记+清除) | 不浪费 | CMS 老年代 |
| 标记-复制 | ✅ 无碎片 | 快(批量复制) | 浪费 50% | 新生代(对象少,浪费一半无所谓) |
| 标记-整理 | ✅ 无碎片 | 慢(移动对象) | 不浪费 | Serial Old / Parallel Old |
分代收集
新生代(Young Gen):对象朝生夕死 → 用"标记-复制"(快,浪费一半不心疼)
每次 Minor GC:Eden 活着的对象 → Survivor 区,Survivor 满了 → 老年代
老年代(Old Gen):对象长期存活 → 用"标记-整理"或"标记-清除"
对象经历了 N 次 Minor GC 还活着 → 晋升到老年代
大对象(如大数组)→ 直接进老年代
记忆锚
"新生用复制(快),老年代用整理(稳),GC 分代各有分工"
Q3:G1 GC 原理与调优
TL;DR
G1 = Region 化堆(不分代大小,分 2048 个 Region)+ Mixed GC(同时回收新生代和部分老年代)+ SATB(快照标记算法)+ 停顿预测模型。核心参数:-XX:MaxGCPauseMillis=200。
类比
🧩 拼图游戏:整个堆 = 2048 个拼图块(Region)。每次 GC 不拼全图,只挑"最有价值的几块"(Garbage 最多的 Region)来清理。先拼四个角(回收效益最大的 Region),停 200ms 就停手。
G1 核心概念
| 概念 | 说明 |
|---|---|
| Region | 1-32MB 的堆区块,共 2048 个 |
| Mixed GC | 不仅回收新生代,还回收部分老年代 |
| SATB | Snapshot-At-The-Beginning,快照标记算法 |
| Remembered Set (RSet) | 记录"有哪些 Region 引用了我这个 Region",避免全堆扫描 |
| 停顿预测模型 | 根据历史 GC 数据预测这次回收能停多久 |
G1 调优参数
-XX:+UseG1GC # 启用 G1
-XX:MaxGCPauseMillis=200 # 目标最大停顿 200ms(核心!)
-XX:G1HeapRegionSize=16m # Region 大小(2^n,1-32MB)
-XX:InitiatingHeapOccupancyPercent=45 # 堆占用 45% 触发 Mixed GC
-XX:G1ReservePercent=10 # 保留 10% 堆空间防止晋升失败
调优铁三角
MaxGCPauseMillis 设小 → 每次回收的 Region 少 → GC 频率变高
MaxGCPauseMillis 设大 → 每次回收的 Region 多 → 单次停顿长但频率低
风控系统:P99 < 50ms → MaxGCPauseMillis=50
离线报表:不在乎停顿 → MaxGCPauseMillis=1000
记忆锚
"Region 拼图 + SATB 快照 + Mixed GC + 设 MaxGCPauseMillis"
Q4:ZGC 原理(染色指针 + 读屏障)
TL;DR
ZGC = 目标亚毫秒停顿的 GC。核心技术:染色指针(在指针里存 GC 状态,不占对象头)+ 读屏障(访问对象时检查指针颜色,并发处理)+ 并发整理(移动对象和应用线程同时进行)。
类比
⚡ 手术中换心脏:传统 GC 要"停心跳→换心→重启"(STW)。ZGC 在心脏跳动的同时(并发),通过体外循环机(读屏障)维持血液循环(对象访问),悄悄把旧心脏换成新的。病人全程清醒。
染色指针(Colored Pointer)
普通 64 位指针:地址用了 42 位,高 22 位闲着
ZGC 染色指针:高 4 位用来存 GC 状态标记(颜色)
┌──4 bits──┬─────────────────42 bits────────────────┬──18 bits──┐
│ Color │ 对象地址 │ 保留 │
└──────────┴────────────────────────────────────────┴───────────┘
颜色含义:
00 = Remapped(已搬完,正常状态)
01 = Marked0 / 10 = Marked1(交替使用,标记中)
11 = 尚未使用
读屏障
// 伪代码:读屏障
Object readReference(Object* p) {
Object obj = *p;
if (isBadColor(obj)) {
// 颜色不对 → 触发修复:要么标记,要么转发到新地址
return fixColor(p, obj);
}
return obj;
}ZGC vs G1
| G1 | ZGC | |
|---|---|---|
| 目标停顿 | <200ms | <1ms(亚毫秒) |
| 技术核心 | Region + SATB | 染色指针 + 读屏障 |
| 指针限制 | 无 | 需要 64 位指针中 4 位做标记 |
| 适用 | 大多数应用 | 超低延迟系统(交易/风控) |
| 内存开销 | 低 | 高(染色指针 + 对象转发表) |
记忆锚
"染色指针标状态 + 读屏障救场 + 并发搬对象 = 毫秒级停顿"
Q5:类加载机制 + 双亲委派 + 打破场景
TL;DR
类加载 = 加载→验证→准备→解析→初始化。双亲委派:子加载器先问父加载器,逐级向上,找到为止。打破场景:Tomcat(WebApp 隔离)→ SPI(JDBC Driver 用线程上下文加载器反向加载)→ OSGi(网状加载)。
类比
👨👩👧 家庭寻物链:孩子(App ClassLoader)找东西,先问爸爸(Ext ClassLoader)有没有,爸爸问爷爷(Bootstrap ClassLoader),爷爷找不到才让孩子自己找。加载顺序:爷爷→爸爸→孩子。
双亲委派模型
三个打破场景
| 场景 | 打破方式 | 为什么 |
|---|---|---|
| Tomcat | 每个 WebApp 用自己的 WebappClassLoader | 不同应用的同名类隔离(App1 的 v1.0,App2 的 v2.0) |
| SPI(如 JDBC) | ThreadContextClassLoader | Driver 在 Bootstrap 层,但实现类在 App 层,Bootstrap 找不到 → 用 TCCL 反向找 |
| OSGi | 网状委派 | 模块间可见性由 Import/Export 声明控制 |
Tomcat 类加载
每个 WebApp 独立 ClassLoader:
WebApp1 → 用 v1.0 的 UserService
WebApp2 → 用 v2.0 的 UserService
互不影响!
而且 WebappClassLoader 先自己加载(不走双亲),再委托给父:
→ 破坏了双亲委派顺序,但实现了应用隔离
记忆锚
"孩子问爸爸,爸爸问爷爷——Tomcat 家孩子自己先找,不按套路"
Q6:JVM 调优实战:GC 日志解读 + 参数优化
TL;DR
开启 GC 日志:-Xlog:gc*:file=gc.log:time,level,tags(JDK 9+)。关键指标:停顿时间(越大越卡)、GC 频率(越高越消耗 CPU)、晋升量(突然暴增 = 内存泄漏)。
一段真实的 GC 日志(G1)
[2025-06-15T10:30:15.123+0800] GC(42) Pause Young (Normal) (G1 Evacuation Pause)
22M->15M(256M) 8.5ms
[2025-06-15T10:30:16.456+0800] GC(43) Pause Young (Concurrent Start) (Metadata GC Threshold)
158M->142M(256M) 12.3ms
[2025-06-15T10:30:17.789+0800] GC(46) Pause Full (G1 Evacuation Pause)
250M->248M(256M) 452.8ms ← ⚠️ Full GC!456ms 停顿!
解读
22M→15M(256M) 8.5ms
↓ ↓ ↓ ↓
回收前 回收后 堆总大小 本次 GC 耗时
异常信号
| 信号 | 含义 | 排查方向 |
|---|---|---|
| Full GC 频繁(每几秒一次) | 老年代满了 → 内存泄漏或堆太小 | 调大堆 / dump 分析 |
| GC 后回收量极少(250→248M) | 全是活对象,回收不了 → 内存泄漏 | 排查大对象/集合 |
| Promotion Failed | 老年代装不下新生代晋升 → 触发 Full GC | 增大老年代或减小新生代 |
| To-space overflow | Survivor 区太小 | 调大 SurvivorRatio |
风控低延迟系统 GC 参数
java -Xms4G -Xmx4G \ # 堆固定 4G(避免动态扩缩)
-XX:+UseZGC \ # ZGC(亚毫秒停顿)
-XX:ZCollectionInterval=5 \ # 每 5 秒触发一次 ZGC
-XX:+UseStringDeduplication \ # 字符串去重
-XX:+AlwaysPreTouch \ # 启动时预分配物理内存
-Xlog:gc*:file=/var/log/gc.log:time,level,tags:filecount=10,filesize=100M \
-jar risk-engine.jar记忆锚
"停顿时间 + GC 频率 + 晋升量 三个数看 GC 健康,ZGC 是风控首选"
Q7:OOM 排查 + MAT 堆转储分析
TL;DR
OOM 排查 = 保留现场(-XX:+HeapDumpOnOutOfMemoryError)→ MAT 打开 hprof → Dominator Tree 找最大对象 → Leak Suspect 自动报告 → GC Root 路径分析。
类比
🔍 法医尸检:heap dump = 尸体解剖报告,MAT = 法医工具。Dominator Tree 告诉你"谁占的身体比例最大",Leak Suspect 告诉你"疑似死因",GC Root 路径 = 凶手作案的完整证据链。
排查 5 步
1. 获取 heap dump:
- 启动参数:-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/
- 手动:jmap -dump:format=b,file=heap.hprof <pid>
2. MAT 打开 hprof → 查看 Overview
3. Dominator Tree(支配树):
→ 看 Retained Heap 最大的是谁(它和它引用的所有对象占了多少内存)
4. Leak Suspect(泄漏嫌疑人):
→ MAT 自动分析,给出 Top N 可疑对象
5. GC Root 路径:
→ 选中大对象 → Path to GC Roots → 看引用链
→ 例:Thread → ThreadLocalMap → HashMap → 100万个Entry
四种 OOM 类型
| 类型 | 错误信息 | 常见原因 |
|---|---|---|
| 堆 OOM | Java heap space | 内存泄漏 / 堆太小 / 大对象 |
| 元空间 OOM | Metaspace | 动态生成太多类(CGLIB 代理) |
| 直接内存 OOM | Direct buffer memory | 堆外内存未释放(Netty ByteBuf) |
| 线程 OOM | unable to create new native thread | 线程创建太多超过 OS 限制 |
记忆锚
"dump 现场→Dominator Tree 找大户→GC Root 追引用链"
Q8:JVM 性能监控工具链
TL;DR
jps(找进程)→ jstack(看线程栈/死锁)→ jmap(看堆/dump)→ jstat(GC 统计)→ Arthas(阿里神器,在线排查)。生产环境优先用 Arthas。
工具速查
| 工具 | 命令 | 用途 | 金句 |
|---|---|---|---|
| jps | jps -l | 列出所有 Java 进程 | "哪个进程是我的" |
| jstack | jstack <pid> | 线程快照 + 死锁检测 | "线程都在干嘛" |
| jmap | jmap -histo <pid> | 堆对象统计 | "谁占内存最多" |
| jstat | jstat -gc <pid> 1000 | GC 实时监控 | "GC 的实时战况" |
| jinfo | jinfo <pid> | 查看/修改 JVM 参数 | "当前的 JVM 配置" |
| Arthas | dashboard / thread / jad | 在线诊断(不重启!) | "瑞士军刀,生产利器" |
Arthas 高频命令
dashboard # 实时面板:CPU/内存/GC/线程
thread -n 5 # CPU 最高的 5 个线程
thread -b # 检测死锁
jad com.xxx.Service # 反编译线上运行的代码(比源码还准!)
watch com.xxx.Service method '{params, returnObj}' # 方法出入参监控
trace com.xxx.Service method # 方法调用链路耗时记忆锚
"jps 找进程→jstack 看线程→jmap 查堆→Arthas 在线修"
Q9:线上频繁 GC(minor/major/full)定位和排查思路
TL;DR
频繁 GC 排查 = jstat 看 GC 频率和回收量 → 回收量极少 = 内存泄漏 → dump 分析;回收量正常但频率高 = 堆太小/对象分配太快 → 调大堆或优化代码。
类比
🗑️ 垃圾桶总是满:两种情况——①垃圾桶太小(堆不够大,正常用也满);②有人偷偷往你垃圾桶扔东西(内存泄漏)。
排查决策树
具体命令
# 看 GC 频率和回收情况
jstat -gcutil <pid> 1000
# 输出:S0 S1 E O M YGC YGCT FGC FGCT GCT
# 0 50 80 95 90 120 3.5 20 12.3 15.8
# 解读:O(老年代) = 95%,FGC(Full GC次数) = 20 → 老年代快满了!常见根因
1. 大对象直接老年代 → -XX:PretenureSizeThreshold=1m(超过 1MB 先进老年代)
2. 代码创建大量临时对象 → String 拼接/StringBuilder/Stream 滥用
3. ThreadLocal 没 remove → 线程复用导致数据累积
4. 缓存没上限 → 用 Caffeine 代替 HashMap 做缓存
记忆锚
"jstat 看频率→回收少=泄漏→dump;回收多=堆小/对象多→调参"
Q10:OOM + StackOverflow 排查
TL;DR
OOM 排查见 Q7(dump→MAT→GC Root)。StackOverflow = 递归太深或循环依赖。快速定位:看堆栈最底部的反复出现的类和方法名。
StackOverflow 排查
// 典型场景 1:无限递归
public int fib(int n) {
return fib(n); // ← 没有终止条件!
}
// 典型场景 2:循环依赖
A a = new A();
B b = new B();
a.setB(b);
b.setA(a);
// → Spring 中构造器循环依赖也会导致区分 OOM 和 StackOverflow
| OOM | StackOverflow | |
|---|---|---|
| 根因 | 堆空间不够放对象 | 栈帧太多(递归太深) |
| 错误 | OutOfMemoryError | StackOverflowError |
| 定位工具 | heap dump + MAT | jstack 看线程栈底部 |
| 解决 | 调大堆 / 修泄漏 | 修递归终止条件 / 加尾递归 |
记忆锚
"OOM dump 查大户,StackOverflow 栈底看重复"
Q11:线上 Full GC 频繁——JVM 参数调优 + G1 vs CMS
TL;DR
Full GC 频繁 → 先调 MaxGCPauseMillis(G1) → 再调大堆(不行就说明泄漏了) → 降级到 dump 分析。G1 相比 CMS:不会产生碎片、有停顿预测、Mixed GC 比 CMS 的并发回收更可控。
G1 vs CMS
| CMS | G1 | |
|---|---|---|
| 算法 | 标记-清除(有碎片) | 标记-整理(无碎片) |
| 碎片问题 | ✅ 严重 → 碎片导致 Concurrent Mode Failure → Full GC | ❌ 无 |
| 停顿预测 | ❌ 无 | ✅ 有(基于历史数据) |
| Mixed GC | 只有老年代 GC | 同时回收新生代+部分老年代 |
| 状态 | JDK 14 已废弃 | 当前默认(JDK 9+) |
| 适用 | — | 大堆(>4GB)+ 低延迟 |
调优参数
# 从 CMS 迁移到 G1
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200 # 目标:每次 GC 最多 200ms
-XX:InitiatingHeapOccupancyPercent=45 # 堆占 45% 触发 Mixed GC
-XX:G1HeapRegionSize=16m # Region 大小
-XX:ConcGCThreads=4 # 并发 GC 线程数
# 如果 G1 还是频繁 Full GC → 大概率是内存泄漏
# 参数救不了逻辑 bug决策树
G1 频繁 Full GC →
├── 调大 Xmx(8G→16G)
├── 调小 InitiatingHeapOccupancyPercent(让 Mixed GC 更早触发)
├── 减小 MaxGCPauseMillis(每次 GC 干净点)
├── 还不行 → 大概率内存泄漏 → dump 分析
└── 终极方案:换 ZGC(亚毫秒)
记忆锚
"CMS 有碎片已被废弃,G1 有预测是当前默认,ZGC 是终极低延迟"
Q12:G1 和 ZGC 各适用于可观测性平台的哪些场景?
TL;DR
可观测性平台 GC 选型:指标采集 Agent(对延迟敏感)→ ZGC;离线日志批处理(吞吐优先)→ G1;流式处理(混合场景)→ G1 调小 MaxGCPauseMillis。
场景匹配
| 可观测性场景 | GC 选择 | 原因 |
|---|---|---|
| Metrics Agent(边车模式) | ZGC | 不能影响业务应用,P99 < 1ms |
| 日志采集 Fluentd | G1(调优) | 吞吐优先,延迟不敏感 |
| Trace Span 处理 | ZGC | 实时链路,延迟敏感 |
| Prometheus 查询 | G1 | 批量查询,吞吐优先 |
| ES 写入/聚合 | G1 | 大堆(16G+),停顿可接受 ~100ms |
记忆锚
"Agent 用 ZGC(不能拖累业务),后端用 G1(吞吐重要)"
Q13:Java Virtual Threads (Project Loom) 原理
TL;DR
虚拟线程 = JVM 内部管理的轻量级用户态线程,不 1:1 映射 OS 线程。遇到阻塞(IO/sleep)时自动 yield 到其他虚拟线程,由 ForkJoinPool 的 Carrier Thread 承载执行。核心价值:阻塞不再昂贵,百万并发不是梦。
类比
📞 呼叫中心接线员:传统线程 = 每个客户独占一个接线员(1000 个客户 = 1000 个接线员,成本巨大)。虚拟线程 = 智能排队系统,客户等待时(IO 阻塞)接线员去服务其他客户,客户数据(栈帧)存在系统里(堆内存),接线员回来时恢复。1 个接线员(Carrier Thread)可以同时服务几百个客户。
架构对比
传统平台线程: 虚拟线程:
Thread1 ── OS Thread1 VirtualThread1 ─┐
Thread2 ── OS Thread2 VirtualThread2 ─┤
Thread3 ── OS Thread3 VirtualThread3 ─┼── Carrier Thread (OS Thread)
Thread4 ── OS Thread4 VirtualThread4 ─┤
VirtualThread5 ─┘
OS 线程数 = 应用线程数 OS 线程数 ≪ 应用线程数
阻塞时发生了什么?
// 虚拟线程执行 HTTP 请求
Thread.ofVirtual().start(() -> {
String result = httpClient.get("https://api.大型加密货币交易所.com"); // IO 阻塞
// ↑ 阻塞时:虚拟线程的栈帧从 Carrier Thread 卸下,存到堆中
// Carrier Thread 去执行其他虚拟线程
// IO 完成后:栈帧恢复,继续执行
processResult(result);
});关键限制
✅ 适用:IO 密集型(HTTP 调用、DB 查询、文件读取)
❌ 不适用:
- CPU 密集型(虚拟线程不增加算力)
- synchronized 块内(JDK 21 以前会 pin 住 Carrier Thread,JDK 24 已修复)
- native 方法调用
记忆锚
"用户态线程 + IO 自动 yield + Carrier Thread 复用 = 百万并发不费劲"
Q14:Virtual Threads vs Go Goroutine 对比
TL;DR
两者都是用户态轻量级并发,核心机制类似:阻塞时自动切换。主要差异:Virtual Threads 由 JVM ForkJoinPool 调度,Goroutine 由 Go runtime GMP 调度;Goroutine 栈更小(2KB起步),Virtual Threads 栈动态分配。生产成熟度上 Go 更久经考验,但 Java 21+ 虚拟线程已可用。
对比表
| Virtual Threads (Java 21+) | Goroutine (Go) | |
|---|---|---|
| 调度模型 | ForkJoinPool + Carrier Thread | GMP(G→P→M) |
| 初始栈大小 | 动态(通常 ~200 字节对象头) | 2 KB |
| 栈扩容 | 动态分配,自动增长 | 动态增长,可到 1GB |
| 阻塞处理 | 自动 yield,栈帧存堆中 | 自动 yield,栈保留 |
| 抢占 | IO/sleep 时让出 | 基于协作 + 信号抢占(Go 1.14+) |
| API | Thread.ofVirtual().start(task) | go func(){}() |
| 通道/通信 | 无内置(用 BlockingQueue 等) | Channel(一等公民) |
| GC 影响 | 由 JVM GC 管理,大堆时 GC 是瓶颈 | Go GC 停顿更低 |
| 生产成熟度 | Java 21(2023.9),较新 | Go 1.0(2012),久经考验 |
选型建议
选 Java Virtual Threads:
- 已有 Java 技术栈,不想引入 Go
- 大量 IO 阻塞场景(HTTP/RPC/DB)
- 团队对 JVM 生态熟悉
选 Go Goroutine:
- 新项目,追求极致并发性能
- 需要超低 GC 停顿
- 微服务 + 云原生(K8s 生态)
- Channel 通信模型更适合你的业务
混合:
- 大型加密货币交易所 现实中可能就是:核心交易撮合用 Go(低延迟)
- 风控/管理后台用 Java(生态丰富 + Virtual Threads)
记忆锚
"同是用户态轻量调度,Go 更成熟更极致,Java 更生态更平滑迁移"
Q15:volatile 关键字——交易场景能否保证安全?
TL;DR
volatile = 可见性(一个线程修改,其他线程立即可见)+ 禁止指令重排序。但不能保证原子性!count++ 在 volatile 变量上仍不安全。交易场景:单写多读(如状态标记)可用,多写(如余额扣减)必须加锁或用 Atomic 类。
类比
📢 公司公告栏:volatile = 公告贴在栏上,全公司立即可见(可见性)。但如果两个人同时改公告(多写),谁先谁后没有保证(无原子性)。需要一个人拿锁进去改,其他人等(synchronized/Atomic)。
volatile 三特性
1. 可见性:写 volatile 变量时,JMM 强制刷新到主内存;读时强制从主内存拉取
2. 有序性:禁止指令重排序(通过内存屏障)
3. ❌ 无原子性:i++ 不是原子的(读→加→写 三步)
交易场景适用性
// ✅ 适合 volatile:状态标记
volatile boolean riskEngineReady = false; // 单写多读
// 风控引擎初始化完成 → 设 true → 其他线程看到 true 开始调用
// ❌ 不适合 volatile:余额扣减
volatile long balance = 100;
balance -= 10; // 不是原子操作!并发下会出错
// ✅ 正确:用 AtomicLong 或 synchronized
AtomicLong balance = new AtomicLong(100);
balance.addAndGet(-10); // CAS 原子操作记忆锚
"volatile 保可见禁重排,不保原子——交易场景单写多读 OK,多写不行"
Q16:ThreadLocal 原理 + 链路追踪传上下文
TL;DR
ThreadLocal = 每个线程一个独立 Map,key 是 ThreadLocal 对象的弱引用。用途:同一个线程内传递上下文,如链路追踪的 traceId、用户登录信息、DB 连接。核心:Thread.threadLocals(ThreadLocalMap)。
类比
🗄️ 个人储物柜:每个线程来上班时自带一个储物柜(ThreadLocalMap),ThreadLocal 是钥匙。你用钥匙打开自己的柜子,绝对拿不到同事的东西(线程隔离)。
原理
// Thread 对象里有一个 ThreadLocalMap
class Thread {
ThreadLocal.ThreadLocalMap threadLocals; // 每个线程私有的 Map
}
// ThreadLocal 的 get 方法
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = t.threadLocals;
ThreadLocalMap.Entry e = map.getEntry(this); // key = 当前 ThreadLocal 对象
return (T)e.value;
}链路追踪中的应用
// 请求入口处设置 traceId
public class TraceFilter implements Filter {
@Override
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) {
String traceId = UUID.randomUUID().toString();
TraceContext.setTraceId(traceId); // 存入 ThreadLocal
try {
chain.doFilter(req, resp);
} finally {
TraceContext.remove(); // ⚠️ 必须 remove!
}
}
}
// 任何地方获取
public class TraceContext {
private static final ThreadLocal<String> TRACE_ID = new ThreadLocal<>();
public static String getTraceId() { return TRACE_ID.get(); }
}记忆锚
"Thread 私有 Map + ThreadLocal 做 key + 用完必须 remove"
Q17:ThreadLocal 内存泄漏问题
TL;DR
ThreadLocal 泄漏 = ThreadLocalMap 的 Entry key 是弱引用(GC 回收 ThreadLocal 对象),但 value 是强引用 → key 为 null 后 value 永不回收。线程池场景下线程长期存活 → 泄漏累积 → OOM。
类比
🗄️ 储物柜钥匙丢了:ThreadLocal = 钥匙(弱引用,容易丢)。柜子里的东西(value)还在,但钥匙丢了拿不出来也扔不掉。线程(储物柜使用者)一直不离职(线程池复用),东西越积越多。
泄漏原理
// ThreadLocalMap.Entry
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value; // ← 强引用!
// key 是弱引用:GC 时 ThreadLocal 对象可能被回收 → key = null
// value 是强引用:只要 Thread 还活着,value 就永远存在
}为什么线程池下必泄漏?
线程池 → 核心线程长期存活 → Thread.threadLocals 不会释放
→ 每个请求 set ThreadLocal → 不 remove → Entry 累积
→ ThreadLocal 对象被 GC(key=null)→ value 挂死 → OOM
正确姿势
// ✅ 永远在 finally 中 remove
try {
UserContext.setUser(user);
// 业务逻辑
} finally {
UserContext.remove(); // ← 关键!
}记忆锚
"key 弱 value 强 + 线程池复用 = 必泄漏 → finally remove 是铁律"
Q18:Java 锁升级过程(偏向锁→轻量级锁→重量级锁)
TL;DR
synchronized 锁升级 = 无锁(对象头 001)→ 偏向锁(记录线程 ID,单线程免竞争,101)→ 轻量级锁(CAS 抢,无阻塞,00)→ 重量级锁(操作系统 mutex,阻塞,10)。这是 JVM 的自适应优化。
类比
🚪 办公室会议室使用规则:
- 偏向锁 = 张三常开会,会议室门牌写着"张三专用"——张三进出门不锁(免 CAS)
- 轻量级锁 = 李四也想用,擦掉张三名字,改为"正在使用"——李四在外面转圈等(CAS 自旋)
- 重量级锁 = 王五也来了,三人抢 → 上大锁 + 排号机(OS mutex),没拿到的人去休息室睡觉(阻塞)
升级过程
Mark Word 结构(64 位)
无锁: [unused:25][hash:31][unused:1][age:4][biased_lock:0][lock:01]
偏向锁: [thread:54][epoch:2][unused:1][age:4][biased_lock:1][lock:01]
轻量级锁: [pointer to lock record:62][lock:00]
重量级锁: [pointer to monitor:62][lock:10]
锁优化技巧
锁消除:JIT 发现不可能有竞争 → 去掉锁(如局部变量的 StringBuffer)
锁粗化:连续多个 synchronized → 合并成一个大锁块(减少加解锁次数)
自适应自旋:轻量级锁 CAS 自旋次数动态调整(以前固定 10 次,现在根据历史)
记忆锚
"无→偏(单线程)→轻(CAS 抢)→重(OS 锁),JVM 自适应升级"
Q19:线上内存泄漏 / CPU 飙升排查
TL;DR
CPU 飙升:top -H → 找最高 CPU 线程 → 转 16 进制 → jstack 定位代码行。内存泄漏:jstat 看堆持续上涨 → jmap dump → MAT 分析 → GC Root 追引用链。
注:本题与 B4 交叉,B4 将提供完整场景推断题。此处给出技术排查链。
CPU 飙升排查
# 1. 找到 CPU 最高的进程
top -c
# 2. 找到该进程中 CPU 最高的线程
top -Hp <pid>
# → 假设线程 ID = 12345
# 3. 线程 ID 转 16 进制
printf "%x\n" 12345
# → 0x3039
# 4. jstack 查该线程在做什么
jstack <pid> | grep -A 20 0x3039
# → 定位到具体代码行内存泄漏排查
# 1. 看 GC 趋势(堆是否持续上涨)
jstat -gcutil <pid> 1000
# 2. dump 堆
jmap -dump:format=b,file=heap.hprof <pid>
# 3. MAT 分析
# Dominator Tree → 看 Retained Heap
# Leak Suspect → 自动报告
# GC Root → 找引用链记忆锚
"CPU top→16进制→jstack;内存 jstat→dump→MAT→GC Root"
Q20:线上服务突然 CPU 飙高,排查思路
TL;DR
CPU 飙高排查三步:看是不是 GC(jstat -gc)→ 不是 GC 就看最高 CPU 线程(top -H + jstack)→ 找到具体代码行。可能性:死循环、频繁 GC、正则表达式回溯、JSON 解析大对象。
排查决策树
高频根因
1. 死循环 / 无限递归 → jstack 看线程栈,同一个方法反复出现
2. 正则表达式 ReDoS → 恶意输入导致回溯爆炸
3. 大 JSON 解析 → Jackson 解析 GB 级 JSON CPU 100%
4. HashMap 死循环(JDK7)→ 并发 resize 导致链表成环
5. 频繁 YGC → 每次回收量极少,CPU 全花在 GC 上
记忆锚
"先排除 GC,再 top 找线程,jstack 定代码,常见根因五个"
总结:JVM 面试万能答题链
问内存 → "堆放对象,栈管调用,元空间存类(JDK8 搬家到堆外)"
问 GC → "G1 拼图 + SATB,ZGC 染色指针 + 读屏障,风控选后者"
问调优 → "MaxGCPauseMillis 设目标,GCLog 看停顿,jstat 看频率"
问排查 → "CPU:top→jstack。内存:jstat→dump→MAT→GC Root"
问虚拟线程 → "用户态调度 + IO 自动 yield,百万并发不费劲,对标 Goroutine"
问锁升级 → "无→偏→轻→重,JVM 自适应选最优"
下一篇:B4 线上故障排查面试题(22 题)