JVM GC停顿根因：OopMap、安全点、记忆集与卡表全链路解析

先抛个场景。之前排查过一个线上服务，Young GC 暂停时间从 20ms 一路涨到 120ms，GC 日志翻来覆去看，根因最后落在“老年代对象频繁引用新生代对象”上。顺着这个点继续往下摸，发现真正需要理解的是四个概念：OopMap、安全点、记忆集、卡表。这四个词单拎出来资料不少，但能串成一条完整链路讲清楚的并不多。其实它们对应的是 GC 过程中躲不开的四个问题——根从哪来、何时能停、跨代引用怎么记、卡表怎么落地。这篇就把这条链完整展开，适合正在看 GC 日志但总觉得差一层理解的工程师，也适合面试前想把底层彻底打通的人。

1. 从一次 GC 开始：为什么这四样东西必然同时出现

1.1 GC 开始之前的第一个问题：根从哪来

一次 Young GC，第一件事不是回收，而是找到所有 GC Roots。GC Roots 包括方法栈帧里的局部变量、静态字段、JNI 引用等等。问题在于，JVM 跑的是机器码，栈上就是一段二进制数据。0x7f0012345678 这串数值，可能是一个对象的地址，也可能只是一个碰巧长得像地址的 long。你怎么让 GC 相信它是引用？

早期有所谓的“保守式 GC”，干脆把栈上所有看起来像指针的值都当成引用处理。好处是简单，坏处是误判——可能把整数当指针，导致本该回收的对象永远无法回收，内存被白白攥着。HotSpot 转向精确式 GC 之后，核心就是 OopMap。OopMap 的含义很直白：某条机器指令执行到这里时，栈上哪个偏移、哪个寄存器里放的是对象引用，以映射表的形式记录下来。

1.2 一个完整链路：四者如何互相咬合

沿着 GC 的执行顺序看，四者的关系其实是一条线。GC 开始先要做根枚举，根枚举依赖 OopMap；而 OopMap 不是处处都有，所以线程必须到达安全点才能被暂停；到了根枚举之后，如果一个分代被部分回收，你不可能把整个老年代全扫一遍去看谁引用了新生代，这时记忆集登场；记忆集最常见的实现就是卡表。

为了更直观，我用表格把这四者列一下，看看各自解决什么问题、要付出什么代价：

这个链路上的每一环都不是可有可无的。没有 OopMap，根枚举会漏掉真实的引用或误判非引用；没有安全点，OopMap 再多也等不到一个一致状态；没有记忆集，每次 Minor GC 都要全量扫描老年代；没有卡表，记忆集的维护成本可能比全量扫描还高。所以面试官把这四个概念叠加在一起问，其实问的是你对 GC 整条流水线的理解，而不是名词解释。

2. OopMap：JVM 凭什么认定栈上的某个槽位就是引用

2.1 从机器码视角看栈帧

要理解 OopMap，先把栈帧想象成一段连续内存。局部变量、操作数栈、返回地址混在一起，程序计数器指向某个偏移，这段内存就是一个一个的“槽”。GC 无法只看某个槽里的值判断它是不是指针，尤其在 64 位 JVM、压缩指针开启后，一个大整数完全可能和对象地址长得一模一样。

所以你只能靠额外的元数据来解决：在执行指令 X 时，栈上偏移 0x20 处放的是引用，偏移 0x28 处放的是 long。这就是 OopMap 的原始形态。它本质上是一张表：机器码位置 → 哪些位置是引用。

这里还能引出另一个常见问题：为什么 Java 不直接在字节码层面维护类型信息？因为热点代码最终都被 JIT 编译成了机器码，机器码没有类型概念。对解释器来说还有字节码可以看，对编译后的代码来说，必须把“哪个槽是引用”这个信息显式保存下来。

2.2 OopMap 的产生与存储

JIT 编译阶段，C1/C2 在生成机器码的同时，手头正好有活跃变量信息，所以会顺路把每个安全点位置的引用位置记录下来。这不是额外的一趟扫描，更像是 JIT 编译的副产品。

java复制// Java: Object obj = new Object();
// JIT 生成的机器码片段（示意）
// 0x10: mov %rax, 0x20(%rsp)   // 把 obj 的引用写到栈槽
// 0x1c: test %rax, %rax
// 0x22: call safepoint_poll     // 安全点轮询
//
// 针对指令 0x22 生成的 OopMap:
//   寄存器 %rax 指向对象
//   栈槽 0x20(%rsp) 指向对象

OopMap 放在 Code Cache 伴生的元数据里，不属于 Java 堆对象，GC 过程中不需要扫描它们，但它们确实占用 Native 内存。方法越多、安全点越多，OopMap 体积越大。这也是 JIT 不会给每条指令都生成映射的经济学原因。

解释器的处理方式稍有不同，它不像 C2 那样有编译过程，但 HotSpot 解释器在解释执行时可以通过当前字节码状态推断栈上引用，在调用点、返回点等位置暴露根集合。原理仍然是维护“当前状态下的引用位置”映射，只是不像 JIT 那样有长期保存的静态 OopMap。

2.3 OopMap 扫描的现实约束

写代码时我们习惯把变量分为引用和基本类型，但在机器码里没有这个类型概念。OopMap 能直接减少 GC 根扫描时间吗？多数情况下不能完全，因为还有 JNI、栈上动态生成的对象等。但它是根集合识别的基础，如果 OopMap 信息丢失或错误，GC 很可能把一个整数当成引用，于是对象永远不会被回收，这类问题隐蔽程度极高。

还有一个小知识点：经逃逸分析确认不逃逸的对象会被标量替换或栈上分配，根本没有堆引用，OopMap 里自然不会出现。换句话说，OopMap 只在有“堆引用”的位置才记录，这也是为什么某些小对象场景的 GC 压力远低于直觉预期。

3. 安全点：为什么 GC 必须等线程到达指定站点

3.1 为什么是安全点，而不是每行代码都安全

如果每一条指令都允许 GC 在任意位置介入，JVM 就必须每一条指令都维护 OopMap，并且需要在任何指令处都能恢复执行状态。这个代价太大了。HotSpot 的折中方案是：只在一部分指令位置允许 GC 暂停，这些位置就是安全点。

安全点的选择不是随机的，标准大致有三条：第一，让程序长时间执行的路径上有安全点，避免 GC 等太久；第二，安全点位置的状态容易描述；第三，生成 OopMap 的成本可控。于是实践中常见的位置是方法调用指令、循环回跳分支、异常跳转路径、方法返回前。

3.2 线程各状态下的“安全”怎么定义

GC 发起后，不是所有线程都能马上停下来。HotSpot 把线程区分成两类：Running 线程必须主动撞到安全点，通过轮询指令感知 GC 请求；处于 Blocked、Waiting、Native 调用中的线程不用撞，直接认为它们是安全的，或者说处于安全区域。

刚上手 JVM 调优的人容易忽略这个细节：如果有一个线程踩在很长的循环里，而循环回跳点恰好没有安全点轮询——概率低但确实存在，比如极端内联场景——GC 只能原地等它。表现到现象上就是 GC 日志里的 Safepoint sync wait 异常大，或者 FGC 被拖得非常长。

3.3 安全点轮询是怎么实现的

HotSpot 里的安全点轮询并不是什么魔法指令，而是一个内存读操作，或者特定的跳转/调用序列。JIT 会在合适位置插入一条 test/compare 到某个内存页的指令；GC 发生时，JVM 把该页改为不可读，线程执行到轮询指令就会触发页错误，从而被挂起等待。

这个设计很优雅：线程平时只需一条几乎零成本的内存读，GC 来时给它一个页故障就能拦住它。理解这个机制之后，你也就明白为什么安全点等待时间低是好事、高是信号。

3.4 实际观测安全点

JDK 9 以后可以用 -Xlog:safepoint 看到安全点统计，旧版本则用 -XX:+PrintSafepointStatistics。里面会列出 VM Operation（例如 G1 Young Pause）、耗时、同步等待时间。有一次我看统计，发现一个线程反复执行短循环，等待时间只有几十微秒，而另一个线程却在 Native 方法里跑了近一秒，整个 GC 必须等它返回。

所以要区分清楚：安全点等待时间长，不一定是线程不进安全点，也可能是线程在 Native 区域待太久或者被外部阻塞。这类问题在大量使用 JNI 的系统里尤其明显。

4. 记忆集：记录老年代到新生代的那一根根“跨代指针”

4.1 跨代引用是怎么来的

分代收集自然产生一个问题：“某个对象被老年代对象引用，但该对象本身在新生代。”典型场景：一个长期驻留的缓存容器放在老年代，容器里的 value 是请求处理过程中新建的对象。Minor GC 如果忽略这个引用，会把存活对象误判为垃圾；如果为了找这个引用，把整个老年代全量扫描一遍，代价又完全不能接受。

于是需要一份“台账”，记录哪些老年代区域可能引用了新生代对象。有了这份台账，Minor GC 只需要检查台账范围内的地方，就能找到所有从老年代指向新生代的边。

4.2 记忆集到底记什么

记忆集的作用是“记录跨代引用”，但具体记录到什么粒度，有几种做法：

这里值得深想一层：精度越粗，写屏障越便宜，但 GC 实际扫描范围越大。卡表能成为默认选择，是因为它在空间、时间、复杂度之间找到了一个平衡点。

4.3 为什么只需记录老年代到新生代

很多文章在讲记忆集时只讲“老年代到新生代”，容易让人疑惑：反向的跨代引用呢？实际上 Minor GC 会把整个新生代都扫描一遍，新生代指向老年代的对象会被正常遍历到，不需要额外记录，因为目标区域本来就在本次收集范围内。只有“部分收集”才需要知道“别的区域对我的引用”。

到了 G1，这种思路升级成每个 Region 都有一个 RSet，记录谁引用了我，本质上仍是记忆集，只是粒度从“代”细化到了“Region”。理解代与代之间的记忆集，再看 G1 的 RSet 会顺畅很多。

5. 卡表：记忆集的“低成本高收益”实现

5.1 卡表的数据结构与映射

卡表最常见的形态是一张 byte 数组，堆被划分成一个个 512 字节的卡页，每个卡页对应数组里的一项。GC 开始时遍历这张数组，找出被标记为 dirty 的卡页，再去这些卡页里对象的引用关系里搜。

java复制final byte[] cardTable = new byte[heapSize / CARD_SIZE];

void writeBarrier(Object oldObj, Object newObj) {
    int index = addressToIndex(oldObj); // 老对象地址映射到卡表下标
    cardTable[index] = DIRTY;
}

实际 HotSpot 中使用的是更精细的地址掩码和位运算，但记住“对象地址 → 卡页下标”的映射层级就够了。一个对象引用被写入时，对应的卡页会被标脏；GC 时只扫脏卡页，不扫整片老年代。

5.2 写屏障：JVM 在每次赋值后做了什么

卡表不是 GC 时现算出来的，它是在 Java 代码每次写引用时维护的。HotSpot 会插入写屏障（Write Barrier），可以理解为编译器在所有 putfield、putstatic、数组赋值操作后面追加一段快速逻辑：如果新的引用指向新生代（或另一个 Region），就把卡表对应项标脏。

这里的成本虽然小，但放大了看很可观。高并发应用每秒可能有几百万次字段赋值，如果每次赋值都无脑标脏，压力不小。所以 HotSpot 会对写屏障做各种优化：先判断引用目标是否需要跨代记录；用 -XX:+UseCondCardMark 避免重复写 dirty；对引用类型初始化也可能有特殊处理。GC 日志里若发现卡表相关阶段耗时较高，优先就要想到是写屏障频率过高，或脏卡太多。

5.3 伪共享：卡表最隐蔽的性能杀手

卡表维护最大的坑是伪共享，这不是空间问题，而是 CPU 缓存问题。想象两个线程各自在写老年代里相邻的两个对象，这两个对象落在同一个 64 字节缓存行，同时它们又对应相邻的两张卡。线程 A 标脏卡 1，缓存行失效；线程 B 再标脏卡 2，又需要重新加载缓存行。CPU 缓存来回颠簸，明明各写各的，性能却彼此拖累。

实战中遇到的现象是：多线程写热区对象时，CPU 占用比预期高，GC 暂停变大。排查思路之一是开启 -XX:+UseCondCardMark，让写屏障先判断卡是否已脏，减少无意义的缓存写。原理简单，但效果经常很明显。G1 进一步调整了卡表结构，并通过其他手段缓解伪共享，但也没有完全消除这类问题。

6. 实战视角：从 GC 日志和参数看这四样东西怎么影响你

6.1 日志里这四样东西怎么体现

现代 JDK 的 GC 日志能直接看到不少信息。-Xlog:gc+safepoint 会输出安全点等待时间；-XX:+PrintGCDetails 在 Young GC 后能看到 Root Scan、Update RS、Scan RS 等阶段耗时。Update RS 特别高，问题大概率在记忆集/RSet 更新；Scan RS 高，说明脏卡多或者 Region 多；Root Scan 高，则和线程数目、OopMap 扫描范围、调用栈深度都有关。

有一次我看到 Young Pause 里 Root Scan 占了一半，最初以为是对象多，后来发现是线程池线程数开得太高，大量线程的栈都需要扫描 OopMap。把线程数压下来后，停顿立刻降了三分之一。这类优化在业务代码层面根本看不出来，但在 GC 日志里清清楚楚。

6.2 相关参数与排查思路

排查建议按一条线走：先看 Safepoint sync wait 是否明显，再看 GC 内各阶段耗时，最后决定是调线程、调记忆集还是调卡表。我自己习惯先把 GC 日志打开，观察三到五轮 Pause，把这个判断顺序固定下来。

6.3 不同收集器对记忆集的差异化处理

CMS 使用卡表加写屏障维护记忆集。G1 则把每块 Region 整理成独立 RSet，记录粒度更细，维护成本也更高。到了 ZGC，干脆换了一套思路，用染色指针和读屏障，不再需要传统意义上的卡表了。所以你在不同垃圾收集器上看到的“卡表”并不是一码事。理解了原理之后，再迁移到 G1 的 RSet，会轻松很多。

最后说一个我自己的排查习惯：遇到 GC 停顿，我的第一反应不是调整堆大小，而是先按这个顺序过一遍——打开安全点日志，确认线程是不是都能及时到达安全点；再看 GC 阶段里 Root Scan、Update RS、Scan RS 各占多久；如果 Scan RS 高，去查老年代对象的写入频率，看能不能减少跨代引用。这四个概念相互咬合，根枚举靠 OopMap，OopMap 靠安全点提供停靠条件，跨代引用靠记忆集记账，记忆集用卡表高效落地。把这条链路装在脑子里，以后再看到 GC 日志，你会觉得每一条停顿都有了解释。