一、起源:为什么需要自动内存管理

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),要么用读写屏障把成本摊到每一次内存访问上。

由此产生三个互相冲突的指标:

  1. 吞吐量(Throughput):应用运行时间占总运行时间的比例。GC 占用的 CPU 时间越少,吞吐量越高,常见目标是 95% 以上。
  2. 停顿时间(Latency / Pause Time):单次 STW 的持续时长,直接影响请求的 P99、P999 延迟,以及超时与重试的发生率。
  3. 内存占用(Footprint):堆、元空间、堆外与 GC 自身数据结构(卡表、记忆集、标记位图、转发指针表)的总和。

三者之间存在明确的取舍关系,无法同时取到最优:

取舍 做法 后果
提升吞吐量 减少 GC 次数、批量回收,允许较长停顿 单次停顿变长,长尾延迟恶化
缩短停顿 拆分回收过程、并发执行、并发整理 读写屏障与额外数据结构抬高 CPU 与内存开销,吞吐量下降
降低内存占用 缩小堆、减少 GC 元数据结构 GC 频率上升,停顿与吞吐量同时下降
增大堆 延缓 GC 触发频率 单次 STW 的标记与移动工作量随堆增长,停顿变长(并发收集器除外)

结论不在于"哪个收集器最好",而在于业务能接受多长的停顿、能提供多少内存、需要多高的吞吐量。指标取舍的先后顺序,决定了收集器与参数的选型,这是后面所有具体决策的依据。

1.3 为什么必须理解运行时

理解运行时数据区、对象布局与回收机制,直接决定线上问题的定位边界:什么问题能在 JVM 层面查清,什么问题必须下沉到操作系统层。

  1. 同一句 OOM,来源可能有四类。堆内溢出、元空间溢出、直接内存溢出、线程创建失败都打印 OutOfMemoryError,但对应的排查手段完全不同:堆内看转储,元空间看类加载器数量,直接内存看 NMT,线程失败看线程数与栈大小。不区分类型就抓转储,可能拿到一个"堆里完全正常"的结论。
  2. 进程被杀不一定有异常。堆内溢出会留下栈与转储,被内核 OOM Killer 终止则没有任何 Java 异常,只有退出码与内核日志。区分这两者需要同时掌握 JVM 内存构成与主机侧内存口径。
  3. 停顿归因依赖日志语义。是分配速率过高导致 Young GC 频繁,还是晋升过快导致老年代增长,还是单次 Full GC 的停顿过长,对应的调整方向互相矛盾。判断依据只能是 GC 日志中的字段,而不是经验直觉。
  4. 参数不能凭记忆设置。同一参数在不同收集器下的语义与生效范围不同(例如 -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: Metaspace
OutOfMemoryError: Compressed class space
-XX:MetaspaceSize
-XX:MaxMetaspaceSize
-XX:CompressedClassSpaceSize
直接内存 进程级 NIO 直接缓冲、JNI 与本机库分配 OutOfMemoryError: Direct buffer memory -XX:MaxDirectMemorySize

几个容易混淆的点:

  1. 程序计数器是唯一不发生 OOM 的区域。它只需要保存一条指令地址,容量固定,不存在扩展失败的可能。
  2. 虚拟机栈的两种失败要区分。递归过深、方法调用链过长触发 StackOverflowError;线程数过多导致栈内存总量无法再申请时触发 OutOfMemoryError: unable to create new native thread。前者是单个线程的栈被用尽,后者是进程层面的内存不足,处置方向相反(一个改递归或调大 -Xss,一个降并发或调小 -Xss)。
  3. 方法区的实现从永久代改为元空间。JDK 8 起,HotSpot 移除永久代(JEP 122),类的元数据改存于本地内存的元空间,只留下静态变量的引用仍在堆中。这一改动的直接影响是:永久代时代 "PermGen space" 溢出的场景,在 JDK 8+ 表现为元空间溢出,且因为不再受 -Xmx 约束,默认可以持续增长到耗尽机器的本地内存——因此生产环境设置 -XX:MaxMetaspaceSize 是必要的边界。
  4. 堆的分代只是收集器的组织方式。新生代与老年代的划分来自分代收集假说,-Xmn 在 G1 与 ZGC 下语义不同(G1 不建议手动设定新生代大小,由停顿目标驱动),参数生效范围要以收集器为准。
  5. 直接内存的默认上限与堆上限挂钩。未显式设置 -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 按以下规则重排:

  1. long / double(8 字节)优先排列;
  2. 其余基本类型与引用按 4 字节、2 字节、1 字节分组排列,引用类型在开启指针压缩后占 4 字节;
  3. 父类定义的字段排在子类字段之前;
  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 优化章节,此处只记录与内存管理相关的两点:

  1. 栈上分配是 JIT 的优化结果,只在方法被编译为机器码后生效,解释执行阶段仍然堆分配,因此"程序刚启动时 GC 频繁"属于正常现象。
  2. 该优化不改变语义,不能在代码中依赖"对象一定不会被分配在堆上",它只影响性能表现。

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,超过阈值则晋升老年代。除固定年龄外,还存在两个提前晋升的机制:

  1. 动态年龄判定:Survivor 中某一年龄及以下的对象大小总和超过 Survivor 空间的一半时,该年龄及以上的对象直接晋升。参数 -XX:TargetSurvivorRatio(默认 50,表示 Survivor 的目标使用比例)会间接影响这一判定。
  2. 空间分配担保: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() 曾被设计为资源释放的兜底手段,问题在于:

  1. 时机不确定:只保证"某次 GC 之前或之后执行",不保证何时执行,资源可能长时间不释放。
  2. 代价高:重写了 finalize() 的对象不能直接被回收,需要先入队、由 Finalizer 线程执行、再二次回收,至少多活一轮 GC。
  3. 可能破坏状态:finalize() 中可让对象重新被引用(对象复活),导致回收失效。
  4. 吞掉异常: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 的构成:

  1. 虚拟机栈中引用的对象:各线程栈帧局部变量表中处于作用域内的引用。
  2. 方法区中静态属性引用的对象:类的静态字段(引用本身在堆中,指向的对象是 Root)。
  3. 方法区中常量引用的对象:运行时常量池中的字符串常量、static final 常量引用。
  4. 本地方法栈中 JNI 引用的对象:native 方法中持有的引用(含 JNI Global / Local Reference)。
  5. JVM 内部引用:基本类型对应的 Class 对象、常驻异常对象(如 NullPointerException)、系统类加载器、正在被 JIT 编译的方法所引用的对象。
  6. 被同步锁持有的对象:synchronized 持有者(Monitor)关联的对象。
  7. 活跃线程对象本身:所有存活线程对象及其栈帧可达的对象。

可达性与"对象是否被 gc root 引用链持有"是同一件事。堆转储分析中"到 GC Roots 的最短路径"就是从这组根出发的引用链,泄漏定位的本质就是找到这条链上的哪个容器不该继续持有该对象。

2.5.2 分代假说与记忆集

分代收集并非从算法推导出的结论,而是基于对大量程序行为的经验观察,包含三条假说:

  1. 弱分代假说:绝大多数对象朝生夕灭。
  2. 强分代假说:熬过越多次回收的对象,越难以死亡。
  3. 跨代引用假说:跨代引用相对于同代引用只占极少数。

前两条解释了为什么新生代用复制算法、老年代用标记-整理/标记-清除:新生代存活率低,复制的成本与存活对象数成正比;老年代存活率高,复制成本难以承受。第三条解释了为什么回收新生代时不必扫描整个老年代:既然跨代引用很少,只需在老年代记录"哪些位置存在指向新生代的引用",即可把扫描范围从整个老年代缩小到少量记录。

这套记录结构称为记忆集(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. 灰色:自身被访问过,但其引用的对象还未全部扫描。
  3. 黑色:自身与全部引用都已被扫描完成。

并发过程中用户线程修改引用关系,会导致本应存活的对象被漏标。漏标成立需要同时满足两个条件:

  1. 黑色对象新增了一条指向白色对象的引用(写操作);
  2. 灰色对象到该白色对象的引用被删除(删操作)。

由于条件 1 与条件 2 必须同时发生,破坏其中任意一个即可保证正确性。两种方案对应两种写屏障:

方案 破坏的条件 屏障类型 做法 使用者
增量更新(Incremental Update) 条件 1:记录黑色对象的新增引用 写后屏障 黑色对象新增引用时,把它重新标记为灰色,后续重新扫描 CMS
原始快照(SATB, Snapshot-At-The-Beginning) 条件 2:记录被删除的引用 写前屏障 删除引用前把旧引用记录下来,按标记开始时的快照保证对象存活 G1、Shenandoah

语义差别值得留意:SATB 以标记开始时刻的快照为准,因此在本轮标记期间新产生的对象与新增引用可能被视为存活(浮动垃圾),代价是产生少量本可回收的对象;增量更新以标记结束时刻为准,代价是重新标记阶段需要重新扫描被更新过的对象。两者都是"用一点空间或时间换取正确性"。

2.5.5 安全点与安全区域

STW 需要在"引用关系不会变化"的位置暂停线程,这些位置称为安全点(Safepoint)。JVM 不在任意指令处暂停线程,原因有二:一是任意位置暂停需要为每条指令记录引用位置(OopMap 数量爆炸),二是用户线程需要主动配合才能进入一致状态。

  1. 主动式中断:JVM 设置一个全局标志,各线程在安全点处轮询该标志,发现需要暂停则主动挂起。
  2. OopMap:记录栈帧与寄存器中哪些位置存放引用,使 GC 能快速枚举根节点,无需逐个扫描整个栈与方法区。
  3. 安全点的位置:方法调用、循环回边(防止长循环长时间不进入安全点)、异常跳转等少量"执行状态稳定"的位置。
  4. 安全区域(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 的三个固有问题:

  1. 并发模式失败(Concurrent Mode Failure):并发清除尚未完成时,老年代已被新晋升的对象填满,此时无法继续并发回收,只能退化为 Serial Old 做一次整体压缩式 Full GC,停顿可达数秒。诱因是晋升速率高于回收速率,或触发阈值设置过高(-XX:CMSInitiatingOccupancyFraction)。
  2. 内存碎片:使用标记-清除,不移动对象,长期运行后产生碎片;大对象(如大数组)可能因找不到连续空间而提前触发 Full GC。
  3. 浮动垃圾:并发清除期间新产生的垃圾要留到下一轮,因此 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)

选型脉络可归纳为三条线索:

  1. 按延迟目标选:停顿要求毫秒级且堆较大(数十 GB 以上)→ ZGC(或 Shenandoah);停顿要求百毫秒级、堆中等规模 → G1;停顿不敏感、追求最小 CPU 开销 → Parallel。
  2. 按堆规模选:小堆(数百 MB 以内)、单核或容器限额很小 → Serial;中等堆(数 GB 至数十 GB)→ G1;大堆(数十 GB 以上)→ G1 或 ZGC。
  3. 按现状选:仍在使用 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

配置要点:

  1. gc* 表示同时开启 gc、gc,heap、gc,phases、gc,metaspace、gc,age 等子标签,字段完整是判读的前提(缺少 heap 标签就看不出回收前后的容量与晋升量)。
  2. filecount 与 filesize 必须设置。GC 日志在故障场景下写入量可能很大,没有滚动与上限会把磁盘写满,把内存问题转化为磁盘故障。
  3. time,uptime 同时保留墙钟时间与进程运行时间,前者用于与业务日志对齐,后者用于计算单位时间内的 GC 频率。
  4. 生产环境还可附加 -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 内置工具详解):

  1. 分配速率(Allocation Rate):单位时间内新分配的对象总量,可用"两次 Young GC 之间新生代的增量 ÷ 时间间隔"估算。若单次 Young GC 释放了 900MB、间隔 1.5 秒,则分配速率约为 600MB/s。分配速率决定 Young GC 频率的下限,也是判断"是分配太快还是回收太慢"的起点。
  2. 晋升速率(Promotion Rate):单位时间内进入老年代的对象量,等于老年代增量 ÷ 时间间隔。晋升速率决定老年代填满的速度,是并发模式失败与 Full GC 频率的直接驱动量。
  3. 活跃对象集(Live Set):Full GC(或 G1 的并发标记周期)结束后老年代的占用量,代表"真实存活的对象总量"。堆容量应以活跃对象集的数倍来设定,而不是以 -Xmx 反推。
  4. GC 占比:GC 总耗时 ÷ 进程运行时间。吞吐量目标(如 95%)对应的就是这一指标的补数。
  5. 停顿分布:单次停顿的 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 停顿与业务阻塞

三个易混淆的对照:

  1. 堆内 OOM 与进程被杀:前者有 Java 异常、有栈、可触发堆转储;后者没有异常,只有退出码与内核日志。区分依据是"有没有 Java 层证据"。
  2. 元空间增长与堆内泄漏:元空间不占堆,堆转储看不出异常,容易误判为"没有泄漏"。判断依据是 Metaspace 容量与类加载器数量。
  3. 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 分析思路

堆转储分析围绕三个问题展开:谁最大、谁在持有、能不能回收。

  1. 对象分布:按类统计实例数与总大小(Shallow Size),先找出占用最高的几类对象。java.lang.String、byte[]、char[]、HashMap$Node 这类"容器型"对象占据前列是常见结果,它们通常不是根因,但能指出数据流向。
  2. 大对象与欠支配分析:Shallow Size 只算对象自身,无法反映它间接持有多少。**支配树(Dominator Tree)与保留大小(Retained Size)**才是有效口径——保留大小表示"该对象被回收后能连带释放的总量"。按保留大小排序,排在前面且数量异常增长的对象即为嫌疑对象。
  3. 引用链回溯:对嫌疑对象查看"到 GC Roots 的路径"(Path to GC Roots),并排除弱引用/软引用等不会阻止回收的路径。这条路径上的第一个业务对象,通常就是泄漏点:一个不该继续持有数据的静态集合、一个未注销的监听器、一个未清理的缓存。
  4. 对比分析:单次转储难以区分"正常驻留"与"泄漏"。取两个时点的转储(例如低峰与高峰各一次,或健康节点与异常节点各一次)做对比,观察哪些类的实例数与保留大小在增长,结论比单次快照可靠。

工具方面,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}'

判读要点:

  1. 看趋势不看单点。单次 Full GC 后的使用量偏高可能是瞬时峰值,连续多次(例如连续 5 次 Full GC 后的使用量逐次抬升)才构成泄漏证据。
  2. 区分"回收后使用量上升"与"回收前使用量上升"。前者表示存活对象在增长(泄漏或活跃对象集扩大),后者表示分配速率上升(业务量增加或产生垃圾变多)。
  3. 给停顿设定判定标准。判定"停顿是否影响业务"的标准是:停顿 P99 是否小于上游超时时间。没有标准就无法判断是否需要优化。

3.3.3 与压测基线对照

单看生产日志难以区分"配置问题"与"业务量增长"。有效做法是用压测建立基线,把参数调整的效果放在同一流量条件下对比:

  1. 固定压测模型(并发数、请求配比、数据量、时长),记录吞吐量、P99 延迟、GC 次数与停顿;
  2. 在相同模型下采集 GC 日志,计算分配速率、晋升速率、活跃对象集;
  3. 每次只调整一个参数,重跑同一模型,与基线对比;
  4. 对比结论必须同时满足"业务指标不退化"与"GC 指标改善"才算有效。

压测模型设计、基线定义与容量评估方法见 linux: 压测与性能基线。

3.4 生产调优实践

3.4.1 堆大小的决定依据

堆容量不应按"机器内存的一半"这类经验值直接设定,应按三个输入推导:

  1. 活跃对象集:从压测或生产日志中取得 Full GC(或 G1 并发标记周期)结束后的老年代占用量,这是真实存活的数据量。
  2. 分配速率与晋升速率:决定 GC 频率与老年代填充速度。堆过小会导致 GC 频繁,堆过大则单次停顿变长(并发收集器除外)且堆外预留空间被压缩。
  3. 容器限额与堆外需求:进程总内存 = 堆 + 元空间 + 线程栈(-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 启动时预触碰全部堆页,把页面真正映射到物理内存 关闭

容器场景的两条实践原则:

  1. 显式设置 -Xmx 时,容器限额必须留出堆外空间。常用做法是为堆外与线程栈预留 25%~30%。若堆外预留不足,现象是堆内尚有空间而容器已触发 OOM——堆转储显示"堆还很空",但进程已被杀,这类问题的判断顺序是先比较容器限额、进程 RSS、堆用量三项数值,再确认堆外部分由哪一类组成。堆外构成可借助 NMT 观察(开启方法见 linux: 内存管理 的 Java 堆外内存章节)。
  2. -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 的止损

处置顺序为"先止血、再取证、后修复":

  1. 限流降载:降低并发、暂停批量任务与非核心定时任务,减缓内存增长速度,为后续操作争取时间。
  2. 取证:采集 GC 日志、必要时做类直方图观察对象分布、抓取线程栈确认是否有大量线程阻塞在 GC 之外。
  3. 高危 强制触发 Full GC(jcmd <PID> GC.run、jmap -histo:live、jmap -dump:live 等):影响范围是强制一次整体回收,STW 停顿可达数秒至数十秒,期间所有请求阻塞、上游可能出现超时雪崩;在 CMS/G1 上还可能因空间不足触发并发模式失败,反而放大停顿;该动作只回收当前垃圾,不解决根因,短时间内会再次触发。回滚方式:动作本身不可撤销,只能等待回收结束;若已造成请求超时,应尽快恢复流量并记录该动作的时间点,避免与后续现象混淆;处置上优先选择"低峰期重启"而不是"高峰期强制回收"。
  4. 扩容或重启恢复:按 3.5.2 的顺序执行,重启前完整保留现场。
  5. 定位与修复:把现场数据交接给开发侧,修复后用同一压测模型验证。

3.5.2 OOM 触发后的现场保留与恢复顺序

  1. 确认 OOM 类型:读取异常消息与栈,区分堆内、元空间、直接内存、线程创建失败四类;若进程没有 Java 异常而是被终止,转入 3.5.4 的容器与主机侧判断。
  2. 保留现场:确认堆转储文件已生成(核对 -XX:HeapDumpPath 指向的目录与文件时间),采集 GC 日志、线程栈、NMT 摘要(若已开启)与容器侧的 memory.events;重启后这些现场不可复原。
  3. 限制影响范围:摘除异常节点流量或限流,避免故障节点持续接收请求。
  4. 恢复服务:滚动重启异常实例;恢复顺序是先恢复提供核心链路的部分,再恢复批处理与后台任务,避免重启后立即被批量任务再次压垮。宿主机层面的处置顺序(限流降载 → 重启 → 扩容 → 修复代码 → 长期措施)与 linux: 内存管理 的处置顺序一致,可交叉参照。
  5. 分析与修复:按 3.2 节做堆转储分析,找到持有链与分配点。
  6. 验证:修复后以相同压测条件回归,确认活跃对象集与会话量匹配、Full GC 后使用量不再抬升。

3.5.3 GC 停顿导致超时的降级

当停顿无法在短期内消除时(例如泄漏未修复、堆不能立即扩容),需要在应用侧降低停顿的业务影响:

  1. 超时与重试:调用方超时时间应大于 GC 停顿 P99,并配合幂等重试,避免单次停顿被放大为业务失败。
  2. 限流与熔断:停顿期间请求堆积,恢复瞬间的流量洪峰会形成二次冲击。限流入口与熔断下游可把冲击控制在容量范围内。
  3. 缓存与预计算:把停顿敏感的只读路径改为缓存读取,减少停顿期间的阻塞面。
  4. 降级策略:对非核心功能(推荐、统计、导出)准备开关,停顿或资源紧张时关闭。
  5. 分流:按实例摘除流量,让停顿异常节点退出服务,避免单个节点的长停顿拖累整体成功率。

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 调优的失败大多不源于技术判断错误,而源于方法失控:同时改动多个参数、没有基线、变更后无验证、问题复现时无法归因。以下四条是可控的做法。

  1. 一次只改一个变量。并行改多个参数时,无法从结果中分离出每个变量各自的贡献,也无法在结果变差时定位是哪个改动引起。变量包括:堆大小、新生代大小、收集器、停顿目标、元空间上限、代码层面的对象创建方式。
  2. 先建立基线再改。改之前必须有一组可对比的观测值:吞吐量、P99 延迟、GC 次数与停顿分布、分配速率、晋升速率、活跃对象集。没有基线的"优化"无法证明有效,也无法证明没有引入退化。
  3. 变更需要评审与明确回滚条件。参数与代码的变更应走同一套流程:记录变更内容、影响范围、验证方式、观察窗口与回滚触发条件。GC 调优的变更尤其需要提前声明"什么现象出现即回滚",因为停顿与内存的变化往往需要数小时到数天才稳定显现。变更分级、窗口选择、可逆性设计与复盘要求的完整流程见 linux: 变更与发布管理。
  4. 用压测验证,不用感觉验证。生产环境直接试参数会把用户当作验证对象;压测环境用同一模型对照,是先验证后上线的唯一可靠方式,方法见 linux: 压测与性能基线。

一条可执行的判定标准:

变更结论 判定条件
有效 业务指标(吞吐量、P99、错误率)不退化,且目标 GC 指标(如 Full GC 次数、停顿 P99)改善
无效 目标指标无变化,或变化在观测噪声范围内
有害 任一业务指标退化,或出现新的 GC 事件类型(如新增 Full GC 触发原因)
无法判定 观测窗口内未覆盖业务峰值,或期间存在其他变更同时生效

四、总结

内存管理的出发点,是把"何时释放"的决策从人的记忆转移到运行时机制上。 手动管理会产生悬垂指针与内存泄漏两类结构性错误,自动管理的代价则是停顿时间、吞吐量与内存占用之间的取舍,三者无法同时取到最优。理解运行时的意义在于划定定位边界:同一句 OutOfMemoryError 可能有四种来源,进程被内核终止则没有任何 Java 层证据,判错方向会让排查完全失效。

原理层面可以按四层理解:

  1. 内存区域:程序计数器、虚拟机栈、本地方法栈为线程私有,堆与方法区(元空间)为线程共享,直接内存不在运行时数据区之内。JDK 8 起元空间位于本地内存,因此必须显式设置 -XX:MaxMetaspaceSize 划出边界。
  2. 对象与分配:对象由对象头(Mark Word 与类型指针)、实例数据、对齐填充组成,字段重排与指针压缩决定其实际体积,32GB 是压缩指针失效而非容量枯竭的分界。分配路径按"栈上分配 → TLAB → Eden → 大对象 → 担保晋升"依次尝试。
  3. 引用与回收判定:强、软、弱、虚四种引用强度让开发者可以在"必回收"与"不回收"之间插入档位;引用队列用于在对象回收后释放其代表的外部资源,取代了时机不确定的终结器。
  4. 回收算法与正确性:可达性分析从 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 会切断直接内存的自愈路径,使堆内正常而堆外溢出。这类操作的标准流程是"先取证、后处置、留回滚"。

总结记忆:内存区域定边界,对象布局定体积,分配路径定去向,引用强度定生死,可达性定标记,分代与收集器定代价,日志与转储定证据——调优的方法论是一次只改一个变量、先建基线、明确回滚、压测验证。