JVM（Java 虚拟机）与线上排障

正式学习入口

本模块已经按知识图谱编号拆分为可独立复习的精通级分册。建议先建立运行时、类和对象三种生命周期，再学习收集器、日志参数和事故排查；旧版正文继续保留在本页下方，用于兼容既有链接和快速检索。

兼容保留的旧版正文

1. 简历关联点

简历中写到“熟悉 JVM（Java 虚拟机）底层原理和 GC（垃圾回收）常用算法，有 OOM（内存溢出）问题排查经验、CPU（中央处理器）飙高排查及生产事故处理经验”。面试官会重点追问：

JVM（Java 虚拟机）内存区域分别存什么。
JVM（Java 虚拟机）生命周期从启动到退出经历哪些阶段。
对象如何创建、分配、晋升、回收。
类生命周期和对象生命周期分别是什么。
Minor GC（年轻代垃圾回收）、Major（老年代）GC（垃圾回收）、Full GC（完全垃圾回收）区别。
OOM（内存溢出）如何定位，是堆、元空间、直接内存还是线程栈。
CPU（中央处理器）飙高如何定位到具体线程和代码。
线上事故如何止血、定位、复盘。

2. 面试主线

回答 JVM（Java 虚拟机）问题时，建议按“JVM（Java 虚拟机）生命周期 -> 运行时内存 -> 类生命周期 -> 对象生命周期 -> GC（垃圾回收） -> 监控指标 -> 排障工具 -> 项目经验”展开。

JVM（Java 虚拟机）生命周期从启动、初始化、执行 main（主方法）、运行期管理，到正常退出或异常终止。
JVM（Java 虚拟机）把运行时数据划分为线程私有区和线程共享区。
类生命周期经历加载、验证、准备、解析、初始化、使用、卸载。
对象主要分配在堆，经过 Eden（伊甸园区）、Survivor（幸存者区）、Old（老年代）流转。
GC（垃圾回收）通过可达性分析判断对象是否存活，再用复制、标记清除、标记整理等算法回收。
线上排障先看现象和指标，再用 jstack（线程栈工具）、jmap（内存映射工具）、jstat（虚拟机统计工具）、Arthas（Java 诊断工具）定位。
项目经验要讲“现象、止血、定位、根因、修复、复盘”，不能只说“调大内存”。

3. 基础知识

3.1 JVM（Java 虚拟机）运行时内存结构

flowchart TD
    JVM["JVM（Java 虚拟机）运行时数据区"] --> PC["程序计数器\n线程私有"]
    JVM --> STACK["虚拟机栈\n线程私有"]
    JVM --> NATIVE["本地方法栈\n线程私有"]
    JVM --> HEAP["堆\n线程共享"]
    JVM --> META["方法区/元空间\n线程共享"]
    HEAP --> YOUNG["年轻代"]
    YOUNG --> EDEN["Eden（伊甸园区）"]
    YOUNG --> S0["Survivor0（幸存者区0）"]
    YOUNG --> S1["Survivor1（幸存者区1）"]
    HEAP --> OLD["Old（老年代）"]
    META --> CLASS["类元数据"]
    META --> CONST["运行时常量池"]

区域	是否线程私有	存储内容	常见异常
程序计数器	是	当前线程执行的字节码位置	几乎不会 OOM（内存溢出）
虚拟机栈	是	栈帧、局部变量表、操作数栈	StackOverflowError（栈溢出错误）
本地方法栈	是	Native（本地）方法调用	StackOverflowError（栈溢出错误）
堆	否	对象实例、数组	OutOfMemoryError（内存溢出错误）
元空间	否	类元数据、方法元信息	Metaspace（元空间）OOM（内存溢出）
直接内存	否	NIO（新输入输出）直接缓冲区	Direct buffer memory（直接缓冲内存）OOM（内存溢出）

3.2 JVM（Java 虚拟机）生命周期

JVM（Java 虚拟机）生命周期不是只包含“运行 Java（编程语言）代码”。从操作系统启动 Java（编程语言）进程开始，到 JVM（Java 虚拟机）退出结束，中间会经历启动、初始化、运行、关闭四个大阶段。

flowchart TD
    A["操作系统启动 Java（编程语言）进程"] --> B["创建 JVM（Java 虚拟机）实例"]
    B --> C["初始化运行时环境\n堆/栈/方法区/线程系统"]
    C --> D["加载启动类和主类"]
    D --> E["执行 main（主方法）"]
    E --> F["运行期：类加载/解释执行/JIT（即时编译）/GC（垃圾回收）"]
    F --> G{"是否满足退出条件?"}
    G -->|否| F
    G -->|是| H["执行 Shutdown Hook（关闭钩子）"]
    H --> I["释放资源并退出 JVM（Java 虚拟机）进程"]

JVM（Java 虚拟机）生命周期阶段拆解：

阶段	发生什么	面试关注
启动阶段	操作系统创建 Java（编程语言）进程，加载 JVM（Java 虚拟机）动态库，创建 JVM（Java 虚拟机）实例	JVM（Java 虚拟机）是进程内运行时，不是单独的操作系统进程管理器
初始化阶段	初始化堆、栈、方法区、类加载器、GC（垃圾回收）线程、JIT（即时编译）线程	内存参数和 GC（垃圾回收）参数在此阶段生效
主类加载阶段	Bootstrap-ClassLoader（启动类加载器）、Platform-ClassLoader（平台类加载器）、Application-ClassLoader（应用类加载器）协作加载主类	双亲委派和类路径问题
执行阶段	调用 main（主方法），字节码解释执行，热点代码触发 JIT（即时编译），对象分配和 GC（垃圾回收）持续发生	性能优化、JIT（即时编译）、GC（垃圾回收）、线程状态
关闭阶段	非 daemon（守护线程）结束、System.exit（系统退出）、收到 SIGTERM（终止信号）等触发关闭	Shutdown Hook（关闭钩子）、资源释放、优雅停机
强制终止	kill -9（强杀信号）、Runtime.halt（强制停止运行时）、JVM（Java 虚拟机）崩溃	Shutdown Hook（关闭钩子）可能不执行

JVM（Java 虚拟机）退出条件：

main（主方法）执行结束，并且所有 non-daemon thread（非守护线程）都结束。
代码主动调用 System.exit（系统退出）。
操作系统发送 SIGTERM（终止信号）并触发正常关闭流程。
JVM（Java 虚拟机）发生 fatal error（致命错误），例如本地内存崩溃。
操作系统发送 kill -9（强杀信号），此时 JVM（Java 虚拟机）没有机会执行 Shutdown Hook（关闭钩子）。

daemon thread（守护线程）和 non-daemon thread（非守护线程）区别：

线程类型	是否阻止 JVM（Java 虚拟机）退出	典型场景	风险
non-daemon thread（非守护线程）	会阻止	业务线程、线程池工作线程	未关闭线程池会导致应用无法退出
daemon thread（守护线程）	不会阻止	GC（垃圾回收）线程、监控辅助线程	JVM（Java 虚拟机）退出时可能被直接终止

Shutdown Hook（关闭钩子）适合做优雅停机，比如关闭线程池、停止消费 MQ（消息队列）、刷出内存队列、释放文件句柄。但 Shutdown Hook（关闭钩子）不能写太重的逻辑，也不能假设它一定执行。

sequenceDiagram
    participant OS as OS（操作系统）
    participant JVM as JVM（Java 虚拟机）
    participant APP as App（应用）
    participant HOOK as Shutdown Hook（关闭钩子）
    OS->>JVM: SIGTERM（终止信号）
    JVM->>APP: 标记进入 shutdown（关闭）流程
    JVM->>HOOK: 并发执行已注册 Hook（钩子）
    HOOK->>HOOK: 停止接收新任务/关闭线程池/释放资源
    HOOK-->>JVM: Hook（钩子）执行完成
    JVM->>OS: 进程退出

3.3 类生命周期

类生命周期比“类加载过程”更完整，包含加载、链接、初始化、使用、卸载。

flowchart LR
    A["Loading（加载）"] --> B["Linking（链接）"]
    B --> B1["Verification（验证）"]
    B1 --> B2["Preparation（准备）"]
    B2 --> B3["Resolution（解析）"]
    B3 --> C["Initialization（初始化）"]
    C --> D["Using（使用）"]
    D --> E["Unloading（卸载）"]

阶段	作用	例子
Loading（加载）	读取 Class（类元数据）字节码，生成 Class（类元数据）对象	从 classpath（类路径）、jar（归档包）、网络加载
Verification（验证）	验证字节码安全性	防止非法字节码破坏 JVM（Java 虚拟机）
Preparation（准备）	给 static（静态关键字）变量分配内存并设置默认值	`static int a = 1` 此时先是 0
Resolution（解析）	符号引用转直接引用	方法、字段、类引用解析
Initialization（初始化）	执行 `<clinit>` 类初始化方法	static（静态关键字）变量赋值和 static-block（静态代码块）
Using（使用）	对象创建、方法调用、字段访问	业务运行期
Unloading（卸载）	类加载器可回收，类元数据释放	热部署、动态代理、脚本引擎

类初始化触发条件：

new（创建对象）一个类实例。
读取或设置类的 static（静态关键字）字段，final（最终关键字）编译期常量除外。
调用类的 static（静态关键字）方法。
反射调用类。
初始化子类前，先初始化父类。
JVM（Java 虚拟机）启动时初始化 main（主方法）所在类。

类卸载必须同时满足：

该类所有实例都不可达。
加载该类的 ClassLoader（类加载器）不可达。
该类对应的 Class（类元数据）对象不可达。

线上如果频繁动态生成类，但 ClassLoader（类加载器）被静态集合或线程上下文引用持有，就可能导致 Metaspace（元空间）OOM（内存溢出）。

3.4 对象生命周期

对象创建大致经过：

类加载检查：检查 Class（类元数据）是否已加载、解析、初始化。
分配内存：指针碰撞或空闲列表。
初始化零值：保证对象字段有默认值。
设置对象头：记录 Mark Word（标记字）、类型指针、数组长度。
执行构造方法：执行 <init> 初始化业务字段。

对象完整生命周期：

flowchart TD
    A["类已加载并初始化"] --> B["分配对象内存"]
    B --> C["字段零值初始化"]
    C --> D["设置对象头\nMark Word（标记字）/类型指针"]
    D --> E["执行 <init>（构造方法）"]
    E --> F["对象被引用并使用"]
    F --> G{"是否仍被 GC Roots（垃圾回收根）可达?"}
    G -->|是| F
    G -->|否| H["进入可回收状态"]
    H --> I["GC（垃圾回收）回收内存"]

对象生命周期常见面试点：

对象不一定都在堆上分配，JIT（即时编译）可能通过逃逸分析做栈上分配或标量替换。
对象从“不可达”到“真正回收”不是立刻发生，要等 GC（垃圾回收）。
finalize（终结方法）机制不可靠且已不推荐使用，不能依赖它释放核心资源。
对象如果被 ThreadLocal（线程本地变量）、static（静态关键字）集合、缓存、未关闭线程引用，就可能长期不可回收。

3.5 类加载过程

类加载流程：

flowchart LR
    A["Loading（加载）"] --> B["Verification（验证）"]
    B --> C["Preparation（准备）"]
    C --> D["Resolution（解析）"]
    D --> E["Initialization（初始化）"]
    B -.-> F["Linking（链接）"]
    C -.-> F
    D -.-> F

双亲委派模型：

flowchart TD
    A["应用类加载器"] -->|向上委派| B["平台类加载器"]
    B -->|向上委派| C["启动类加载器"]
    C -->|找不到再向下| B
    B -->|找不到再向下| A

双亲委派的价值是避免核心类被重复加载或恶意替换，比如避免自定义 java.lang.String 破坏 Java（编程语言）基础类库。

4. 底层原理

4.1 对象存活判断

主流 JVM（Java 虚拟机）使用可达性分析，从 GC-Roots（垃圾回收根）出发，能被引用链到达的对象就是存活对象。

常见 GC-Roots（垃圾回收根）：

虚拟机栈中的局部变量引用。
方法区中静态变量引用。
方法区中常量引用。
JNI（Java 本地接口）引用。
synchronized（同步锁）持有的对象。

可达性分析把堆中的对象关系看成一张有向图。GC-Roots（垃圾回收根）是图搜索起点，从这些起点沿引用能够访问到的对象都会被标记为存活；无法到达的对象才进入回收候选集。

flowchart TD
    R1["线程栈局部变量<br/>GC Roots（垃圾回收根）"] --> A["订单任务 A"]
    R2["static（静态关键字）缓存<br/>GC Roots（垃圾回收根）"] --> B["缓存容器 B"]
    A --> C["订单列表 C"]
    B --> D["配置对象 D"]
    X["临时字节数组 X"] --> Y["包装对象 Y"]
    C --> Z["明细对象 Z"]
    subgraph 可回收候选
        X
        Y
    end

上图中，即使 X 和 Y 互相引用，只要没有任何 GC-Roots（垃圾回收根）能够到达它们，整个环仍然可以回收。这也是 Java（编程语言）虚拟机不采用单纯引用计数作为主要对象存活算法的重要原因：引用计数很难自然识别循环引用。

4.2 GC（垃圾回收）算法

算法	原理	优点	缺点	适合区域
标记清除	标记存活对象，清除未标记对象	简单	内存碎片多	老年代
标记整理	标记后移动存活对象到一端	减少碎片	移动成本高	老年代
复制算法	存活对象复制到另一块空间	快，无碎片	浪费空间	年轻代
分代收集	按对象年龄分区采用不同算法	符合大多数对象朝生夕死	参数复杂	堆整体

三种基础算法的核心差异可以用同一块内存中的对象变化表示：

flowchart TD
    S["回收前: A 存活 | X 垃圾 | B 存活 | Y 垃圾"] --> M1["标记清除: A | 空洞 | B | 空洞"]
    S --> M2["标记整理: A | B | 连续空闲空间"]
    S --> M3["复制算法: 将 A、B 复制到另一块连续空间"]
    M1 --> R1["清理快，但产生内存碎片"]
    M2 --> R2["无碎片，但需要移动并修正引用"]
    M3 --> R3["分配简单，但需要预留复制空间"]

算法选择由“对象存活率”和“停顿目标”决定。年轻代大多数对象很快死亡，复制少量存活对象成本低；老年代存活率通常较高，如果仍复制全部存活对象，复制量和备用空间成本都很高，因此更适合标记清除或标记整理。实际收集器往往组合使用这些思想，而不是整台 JVM（Java 虚拟机）只使用一种算法。

4.3 对象晋升流程

flowchart TD
    A["新对象"] --> B{"是否大对象?"}
    B -->|是| O["直接进入 Old（老年代）"]
    B -->|否| E["进入 Eden（伊甸园区）"]
    E --> C{"Eden（伊甸园区）满?"}
    C -->|否| E
    C -->|是| M["触发 Minor GC（年轻代垃圾回收）"]
    M --> S["存活对象进入 Survivor（幸存者区）"]
    S --> AGE{"年龄达到阈值?"}
    AGE -->|否| S2["复制到另一个 Survivor（幸存者区）"]
    AGE -->|是| O
    S2 --> M

晋升到 Old（老年代）的常见原因：

对象年龄达到阈值。
大对象直接进入 Old（老年代）。
Survivor（幸存者区）空间不足，担保进入 Old（老年代）。
动态年龄判断，某年龄对象总大小超过 Survivor（幸存者区）一半。

数据演绎：假设 Eden（伊甸园区）有 800 MB（兆字节），两个 Survivor（幸存者区）各 100 MB（兆字节）。一次 Minor GC（年轻代垃圾回收）前产生了 700 MB（兆字节）对象，其中只有 60 MB（兆字节）存活，这 60 MB（兆字节）可复制到空的 Survivor（幸存者区）；若有 180 MB（兆字节）存活，Survivor（幸存者区）放不下的部分就需要提前晋升 Old（老年代）。如果导出任务每次都让大量对象跨越多次回收，Old（老年代）会快速增长并增加 Mixed-GC（混合垃圾回收）或 Full GC（完全垃圾回收）压力。

4.4 G1（垃圾优先回收器）

G1（垃圾优先回收器）把堆划分为多个 Region（区域），不再严格使用连续年轻代和老年代。它通过优先回收垃圾最多、收益最高的 Region（区域）控制停顿时间。

G1（垃圾优先回收器）关键概念：

概念	说明
Region（区域）	堆的基本管理单位
Humongous（大对象区域）	超过 Region（区域）一半的大对象
Remembered-Set（记忆集）	记录跨 Region（区域）引用
Mixed-GC（混合垃圾回收）	同时回收年轻代和部分老年代 Region（区域）
Pause-Target（停顿目标）	通过参数设置期望最大停顿时间

flowchart LR
    A["Young GC（年轻代垃圾回收）<br/>疏散 Eden（伊甸园区）"] --> B["并发标记触发阈值到达"]
    B --> C["Initial Mark（初始标记）<br/>短暂停顿"]
    C --> D["Concurrent Mark（并发标记）<br/>与应用并行"]
    D --> E["Remark（重新标记）<br/>修正并发变化"]
    E --> F["Cleanup（清理统计）<br/>计算 Region（区域）收益"]
    F --> G["Mixed GC（混合垃圾回收）<br/>回收年轻代和部分老年代"]
    G --> H{"Old（老年代）占用是否受控?"}
    H -->|"是"| A
    H -->|"否"| I["可能退化为 Full GC（完全垃圾回收）"]

5. 架构图与流程图

5.1 OOM（内存溢出）排查流程

flowchart TD
    A["发现 OOM（内存溢出）"] --> B["确认异常类型和日志"]
    B --> C{"是否有 heap dump（堆转储）?"}
    C -->|有| D["用 MAT（内存分析工具）分析大对象和引用链"]
    C -->|无| E["开启 HeapDumpOnOutOfMemoryError（内存溢出自动转储）"]
    B --> F["jstat（虚拟机统计工具）看 GC（垃圾回收）频率"]
    F --> G{"Old（老年代）是否持续上涨?"}
    G -->|是| H["怀疑内存泄漏或缓存无界增长"]
    G -->|否| I["怀疑瞬时大对象或参数不足"]
    H --> J["定位 GC Roots（垃圾回收根）引用链"]
    I --> K["检查批处理、导出、集合、文件加载"]
    J --> L["修复代码或限制缓存/批量大小"]
    K --> L

5.2 CPU（中央处理器）飙高排查流程

flowchart TD
    A["发现 CPU（中央处理器）飙高"] --> B["top（进程查看工具）找 Java（编程语言）进程 PID（进程标识）"]
    B --> C["top -Hp PID（线程查看）找高 CPU（中央处理器）线程"]
    C --> D["printf 转 16 进制线程 ID（线程标识）"]
    D --> E["jstack（线程栈工具）导出线程栈"]
    E --> F["搜索 nid（本地线程标识）"]
    F --> G{"线程在做什么?"}
    G -->|业务循环| H["检查死循环/大循环/递归"]
    G -->|GC（垃圾回收）线程| I["检查内存压力和 Full GC（完全垃圾回收）"]
    G -->|锁竞争| J["检查 synchronized（同步锁）/Lock（锁接口）阻塞"]
    H --> K["止血、修复、复盘"]
    I --> K
    J --> K

5.3 Full GC（完全垃圾回收）治理流程

flowchart LR
    A["Full GC（完全垃圾回收）频繁"] --> B["看 Old（老年代）占用"]
    B --> C["看对象晋升速度"]
    C --> D["看大对象分配"]
    D --> E["看元空间增长"]
    E --> F["看直接内存"]
    F --> G["结合业务流量和批任务"]
    G --> H["限批量/修泄漏/调参数/拆任务"]

6. 表格对比

6.1 OOM（内存溢出）类型对比

类型	常见日志	典型原因	排查重点
堆 OOM（内存溢出）	Java-heap-space（Java 堆空间）	集合无限增长、缓存无界、批量加载过大	heap dump（堆转储）、对象引用链
元空间 OOM（内存溢出）	Metaspace（元空间）	动态生成类过多、类加载器泄漏	类数量、ClassLoader（类加载器）
直接内存 OOM（内存溢出）	Direct buffer memory（直接缓冲内存）	NIO（新输入输出）缓冲区未释放	Netty（网络通信框架）、ByteBuffer（字节缓冲区）
栈溢出	StackOverflowError（栈溢出错误）	递归过深、循环调用	线程栈、递归出口
无法创建线程	unable to create native thread（无法创建本地线程）	线程过多、系统资源不足	线程数、线程池、系统限制

6.2 jmap（内存映射工具）、jstack（线程栈工具）、jstat（虚拟机统计工具）、Arthas（Java 诊断工具）

工具	主要用途	常用场景
jmap（内存映射工具）	导出堆、查看对象统计	OOM（内存溢出）、内存泄漏
jstack（线程栈工具）	查看线程栈	死锁、CPU（中央处理器）飙高、线程阻塞
jstat（虚拟机统计工具）	查看 GC（垃圾回收）统计	Full GC（完全垃圾回收）频繁、堆使用趋势
Arthas（Java 诊断工具）	在线观测方法、线程、类	不重启定位慢方法、异常参数
JFR（Java 飞行记录器）	低开销运行时记录	长周期性能分析

7. 数据演绎

7.1 异步导出 OOM（内存溢出）

假设导出 20 万订单，每条订单对象及关联字段约 3KB（千字节）：

步骤	数据量	内存变化	风险
一次性查询	200000 条	约 600MB（兆字节）对象进入堆	堆压力暴涨
组装 Excel（电子表格）	200000 行	行对象、样式、字符串继续增长	Old（老年代）快速上涨
写入响应	全量驻留内存	GC（垃圾回收）回收不了仍被引用的对象	Full GC（完全垃圾回收）频繁
最终	堆耗尽	抛出 OOM（内存溢出）	服务不可用

治理方案：

分页查询，不一次性拉全量。
流式写 Excel（电子表格），避免全量行对象驻留。
主任务拆分片任务，本地临时文件合并后上传 OSS（对象存储服务）。
任务状态落库，失败可重试，下载走异步通知。
对导出任务设置并发上限，防止多个大导出同时打满内存。

7.2 OkHttp（HTTP 客户端）未单例导致 OOM（内存溢出）

如果每次调用第三方接口都创建新的 OkHttpClient（HTTP 客户端），可能造成连接池、线程池、缓冲对象重复创建。

时间	行为	结果
T1	每次请求 new OkHttpClient（HTTP 客户端）	创建新连接池
T2	高并发请求持续进入	连接池和线程对象增多
T3	对象无法及时回收	堆和本地线程资源上涨
T4	GC（垃圾回收）频繁但回收效果差	Full GC（完全垃圾回收）增多
T5	堆或线程资源耗尽	OOM（内存溢出）或无法创建线程

修复：OkHttpClient（HTTP 客户端）设计为单例，统一连接池、超时、拦截器和监控。

8. 线上排查与实战经验

8.1 OOM（内存溢出）标准排查步骤

先止血：摘除异常节点、限流、关闭大导出或大批处理入口。
保存现场：保留日志、heap dump（堆转储）、GC（垃圾回收）日志、线程栈。
判断类型：看异常是 Java-heap-space（Java 堆空间）、Metaspace（元空间）、Direct buffer memory（直接缓冲内存）还是 native thread（本地线程）。
分析对象：用 MAT（内存分析工具）看 dominator tree（支配树）、retained-size（保留大小）、GC-Roots（垃圾回收根）引用链。
结合业务：看是否批量导出、缓存、消息堆积、任务重试、第三方接口卡顿。
修复代码：限制批量、分页流式处理、缓存过期、线程池隔离、对象及时释放。
复盘：补监控、补压测、补告警阈值、补开关。

8.2 CPU（中央处理器）飙高标准排查步骤

# 1. 找到 Java（编程语言）进程
top

# 2. 查看进程内线程
top -Hp <pid>

# 3. 把十进制线程 ID（线程标识）转成十六进制
printf '%x\n' <tid>

# 4. 导出线程栈并搜索 nid（本地线程标识）
jstack <pid> > /tmp/thread.txt

判断方式：

如果高 CPU（中央处理器）线程在业务方法，检查死循环、递归、大集合遍历。
如果高 CPU（中央处理器）线程是 GC（垃圾回收）线程，检查内存泄漏或对象分配过快。
如果大量线程 BLOCKED（阻塞），检查锁竞争和锁内远程调用。
如果大量线程 WAITING（无限等待），检查线程池、队列、条件变量。

8.3 Full GC（完全垃圾回收）频繁治理

常见根因：

大对象频繁分配，如一次性导出、批量图片、PDF（便携式文档格式）合并。
缓存无上限，如 Map（映射接口）静态缓存不淘汰。
老年代长期占用高，可能有内存泄漏。
元空间增长，可能是动态代理、脚本、类加载器泄漏。
线程池堆积，任务对象在队列里长期被引用。

治理顺序：

先确认业务流量是否异常。
再看 GC（垃圾回收）日志和堆趋势。
然后找大对象和引用链。
最后才考虑调大堆或调 GC（垃圾回收）参数。

9. 项目落地话术

9.1 异步导出 OOM（内存溢出）话术

“我处理过大数据量导出导致的 OOM（内存溢出）。当时问题不是简单内存小，而是一次性查询和一次性生成 Excel（电子表格）导致大量对象长期被引用，Full GC（完全垃圾回收）也回收不掉。我把同步导出改成主任务加分片任务：分页查询、流式写文件、本地临时文件合并、上传 OSS（对象存储服务）、最后通知下载。这样接口不再长时间占用线程，堆内存也不会被一次性打满。”

9.2 CPU（中央处理器）飙高话术

“我排查 CPU（中央处理器）飙高会先用 top（进程监控命令）定位 Java（编程语言）进程，再用 top-Hp（线程查看命令）定位具体线程，把线程 ID（线程标识）转成十六进制后在 jstack（线程栈工具）里找 nid（本地线程标识）。如果线程在业务循环，就看循环条件和数据量；如果是 GC（垃圾回收）线程，就看对象分配和 Old（老年代）趋势；如果是锁竞争，就看 BLOCKED（阻塞）线程和锁持有者。”

9.3 生产事故复盘话术

“我的线上事故处理习惯是先止血，再定位，再修复，再复盘。止血可以限流、摘节点、关开关；定位要保留 GC（垃圾回收）日志、线程栈、堆转储；修复不能只调参数，要找到代码和业务根因；复盘要补监控、补压测、补告警和回滚方案。”

9.4 JVM（Java 虚拟机）生命周期话术

“JVM（Java 虚拟机）生命周期可以从进程视角讲：操作系统先启动 Java（编程语言）进程，JVM（Java 虚拟机）初始化运行时数据区、类加载器、GC（垃圾回收）线程和 JIT（即时编译）线程；然后加载 main（主方法）所在类并执行 main（主方法）。运行过程中会不断发生类加载、字节码解释执行、热点代码 JIT（即时编译）、对象分配和 GC（垃圾回收）。退出时，如果 main（主方法）结束且没有 non-daemon thread（非守护线程），或者调用 System.exit（系统退出），JVM（Java 虚拟机）会进入 shutdown（关闭）流程，执行 Shutdown Hook（关闭钩子）后退出。但 kill -9（强杀信号）或 Runtime.halt（强制停止运行时）不会保证 Shutdown Hook（关闭钩子）执行。”

9.5 优雅停机话术

“在微服务里 JVM（Java 虚拟机）退出不是简单杀进程。比如订单履约、轨迹推送、Redis（远程字典服务）延迟队列消费这类任务，如果直接 kill -9（强杀信号），可能出现任务执行一半、锁未释放、状态没落库的问题。我的做法是接入优雅停机：先从注册中心摘流量，再停止接收新任务，然后等待线程池中任务完成或超时取消，最后释放资源。Shutdown Hook（关闭钩子）可以做兜底，但不能把全部可靠性寄托在 Shutdown Hook（关闭钩子）上，任务本身还要幂等和可恢复。”

10. 高频面试题与追问

10.1 JVM（Java 虚拟机）堆和栈有什么区别？

堆是线程共享的，主要放对象实例，是 GC（垃圾回收）重点管理区域；栈是线程私有的，放方法调用栈帧、局部变量、操作数栈。堆容易出现 OOM（内存溢出），栈容易出现 StackOverflowError（栈溢出错误）。

10.2 OOM（内存溢出）一定是内存泄漏吗？

不一定。OOM（内存溢出）可能是内存泄漏，也可能是瞬时大对象、批处理过大、参数配置太小、线程过多、直接内存不足。面试时要先分类，再定位。

10.3 Full GC（完全垃圾回收）频繁怎么处理？

先看 GC（垃圾回收）日志和 jstat（虚拟机统计工具）趋势，确认 Old（老年代）是否持续上涨；再导出 heap dump（堆转储）分析大对象和引用链；结合业务看是否批任务、缓存、队列堆积；最后修代码或调参数。

10.4 G1（垃圾优先回收器）为什么适合大堆？

G1（垃圾优先回收器）按 Region（区域）管理堆，可以优先回收收益高的 Region（区域），并通过 Pause-Target（停顿目标）尽量控制停顿时间，比传统整代回收更适合大堆和低停顿场景。

10.5 类加载双亲委派有什么意义？

双亲委派可以保证核心类优先由上层类加载器加载，避免核心类被重复加载或篡改，保持 Java（编程语言）类型体系稳定。

10.6 JVM（Java 虚拟机）生命周期有哪些阶段？

可以按启动、初始化、运行、关闭讲。启动阶段操作系统创建 Java（编程语言）进程并创建 JVM（Java 虚拟机）实例；初始化阶段准备内存区域、类加载器、GC（垃圾回收）线程、JIT（即时编译）线程；运行阶段执行 main（主方法）、解释执行字节码、JIT（即时编译）、对象分配、GC（垃圾回收）；关闭阶段执行 Shutdown Hook（关闭钩子）并释放资源。kill -9（强杀信号）这类强制终止不会保证关闭流程完整执行。

10.7 类生命周期和对象生命周期有什么区别？

类生命周期是 Class（类元数据）层面的：Loading（加载）、Linking（链接）、Initialization（初始化）、Using（使用）、Unloading（卸载）。对象生命周期是实例层面的：内存分配、零值初始化、对象头设置、构造方法执行、被引用使用、不可达、被 GC（垃圾回收）回收。一个类通常先被加载和初始化，才能创建这个类的对象。

10.8 为什么 main（主方法）结束后 JVM（Java 虚拟机）不一定退出？

因为 JVM（Java 虚拟机）退出取决于是否还存在 non-daemon thread（非守护线程）。如果线程池里的工作线程不是 daemon thread（守护线程），即使 main（主方法）结束，JVM（Java 虚拟机）也会继续运行。所以线上服务关闭时必须正确 shutdown（关闭）线程池。

10.9 Shutdown Hook（关闭钩子）一定会执行吗？

不一定。正常 System.exit（系统退出）或 SIGTERM（终止信号）通常会触发 Shutdown Hook（关闭钩子）；但 kill -9（强杀信号）、Runtime.halt（强制停止运行时）、操作系统崩溃、JVM（Java 虚拟机）fatal error（致命错误）可能不会执行。所以 Shutdown Hook（关闭钩子）只能做优雅停机的一部分，业务还要靠幂等、状态机和补偿机制兜底。

模块综合热门面试题补强

10.6 JVM（Java 虚拟机）从启动到退出经历哪些阶段？

问题：JVM（Java 虚拟机）从启动到退出经历哪些阶段？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.7 类生命周期和对象生命周期有什么区别？

问题：类生命周期和对象生命周期有什么区别？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.8 Class-File（类文件）结构为什么重要？

问题：Class-File（类文件）结构为什么重要？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.9 操作数栈和局部变量表如何执行字节码？

问题：操作数栈和局部变量表如何执行字节码？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.10 JIT（即时编译）如何识别热点代码？

问题：JIT（即时编译）如何识别热点代码？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.11 逃逸分析如何减少对象分配？

问题：逃逸分析如何减少对象分配？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.12 强引用、软引用、弱引用、虚引用怎么区分？

问题：强引用、软引用、弱引用、虚引用怎么区分？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.13 Serial（串行收集器）、Parallel（并行收集器）、CMS（并发标记清除）、G1（垃圾优先回收器）怎么选？

问题：Serial（串行收集器）、Parallel（并行收集器）、CMS（并发标记清除）、G1（垃圾优先回收器）怎么选？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.14 如何阅读 GC（垃圾回收）日志？

问题：如何阅读 GC（垃圾回收）日志？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.15 Full GC（完全垃圾回收）频繁如何定位？

问题：Full GC（完全垃圾回收）频繁如何定位？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.16 OOM（内存溢出）一定是堆不够吗？

问题：OOM（内存溢出）一定是堆不够吗？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.17 DirectBuffer（直接缓冲区）为什么会导致本地内存问题？

问题：DirectBuffer（直接缓冲区）为什么会导致本地内存问题？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.18 Docker（容器技术）里 JVM（Java 虚拟机）内存如何设置？

问题：Docker（容器技术）里 JVM（Java 虚拟机）内存如何设置？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.19 jstack（线程栈工具）如何定位 CPU（中央处理器）飙高线程？

问题：jstack（线程栈工具）如何定位 CPU（中央处理器）飙高线程？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.20 Shutdown Hook（关闭钩子）为什么不能保证一定执行？

问题：Shutdown Hook（关闭钩子）为什么不能保证一定执行？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

10.21 线上 JVM（Java 虚拟机）事故如何复盘？

问题：线上 JVM（Java 虚拟机）事故如何复盘？
考点：核心概念、底层机制、失败边界、项目落地。
回答思路：先给结论，再讲工作流程和关键取舍，最后结合异步导出 OOM（内存溢出）、CPU（中央处理器）飙高、容器内存限制说明线上怎么兜底。
进阶追问：如果出现并发冲突、数据不一致、性能下降或服务重启，你如何定位、恢复和复盘？

11. 本模块复习清单

能完整讲出 JVM（Java 虚拟机）启动、初始化、运行、关闭生命周期。
能说明 main（主方法）结束后 JVM（Java 虚拟机）为什么不一定退出。
能说明 daemon thread（守护线程）和 non-daemon thread（非守护线程）的区别。
能说明 Shutdown Hook（关闭钩子）的作用和不可靠边界。
能讲出类生命周期：Loading（加载）、Linking（链接）、Initialization（初始化）、Using（使用）、Unloading（卸载）。
能讲出对象生命周期：分配、初始化、使用、不可达、GC（垃圾回收）回收。
能画出 JVM（Java 虚拟机）运行时内存结构图。
能说明堆、栈、元空间、直接内存分别可能出现什么问题。
能讲对象创建、分配、晋升、回收流程。
能解释 GC（垃圾回收）可达性分析和 GC-Roots（垃圾回收根）。
能对比标记清除、标记整理、复制算法。
能讲清 G1（垃圾优先回收器）Region（区域）模型。
能按步骤排查 OOM（内存溢出）、Full GC（完全垃圾回收）、CPU（中央处理器）飙高、死锁。
能把异步导出 OOM（内存溢出）、OkHttp（HTTP 客户端）未单例化内存问题讲成完整事故案例。