Skip to content

2.3-4 垃圾回收基础:分代、可达性、三色标记、读写屏障 ​

所属:02 Java 运行时 / 2.3 JVM 分级:A 状态:◐ 初稿 关联:2.3-5、2.3-6、2.3-7、2.3-10、2.3-12

  • 题型:原理

  • 一句话结论:GC 的本质是“从 GC Roots 出发找出不可达对象并回收其内存”;分代假设让新生代用复制、老年代用标记-整理/清除,跨代引用靠卡表/RSet 避免全堆扫描;并发标记靠三色标记加读写屏障解决漏标,STW、吞吐、延迟和内存占用之间的取舍决定了收集器的选型。

  • 分层要点:

    1. 为什么分代:弱分代假说认为绝大多数对象朝生夕死,强分代假说认为熬过多次 GC 的对象往往继续存活。于是堆逻辑上分为新生代(Eden + 两个 Survivor)和老年代:新对象先进 Eden 或 TLAB,Young GC 把存活对象复制到 Survivor,年龄达到阈值(默认 MaxTenuringThreshold=15)或 Survivor 中同年龄对象总和超过一半时晋升老年代;大对象可能直接进老年代。分代是逻辑模型,G1 是 Region 化的逻辑分代,ZGC 长期不分代,JDK 21 才引入分代 ZGC。
    2. 可达性分析与 GC Roots:从一组根引用出发遍历对象图,遍历不到的就是不可达、可回收。GC Roots 包括:虚拟机栈/本地方法栈中的局部变量、方法区静态变量与常量、JNI 引用、同步锁持有的对象、JVM 内部引用(类加载器、基本类型 Class、常驻异常等)。finalize() 允许对象“复活”,但已废弃(JDK 18 起可禁用,JEP 421);需要清理资源用 try-with-resources 或 Cleaner/虚引用。GC 需要线程到达安全点(Safepoint)才能 STW,长循环、JNI 调用可能拉长到达安全点的时间。
    3. 三种基础算法:标记-清除简单、不移动对象,但有内存碎片、分配变慢,CMS 的老年代用它;标记-复制把存活对象复制到另一半空间,无碎片、分配快,但浪费空间、要移动对象,新生代用它;标记-整理在标记后把存活对象向一端压缩,无碎片,但移动和更新引用成本高,适合老年代。实际收集器是这些算法的组合。
    4. 三色标记与漏标:白色=未访问,灰色=自身访问过、子引用待扫描,黑色=自身和子引用都扫描完。并发标记时用户线程可能改引用,导致“对象消失”:黑色对象新增指向白色对象的引用,同时灰色对象删除了指向该白色对象的唯一路径。解决方式两类:增量更新(写屏障记录新增的黑色→白色引用,重新标记时再扫,CMS 用)和 SATB(在标记开始时做快照,写屏障记录被删除的旧引用,保证快照中的可达对象不被漏掉,G1 用)。SATB 会产生浮动垃圾,增量更新可能需要重新扫描。
    5. 读写屏障:写屏障是在引用赋值前后插入的屏障代码,用来维护卡表/记忆集和标记状态;读屏障是在读取引用时插入,ZGC 用染色指针 + 读屏障,Shenandoah 用 Brooks 转发指针 + 读屏障,做并发转移和自愈。屏障不是免费的,越细的并发控制通常越牺牲吞吐。
    6. 跨代引用与记忆集:Young GC 的根集合 = GC Roots + 老年代指向新生代的跨代引用;如果每次都扫整个老年代,停顿会随堆增长。记忆集(Remembered Set)就是记录跨代引用的结构:CMS/Parallel 用卡表(Card Table),HotSpot 默认把堆按 512B 分卡,写屏障在引用赋值时把对应卡标脏,Young GC 只扫脏卡、扫描后清理,卡表本身约占堆 1/512;G1 在此之上为每个 Region 维护 RSet,记录“谁指向我”(points-into),支撑只回收部分 Region。卡表粗粒度、保守(整卡扫描,可能多扫),RSet 更精确但占内存、更新耗 CPU;G1 底层也有卡表,RSet 由脏卡细化而来,细节见 2.3-6。
  • 图/流程:

text
GC Roots(栈、静态变量、JNI、锁、类加载器…)
        │ 可达性遍历
        ▼
   对象图 ──► 不可达对象 ──► 回收
        │
        └─ 并发标记三色:
             白:未访问
             灰:自身已访问,子引用待扫描
             黑:自身和子引用都扫描完

漏标条件:
  1) 黑色对象新增 → 白色对象的引用
  2) 灰色对象删除 → 该白色对象的唯一路径
解决:
  增量更新(CMS):记录新增引用,重新标记
  SATB(G1):记录删除的旧引用,按快照标记

跨代引用与记忆集:
  Young GC 根集合 = GC Roots + 老年代 → 新生代的跨代引用
  写屏障(old → young 赋值)→ 标记卡 dirty
  Young GC 扫脏卡 → 清理 / 细化进 RSet
  没有记忆集 → 整个老年代当根扫,停顿随堆增长

  卡表:每 512B 一格,粗粒度、保守
  RSet:每个 Region 记录“谁指向我”,细粒度、G1 用
  • 版本/源码锚点:

    • JDK 8/11/17/21:分代模型、可达性分析、三色标记是共通基础。
    • JDK 9:finalize() 标记废弃;JDK 18:JEP 421 可禁用 finalization。
    • CMS 用增量更新;G1 用 SATB;ZGC 用染色指针 + 读屏障,Shenandoah 用转发指针 + 读屏障。
    • JDK 21:JEP 439 引入分代 ZGC(-XX:+ZGenerational),后续版本逐步默认。
    • HotSpot 实现:CardTable(card_shift=9,512B/卡)、G1RemSet/HeapRegionRemSet;分代 ZGC 也维护跨代引用记录,细节以 JDK 21+ 实现为准。
  • 对比表:

算法优点缺点典型使用
标记-清除实现简单,不移动对象内存碎片,分配慢CMS 老年代
标记-复制无碎片,分配快浪费一半空间,移动成本新生代
标记-整理无碎片,内存紧凑移动和更新引用成本高Serial Old、Parallel Old
屏障作用典型
写屏障拦截引用写,维护卡表/记忆集/标记CMS 增量更新、G1 SATB
读屏障拦截引用读,修正指针/转发ZGC(染色指针)、Shenandoah(转发指针)
维度卡表(Card Table)RSet
使用者Serial/Parallel/CMS;G1 也用作底层G1(每个 Region 一个)
粒度512B 卡卡 / 区域 / 粗化条目
记录内容“这块内存可能脏”“谁指向我”(points-into)
精确性粗,整卡扫描,可能多扫较细,按来源 Region 找
开销约堆的 1/512 + 写屏障更大内存 + 更新 CPU
目的Young GC 避免扫老年代部分回收时找跨 Region 引用
  • 追问链:

    1. 为什么分代? → 弱/强分代假说:大多数对象很快死亡,少数对象长期存活;分代后新生代可以频繁、低成本复制回收,老年代减少扫描频率。
    2. GC Roots 到底有哪些? → 栈帧局部变量、静态变量、常量、JNI 引用、同步锁、类加载器和 JVM 内部引用;不是“所有对象”,而是这些根出发的可达图。
    3. 三色标记为什么会漏标? → 黑色对象新增指向白色对象的引用,同时灰色对象删除了指向该白色对象的唯一路径;两个条件同时满足,白色对象就会被漏掉。
    4. 增量更新和 SATB 有什么区别? → 增量更新记录“新增的引用”,重新标记时补扫,CMS 用;SATB 在标记开始时做快照,记录“被删除的旧引用”,保证快照可达性,G1 用,代价是浮动垃圾。
    5. 为什么 CMS 用增量更新,G1 用 SATB? → CMS 的目标是低停顿标记-清除,重新标记阶段可以重扫脏卡;G1 要并发转移 Region,SATB 更适合维持标记快照,避免漏标,但会产生浮动垃圾。
    6. 写屏障和读屏障有什么区别? → 写屏障拦截引用赋值,维护记忆集和标记;读屏障拦截引用读取,ZGC 用染色指针、Shenandoah 用转发指针,配合读屏障做自愈和并发转发。
    7. Young GC 的根集合是什么? → GC Roots + 老年代指向新生代的跨代引用(记忆集),不是整个老年代;否则停顿随堆增长。
    8. 卡表怎么维护? → 引用赋值时写屏障把对应 512B 卡标脏;Young GC 扫脏卡后清理;卡表约占堆 1/512。
    9. 卡表和 RSet 有什么区别? → 卡表粗粒度、保守、通常只服务 old→young;RSet 记录“谁指向我”,更精确、支持 Region 部分回收,但占内存、更新耗 CPU。
    10. 没有记忆集会怎样? → Young GC 要把整个老年代当根扫,停顿和内存带宽随堆增长。
    11. 写屏障为跨代引用做了什么? → old→young 写入时标脏卡/更新 RSet;G1 的 pre-barrier 还负责 SATB,post-barrier 标脏卡,后续由 refinement 细化进 RSet。
    12. 安全点是什么?为什么 GC 要等安全点? → 线程只有在安全点才能安全地暂停并让 GC 扫描栈;长时间循环、JNI 调用会延迟到达安全点,表现为 STW 时间被拉长。
    13. 对象一定分配在堆上吗? → 不一定;逃逸分析后可能栈上分配、标量替换,TLAB 只是堆内线程私有分配区。但这不是“对象一定不进堆”,要看 JIT 优化。
    14. finalize 能不能用来释放资源? → 不推荐;执行时机不确定、可能复活对象、拖慢 GC;用 try-with-resources、Cleaner 或显式 close。
    15. ZGC 是不是完全没有 STW? → 不是;它有极短的初始标记、重新标记等 STW 阶段,只是把标记、转移等大部分工作并发化,停顿通常在毫秒级甚至更低。
  • 生产案例/取舍(示例,替换成你的项目):

    • 线上 Young GC 频繁但单次很短,先看 Eden 大小和分配速率;如果对象晋升过快,检查 Survivor 是否过小、是否有大对象直接进老年代。
    • Full GC 频繁时,不要先调 MaxGCPauseMillis;先看 GC 日志里的晋升失败、Humongous 分配、Metaspace 膨胀、显式 System.gc(),再决定是调堆、调 Region、还是查内存泄漏。
    • 用 -Xlog:gc*(JDK 9+)或 -XX:+PrintGCDetails(JDK 8)看停顿分布,用 jstat/JFR/MAT 定位对象来源;GC 调优是“先定位,再调参”,不是背参数。
    • 取舍:低延迟收集器(G1/ZGC)用更多屏障和并发线程换停顿,吞吐会下降;批处理场景反而应该选 Parallel,把 CPU 用在业务上。
  • 易错点:

    • 把 GC Roots 说成“所有栈上的对象”,忽略静态变量、JNI、锁、类加载器等。
    • 认为三色标记只在 STW 下工作——并发标记才是漏标的来源。
    • 把 CMS 说成 SATB、把 G1 说成增量更新。
    • 认为 ZGC/Shenandoah 完全没有 STW。
    • 认为分代是物理上连续的两块内存;G1 是 Region 化的逻辑分代。
    • 认为对象一定分配在堆上,忽略逃逸分析和标量替换。
    • 用 finalize() 释放连接、文件等资源。
    • 只背“标记-清除/复制/整理”,讲不清收集器为什么这样组合。
    • 认为 Young GC 只扫新生代——还要扫 GC Roots 和记忆集里的跨代引用。
    • 认为卡表就是 RSet——卡表是粗粒度脏卡位图,RSet 是“谁指向我”的集合。
    • 认为 G1 只有 RSet 没有卡表——G1 底层也有卡表,RSet 由脏卡细化而来。
  • 30 秒口述稿:

GC 从 GC Roots 出发做可达性分析,找不到的对象就可以回收。分代是因为大多数对象朝生夕死:新生代用复制,老年代用标记-清除或标记-整理;Young GC 还要靠卡表/RSet 找老年代指向新生代的引用,避免扫全堆。并发标记用三色标记,漏标要同时满足“黑色新增指向白色”和“灰色删除指向白色”,CMS 用增量更新,G1 用 SATB;ZGC 用染色指针、Shenandoah 用转发指针,配合读屏障做并发转移。所有收集器都有 STW,只是长短不同,选型就是吞吐、延迟、内存和堆大小的取舍。

  • 3 分钟展开顺序:结论 → 分代假设与对象晋升 → GC Roots 与可达性 → 三种基础算法 → 三色标记与漏标两条件 → 增量更新 vs SATB → 读写屏障 → 跨代引用与卡表/RSet → 安全点与 STW → 生产排查与选型。