定位:面试官问"G1和ZGC的区别""OOM怎么排查""Arthas用过哪些命令""ThreadLocal在线程池里怎么泄漏""GC日志怎么看",你答不出实操步骤。本节专治这个gap。
┌────────────┬──────────────────┬──────────────────┬──────────────────┐
│ │ CMS │ G1 │ ZGC │
├────────────┼──────────────────┼──────────────────┼──────────────────┤
│ 分代 │ 老年代收集器 │ 分代(Region) │ 不分代(JDK17+) │
│ 算法 │ 标记-清除 │ 标记-整理 │ 染色指针+读屏障 │
│ STW时间 │ 较低(并发) │ 可预测(<200ms) │ <10ms(亚毫秒) │
│ 适用堆 │ <8GB │ 4-32GB │ 8GB-数TB │
│ JDK版本 │ JDK 8默认 │ JDK 9+默认 │ JDK 11+可用 │
│ 碎片问题 │ 有(标记-清除) │ 无(Region整理) │ 无 │
│ 调优难度 │ 高(7个核心参数) │ 中(MaxGCPause) │ 低(几乎免调) │
│ 缺点 │ 浮动垃圾+碎片 │ 写屏障开销 │ JDK15前不支持分代│
└────────────┴──────────────────┴──────────────────┴──────────────────┘
面试回答策略:
→ JDK 8: CMS(或ParNew+CMS)
→ JDK 9-15: G1(默认)
→ JDK 16+: ZGC(低延迟场景)
→ 不要无脑追求ZGC,根据业务选择
堆内存参数(面试必背):
┌─────────────────────────────┬─────────────────────────────────────────┐
│ 参数 │ 含义 │
├─────────────────────────────┼─────────────────────────────────────────┤
│ -Xms │ 初始堆大小(建议=Xmx,避免动态扩缩) │
│ -Xmx │ 最大堆大小 │
│ -Xmn │ 年轻代大小 │
│ -XX:MetaspaceSize │ 元空间初始大小 │
│ -XX:MaxMetaspaceSize │ 元空间最大大小 │
│ -XX:NewRatio │ 老年代/年轻代比例(默认2,即1:2) │
│ -XX:SurvivorRatio │ Eden/Survivor比例(默认8,即8:1:1) │
└─────────────────────────────┴─────────────────────────────────────────┘
GC选择参数:
┌─────────────────────────────┬─────────────────────────────────────────┐
│ -XX:+UseG1GC │ 使用G1收集器(JDK9+默认) │
│ -XX:+UseZGC │ 使用ZGC收集器 │
│ -XX:MaxGCPauseMillis=200 │ G1最大暂停时间目标(默认200ms) │
│ -XX:+UseConcMarkSweepGC │ 使用CMS(JDK14已移除) │
└─────────────────────────────┴─────────────────────────────────────────┘
GC日志参数:
# JDK 8
-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:/tmp/gc.log
# JDK 9+(统一日志框架)
-Xlog:gc*:file=/tmp/gc.log:time,uptime,level,tags
OOM时自动dump:
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/tmp/heapdump.hprof
示例G1 GC日志(简化):
[GC pause (G1 Evacuation Pause) (young), 0.0234567 secs]
[Eden: 256.0M(256.0M)->0.0B(230.0M)
Survivors: 0.0B->26.0M
Heap: 512.0M(1024.0M)->280.0M(1024.0M)]
解读:
- GC类型: G1年轻代回收(Evacuation Pause)
- 耗时: 23ms(正常,G1目标<200ms)
- Eden: 256M -> 0(全清空)
- Survivors: 0 -> 26M(存活对象进入Survivor)
- 堆使用: 512M -> 280M(回收了232M)
- 堆总容量: 1024M
关键指标:
- GC频率:多久一次Young GC?
- GC耗时:单次STW多久?
- 老年代增长速率:多久触发一次Full GC?
- Full GC耗时:如果>1s说明有问题
正常基线:
- Young GC: 10-50ms,频率几秒一次
- Full GC: 几分钟到几小时一次,<500ms
- 如果Full GC频繁(分钟级),必须排查
┌─────────────────────┬───────────────────────────────────────────┐
│ OOM类型 │ 原因和排查方向 │
├─────────────────────┼───────────────────────────────────────────┤
│ Java heap space │ 堆内存不足,对象太多或内存泄漏 │
│ │ → jmap -histo 看对象分布 │
│ │ → MAT分析dump文件 │
├─────────────────────┼───────────────────────────────────────────┤
│ Metaspace │ 类加载太多(动态代理、Groovy等) │
│ │ → -XX:MaxMetaspaceSize 限制 │
│ → jstat -class 看类加载情况 │
├─────────────────────┼───────────────────────────────────────────┤
│ GC overhead limit │ GC回收的内存<2%且连续5次Full GC │
│ │ 本质还是堆不够,和Java heap space同根源 │
├─────────────────────┼───────────────────────────────────────────┤
│ unable to create │ 线程数太多,每个线程占用~1MB栈空间 │
│ new native thread │ → 减少线程数或降低-Xss │
├─────────────────────┼───────────────────────────────────────────┤
│ Direct buffer memory │ NIO的ByteBuffer.allocateDirect分配的堆外 │
│ │ → -XX:MaxDirectMemorySize 限制 │
└─────────────────────┴───────────────────────────────────────────┘
标准排查流程(面试必背):
Step 1: jps 确认Java进程PID
$ jps -l
12345 com.example.MyApplication
Step 2: jstat 观察GC概况
$ jstat -gcutil 12345 1000 10 (每秒采样,共10次)
关注: FGC(Full GC次数)、FGCT(Full GC总耗时)、OU(老年代使用率)
Step 3: jmap 导出堆信息
$ jmap -histo 12345 | head -20 ← 看对象数量排行
$ jmap -dump:format=b,file=dump.hprof 12345 ← 导出dump文件
Step 4: jstack 看线程状态
$ jstack 12345 > thread.txt
查找: BLOCKED线程、WAITING线程、死锁(deadlock)
Step 5: MAT 分析dump文件
打开dump.hprof → Leak Suspects Report → Dominator Tree
找到占用最大的对象 → GC Roots引用链 → 定位泄漏源
Arthas(阿里开源的Java诊断工具):
# 启动Arthas
$ java -jar arthas-boot.jar
dashboard ← 实时面板(线程、内存、GC)
thread ← 查看所有线程状态
thread -n 3 ← 查看CPU占用最高的3个线程
thread -b ← 查找死锁
thread 线程ID ← 查看指定线程堆栈
heapdump /tmp/dump.hprof ← 导出堆dump
sc *Controller* ← 搜索已加载的类
sc -d 类名 ← 查看类的详细信息(ClassLoader等)
watch 类名 方法名 "{params,returnObj,throwExp}" ← 观察方法调用
watch com.example.Service process "{params[0],returnObj}" -x 2
ognl '@com.example.App@staticField' ← 查看静态字段值
vmtool --action getInstances --className java.lang.String --limit 10
import java.util.ArrayList;
import java.util.List;
/**
* 实验1:模拟堆内存泄漏
*
* 运行参数:-Xms64m -Xmx64m -XX:+HeapDumpOnOutOfMemoryError
* -XX:HeapDumpPath=/tmp/heapdump.hprof
*
* 预期:运行一段时间后抛出 java.lang.OutOfMemoryError: Java heap space
*/
public class HeapOOMDemo {
static class BigObject {
private byte[] data;
BigObject(int sizeKB) {
this.data = new byte[sizeKB * 1024]; // 占用sizeKB KB
}
}
public static void main(String[] args) {
List<BigObject> list = new ArrayList<>();
int count = 0;
try {
while (true) {
// 每次分配100KB,并持有引用不释放
list.add(new BigObject(100));
count++;
if (count % 100 == 0) {
System.out.printf("已分配 %d 个对象,约 %d MB%n",
count, count * 100 / 1024);
}
Thread.sleep(10); // 放慢速度便于观察
}
} catch (OutOfMemoryError e) {
System.err.println("OOM! 已分配对象数: " + count);
System.err.println("异常类型: " + e.getMessage());
e.printStackTrace();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
import java.util.concurrent.*;
import java.util.ArrayList;
import java.util.List;
/**
* 实验2:ThreadLocal在线程池中的内存泄漏
*
* 原因:
* 1. 线程池中线程不销毁,ThreadLocalMap一直存在
* 2. ThreadLocalRef被回收后,Entry的key变为null(弱引用)
* 3. 但value仍然被Entry强引用,无法被GC
* 4. 只有下次get/set/remove时才会清理(expungeStaleEntry)
* 5. 如果不再调用get/set/remove,value永远不被回收
*
* 解决方案:用完后必须调用 threadLocal.remove()
*/
public class ThreadLocalLeakDemo {
// 模拟大对象的ThreadLocal
static class BigContext {
private byte[] data = new byte[1024 * 1024]; // 1MB
private String requestId;
BigContext(String requestId) {
this.requestId = requestId;
}
}
static final ThreadLocal<BigContext> threadLocal = new ThreadLocal<>();
public static void main(String[] args) throws Exception {
// 固定大小线程池(线程不销毁)
ExecutorService pool = Executors.newFixedThreadPool(5);
List<String> results = new ArrayList<>();
// 模拟100次请求
for (int i = 0; i < 100; i++) {
final int taskId = i;
pool.submit(() -> {
try {
// 设置ThreadLocal(模拟请求上下文)
threadLocal.set(new BigContext("request-" + taskId));
// 模拟业务处理
String result = threadLocal.get().requestId;
results.add(result);
// 关键:如果不remove,ThreadLocal中的BigContext不会被释放!
// 正确做法:
threadLocal.remove(); // 注释掉这行观察内存变化
} catch (Exception e) {
e.printStackTrace();
}
});
}
Thread.sleep(2000);
System.out.println("完成任务数: " + results.size());
// 观察内存(配合jmap或Arthas)
System.out.println("用 jmap -histo <pid> | grep BigContext 观察对象数量");
System.out.println("remove()调用时: 线程池中最多5个BigContext(5个线程)");
System.out.println("remove()不调用: 线程池中可能残留更多BigContext");
pool.shutdown();
}
}
/**
* 实验3:GC日志分析
*
* 运行参数:
* JDK 8:
* -Xms256m -Xmx256m -XX:+UseG1GC
* -XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:/tmp/gc.log
*
* JDK 11+:
* -Xms256m -Xmx256m -XX:+UseG1GC
* -Xlog:gc*:file=/tmp/gc.log:time,uptime,level,tags
*/
public class GCLogDemo {
public static void main(String[] args) throws Exception {
System.out.println("开始GC日志分析演示...");
System.out.println("PID: " + ProcessHandle.current().pid());
// 阶段1:稳定分配(Young GC为主)
System.out.println("\n=== 阶段1:稳定分配 ===");
for (int i = 0; i < 5; i++) {
byte[] data = new byte[10 * 1024 * 1024]; // 10MB
Thread.sleep(500);
}
// 阶段2:大量分配(触发频繁GC)
System.out.println("\n=== 阶段2:大量分配 ===");
List<byte[]> holder = new ArrayList<>();
for (int i = 0; i < 30; i++) {
holder.add(new byte[5 * 1024 * 1024]); // 5MB
Thread.sleep(100);
}
// 阶段3:释放后观察GC
System.out.println("\n=== 阶段3:释放内存 ===");
holder.clear();
System.gc(); // 建议Full GC(仅用于演示,生产不要调)
Thread.sleep(1000);
System.out.println("完成。请查看 gc.log 分析GC行为。");
System.out.println("关键指标:Young GC次数、Young GC耗时、Full GC次数、堆使用趋势");
}
}
#!/bin/bash
# 实验4:Arthas排查OOM的完整流程
# Step 1: 找到Java进程PID
echo "=== Step 1: 查找Java进程 ==="
jps -l
# Step 2: 用jstat监控GC(每2秒一次,共5次)
echo "=== Step 2: GC监控 ==="
# jstat -gcutil <PID> 2000 5
# Step 3: 用jmap看对象分布(Top 20)
echo "=== Step 3: 对象数量排行 ==="
# jmap -histo <PID> | head -20
# Step 4: 启动Arthas
echo "=== Step 4: 启动Arthas ==="
# java -jar arthas-boot.jar <PID>
# Step 5: Arthas内操作
echo "=== Arthas常用命令 ==="
cat << 'EOF'
# 实时面板
dashboard
# 查看最繁忙的线程
thread -n 5
# 查看死锁
thread -b
# 导出堆dump
heapdump /tmp/arthas-dump.hprof
# 查看类加载信息
sc -d com.example.BigObject
# 监控方法调用
watch com.example.Service process "{params,returnObj}" -x 2
# 退出
quit
EOF
import java.util.*;
import java.util.concurrent.*;
/**
* 实验5:综合OOM模拟与排查
*
* 场景:模拟一个线上OOM问题
* - 内存持续增长
* - Young GC无法回收
* - 最终Full GC也回收不了
*
* 运行参数:
* -Xms128m -Xmx128m -XX:+UseG1GC
* -XX:+HeapDumpOnOutOfMemoryError
* -XX:HeapDumpPath=/tmp/oom-dump.hprof
* -Xlog:gc*:file=/tmp/oom-gc.log:time,uptime,level,tags
*/
public class OOMInvestigation {
// 模拟缓存泄漏:只加不删
static final Map<String, byte[]> CACHE = new ConcurrentHashMap<>();
public static void main(String[] args) throws Exception {
System.out.println("PID: " + ProcessHandle.current().pid());
System.out.println("模拟缓存泄漏场景...");
System.out.println("排查步骤:");
System.out.println(" 1. jstat -gcutil <PID> 1000 → 观察OU(老年代使用率)持续上升");
System.out.println(" 2. jmap -histo <PID> | head -20 → byte[]数量异常多");
System.out.println(" 3. jmap -dump → MAT分析 → 发现CACHE引用了大量byte[]");
System.out.println(" 4. 定位到CACHE只put不remove");
System.out.println();
ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
// 模拟不断写入缓存
executor.scheduleAtFixedRate(() -> {
String key = "cache-key-" + System.nanoTime();
CACHE.put(key, new byte[50 * 1024]); // 每次放50KB
// 注意:没有remove,缓存只增不减 → 泄漏!
}, 0, 10, TimeUnit.MILLISECONDS);
// 定期打印内存状态
executor.scheduleAtFixedRate(() -> {
Runtime rt = Runtime.getRuntime();
long usedMB = (rt.totalMemory() - rt.freeMemory()) / 1024 / 1024;
long maxMB = rt.maxMemory() / 1024 / 1024;
System.out.printf("缓存条目: %d, 堆使用: %dMB / %dMB%n",
CACHE.size(), usedMB, maxMB);
}, 0, 1, TimeUnit.SECONDS);
Thread.sleep(Long.MAX_VALUE); // 等待OOM
}
}
Q1.1: Xms和Xmx为什么要设置一样?
→ 避免堆动态扩缩引起的GC停顿
→ 扩容时需要Full GC,缩容也需要Full GC
→ 生产环境固定大小,减少不可预测的停顿
Q1.2: 怎么选择GC收集器?
→ 延迟敏感(交易、支付): ZGC(JDK17+)或G1
→ 吞吐量优先(批处理、离线分析): Parallel GC
→ JDK 8维护的老项目: CMS(注意已废弃)
→ 不要盲目追新,根据业务选择
Q1.3: 怎么判断GC是否正常?
→ Young GC频率: 几秒一次正常
→ Young GC耗时: <50ms正常
→ Full GC频率: 几小时甚至几天一次正常
→ 如果Full GC分钟级,必须排查内存泄漏
Q2.1: 排查OOM的标准流程?
→ 1. jps找到进程PID
→ 2. jstat -gcutil观察GC概况
→ 3. jmap -histo看对象分布
→ 4. jmap -dump导出dump文件
→ 5. MAT分析dump,找Leak Suspects
→ 6. 沿GC Roots引用链定位泄漏源
Q2.2: 如果来不及dump就挂了怎么办?
→ 启动参数加 -XX:+HeapDumpOnOutOfMemoryError
→ OOM时自动dump,重启后分析
→ 也可以用Arthas提前heapdump
Q2.3: CPU 100%怎么排查?
→ 1. top找到CPU高的Java进程PID
→ 2. top -Hp <PID> 找到高CPU线程TID
→ 3. printf "%x\n" <TID> 转为十六进制
→ 4. jstack <PID> | grep <十六进制TID> 看线程堆栈
→ 或直接用Arthas: thread -n 3
Q3.1: ThreadLocal的底层结构?
→ 每个Thread对象有一个ThreadLocalMap字段
→ ThreadLocalMap的Entry extends WeakReference<ThreadLocal<?>>
→ key是ThreadLocal的弱引用,value是强引用
Q3.2: 泄漏的完整链条?
→ 1. ThreadLocalRef被设为null(业务代码不再持有)
→ 2. GC回收ThreadLocal对象,Entry的key变为null
→ 3. 但value仍被Entry强引用
→ 4. 线程池线程不销毁 → ThreadLocalMap一直存在
→ 5. value无法被GC → 内存泄漏
Q3.3: 怎么解决?
→ 用完后必须调用 threadLocal.remove()
→ 最佳实践:try-finally中调用remove
→ 不要用线程池共享ThreadLocal存储大对象
1. 以为-Xmx设大就能解决OOM —— 内存泄漏不解决,多大都会OOM
2. 以为System.gc()能解决问题 —— 只是建议JVM做Full GC,不保证执行
3. 生产环境忘记加HeapDumpOnOutOfMemoryError —— 挂了无法分析
4. ThreadLocal用完不remove —— 线程池中必泄漏
5. Metaspace OOM被忽略 —— 动态代理、Groovy脚本等场景容易触发
用以下参数运行一个Spring Boot应用:
-Xms256m -Xmx256m -XX:+UseG1GC
-Xlog:gc*:file=gc.log:time,uptime,level,tags
-XX:+HeapDumpOnOutOfMemoryError
用压测工具模拟100并发,分析GC日志中的Young GC频率和耗时。
修改实验2的代码:
1. 注释掉threadLocal.remove(),用jmap观察BigContext对象数量
2. 加上threadLocal.remove(),再观察对比
3. 总结泄漏和正常的对象数量差异
安装Arthas,连接到本地Java进程,完成以下操作:
1. dashboard观察内存和线程状态
2. thread -n 3查看CPU最高的线程
3. sc搜索一个Spring Controller类
4. watch观察一个Service方法的入参和返回值
编写一个有内存泄漏的程序(如缓存只加不删),用jps→jstat→jmap→MAT完整排查,写出排查报告: