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

通识对照:JMM、volatile 与 synchronized:共享可变状态的可见性合同与选型边界

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

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:20 题
重点:Q11(Virtual Threads 补课)、Q9-Q10(结合线上故障排查思路的教学案例)、Q13-Q14(Virtual Threads vs Go)


Q1:JVM 内存区域划分 + 元空间

TL;DR

JVM 运行时数据区 = 堆(对象实例)+ 方法区/元空间(类信息、常量)+ 栈(方法调用、局部变量)+ 程序计数器(当前执行位置)+ 本地方法栈(Native 方法)。JDK 8 元空间替代永久代,用本地内存而非堆内存。

类比

🏢 办公楼:堆 = 仓库(所有人共享,放货/GC 就是清理仓库),栈 = 每人独立工位(方法调用压栈,结束出栈),元空间 = 公司档案室(存类定义和常量,不是货也不是工位)。

区域划分

interview jvm qa · 图 1
interview jvm qa · 图 1 · 点击查看 SVG 原图
区域存储内容线程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 分代收集:新生代用复制(对象朝生夕死),老年代用整理(对象长期存活)。

类比

🗑️ 三种倒垃圾方式:

  • 标记-清除 = 把垃圾袋挑出来扔掉 → 留下空隙,再放新东西要挪来挪去
  • 标记-复制 = 把有用的搬到隔壁屋,整间屋清空 → 干净但需要两间屋
  • 标记-整理 = 把有用的推到屋子一头,垃圾推到另一头扔掉 → 整齐但费力气

三种算法对比

interview jvm qa · 图 2
interview jvm qa · 图 2 · 点击查看 SVG 原图
算法碎片速度空间适用
标记-清除❌ 有碎片快(只标记+清除)不浪费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 核心概念

interview jvm qa · 图 3
interview jvm qa · 图 3 · 点击查看 SVG 原图
概念说明
Region1-32MB 的堆区块,共 2048 个
Mixed GC不仅回收新生代,还回收部分老年代
SATBSnapshot-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

G1ZGC
目标停顿<200ms<1ms(亚毫秒)
技术核心Region + SATB染色指针 + 读屏障
指针限制无需要 64 位指针中 4 位做标记
适用大多数应用超低延迟系统(交易/风控)
内存开销低高(染色指针 + 对象转发表)

记忆锚

"染色指针标状态 + 读屏障救场 + 并发搬对象 = 毫秒级停顿"


Q5:类加载机制 + 双亲委派 + 打破场景

TL;DR

类加载 = 加载→验证→准备→解析→初始化。双亲委派:子加载器先问父加载器,逐级向上,找到为止。打破场景:Tomcat(WebApp 隔离)→ SPI(JDBC Driver 用线程上下文加载器反向加载)→ OSGi(网状加载)。

类比

👨‍👩‍👧 家庭寻物链:孩子(App ClassLoader)找东西,先问爸爸(Ext ClassLoader)有没有,爸爸问爷爷(Bootstrap ClassLoader),爷爷找不到才让孩子自己找。加载顺序:爷爷→爸爸→孩子。

双亲委派模型

interview jvm qa · 图 4
interview jvm qa · 图 4 · 点击查看 SVG 原图

三个打破场景

场景打破方式为什么
Tomcat每个 WebApp 用自己的 WebappClassLoader不同应用的同名类隔离(App1 的 v1.0,App2 的 v2.0)
SPI(如 JDBC)ThreadContextClassLoaderDriver 在 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 overflowSurvivor 区太小调大 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 类型

类型错误信息常见原因
堆 OOMJava heap space内存泄漏 / 堆太小 / 大对象
元空间 OOMMetaspace动态生成太多类(CGLIB 代理)
直接内存 OOMDirect buffer memory堆外内存未释放(Netty ByteBuf)
线程 OOMunable to create new native thread线程创建太多超过 OS 限制

记忆锚

"dump 现场→Dominator Tree 找大户→GC Root 追引用链"


Q8:JVM 性能监控工具链

TL;DR

jps(找进程)→ jstack(看线程栈/死锁)→ jmap(看堆/dump)→ jstat(GC 统计)→ Arthas(阿里神器,在线排查)。生产环境优先用 Arthas。

工具速查

工具命令用途金句
jpsjps -l列出所有 Java 进程"哪个进程是我的"
jstackjstack <pid>线程快照 + 死锁检测"线程都在干嘛"
jmapjmap -histo <pid>堆对象统计"谁占内存最多"
jstatjstat -gc <pid> 1000GC 实时监控"GC 的实时战况"
jinfojinfo <pid>查看/修改 JVM 参数"当前的 JVM 配置"
Arthasdashboard / 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 分析;回收量正常但频率高 = 堆太小/对象分配太快 → 调大堆或优化代码。

类比

🗑️ 垃圾桶总是满:两种情况——①垃圾桶太小(堆不够大,正常用也满);②有人偷偷往你垃圾桶扔东西(内存泄漏)。

排查决策树

interview jvm qa · 图 5
interview jvm qa · 图 5 · 点击查看 SVG 原图

具体命令

# 看 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

OOMStackOverflow
根因堆空间不够放对象栈帧太多(递归太深)
错误OutOfMemoryErrorStackOverflowError
定位工具heap dump + MATjstack 看线程栈底部
解决调大堆 / 修泄漏修递归终止条件 / 加尾递归

记忆锚

"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

CMSG1
算法标记-清除(有碎片)标记-整理(无碎片)
碎片问题✅ 严重 → 碎片导致 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
日志采集 FluentdG1(调优)吞吐优先,延迟不敏感
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 ThreadGMP(G→P→M)
初始栈大小动态(通常 ~200 字节对象头)2 KB
栈扩容动态分配,自动增长动态增长,可到 1GB
阻塞处理自动 yield,栈帧存堆中自动 yield,栈保留
抢占IO/sleep 时让出基于协作 + 信号抢占(Go 1.14+)
APIThread.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),没拿到的人去休息室睡觉(阻塞)

升级过程

interview jvm qa · 图 6
interview jvm qa · 图 6 · 点击查看 SVG 原图

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 解析大对象。

排查决策树

interview jvm qa · 图 7
interview jvm qa · 图 7 · 点击查看 SVG 原图

高频根因

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 题)