一、起源:为什么需要自动内存管理
1.1 手动管理内存的两类错误
C/C++ 这类语言把内存的生命周期交给开发者:申请用 malloc/new,释放在代码里显式写出。这套模型能压榨出极致的内存利用率,同时也把两类错误固化进了语言使用方式里。
第一类:悬垂指针(Dangling Pointer)
// 示意:C 语言中释放后继续使用
int *p = malloc(sizeof(int) * 10);
free(p);
*p = 42; // p 已失效,写入的地址可能已被分配器转给其他对象
printf("%d", *p); // 读取到随机值,或触发段错误
释放动作与使用动作之间没有任何机制约束,指针变量本身不会因为 free 而失效。释放后继续读写,行为取决于该地址后续被谁复用:可能读到脏数据,可能破坏别的对象,也可能触发段错误。这类问题的特征是错误现场与根因不在同一位置——崩溃点往往不是犯错点。
第二类:内存泄漏(Memory Leak)
// 示意:分配与释放路径不成对
void handle() {
char *buf = malloc(4096);
if (parse(buf) < 0) {
return; // 提前返回,buf 未被释放
}
free(buf);
}
分配的每一处都必须有对应的释放,且要覆盖全部控制流分支。分支越多、异常路径越多,遗漏的概率越高。这类问题的特征是进程 RSS 单调上升不回落,最终耗尽内存或被内核终止。
除了这两类,还有双重释放、越界写、释放非堆内存等派生问题,它们的共同根源是同一件事:内存的可见生命周期由人的记忆和纪律维护,而不是由语言机制保证。
| 维度 | 手动管理 | 自动管理 |
|---|---|---|
| 释放责任 | 开发者显式调用释放 | 运行时根据可达性判定 |
| 错误类型 | 悬垂指针、泄漏、双重释放、越界 | 泄漏(引用未断)、溢出、停顿 |
| 错误发现时机 | 运行时随机位置崩溃,或长期占用增长 | 可达性判定与容量上限,可观测 |
| 调试成本 | 依赖工具回溯分配栈,跨模块排查 | 堆转储与 GC 日志可直接定位到持有链 |
1.2 自动管理的代价
自动内存管理把"什么时候释放"的决策权从开发者转移给运行时,代价是运行时必须在业务执行过程中插入自己的活动:标记存活对象、移动对象、更新引用。这些活动要么暂停业务线程(Stop-The-World,下文简称 STW),要么用读写屏障把成本摊到每一次内存访问上。
由此产生三个互相冲突的指标:
- 吞吐量(Throughput):应用运行时间占总运行时间的比例。GC 占用的 CPU 时间越少,吞吐量越高,常见目标是 95% 以上。
- 停顿时间(Latency / Pause Time):单次 STW 的持续时长,直接影响请求的 P99、P999 延迟,以及超时与重试的发生率。
- 内存占用(Footprint):堆、元空间、堆外与 GC 自身数据结构(卡表、记忆集、标记位图、转发指针表)的总和。
三者之间存在明确的取舍关系,无法同时取到最优:
| 取舍 | 做法 | 后果 |
|---|---|---|
| 提升吞吐量 | 减少 GC 次数、批量回收,允许较长停顿 | 单次停顿变长,长尾延迟恶化 |
| 缩短停顿 | 拆分回收过程、并发执行、并发整理 | 读写屏障与额外数据结构抬高 CPU 与内存开销,吞吐量下降 |
| 降低内存占用 | 缩小堆、减少 GC 元数据结构 | GC 频率上升,停顿与吞吐量同时下降 |
| 增大堆 | 延缓 GC 触发频率 | 单次 STW 的标记与移动工作量随堆增长,停顿变长(并发收集器除外) |
结论不在于"哪个收集器最好",而在于业务能接受多长的停顿、能提供多少内存、需要多高的吞吐量。指标取舍的先后顺序,决定了收集器与参数的选型,这是后面所有具体决策的依据。
1.3 为什么必须理解运行时
理解运行时数据区、对象布局与回收机制,直接决定线上问题的定位边界:什么问题能在 JVM 层面查清,什么问题必须下沉到操作系统层。
- 同一句 OOM,来源可能有四类。堆内溢出、元空间溢出、直接内存溢出、线程创建失败都打印
OutOfMemoryError,但对应的排查手段完全不同:堆内看转储,元空间看类加载器数量,直接内存看 NMT,线程失败看线程数与栈大小。不区分类型就抓转储,可能拿到一个"堆里完全正常"的结论。 - 进程被杀不一定有异常。堆内溢出会留下栈与转储,被内核 OOM Killer 终止则没有任何 Java 异常,只有退出码与内核日志。区分这两者需要同时掌握 JVM 内存构成与主机侧内存口径。
- 停顿归因依赖日志语义。是分配速率过高导致 Young GC 频繁,还是晋升过快导致老年代增长,还是单次 Full GC 的停顿过长,对应的调整方向互相矛盾。判断依据只能是 GC 日志中的字段,而不是经验直觉。
- 参数不能凭记忆设置。同一参数在不同收集器下的语义与生效范围不同(例如
-XX:PretenureSizeThreshold在 G1 下无效),默认值也随版本变化。设定依据应当是实测的活跃对象集与停顿目标,而不是从别处复制的一行启动脚本。
本篇聚焦对象的内存生命周期与回收:内存区域的构成与线程共享性、对象在内存中的排布、分配的路径、回收的算法与收集器实现、日志判读与故障处置。类加载的五阶段、双亲委派、实例化过程与 JIT 执行引擎不属于本篇范围,二者的边界见 类加载机制与执行引擎;诊断命令本身的参数与用法见 JDK 内置工具详解,本篇只引用命令,不重复其清单。内存模型与可见性问题属于并发领域,见 Java 并发编程。内存区域划分、类加载与收集器的概览式速查见 java 完整手册 的 JVM 基础章节,本篇是该部分的展开与补充。
二、原理
2.1 运行时数据区
JVM 在启动时向操作系统申请内存,并按用途划分为若干区域。划分的第一维度是线程共享性:线程私有的区域随线程创建与销毁,不存在并发访问;线程共享的区域是所有线程的工作对象,也是回收机制作用的主战场。
JVM 进程内存
├── 线程私有(随线程生命周期)
│ ├── 程序计数器(Program Counter Register)
│ ├── 虚拟机栈(VM Stack,HotSpot 中与本地方法栈合并)
│ │ └── 栈帧:局部变量表 / 操作数栈 / 动态链接 / 方法返回地址
│ └── 本地方法栈(Native Method Stack)
│
├── 线程共享(随 JVM 进程生命周期)
│ ├── 堆(Heap)—— GC 主要区域
│ │ ├── 新生代(Young):Eden + Survivor0 + Survivor1
│ │ └── 老年代(Old / Tenured)
│ └── 方法区(Method Area)
│ ├── 类的元数据(运行时常量池、字段与方法信息、注解)
│ └── 静态变量(引用本身)
│
└── 直接内存(Direct Memory)—— 不属于运行时数据区
└── NIO DirectByteBuffer、JNI 与第三方本地库分配
| 区域 | 共享性 | 存放内容 | 异常类型 | 主要参数 |
|---|---|---|---|---|
| 程序计数器 | 私有 | 当前线程执行的字节码指令地址(执行 native 方法时为空) | 无(唯一不抛 OOM 的区域) | 无 |
| 虚拟机栈 | 私有 | 栈帧:局部变量表、操作数栈、动态链接、方法返回地址 | StackOverflowError(深度超限)、OutOfMemoryError(扩展失败) | -Xss |
| 本地方法栈 | 私有 | native 方法的栈帧 | 同虚拟机栈 | -Xss(HotSpot 与虚拟机栈合并) |
| 堆 | 共享 | 对象实例、数组 | OutOfMemoryError: Java heap space | -Xms、-Xmx、-Xmn、-XX:MaxTenuringThreshold |
| 方法区(元空间) | 共享 | 类元数据、运行时常量池、静态变量引用、方法字节码 | OutOfMemoryError: MetaspaceOutOfMemoryError: Compressed class space | -XX:MetaspaceSize-XX:MaxMetaspaceSize-XX:CompressedClassSpaceSize |
| 直接内存 | 进程级 | NIO 直接缓冲、JNI 与本机库分配 | OutOfMemoryError: Direct buffer memory | -XX:MaxDirectMemorySize |
几个容易混淆的点:
- 程序计数器是唯一不发生 OOM 的区域。它只需要保存一条指令地址,容量固定,不存在扩展失败的可能。
- 虚拟机栈的两种失败要区分。递归过深、方法调用链过长触发
StackOverflowError;线程数过多导致栈内存总量无法再申请时触发OutOfMemoryError: unable to create new native thread。前者是单个线程的栈被用尽,后者是进程层面的内存不足,处置方向相反(一个改递归或调大-Xss,一个降并发或调小-Xss)。 - 方法区的实现从永久代改为元空间。JDK 8 起,HotSpot 移除永久代(JEP 122),类的元数据改存于本地内存的元空间,只留下静态变量的引用仍在堆中。这一改动的直接影响是:永久代时代 "PermGen space" 溢出的场景,在 JDK 8+ 表现为元空间溢出,且因为不再受
-Xmx约束,默认可以持续增长到耗尽机器的本地内存——因此生产环境设置-XX:MaxMetaspaceSize是必要的边界。 - 堆的分代只是收集器的组织方式。新生代与老年代的划分来自分代收集假说,
-Xmn在 G1 与 ZGC 下语义不同(G1 不建议手动设定新生代大小,由停顿目标驱动),参数生效范围要以收集器为准。 - 直接内存的默认上限与堆上限挂钩。未显式设置
-XX:MaxDirectMemorySize时,其默认值近似等于-Xmx。这意味着堆上限调大之后,进程的总内存需求会同步抬升,容器限额必须按堆 + 堆外的总和评估。
2.2 对象的内存布局与访问
对象在堆中的排布分三部分,理解它的意义在于两点:一是能算出对象实际占用(判断大对象与晋升风险),二是能解释锁状态、哈希值、分代年龄这些运行时数据存在哪里。
普通对象:
┌──────────────────────────────────────────────┐
│ 对象头(Object Header) │
│ ├─ Mark Word(8 字节) │ 运行时数据:哈希、GC 年龄、锁状态
│ └─ 类型指针(4 字节,开启指针压缩时) │ 指向方法区的类元数据
├──────────────────────────────────────────────┤
│ 实例数据(Instance Data) │
│ ├─ 父类定义的字段 │
│ └─ 本类定义的字段(按 JVM 分配策略重排) │
├──────────────────────────────────────────────┤
│ 对齐填充(Padding) │ 补齐到 8 字节的整数倍
└──────────────────────────────────────────────┘
数组对象:对象头中额外有 4 字节的长度字段
2.2.1 对象头
Mark Word 在 64 位 HotSpot 上占 8 字节,是一个按位复用的结构:同一批比特在无锁、偏向、轻量级锁、重量级锁、GC 标记状态下表示不同含义。位域划分(无锁状态):
| 位段 | 长度 | 含义 |
|---|---|---|
| unused | 25 位 | 未使用 |
| identity_hashcode | 31 位 | 对象哈希值,首次调用 hashCode() 或 System.identityHashCode() 时惰性写入 |
| unused | 1 位 | 未使用 |
| age | 4 位 | 分代年龄,最大 15,这是 -XX:MaxTenuringThreshold 上限为 15 的原因 |
| biased_lock | 1 位 | 偏向锁标志 |
| lock | 2 位 | 锁状态:01 无锁/偏向、00 轻量级锁、10 重量级锁、11 GC 标记 |
锁状态演化与 Mark Word 的替换过程见 Java 并发编程 的锁升级章节,本篇不再展开。需要留意的是两点:哈希值写入后无法再进入偏向锁(偏向锁需要整个 64 位的线程 ID,与哈希字段冲突),以及 age 只有 4 位,因此对象晋升年龄的可调范围是 0~15。
类型指针指向方法区中该对象的类元数据,未开启指针压缩时占 8 字节,开启后占 4 字节。
2.2.2 实例数据与字段重排
字段在对象中的排列顺序与源码书写顺序无关,JVM 按以下规则重排:
long/double(8 字节)优先排列;- 其余基本类型与引用按 4 字节、2 字节、1 字节分组排列,引用类型在开启指针压缩后占 4 字节;
- 父类定义的字段排在子类字段之前;
- 相同宽度的字段尽量排在一起,减少填充字节。
重排的目的是让字段尽量落在同一个 8 字节字内,减少对齐填充与外层指针的跨缓存行访问。基本类型与引用类型在内存中的差异见 数据类型系统。
2.2.3 对齐填充与指针压缩
HotSpot 要求对象起始地址按 8 字节对齐,因此对象总大小必须是 8 的整数倍,不足部分由对齐填充补齐。空对象 new Object() 占 16 字节(8 字节 Mark Word + 4 字节压缩类型指针 + 4 字节填充)即由此而来。
指针压缩(Compressed Oops)把 64 位引用压缩为 32 位存储。实现方式是存储相对偏移并左移 3 位:32 位可表示的偏移范围是 4G,乘以 8 字节的对齐粒度,得到 32GB 的寻址上限。这解释了一个常见现象:
堆上限从 32GB 以内调到 32GB 以上时,进程内存占用会明显跳升——超过阈值后指针压缩自动失效,所有引用从 4 字节变回 8 字节,对象体积与缓存压力同步增大。32GB 不是"最多能用多少"的分界线,而是"是否还启用压缩指针"的分界线。
相关参数:
-XX:+UseCompressedOops # 压缩普通对象指针,堆小于约 32GB 时默认开启
-XX:+UseCompressedClassPointers # 压缩类型指针,默认开启
-XX:ObjectAlignmentInBytes=8 # 对象对齐字节数,可调整为 16 以扩大压缩寻址范围
2.2.4 对象的两种访问方式
| 方式 | 实现 | 优点 | 缺点 |
|---|---|---|---|
| 句柄访问 | 堆中划分一块句柄池,引用指向句柄,句柄含实例数据指针与类型指针 | 对象移动时只需更新句柄,引用本身稳定 | 多一次间接寻址 |
| 直接指针 | 引用直接指向对象,类型指针存在对象头中 | 访问快(少一次跳转),HotSpot 采用 | 对象移动时需更新引用(依赖 GC 与读屏障配合) |
HotSpot 使用直接指针。在 G1、ZGC、Shenandoah 这类会并发移动对象的收集器上,"更新引用"不再依赖 STW 期间整体修正,而是通过读屏障或转发指针在访问路径上完成,这正是它们能并发整理的原因。
2.3 对象分配
创建对象的完整语义(类加载检查、清零、设置对象头、执行构造方法)见 类加载机制与执行引擎,本节只关注内存在哪一块区域被划出来,也就是分配路径。
对象分配路径(按优先级)
│
├─ 1. 逃逸分析判定不逃逸 → 标量替换 / 栈上分配(不进入堆)
│
├─ 2. 在 TLAB 中指针碰撞分配(无锁,最快路径)
│
├─ 3. TLAB 不足 → 在 Eden 区分配(需要 CAS 或加锁)
│ └─ Eden 空间不足 → 触发 Minor GC
│
├─ 4. 大对象 → 直接进入老年代(或 G1 的 Humongous Region)
│
└─ 5. Minor GC 后仍不足 → 动态年龄判定提前晋升 / 空间分配担保
└─ 最终失败 → Full GC → 仍失败 → OutOfMemoryError
2.3.1 逃逸分析与栈上分配
逃逸分析判断对象的动态作用域是否超出方法或线程。若对象只在方法内使用,其字段可被拆解为局部变量(标量替换),对象本身不再分配在堆上,也就不产生 GC 压力。分析手段与优化细节见 类加载机制与执行引擎 的 JIT 优化章节,此处只记录与内存管理相关的两点:
- 栈上分配是 JIT 的优化结果,只在方法被编译为机器码后生效,解释执行阶段仍然堆分配,因此"程序刚启动时 GC 频繁"属于正常现象。
- 该优化不改变语义,不能在代码中依赖"对象一定不会被分配在堆上",它只影响性能表现。
2.3.2 TLAB
TLAB(Thread Local Allocation Buffer)为每个线程在 Eden 区预分配一块私有缓冲区,线程在自己的 TLAB 内用指针碰撞分配,不需要同步。这是分配路径上最关键的性能设计——绝大多数对象分配都是无锁的。
| 参数 | 含义 | 默认值 |
|---|---|---|
-XX:+UseTLAB | 启用 TLAB | 开启 |
-XX:+ResizeTLAB | 允许 TLAB 大小动态调整 | 开启 |
-XX:TLABSize | 起始大小 | 0,表示由 JVM 按 Eden 大小与线程数自适应 |
-XX:TLABWasteTargetPercent | 允许 TLAB 内浪费的比例,超过则新申请 TLAB | 1(%) |
-XX:TLABWasteIncrement | 分配失败重试时浪费阈值的增量 | 4(%) |
TLAB 的代价是空间浪费:每个 TLAB 末尾的剩余空间不足以放下新对象时,这部分空间只能废弃。线程数多、对象较大时浪费比例上升,可通过 jstat -gc 观察 Eden 实际可用容量与分配效率。
2.3.3 大对象与 Humongous 对象
大对象(长数组、大字符串、大缓冲)若在新生代分配,会在 Eden 与 Survivor 之间反复复制,成本远高于其回收收益,因此实现上直接进入老年代。
| 收集器 | 判定方式 | 参数 |
|---|---|---|
| Serial / ParNew | 对象大小超过阈值 | -XX:PretenureSizeThreshold=<字节> |
| G1 | 对象大小超过 Region 的 50% | 阈值由 -XX:G1HeapRegionSize 决定 |
| Parallel Scavenge | 无直接阈值参数,按新生代结构分配 | 无 |
需要特别注意:-XX:PretenureSizeThreshold 对 Parallel Scavenge 与 G1 无效。G1 中大对象进入连续的 Humongous Region,占用整段连续 Region;若 Humongous 对象产生的速率很高(例如批量处理大数组),会频繁触发并发标记与 Full GC,日志中出现 Humongous regions 数量摇摆或 Pause Full (G1 Compaction Pause)。
2.3.4 动态年龄判定与空间分配担保
Minor GC 后存活对象进入 Survivor。对象每经历一次 Minor GC 且仍存活,age 加 1,超过阈值则晋升老年代。除固定年龄外,还存在两个提前晋升的机制:
- 动态年龄判定:Survivor 中某一年龄及以下的对象大小总和超过 Survivor 空间的一半时,该年龄及以上的对象直接晋升。参数
-XX:TargetSurvivorRatio(默认 50,表示 Survivor 的目标使用比例)会间接影响这一判定。 - 空间分配担保:Minor GC 是按"最坏情况"预留空间的——若老年代最大连续可用空间大于新生代全部对象总大小,或大于历次晋升对象的平均大小,则允许 Minor GC;否则必须先做一次 Full GC。JDK 6 Update 24 之后
-XX:+HandlePromotionFailure不再影响这一判断,规则固定为上述形式。
-XX:MaxTenuringThreshold=15 # 晋升年龄,0-15,默认 15(不同收集器默认值可能不同)
-XX:TargetSurvivorRatio=50 # Survivor 目标使用比例(%)
-XX:SurvivorRatio=8 # Eden 与单个 Survivor 的比值 8:1(Parallel/Serial)
-XX:NewRatio=2 # 老年代与新生代比值 2:1(Parallel/Serial)
-XX:PretenureSizeThreshold=1m # 大对象阈值,仅 Serial/ParNew 生效
查看当前进程真实的默认值,应以
java -XX:+PrintFlagsFinal -version或jcmd <PID> VM.flags -all的输出为准,不同收集器与不同 JDK 版本之间存在差异。
2.4 引用类型与生命周期干预
可达性分析判定"对象是否可达"依赖引用的强度。Java 定义了四种强度递减的引用,允许开发者在"一定被回收"与"一定不被回收"之间插入中间档位。
| 引用类型 | 类 | 回收时机 | 典型用途 |
|---|---|---|---|
| 强引用 | 默认(new、赋值) | 只要可达就不回收;不可达时下次 GC 回收 | 常规对象引用 |
| 软引用 | SoftReference | 内存不足(即将发生 OOM)时才回收 | 内存敏感的缓存 |
| 弱引用 | WeakReference | 下一次 GC 时必回收 | 关联数据、规范化映射、WeakHashMap 的 key |
| 虚引用 | PhantomReference | 无法通过它访问对象;对象被回收时入队 | 回收通知、堆外资源释放 |
2.4.1 软引用与弱引用
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.Map;
import java.util.WeakHashMap;
public class ReferenceUsage {
// 软引用缓存:内存不足时由 GC 自动腾出空间,无需应用层淘汰策略
private SoftReference<byte[]> cache = new SoftReference<>(new byte[1024 * 1024]);
public byte[] get() {
byte[] data = cache.get(); // 可能已被回收,返回 null
if (data == null) {
data = load(); // 重新加载
cache = new SoftReference<>(data); // 引用不可原地重设,改为替换整个 SoftReference
}
return data;
}
// 弱引用:key 被回收后条目自动消失,避免"key 已无用但映射仍持有"的泄漏
private final Map<Object, String> registry = new WeakHashMap<>();
public void register(Object key, String value) {
registry.put(key, value); // key 无其他强引用时,条目可被回收
}
private byte[] load() {
return new byte[1024 * 1024];
}
}
两者的差别在于触发条件:软引用绑定"内存压力",弱引用绑定"GC 发生"。因此软引用适合做缓存(内存充足时保留,紧张时释放),弱引用适合做"生命周期跟随其他对象"的辅助结构。应用层的缓存过期与淘汰策略属于另一个层面,见 缓存基础与一致性。
WeakHashMap 的典型陷阱是:若 value 反过来强引用了 key(例如 map.put(k, k) 或 value 持有 key 的引用),则 key 永远不会变成不可达,整个结构退化为普通 Map,条目不会释放。
2.4.2 虚引用与引用队列
虚引用无法通过 get() 取回对象(始终返回 null),它的唯一用途是在对象被回收时收到通知。这需要与 ReferenceQueue 配合使用:对象被回收后,Reference 实例本身被放入队列,由后台线程或应用线程取出处理。
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
public class PhantomWatcher {
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
private final PhantomReference<Object> ref = new PhantomReference<>(new Object(), queue);
public void poll() {
Reference<?> r = queue.poll();
if (r != null) {
// 此处执行与被回收对象关联的清理动作,例如释放句柄、注销注册表条目
releaseAssociatedResource();
}
}
private void releaseAssociatedResource() {
}
}
引用队列解决的是**"对象死了,但它代表的外部资源还没释放"**这一类问题:本地句柄、文件描述符、网络连接、堆外内存块的生命周期不在 JVM 堆内,GC 无法直接管理,必须由应用在对象被回收后主动释放。
2.4.3 终结器机制与其替代
finalize() 曾被设计为资源释放的兜底手段,问题在于:
- 时机不确定:只保证"某次 GC 之前或之后执行",不保证何时执行,资源可能长时间不释放。
- 代价高:重写了
finalize()的对象不能直接被回收,需要先入队、由 Finalizer 线程执行、再二次回收,至少多活一轮 GC。 - 可能破坏状态:
finalize()中可让对象重新被引用(对象复活),导致回收失效。 - 吞掉异常:
finalize()中抛出的异常被忽略,资源释放失败没有痕迹。
演进结果是逐步废弃:Object.finalize() 在 JDK 9 标记为废弃,JDK 18 起终结机制默认禁用(JEP 421)。替代方案是 java.lang.ref.Cleaner(JDK 9+,基于虚引用与引用队列的应用层封装)或更直接的做法——显式关闭。
| 方案 | 确定性 | 适用 |
|---|---|---|
try-with-resources / 显式 close() | 完全确定 | 首选,所有实现了 AutoCloseable 的资源 |
Cleaner | 对象不可达后触发,不确定但无需二次回收 | 兜底,堆外资源及第三方库无法显式关闭时 |
finalize() | 不确定,且多一轮回收 | 已废弃,新代码不应使用 |
2.5 GC 基础
2.5.1 可达性分析
判定对象是否可回收的主流做法是可达性分析:从一组称为 GC Roots 的对象出发遍历引用图,遍历结束后仍不可达的对象即为可回收。引用计数法因无法处理循环引用(两个互相引用但整体不可达的对象)而未被 HotSpot 采用。
GC Roots 的构成:
- 虚拟机栈中引用的对象:各线程栈帧局部变量表中处于作用域内的引用。
- 方法区中静态属性引用的对象:类的静态字段(引用本身在堆中,指向的对象是 Root)。
- 方法区中常量引用的对象:运行时常量池中的字符串常量、
static final常量引用。 - 本地方法栈中 JNI 引用的对象:native 方法中持有的引用(含 JNI Global / Local Reference)。
- JVM 内部引用:基本类型对应的 Class 对象、常驻异常对象(如
NullPointerException)、系统类加载器、正在被 JIT 编译的方法所引用的对象。 - 被同步锁持有的对象:
synchronized持有者(Monitor)关联的对象。 - 活跃线程对象本身:所有存活线程对象及其栈帧可达的对象。
可达性与"对象是否被 gc root 引用链持有"是同一件事。堆转储分析中"到 GC Roots 的最短路径"就是从这组根出发的引用链,泄漏定位的本质就是找到这条链上的哪个容器不该继续持有该对象。
2.5.2 分代假说与记忆集
分代收集并非从算法推导出的结论,而是基于对大量程序行为的经验观察,包含三条假说:
- 弱分代假说:绝大多数对象朝生夕灭。
- 强分代假说:熬过越多次回收的对象,越难以死亡。
- 跨代引用假说:跨代引用相对于同代引用只占极少数。
前两条解释了为什么新生代用复制算法、老年代用标记-整理/标记-清除:新生代存活率低,复制的成本与存活对象数成正比;老年代存活率高,复制成本难以承受。第三条解释了为什么回收新生代时不必扫描整个老年代:既然跨代引用很少,只需在老年代记录"哪些位置存在指向新生代的引用",即可把扫描范围从整个老年代缩小到少量记录。
这套记录结构称为记忆集(Remembered Set),其常见实现是卡表(Card Table):把堆按 512 字节划分为卡页,用字节数组标记哪些卡页存在跨代引用。写屏障在赋值动作发生时把对应的卡页标记为脏,回收时只扫描脏卡页。
| 概念 | 含义 | 特点 |
|---|---|---|
| 记忆集 | 抽象概念:记录从非收集区域指向收集区域的引用 | 有不同精度实现(字长精度、对象精度、卡精度) |
| 卡表 | 记忆集最常见的实现,按固定大小的卡页记录 | 实现简单,存在伪共享(同一卡页多个对象只有一个跨代引用也要扫描);写屏障带来微小开销 |
| G1 的 RSet | 每个 Region 一份,记录"哪些其他 Region 指向我"(Points-Into) | 结构更精细(Sparse / Fine / Coarse 三级),内存开销显著高于卡表 |
2.5.3 三种基础回收算法
| 算法 | 步骤 | 优点 | 缺点 | 适用 |
|---|---|---|---|---|
| 标记-清除 | 标记存活对象,清除未标记对象 | 实现简单,不移动对象 | 产生内存碎片;标记与清除效率随对象数下降 | CMS 的老年代 |
| 标记-复制 | 标记存活对象,复制到另一块空间后整体清空原空间 | 无碎片,分配只需指针碰撞 | 需预留一半空间或接受空间利用率下降;存活率高时复制成本大 | 新生代(Eden + Survivor) |
| 标记-整理 | 标记存活对象,向一端移动后清理边界外空间 | 无碎片,空间利用率高 | 移动对象成本高,需更新引用,通常需要 STW 或并发处理 | 老年代(Serial Old、Parallel Old);G1 Region 内部 |
2.5.4 三色标记与并发标记的正确性
并发标记允许标记线程与用户线程同时运行,这带来了漏标与错标的风险。用三色抽象描述对象的标记状态:
- 白色:尚未被访问,标记结束后仍是白色的对象被视为不可达。
- 灰色:自身被访问过,但其引用的对象还未全部扫描。
- 黑色:自身与全部引用都已被扫描完成。
并发过程中用户线程修改引用关系,会导致本应存活的对象被漏标。漏标成立需要同时满足两个条件:
- 黑色对象新增了一条指向白色对象的引用(写操作);
- 灰色对象到该白色对象的引用被删除(删操作)。
由于条件 1 与条件 2 必须同时发生,破坏其中任意一个即可保证正确性。两种方案对应两种写屏障:
| 方案 | 破坏的条件 | 屏障类型 | 做法 | 使用者 |
|---|---|---|---|---|
| 增量更新(Incremental Update) | 条件 1:记录黑色对象的新增引用 | 写后屏障 | 黑色对象新增引用时,把它重新标记为灰色,后续重新扫描 | CMS |
| 原始快照(SATB, Snapshot-At-The-Beginning) | 条件 2:记录被删除的引用 | 写前屏障 | 删除引用前把旧引用记录下来,按标记开始时的快照保证对象存活 | G1、Shenandoah |
语义差别值得留意:SATB 以标记开始时刻的快照为准,因此在本轮标记期间新产生的对象与新增引用可能被视为存活(浮动垃圾),代价是产生少量本可回收的对象;增量更新以标记结束时刻为准,代价是重新标记阶段需要重新扫描被更新过的对象。两者都是"用一点空间或时间换取正确性"。
2.5.5 安全点与安全区域
STW 需要在"引用关系不会变化"的位置暂停线程,这些位置称为安全点(Safepoint)。JVM 不在任意指令处暂停线程,原因有二:一是任意位置暂停需要为每条指令记录引用位置(OopMap 数量爆炸),二是用户线程需要主动配合才能进入一致状态。
- 主动式中断:JVM 设置一个全局标志,各线程在安全点处轮询该标志,发现需要暂停则主动挂起。
- OopMap:记录栈帧与寄存器中哪些位置存放引用,使 GC 能快速枚举根节点,无需逐个扫描整个栈与方法区。
- 安全点的位置:方法调用、循环回边(防止长循环长时间不进入安全点)、异常跳转等少量"执行状态稳定"的位置。
- 安全区域(Safe Region):线程处于
Sleep、Blocked等状态时无法自主轮询,此时用安全区域覆盖"进入时已记录引用状态、离开前检查是否需要 GC"的语义,避免 STW 无限期等待。
与停顿相关的常见现象是安全点停顿远大于 GC 本身。若日志中 GC 自身耗时只有几毫秒,而请求延迟抖动达到数百毫秒,需要排查线程长时间不进入安全点的情况(典型是超大循环、计数循环被 JIT 消除安全点轮询),此时观察工具与手段属于诊断范畴,见 3.3 节。
2.6 收集器
收集器的演进围绕同一个矛盾展开:标记与移动的成本能否从 STW 中挪出去。下面按时间顺序梳理各代收集器的机制、关键参数与现状。
2.6.1 Serial 与 Serial Old
单线程收集器。Serial 作用于新生代,使用标记-复制;Serial Old 作用于老年代,使用标记-整理。工作时必须暂停所有用户线程。其价值不在性能,而在两点:单核或极小内存环境下开销最低;作为其他收集器出现故障时的兜底方案(例如 CMS 并发模式失败时退化为 Serial Old)。
-XX:+UseSerialGC # 新生代 Serial + 老年代 Serial Old
2.6.2 ParNew
Serial 的多线程版本,算法与划分完全相同(新生代标记-复制),只是标记与复制阶段并行执行。它存在的意义是配合 CMS——CMS 只能与 Serial 或 ParNew 搭配使用。随 CMS 被移除,ParNew 的主要使用场景也一并消失。
-XX:+UseParNewGC # 新生代 ParNew(与 CMS 搭配)
-XX:ParallelGCThreads=<N> # 并行 GC 线程数,默认按 CPU 数推导
2.6.3 Parallel Scavenge 与 Parallel Old
吞吐量优先的收集器组合。Parallel Scavenge 使用复制算法收集新生代,Parallel Old 使用标记-整理收集老年代。与 CMS 的差别在于目标不同:CMS 追求最短停顿,Parallel 追求最高吞吐量(即 GC 占用 CPU 时间比例最小),适合离线批处理、数据计算这类不敏感于单次停顿、但受总运行时间影响的场景。
-XX:+UseParallelGC # 新生代 Parallel Scavenge + 老年代 Parallel Old
-XX:MaxGCPauseMillis=<N> # 期望最大停顿(毫秒),是目标而非硬约束
-XX:GCTimeRatio=<N> # 吞吐量目标,GC 时间占比 = 1/(1+N),默认 99(即 1%)
-XX:+UseAdaptiveSizePolicy # 自适应调节新生代与晋升阈值,默认开启
-XX:MaxGCPauseMillis与-XX:GCTimeRatio是两个方向相反的目标,自适应策略会在二者之间取舍。设置MaxGCPauseMillis会触发缩小新生代,代价是 GC 频率上升、吞吐量下降——这一点在 G1 上同样成立。
2.6.4 CMS
CMS(Concurrent Mark Sweep)是第一个真正把标记与清除阶段并发化的主流收集器,目标是降低老年代回收的停顿。它只作用于老年代,必须与 Serial 或 ParNew 搭配。
回收流程分四个阶段,其中两个仍需 STW:
| 阶段 | 是否 STW | 工作内容 |
|---|---|---|
| 初始标记 | 是 | 标记 GC Roots 直接关联的对象,停顿短 |
| 并发标记 | 否 | 从初始标记的对象出发遍历整个对象图,与用户线程并发,耗时最长 |
| 重新标记 | 是 | 修正并发标记期间因用户线程修改引用导致的变动(增量更新),停顿比初始标记长但可控 |
| 并发清除 | 否 | 清除不可达对象,与用户线程并发 |
CMS 的三个固有问题:
- 并发模式失败(Concurrent Mode Failure):并发清除尚未完成时,老年代已被新晋升的对象填满,此时无法继续并发回收,只能退化为 Serial Old 做一次整体压缩式 Full GC,停顿可达数秒。诱因是晋升速率高于回收速率,或触发阈值设置过高(
-XX:CMSInitiatingOccupancyFraction)。 - 内存碎片:使用标记-清除,不移动对象,长期运行后产生碎片;大对象(如大数组)可能因找不到连续空间而提前触发 Full GC。
- 浮动垃圾:并发清除期间新产生的垃圾要留到下一轮,因此 CMS 不能在老年代完全填满时才启动,必须预留空间。
-XX:+UseConcMarkSweepGC # 启用 CMS(JDK 9 废弃,JDK 14 移除)
-XX:CMSInitiatingOccupancyFraction=70 # 老年代占用达到该比例时启动 CMS
-XX:+UseCMSInitiatingOccupancyOnly # 仅按上述比例触发,不做运行时自适应调整
-XX:+CMSScavengeBeforeRemark # 重新标记前先做一次 Minor GC,减少扫描范围
-XX:CMSFullGCsBeforeCompaction=5 # 每 N 次不压缩的 Full GC 后做一次压缩
CMS 在 JDK 9 被标记废弃(JEP 291),JDK 14 正式移除(JEP 363)。新部署不应再选择 CMS;现存使用 CMS 的系统迁移目标通常是 G1(JDK 9 起为默认)或 ZGC。
2.6.5 G1
G1(Garbage First)是 JDK 9 起的默认收集器(JEP 248),设计目标是在可控停顿的前提下兼顾吞吐量,适用于大堆(数 GB 至数十 GB)。
Region 化的堆布局:G1 不再把堆划分为物理连续的固定分代区域,而是划分为大小相等的 Region(默认约 2048 个,-XX:G1HeapRegionSize 取 1MB~32MB 的 2 的幂),每个 Region 在逻辑上扮演 Eden、Survivor、Old 或 Humongous 角色,角色随回收过程动态变化。
G1 堆布局(Region 逻辑角色)
┌────┬────┬────┬────┬────┬────┬────┬────┐
│ E │ E │ S │ O │ O │ H │ H │ 空闲│
└────┴────┴────┴────┴────┴────┴────┴────┘
E=Eden S=Survivor O=Old H=Humongous(大对象占用的连续 Region)
一次 Young GC:回收全部 Eden 与部分 Survivor,存活对象复制到新 Region 或晋升
一次 Mixed GC:Young 区 + 部分"回收收益最高"的老年代 Region(Garbage First 的命名由来)
记忆集与卡表:G1 每个 Region 维护一份 RSet,记录"哪些外部 Region 指向本 Region"的引用位置。RSet 使回收对某个 Region 时无需扫描整个堆。代价是内存开销——RSet 通常占堆的 1%~20%,对象引用密集或跨 Region 引用多时膨胀明显,需要在容量规划时预留。
回收流程:
| 阶段 | 是否 STW | 说明 |
|---|---|---|
| 初始标记 | 是 | 借助一次 Young GC 完成,标记 GC Roots 直接关联对象,同时修正 TAMS |
| 并发标记 | 否 | 并发遍历对象图,采用 SATB 记录引用删除 |
| 最终标记 | 是 | 处理 SATB 缓冲区中剩余的引用,停顿短 |
| 筛选回收 | 是 | 按回收收益排序选择 Region,把存活对象复制到空闲 Region 并整体清理,停顿由用户设定的目标约束 |
停顿预测模型:G1 根据历史数据估算每个 Region 的回收耗时,在 -XX:MaxGCPauseMillis(默认 200ms,软目标)允许的范围内挑选 Region 子集,从而把单次停顿控制在目标附近。这是"可预测停顿"的实现方式,也是它与 CMS 的根本差别:CMS 无法约束停顿,G1 用选择性回收换取停顿可控。
-XX:+UseG1GC # 启用 G1(JDK 9+ 默认)
-XX:MaxGCPauseMillis=200 # 停顿目标(软目标),默认 200
-XX:G1HeapRegionSize=16m # Region 大小,1MB~32MB 的 2 的幂;大对象多时可调大
-XX:InitiatingHeapOccupancyPercent=45 # 触发并发标记周期的堆占用比例,默认 45
-XX:G1NewSizePercent=5 # 新生代下限(占堆比例),默认 5
-XX:G1MaxNewSizePercent=60 # 新生代上限,默认 60
-XX:G1MixedGCLiveThresholdPercent=85 # Region 存活率超过该值则不纳入 Mixed GC
-XX:G1HeapWastePercent=5 # 可容忍的垃圾占比,低于此值停止 Mixed GC
-XX:G1MixedGCCountTarget=8 # 一个并发标记周期内 Mixed GC 的目标次数
-XX:+G1UseAdaptiveIHOP # 自适应调整 IHOP,默认开启
G1 使用上的常见误区是同时设置
-Xmn与MaxGCPauseMillis。手动固定新生代大小会让停顿预测模型失去调节空间,通常只保留停顿目标,让 G1 自行决定新生代规模。
2.6.6 ZGC 与 Shenandoah
这两个收集器把目标从"可控停顿"推进到"停顿与堆大小解耦":无论堆是 8GB 还是 16TB,STW 时间都维持在毫秒级。实现手段是把标记、移动、重定位这些重活全部并发化,仅保留极短的初始标记与最终标记停顿(主要是根集合扫描与屏障相关的收尾工作)。
ZGC 的着色指针(Colored Pointers):利用 64 位指针中未被使用的若干高位作为状态标志,同一个地址在不同标记视图下有不同的编码。核心是四个视图:
| 视图 | 含义 |
|---|---|
| Marked0 / Marked1 | 本轮与上一轮标记周期使用,交替切换以实现"标记位翻转"而无需清除旧标记 |
| Remapped | 指向对象当前真实位置(重定位完成后) |
| Finalizable | 仅用于终结器相关的对象 |
读屏障(Load Barrier):ZGC 在每次读取引用时插入一小段代码,检查指针的着色状态。若指针处于旧视图或指向已被移动的对象,则由屏障当场修正引用(自愈,Self-healing),而不是等到某个阶段统一修正。正因为修正发生在访问路径上,对象可以在用户线程运行期间被移动并并发重定位。
Shenandoah 与 ZGC 目标相近,早期实现使用 Brooks 转发指针(每个对象前多一个转发字段),后续版本改为 LRB(Load Reference Barrier)方案,同样把并发整理的负担放在读屏障上。
两者的关键差异:
| 维度 | ZGC | Shenandoah |
|---|---|---|
| 实现手段 | 着色指针 + 读屏障 | 早期 Brooks 转发指针,后改为 LRB + 读屏障 |
| 指针压缩 | 不支持(依赖 64 位指针高位做标志,需禁用压缩指针) | 支持压缩指针(转发指针方案下) |
| 内存开销 | 堆外元数据结构较大(多重映射),进程占用高于同堆的 G1 | 相对较小 |
| 分代支持 | JDK 21 起支持分代 ZGC(JEP 439) | 有分代实验实现,成熟度低于 ZGC |
| 可用性 | JDK 11 实验(JEP 333),JDK 15 正式(JEP 377) | JDK 12 引入(JEP 189,主要在 OpenJDK 生态) |
-XX:+UseZGC # 启用 ZGC(JDK 15+)
-XX:+ZGenerational # 分代 ZGC(JDK 21+)
-XX:ZAllocationSpikeTolerance=5 # 分配速率突增容忍度,影响 GC 启动时机
-XX:SoftMaxHeapSize=8g # 软上限:尽量不超过该值,但允许在压力下突破 -Xmx 以下的硬上限
-XX:+UseShenandoahGC # 启用 Shenandoah
ZGC 与 Shenandoah 的停顿目标通常在个位数毫秒。需要留意的是停顿不再是瓶颈之后,瓶颈会转移到分配速率与内存带宽上:若分配速率过高(例如每秒数十 GB 的临时对象),GC 周期会被迫频繁启动,CPU 被 GC 线程吃掉,表现为吞吐量下降而非停顿上升。此时的处理方向是减少垃圾产生,而不是继续调 GC 参数。
2.6.7 收集器演进与选型脉络
时间线(与内存管理相关的节点)
JDK 1.3 Serial / Serial Old
JDK 5 CMS 稳定
JDK 6 Parallel Scavenge + Parallel Old(吞吐量优先)
JDK 7 G1 引入(实验)
JDK 8 移除永久代,引入元空间(JEP 122)
JDK 9 G1 成为默认(JEP 248);CMS 标记废弃(JEP 291)
JDK 11 ZGC 实验(JEP 333);Epsilon 无操作 GC(JEP 318)
JDK 12 Shenandoah 引入(JEP 189)
JDK 14 CMS 移除(JEP 363)
JDK 15 ZGC 正式(JEP 377);偏向锁默认关闭(JEP 374)
JDK 18 finalization 默认禁用(JEP 421)
JDK 21 分代 ZGC(JEP 439)
选型脉络可归纳为三条线索:
- 按延迟目标选:停顿要求毫秒级且堆较大(数十 GB 以上)→ ZGC(或 Shenandoah);停顿要求百毫秒级、堆中等规模 → G1;停顿不敏感、追求最小 CPU 开销 → Parallel。
- 按堆规模选:小堆(数百 MB 以内)、单核或容器限额很小 → Serial;中等堆(数 GB 至数十 GB)→ G1;大堆(数十 GB 以上)→ G1 或 ZGC。
- 按现状选:仍在使用 CMS 的系统应迁移到 G1 或 ZGC;JDK 8 环境默认收集器是 Parallel(JDK 8 中
-XX:+UseParallelGC为服务端默认),升级到 JDK 9+ 后默认变为 G1,升级前必须按新收集器重新做一次压测基线,否则停顿特征会发生非预期变化。
Epsilon(-XX:+UseEpsilonGC)是不做任何回收的收集器,堆满即退出,仅用于性能测试与短生命周期任务,不能用于生产。
2.7 GC 日志与指标
2.7.1 日志参数
JDK 9 起统一使用 -Xlog 标签式日志框架,替代 JDK 8 的 -XX:+PrintGCDetails 系列参数。两者不能混用。
# JDK 9+(推荐)
-Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=10,filesize=50M
# JDK 8(历史参数,升级后需改写)
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-XX:+PrintTenuringDistribution
-Xloggc:/var/log/app/gc.log
-XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=50M
配置要点:
gc*表示同时开启gc、gc,heap、gc,phases、gc,metaspace、gc,age等子标签,字段完整是判读的前提(缺少 heap 标签就看不出回收前后的容量与晋升量)。filecount与filesize必须设置。GC 日志在故障场景下写入量可能很大,没有滚动与上限会把磁盘写满,把内存问题转化为磁盘故障。time,uptime同时保留墙钟时间与进程运行时间,前者用于与业务日志对齐,后者用于计算单位时间内的 GC 频率。- 生产环境还可附加
-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/data/dump/,让 OOM 时刻自动保留堆现场,这是唯一无需人工干预就能拿到堆内证据的手段。
2.7.2 日志字段判读
G1 的一次 Young GC 日志(节选):
[12.345s][info][gc,start ] GC(128) Pause Young (Normal) (G1 Evacuation Pause)
[12.347s][info][gc,phases ] GC(128) Pre Evacuate Collection Set: 0.21ms
[12.347s][info][gc,phases ] GC(128) Merge Heap Roots: 0.35ms
[12.347s][info][gc,phases ] GC(128) Evacuate Collection Set: 2.41ms
[12.347s][info][gc,phases ] GC(128) Post Evacuate Collection Set: 0.52ms
[12.347s][info][gc,phases ] GC(128) Other: 0.18ms
[12.348s][info][gc,heap ] GC(128) Eden regions: 320->0(320)
[12.348s][info][gc,heap ] GC(128) Survivor regions: 12->14(42)
[12.348s][info][gc,heap ] GC(128) Old regions: 186->192
[12.348s][info][gc,heap ] GC(128) Humongous regions: 3->3
[12.348s][info][gc,metaspace] GC(128) Metaspace: 68432K->68432K(1097728K)
[12.348s][info][gc ] GC(128) Pause Young (Normal) (G1 Evacuation Pause) 1018M->482M(2048M) 3.671ms
Parallel 的一次 Young GC 与一次 Full GC:
[35.120s][info][gc,start] GC(87) Pause Young (Allocation Failure)
[35.142s][info][gc,heap ] GC(87) PSYoungGen: 262144K->43520K(305664K)
[35.142s][info][gc,heap ] GC(87) ParOldGen: 120000K->120128K(699392K)
[35.142s][info][gc ] GC(87) Pause Young (Allocation Failure) 373M->159M(981M) 22.345ms
[61.870s][info][gc,start] GC(91) Pause Full (Metadata GC Threshold)
[62.905s][info][gc,heap ] GC(91) PSYoungGen: 51200K->0K(305664K)
[62.905s][info][gc,heap ] GC(91) ParOldGen: 699000K->312456K(699392K)
[62.905s][info][gc,meta ] GC(91) Metaspace: 1052672K->268800K(1097728K)
[62.905s][info][gc ] GC(91) Pause Full (Metadata GC Threshold) 732M->305M(981M) 1035.221ms
关键字段与判读方式:
| 字段 | 含义 | 判读用途 |
|---|---|---|
Pause Young / Pause Full / Pause Remark | 本次事件类型 | 区分 Young GC、Full GC、并发周期中的停顿阶段 |
括号中的原因(Allocation Failure / G1 Evacuation Pause / Metadata GC Threshold / Ergonomics / System.gc() / G1 Compaction Pause) | 触发原因 | 定位是分配压力、元空间增长、自适应决策还是代码显式调用 |
回收前 M -> 回收后 M (总容量 M) | 堆使用量的变化 | 差值反映本次回收释放的空间;回收后使用量(Live Set)是判断泄漏的核心依据 |
Eden 320->0(320) | Region 或容量单位的前后变化 | 观察新生代是否被完整回收、Survivor 是否接近填满 |
Old regions: 186->192 | 老年代绝对量 | 连续多次 Young GC 后老年代只增不减 → 晋升过快或泄漏 |
Humongous regions | 大对象占用 | 数量高且波动大 → 大对象分配频繁,考虑调大 Region 或优化数据结构 |
| 事件末尾的毫秒数 | 本次事件总耗时 | 停顿时间,用于统计 P99 与最长停顿 |
Metaspace: ... | 元空间容量与使用 | 只增不降 → 类加载器泄漏或动态类生成失控 |
User / Real / Sys(JDK 8 格式中) | 用户态、墙钟、内核态耗时 | Real 明显大于 User 说明存在并行效率损失或线程等待 |
2.7.3 由日志推导的核心指标
日志字段本身只是原始数据,判断问题需要几个派生指标。以下推导方式可以直接用文本处理完成,无需额外工具(命令细节见 JDK 内置工具详解):
- 分配速率(Allocation Rate):单位时间内新分配的对象总量,可用"两次 Young GC 之间新生代的增量 ÷ 时间间隔"估算。若单次 Young GC 释放了 900MB、间隔 1.5 秒,则分配速率约为 600MB/s。分配速率决定 Young GC 频率的下限,也是判断"是分配太快还是回收太慢"的起点。
- 晋升速率(Promotion Rate):单位时间内进入老年代的对象量,等于老年代增量 ÷ 时间间隔。晋升速率决定老年代填满的速度,是并发模式失败与 Full GC 频率的直接驱动量。
- 活跃对象集(Live Set):Full GC(或 G1 的并发标记周期)结束后老年代的占用量,代表"真实存活的对象总量"。堆容量应以活跃对象集的数倍来设定,而不是以
-Xmx反推。 - GC 占比:GC 总耗时 ÷ 进程运行时间。吞吐量目标(如 95%)对应的就是这一指标的补数。
- 停顿分布:单次停顿的 P50 / P99 / 最大值。平均值掩盖长尾,判断是否影响业务必须看 P99 与最长停顿。
GC 日志判读的核心逻辑是:用回收后的使用量判断"该不该回收",用回收的频率与耗时判断"回收得好不好"。回收后使用量稳定、频率与耗时符合预期,说明配置正常;回收后使用量持续上升,问题在对象生命周期(代码);回收后使用量稳定但 Full GC 频繁,问题在参数与代际空间划分。
2.8 内存问题的分类
OutOfMemoryError 只是一个异常类型,具体成因由其消息与伴随现象决定。先分类再取证,可以避免"抓了转储发现堆内正常"的无效排查。
| 类别 | 典型现象 | 主要成因 | 首要手段 |
|---|---|---|---|
| 堆内泄漏 | 老年代占用单调上升;Full GC 后仍不回落;GC 回收收益越来越小 | 静态集合只增不减;监听器/回调未注销;缓存无上限;ThreadLocal 未 remove;连接与流未关闭 | 堆转储 + 支配树,定位持有链 |
| 堆内存溢出 | OutOfMemoryError: Java heap space | 瞬时批处理大对象;容量小于活跃对象集;泄漏的终局 | 堆转储对比;核对活跃对象集与 -Xmx |
| 堆外内存溢出 | OutOfMemoryError: Direct buffer memory | NIO/Netty 直接缓冲未释放;-XX:MaxDirectMemorySize 小于实际需求;显式 GC 被禁用导致清理不及时 | NMT(jcmd VM.native_memory)核对堆外构成 |
| 元空间溢出 | OutOfMemoryError: Metaspace、Compressed class space | 动态生成类(CGLIB、反射、脚本引擎)失控;热部署导致类加载器无法卸载 | jstat -class / jcmd VM.classloader_stats;堆转储看 ClassLoader 数量 |
| GC 开销超限 | OutOfMemoryError: GC overhead limit exceeded | GC 占用了超过约 98% 的时间却回收不到 2% 的空间(近似判定),本质仍是堆不足或泄漏 | 同堆内存溢出,先扩容保证可用,再定位泄漏 |
| 虚拟机栈溢出 | StackOverflowError | 递归深度过大;深层嵌套调用;-Xss 过小 | 看异常栈的重复帧,定位递归出口 |
| 线程创建失败 | OutOfMemoryError: unable to create new native thread | 线程数过多(线程池未限界、每请求建线程);-Xss 过大导致单线程占用高 | 核对线程数与 -Xss,检查线程池配置 |
| 原生内存耗尽 | 进程被内核终止,退出码 137,Java 层无异常(容器场景 OOMKilled=true) | 堆 + 元空间 + 线程栈 + 直接内存 + 代码缓存总和超过容器限额或宿主机可用内存 | 对照容器限额、进程 RSS、堆用量三项数值 |
| 非内存问题被误判 | 请求超时、线程卡住、CPU 高但堆与 GC 正常 | 死锁、连接池耗尽、下游阻塞、业务死循环 | 线程栈快照;明确区分 GC 停顿与业务阻塞 |
三个易混淆的对照:
- 堆内 OOM 与进程被杀:前者有 Java 异常、有栈、可触发堆转储;后者没有异常,只有退出码与内核日志。区分依据是"有没有 Java 层证据"。
- 元空间增长与堆内泄漏:元空间不占堆,堆转储看不出异常,容易误判为"没有泄漏"。判断依据是
Metaspace容量与类加载器数量。 - GC 高 CPU 与业务死循环:两者都表现为 CPU 满载。前者由线程栈中大量
GC相关帧、GC 日志密集出现证实;后者表现为某个业务线程栈长时间停留在同一方法。线程栈排查手段见 Java 并发编程 与 JDK 内置工具详解。
三、实现
3.1 观察与诊断顺序
从现象到证据的排查顺序固定为四步,每一步都以"产出可判读的证据"为目标,避免在没有证据的情况下调整参数。
现象(用户或监控发现)
│
├─ 第一步:监控指标 —— 判断问题类别
│ 堆使用曲线、GC 次数与耗时、RSS、容器内存、CPU
│ 产出:是内存增长、频繁 GC 还是进程被杀
│
├─ 第二步:GC 日志 —— 判断回收是否正常
│ 回收前后容量、频率、停顿、触发原因、晋升量
│ 产出:是分配速率、晋升速率还是参数问题
│
├─ 第三步:堆与线程快照 —— 定位到对象与线程
│ 堆转储(谁持有)、线程栈(谁在阻塞)、NMT(堆外构成)
│ 产出:持有链与可疑对象类型
│
└─ 第四步:代码定位 —— 找到分配点与持有者
从支配树的最短 GC Roots 路径回到代码位置
产出:修复方案
每一步的首查项与判读依据:
| 现象 | 首查 | 判读依据 | 下一步 |
|---|---|---|---|
| 内存持续增长 | 老年代占用曲线 | Full GC 后使用量是否回落;不回落即为泄漏 | 堆转储 |
| 响应变慢、长尾抖动 | GC 停顿分布 | 停顿 P99 与最长停顿是否落在请求超时阈值内 | GC 日志与安全点排查 |
| CPU 高但 QPS 下降 | GC 占比与 GC 线程 | GC 占用 CPU 比例是否显著上升 | GC 日志与线程栈 |
| 进程无异常退出 | 退出码与内核日志 | 是否为内核 OOM 终止(137);容器场景看 OOMKilled | 容器限额与进程内存构成 |
抛 OutOfMemoryError | 异常消息 | 区分 heap / Metaspace / Direct buffer / native thread | 对应章节的手段 |
| 类加载数量持续上升 | 类计数 | 类只增不减通常伴随类加载器泄漏 | 元空间与类加载器分析 |
现场采集的顺序原则是先取证再处置。堆转储、NMT 报告、GC 日志、线程栈这些证据在重启后无法复原,而重启本身通常是恢复服务最快的手段。因此处置流程应固化为"先采集、后重启"。
命令本身(jps、jstat、jmap、jstack、jcmd、JFR)的参数与用法见 JDK 内置工具详解,本节只涉及选取哪类证据。
3.2 堆转储分析
3.2.1 获取方式与触发时机
| 方式 | 触发条件 | 特点 |
|---|---|---|
-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/data/dump/ | OOM 抛出时自动 | 唯一能在无人干预下拿到现场的方式;必须确保路径可用且有足够空间 |
jcmd <PID> GC.heap_dump <path> | 人工触发 | 运行中随时可dump,但会带来停顿 |
jmap -dump:format=b,file=<path> <PID> | 人工触发 | 与上者等效;-dump:live 只保留活对象但会触发一次 Full GC |
高危 在线上进程手动执行堆转储(jcmd GC.heap_dump / jmap -dump)
- 影响范围:转储过程需要暂停用户线程以获取一致的堆快照,停顿时间随堆大小增长(数 GB 堆通常为秒级,数十 GB 可达数十秒),期间所有请求阻塞;转储文件大小约等于堆的占用量,写入会占用磁盘 IO,若磁盘空间不足会直接导致服务不可用;使用
-dump:live还会额外触发一次 Full GC,可能加剧停顿并引起上游超时。 - 回滚方式:转储动作本身不改变进程状态,无需回滚;若因磁盘被写满导致故障,需删除转储文件释放空间后恢复。为避免文件写满磁盘,应事先确认目标目录可用空间大于堆上限,或直接指定独立的数据盘路径。
- 替代做法:优先在压测环境复现并转储;线上场景先用
GC.class_histogram观察对象分布(代价低得多),确认有必要后再转储;如果必须在线转储,选在业务低峰并提前摘除流量。线上取证与止损的先后顺序、堆转储在容器环境下的判读差异,见 Java 应用诊断与部署调优。
3.2.2 分析思路
堆转储分析围绕三个问题展开:谁最大、谁在持有、能不能回收。
- 对象分布:按类统计实例数与总大小(Shallow Size),先找出占用最高的几类对象。
java.lang.String、byte[]、char[]、HashMap$Node这类"容器型"对象占据前列是常见结果,它们通常不是根因,但能指出数据流向。 - 大对象与欠支配分析:Shallow Size 只算对象自身,无法反映它间接持有多少。**支配树(Dominator Tree)与保留大小(Retained Size)**才是有效口径——保留大小表示"该对象被回收后能连带释放的总量"。按保留大小排序,排在前面且数量异常增长的对象即为嫌疑对象。
- 引用链回溯:对嫌疑对象查看"到 GC Roots 的路径"(Path to GC Roots),并排除弱引用/软引用等不会阻止回收的路径。这条路径上的第一个业务对象,通常就是泄漏点:一个不该继续持有数据的静态集合、一个未注销的监听器、一个未清理的缓存。
- 对比分析:单次转储难以区分"正常驻留"与"泄漏"。取两个时点的转储(例如低峰与高峰各一次,或健康节点与异常节点各一次)做对比,观察哪些类的实例数与保留大小在增长,结论比单次快照可靠。
工具方面,Eclipse MAT 提供 Leak Suspects 报告、支配树、OQL 查询与转储对比;JDK 自带的 jvisualvm(JDK 8)或 VisualVM/JMC 也支持基本的堆分析。打开大转储文件本身需要数倍于文件大小的内存,应在独立机器或大内存分析机上操作,避免在故障节点上二次施压。
3.2.3 常见泄漏模式
| 模式 | 机制 | 识别特征 | 修复方向 |
|---|---|---|---|
| 静态集合只增不减 | static Map/List 作为全局缓存或注册表,写入后从不移除 | 静态字段持有的集合保留大小持续增长,元素类型固定 | 引入上限与淘汰策略;改用弱引用/软引用结构 |
| 监听器与回调未注销 | 注册到长生命周期容器(Spring 上下文、全局事件总线、被复用的客户端)后未反注册 | 被注册对象被容器集合持有,数量与注册次数同增 | 显式反注册;使用生命周期回调或弱引用注册表 |
线程池与 ThreadLocal | 线程池中的线程长期存活;ThreadLocalMap 的 value 被线程强引用,key 是弱引用 | 线程对象持有 ThreadLocalMap,value 对象保留大小大且不释放 | 在 finally 中 remove();机制细节见 Java 并发编程 |
| 连接、流与句柄未关闭 | 异常路径漏掉 close(),连接池与句柄持续被占用 | 驱动层对象(连接、Statement、InputStream)数量与失败次数相关 | try-with-resources;连接池配置上限与泄漏检测 |
| 缓存无上限 | 本地缓存无容量上限与过期时间,或 key 的基数不可控 | 缓存 Map 保留大小与请求量线性相关 | 使用有界缓存(含淘汰策略)或改为集中式缓存;策略参见 缓存基础与一致性 |
| 类加载器泄漏 | 自定义类加载器被长生命周期对象引用,导致其加载的全部类无法卸载 | 堆中 ClassLoader 与其 Class 对象数量持续增长,元空间同步增长 | 断开对 ClassLoader 的强引用;核对热部署与动态代理的实现 |
上述模式中多数增长发生在集合与缓存结构上,各类集合的单元素结构开销、扩容时的内存峰值与常见膨胀来源见 Java 集合框架实现原理。
泄漏定位的常见误区是只看实例数量而不看持有链。字符串实例多属于正常现象(业务数据本身就在字符串里),关键在这些字符串为什么没有被释放——答案只能在到 GC Roots 的路径上。
3.3 GC 日志分析实践
3.3.1 四类典型问题的日志特征
| 问题 | 日志特征 | 判断依据 | 调整方向 |
|---|---|---|---|
| 分配速率过高 | Young GC 间隔极短、单次耗时不长、每次回收前新生代被填满 | 分配速率(新生代增量 ÷ 间隔)远高于预期;Young GC 每秒数次以上 | 减少临时对象(避免循环内拼接字符串、减少装箱、复用大对象);适当扩大新生代以降低频率 |
| 晋升过快 | 每次 Young GC 后老年代明显增长;Old regions 递增;日志中年龄分布集中在低年龄段 | 晋升速率高;Survivor 空间偏小或动态年龄判定提前触发 | 扩大新生代与 Survivor;核对 SurvivorRatio、TargetSurvivorRatio、MaxTenuringThreshold;排查是否有大对象或长生命周期对象被放入短生命周期结构 |
| Full GC 频繁 | Pause Full 密集出现;触发原因多样(Metadata GC Threshold、Ergonomics、Allocation Failure、System.gc()) | 原因字段即线索:元空间相关 → 类加载问题;System.gc() → 代码显式调用;Allocation Failure → 老年代空间不足 | 按原因分别处理:调大元空间、查处显式 GC 调用、调整老年代空间或收集器 |
| 停顿过长 | 单次停顿显著高于平时;长尾突出 | 区分是 GC 自身耗时长(标记/复制工作量大)还是安全点等待(GC 耗时短但墙钟时间长) | GC 自身长 → 调小堆或改并发收集器、拆分回收;安全点等待长 → 排查长循环与线程阻塞,手段见 JDK 内置工具详解 |
3.3.2 由日志计算关键指标的示例
以下命令仅演示从日志文本中提取证据的思路(日志文件名需替换为实际路径):
# 1. 统计各类 GC 事件的次数与停顿分布
grep -o 'Pause Young[^ ]*' gc.log | sort | uniq -c
grep -o 'Pause Full[^ ]*' gc.log | sort | uniq -c
# 2. 提取 Full GC 的触发原因,判断是元空间、显式调用还是空间不足
grep 'Pause Full' gc.log | sed -E 's/.*Pause Full \(([^)]*)\).*/\1/' | sort | uniq -c | sort -rn
# 3. 提取每次事件的停顿毫秒数,观察长尾
grep -oE '[0-9]+\.[0-9]+ms$' gc.log | tr -d 'ms' | sort -n | tail -20
# 4. 观察回收后使用量(括号前的数值)是否持续上升
grep 'Pause Young' gc.log | grep -oE '[0-9]+M->[0-9]+M\([0-9]+M\)' | awk -F'->' '{print $2}'
判读要点:
- 看趋势不看单点。单次 Full GC 后的使用量偏高可能是瞬时峰值,连续多次(例如连续 5 次 Full GC 后的使用量逐次抬升)才构成泄漏证据。
- 区分"回收后使用量上升"与"回收前使用量上升"。前者表示存活对象在增长(泄漏或活跃对象集扩大),后者表示分配速率上升(业务量增加或产生垃圾变多)。
- 给停顿设定判定标准。判定"停顿是否影响业务"的标准是:停顿 P99 是否小于上游超时时间。没有标准就无法判断是否需要优化。
3.3.3 与压测基线对照
单看生产日志难以区分"配置问题"与"业务量增长"。有效做法是用压测建立基线,把参数调整的效果放在同一流量条件下对比:
- 固定压测模型(并发数、请求配比、数据量、时长),记录吞吐量、P99 延迟、GC 次数与停顿;
- 在相同模型下采集 GC 日志,计算分配速率、晋升速率、活跃对象集;
- 每次只调整一个参数,重跑同一模型,与基线对比;
- 对比结论必须同时满足"业务指标不退化"与"GC 指标改善"才算有效。
压测模型设计、基线定义与容量评估方法见 linux: 压测与性能基线。
3.4 生产调优实践
3.4.1 堆大小的决定依据
堆容量不应按"机器内存的一半"这类经验值直接设定,应按三个输入推导:
- 活跃对象集:从压测或生产日志中取得 Full GC(或 G1 并发标记周期)结束后的老年代占用量,这是真实存活的数据量。
- 分配速率与晋升速率:决定 GC 频率与老年代填充速度。堆过小会导致 GC 频繁,堆过大则单次停顿变长(并发收集器除外)且堆外预留空间被压缩。
- 容器限额与堆外需求:进程总内存 = 堆 + 元空间 + 线程栈(
-Xss× 线程数)+ 直接内存 + 代码缓存 + GC 结构 + JNI/本机库。容器限额必须覆盖这一总和。
常用的设定方法:-Xmx 取活跃对象集的 3~4 倍,-Xms 与 -Xmx 设为相同值以避免堆在运行期反复扩容收缩(扩容会触发 GC,收缩增加了后续 GC 的负担)。
3.4.2 新生代与老年代比例
| 收集器 | 调节方式 | 建议 |
|---|---|---|
| Serial / ParNew / Parallel | -Xmn 或 -XX:NewRatio、-XX:SurvivorRatio | 新生代过小 → Young GC 频繁;过大 → 单次复制成本与晋升量上升。以"每次 Young GC 后 Survivor 未溢出、晋升速率可接受"为准 |
| G1 | 由停顿目标驱动,不手动设 -Xmn | 仅在必要时用 -XX:G1NewSizePercent / -XX:G1MaxNewSizePercent 约束区间 |
| ZGC / Shenandoah | 分代实现下同样由自适应策略调节 | 一般不手动干预 |
3.4.3 收集器选择
| 场景 | 推荐 | 理由 |
|---|---|---|
| Web 服务、RPC 服务,堆 4~32GB,停顿目标 100~200ms | G1 | 停顿可控,吞吐量损失小,工具链与调优经验成熟 |
| 大堆(32GB 以上)、停顿目标 10ms 以内 | ZGC(JDK 15+,JDK 21+ 可用分代) | 停顿与堆大小解耦,适合延迟敏感且内存充裕的场景 |
| 离线批处理、数据计算、日志聚合 | Parallel | CPU 开销最小,总运行时间最短,对单次停顿不敏感 |
| 极小堆(数百 MB)、单核或受限容器 | Serial | 线程与结构开销最小 |
| 短生命周期任务、性能对比测试 | Epsilon(仅测试) | 不做回收,用于测量不掺 GC 影响的基线 |
3.4.4 停顿目标与关键上限参数
# 停顿目标(软目标,非硬约束)
-XX:MaxGCPauseMillis=200 # G1 默认 200;设置过小会推动新生代缩小、GC 频率上升
# 元空间与代码缓存上限(默认无上限,生产必须设置边界)
-XX:MetaspaceSize=256m # 首次触发元空间 GC 的阈值,并非上限
-XX:MaxMetaspaceSize=512m # 硬上限,防止类加载器泄漏耗尽本地内存
-XX:CompressedClassSpaceSize=256m # 压缩类空间上限,默认 1G
-XX:ReservedCodeCacheSize=256m # JIT 机器码缓存上限,写满会导致退回解释执行
# 直接内存
-XX:MaxDirectMemorySize=512m # 未设置时默认为 0,含义是"与 -Xmx 相同"
3.4.5 容器环境下的内存感知
JDK 10 起容器感知默认开启(JDK 8u191 之后版本也已回移),JVM 会读取 cgroup 限额而非宿主机物理内存来推导默认堆大小。
| 参数 | 作用 | 默认值 |
|---|---|---|
-XX:+UseContainerSupport | 启用容器内存与 CPU 感知 | 开启 |
-XX:MaxRAMPercentage | 堆上限占容器限额的百分比 | 25% |
-XX:InitialRAMPercentage | 初始堆占容器限额的百分比 | 1.5625% |
-XX:MinRAMPercentage | 小内存场景下的堆占比(限额小于约 256MB 时生效) | 50% |
-XX:+AlwaysPreTouch | 启动时预触碰全部堆页,把页面真正映射到物理内存 | 关闭 |
容器场景的两条实践原则:
- 显式设置
-Xmx时,容器限额必须留出堆外空间。常用做法是为堆外与线程栈预留 25%~30%。若堆外预留不足,现象是堆内尚有空间而容器已触发 OOM——堆转储显示"堆还很空",但进程已被杀,这类问题的判断顺序是先比较容器限额、进程 RSS、堆用量三项数值,再确认堆外部分由哪一类组成。堆外构成可借助 NMT 观察(开启方法见 linux: 内存管理 的 Java 堆外内存章节)。 -XX:+AlwaysPreTouch的取舍:开启后启动阶段就把堆内存实占满,运行期不再有缺页中断带来的延迟抖动,但启动变慢、进程 RSS 立即达到堆上限(容器限额必须按最大值预留)。延迟敏感且容器限额固定时值得开启,弹性伸缩或超卖场景下不建议。
常用参数组合示例:
# 组合一:容器内 G1,限额 4G,堆上限 2.8G,留出约 30% 堆外
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-Xms2560m -Xmx2560m
-XX:MaxMetaspaceSize=512m
-XX:MaxDirectMemorySize=256m
-XX:ReservedCodeCacheSize=256m
-Xss512k
-Xlog:gc*:file=/var/log/app/gc.log:time,uptime:filecount=10,filesize=50M
-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/data/dump/
# 组合二:大内存低延迟,16G 堆,ZGC(JDK 21+ 分代)
-XX:+UseZGC -XX:+ZGenerational
-Xms16g -Xmx16g
-XX:SoftMaxHeapSize=14g
-XX:ZAllocationSpikeTolerance=5
-XX:MaxMetaspaceSize=512m
# 组合三:离线批处理,吞吐量优先
-XX:+UseParallelGC
-Xms8g -Xmx8g
-XX:GCTimeRatio=99
-XX:MaxGCPauseMillis=1000
3.4.6 危险参数操作
高危 修改堆参数并重启进程(-Xmx / -Xms / 收集器 / -XX:MaxMetaspaceSize 等)
- 影响范围:修改启动参数必须重启进程,重启期间该实例不可用,全量重启会中断服务;参数方向错误会直接引入新故障——
-Xmx设置超过容器限额会导致进程被内核终止,堆上限设置过小会导致 GC 频繁甚至 OOM,切换收集器会让停顿特征与日志格式同时变化,使既有监控阈值与告警规则失效;-Xmx与容器限额不匹配时,故障可能在流量高峰才暴露。 - 回滚方式:保留变更前的完整启动参数与镜像/发布包版本,出现异常时按原参数与原版本回退;采用滚动或灰度方式变更,先在一台或一个分组验证,观察 GC 日志与业务指标后再全量;参数变更需与发布流程一并管理,具备明确的回滚触发条件。
- 配套要求:参数变更前后各采集一段 GC 日志与业务基线(方法见 3.3 节),用同一压测模型验证,避免"改了但没证据说明是否变好"。
高危 关闭显式 GC(-XX:+DisableExplicitGC)
- 影响范围:该参数使
System.gc()调用变为空操作。JDK 的直接内存分配路径(Bits.reserveMemory)在堆外内存不足时会调用System.gc()期望触发一次回收来清理已无用的DirectByteBuffer;一旦显式 GC 被禁用,这条自愈路径失效,堆外内存持续堆积,最终抛OutOfMemoryError: Direct buffer memory——而堆内完全正常。使用 NIO、Netty、MappedByteBuffer 或依赖System.gc()做清理的第三方库时风险最高。此外,部分框架(如基于System.gc()触发清理的缓存实现)行为会静默改变,问题难以归因。 - 回滚方式:移除该参数并重启进程。若短期内无法重启,可先用
jcmd <PID> VM.flags确认参数确实生效,并通过重启或限制堆外使用量缓解。 - 折中方案:若目的是避免
System.gc()引发 Full GC 停顿,应使用-XX:+ExplicitGCInvokesConcurrent(CMS/G1 下把显式 GC 转为并发 GC),而不是彻底关闭它。该参数保留了清理能力,同时避免长时间停顿。
3.5 常见故障处置
3.5.1 频繁 Full GC 的止损
处置顺序为"先止血、再取证、后修复":
- 限流降载:降低并发、暂停批量任务与非核心定时任务,减缓内存增长速度,为后续操作争取时间。
- 取证:采集 GC 日志、必要时做类直方图观察对象分布、抓取线程栈确认是否有大量线程阻塞在 GC 之外。
- 高危 强制触发 Full GC(
jcmd <PID> GC.run、jmap -histo:live、jmap -dump:live等):影响范围是强制一次整体回收,STW 停顿可达数秒至数十秒,期间所有请求阻塞、上游可能出现超时雪崩;在 CMS/G1 上还可能因空间不足触发并发模式失败,反而放大停顿;该动作只回收当前垃圾,不解决根因,短时间内会再次触发。回滚方式:动作本身不可撤销,只能等待回收结束;若已造成请求超时,应尽快恢复流量并记录该动作的时间点,避免与后续现象混淆;处置上优先选择"低峰期重启"而不是"高峰期强制回收"。 - 扩容或重启恢复:按 3.5.2 的顺序执行,重启前完整保留现场。
- 定位与修复:把现场数据交接给开发侧,修复后用同一压测模型验证。
3.5.2 OOM 触发后的现场保留与恢复顺序
- 确认 OOM 类型:读取异常消息与栈,区分堆内、元空间、直接内存、线程创建失败四类;若进程没有 Java 异常而是被终止,转入 3.5.4 的容器与主机侧判断。
- 保留现场:确认堆转储文件已生成(核对
-XX:HeapDumpPath指向的目录与文件时间),采集 GC 日志、线程栈、NMT 摘要(若已开启)与容器侧的memory.events;重启后这些现场不可复原。 - 限制影响范围:摘除异常节点流量或限流,避免故障节点持续接收请求。
- 恢复服务:滚动重启异常实例;恢复顺序是先恢复提供核心链路的部分,再恢复批处理与后台任务,避免重启后立即被批量任务再次压垮。宿主机层面的处置顺序(限流降载 → 重启 → 扩容 → 修复代码 → 长期措施)与 linux: 内存管理 的处置顺序一致,可交叉参照。
- 分析与修复:按 3.2 节做堆转储分析,找到持有链与分配点。
- 验证:修复后以相同压测条件回归,确认活跃对象集与会话量匹配、Full GC 后使用量不再抬升。
3.5.3 GC 停顿导致超时的降级
当停顿无法在短期内消除时(例如泄漏未修复、堆不能立即扩容),需要在应用侧降低停顿的业务影响:
- 超时与重试:调用方超时时间应大于 GC 停顿 P99,并配合幂等重试,避免单次停顿被放大为业务失败。
- 限流与熔断:停顿期间请求堆积,恢复瞬间的流量洪峰会形成二次冲击。限流入口与熔断下游可把冲击控制在容量范围内。
- 缓存与预计算:把停顿敏感的只读路径改为缓存读取,减少停顿期间的阻塞面。
- 降级策略:对非核心功能(推荐、统计、导出)准备开关,停顿或资源紧张时关闭。
- 分流:按实例摘除流量,让停顿异常节点退出服务,避免单个节点的长停顿拖累整体成功率。
3.5.4 容器内 OOMKilled 与 JVM 堆外内存的区分
两者的现象相似(进程被杀),但证据位置与处置方向完全不同:
| 维度 | 容器 cgroup OOM | JVM 堆内 OOM |
|---|---|---|
| Java 层证据 | 无异常、无栈、通常无转储 | 有 OutOfMemoryError 与栈;配置了自动转储则有 hprof 文件 |
| 进程退出码 | 137(128 + SIGKILL) | 由应用或启动脚本决定,通常非 137 |
| 容器标记 | docker inspect 的 State.OOMKilled 为 true | 通常为 false |
| cgroup 计数 | memory.events 的 oom_kill 大于 0 | 不增长 |
| 堆内情况 | 堆转储(若有)显示仍有余量 | 堆接近 -Xmx |
| 日志线索 | 应用日志无输出即中断(无机会落盘) | 有 GC 日志密集出现与异常栈 |
| 处置方向 | 核对容器限额与进程内存构成,预留堆外空间 | 分析堆转储,修复泄漏或调整堆上限 |
判断顺序:先比较容器限额、进程 RSS 与堆用量三项数值,再确认堆外部分由哪一类组成(元空间、线程栈、直接内存、代码缓存)。若 RSS 明显大于堆用量且限额已被触达,问题在堆外或限额设置;若 RSS 与堆用量接近且堆已满,问题在堆内。
需要同时注意的是宿主机全局内存不足会放大容器侧表现:此时容器限额可能未被触达,容器内 oom_kill 计数不增长,但进程仍被内核终止(全局 OOM),根因在宿主机内存总量与同宿主其他进程。区分依据是内核日志中是否出现 cgroup 字样。容器侧退出码与 OOM 判定的完整方法见 Docker 容器排障与命名空间诊断,容器内存限额参数的用法见 Docker 容器管理。
3.6 调优方法论
内存与 GC 调优的失败大多不源于技术判断错误,而源于方法失控:同时改动多个参数、没有基线、变更后无验证、问题复现时无法归因。以下四条是可控的做法。
- 一次只改一个变量。并行改多个参数时,无法从结果中分离出每个变量各自的贡献,也无法在结果变差时定位是哪个改动引起。变量包括:堆大小、新生代大小、收集器、停顿目标、元空间上限、代码层面的对象创建方式。
- 先建立基线再改。改之前必须有一组可对比的观测值:吞吐量、P99 延迟、GC 次数与停顿分布、分配速率、晋升速率、活跃对象集。没有基线的"优化"无法证明有效,也无法证明没有引入退化。
- 变更需要评审与明确回滚条件。参数与代码的变更应走同一套流程:记录变更内容、影响范围、验证方式、观察窗口与回滚触发条件。GC 调优的变更尤其需要提前声明"什么现象出现即回滚",因为停顿与内存的变化往往需要数小时到数天才稳定显现。变更分级、窗口选择、可逆性设计与复盘要求的完整流程见 linux: 变更与发布管理。
- 用压测验证,不用感觉验证。生产环境直接试参数会把用户当作验证对象;压测环境用同一模型对照,是先验证后上线的唯一可靠方式,方法见 linux: 压测与性能基线。
一条可执行的判定标准:
| 变更结论 | 判定条件 |
|---|---|
| 有效 | 业务指标(吞吐量、P99、错误率)不退化,且目标 GC 指标(如 Full GC 次数、停顿 P99)改善 |
| 无效 | 目标指标无变化,或变化在观测噪声范围内 |
| 有害 | 任一业务指标退化,或出现新的 GC 事件类型(如新增 Full GC 触发原因) |
| 无法判定 | 观测窗口内未覆盖业务峰值,或期间存在其他变更同时生效 |
四、总结
内存管理的出发点,是把"何时释放"的决策从人的记忆转移到运行时机制上。 手动管理会产生悬垂指针与内存泄漏两类结构性错误,自动管理的代价则是停顿时间、吞吐量与内存占用之间的取舍,三者无法同时取到最优。理解运行时的意义在于划定定位边界:同一句
OutOfMemoryError可能有四种来源,进程被内核终止则没有任何 Java 层证据,判错方向会让排查完全失效。原理层面可以按四层理解:
- 内存区域:程序计数器、虚拟机栈、本地方法栈为线程私有,堆与方法区(元空间)为线程共享,直接内存不在运行时数据区之内。JDK 8 起元空间位于本地内存,因此必须显式设置
-XX:MaxMetaspaceSize划出边界。- 对象与分配:对象由对象头(Mark Word 与类型指针)、实例数据、对齐填充组成,字段重排与指针压缩决定其实际体积,32GB 是压缩指针失效而非容量枯竭的分界。分配路径按"栈上分配 → TLAB → Eden → 大对象 → 担保晋升"依次尝试。
- 引用与回收判定:强、软、弱、虚四种引用强度让开发者可以在"必回收"与"不回收"之间插入档位;引用队列用于在对象回收后释放其代表的外部资源,取代了时机不确定的终结器。
- 回收算法与正确性:可达性分析从 GC Roots 出发,分代假说决定了新生代用复制、老年代用标记-整理/清除;并发标记的正确性由增量更新(破坏黑色对象新增引用)或原始快照(破坏灰色对象删除引用)保证;安全点与安全区域是 STW 得以成立的前提。
收集器的演进主线是将标记与移动的成本从 STW 中挪出去:Serial 与 Parallel 接受较长停顿换取最低开销;CMS 首次把标记与清除并发化,但无法约束停顿且存在碎片与并发模式失败(JDK 9 废弃、JDK 14 移除);G1 用 Region 化布局、RSet 与停顿预测模型把停顿变成可控目标,成为 JDK 9+ 默认;ZGC 与 Shenandoah 用着色指针或转发指针配合读屏障,把停顿与堆大小解耦。选型依据是延迟目标、堆规模与吞吐量要求,而非"越新越好"。
实现层面是一条"证据链":监控指标判断问题类别,GC 日志判断回收是否正常(回收后使用量看是否泄漏,频率与耗时看配置是否合理),堆转储与线程栈定位到对象与线程,最后回到代码找到分配点与持有者。堆转储的价值在支配树的保留大小与到 GC Roots 的路径,而不是实例数量排名。容器场景必须先比较容器限额、进程 RSS 与堆用量三项数值,再判断问题在堆内还是堆外。
需要显式防范的三类操作:线上手动堆转储会带来秒级至数十秒停顿并占用大量磁盘;强制 Full GC 只缓解症状不解决根因;关闭显式 GC 会切断直接内存的自愈路径,使堆内正常而堆外溢出。这类操作的标准流程是"先取证、后处置、留回滚"。
总结记忆:内存区域定边界,对象布局定体积,分配路径定去向,引用强度定生死,可达性定标记,分代与收集器定代价,日志与转储定证据——调优的方法论是一次只改一个变量、先建基线、明确回滚、压测验证。