← 返回首页 📚 实战课程
📑 本篇章节导航 (共4章,点击直达)
一、理论篇(30%)—— GC算法到JVM参数二、动手篇(40%)—— 实战OOM模拟与排查三、面试模拟篇(20%)—— 追问链式考核四、练习篇(10%)

P1-06 - JVM调优实战与OOM排查

定位:面试官问"G1和ZGC的区别""OOM怎么排查""Arthas用过哪些命令""ThreadLocal在线程池里怎么泄漏""GC日志怎么看",你答不出实操步骤。本节专治这个gap。

一、理论篇(30%)—— GC算法到JVM参数

1.1 GC算法对比


┌────────────┬──────────────────┬──────────────────┬──────────────────┐
│            │ 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,根据业务选择

1.2 JVM核心参数


堆内存参数(面试必背):
┌─────────────────────────────┬─────────────────────────────────────────┐
│ 参数                         │ 含义                                     │
├─────────────────────────────┼─────────────────────────────────────────┤
│ -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

1.3 GC日志分析


示例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频繁(分钟级),必须排查

1.4 OOM类型


┌─────────────────────┬───────────────────────────────────────────┐
│ 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 限制              │
└─────────────────────┴───────────────────────────────────────────┘

1.5 OOM排查流程


标准排查流程(面试必背):

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引用链 → 定位泄漏源

1.6 Arthas常用命令


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

二、动手篇(40%)—— 实战OOM模拟与排查

2.1 模拟堆内存泄漏


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();
        }
    }
}

2.2 ThreadLocal在线程池中的内存泄漏


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();
    }
}

2.3 GC日志分析实战


/**
 * 实验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次数、堆使用趋势");
    }
}

2.4 Arthas实战排查流程


#!/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

2.5 OOM排查完整流程代码


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
    }
}

三、面试模拟篇(20%)—— 追问链式考核

Q1: 你们的JVM参数是怎么配的?


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: 线上OOM怎么排查?


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: ThreadLocal为什么在线程池中泄漏?


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脚本等场景容易触发


四、练习篇(10%)

练习1:GC日志分析

用以下参数运行一个Spring Boot应用:


-Xms256m -Xmx256m -XX:+UseG1GC
-Xlog:gc*:file=gc.log:time,uptime,level,tags
-XX:+HeapDumpOnOutOfMemoryError

用压测工具模拟100并发,分析GC日志中的Young GC频率和耗时。

练习2:ThreadLocal泄漏验证

修改实验2的代码:

1. 注释掉threadLocal.remove(),用jmap观察BigContext对象数量

2. 加上threadLocal.remove(),再观察对比

3. 总结泄漏和正常的对象数量差异

练习3:Arthas实战

安装Arthas,连接到本地Java进程,完成以下操作:

1. dashboard观察内存和线程状态

2. thread -n 3查看CPU最高的线程

3. sc搜索一个Spring Controller类

4. watch观察一个Service方法的入参和返回值

练习4:OOM排查全流程

编写一个有内存泄漏的程序(如缓存只加不删),用jps→jstat→jmap→MAT完整排查,写出排查报告: