← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L08 - JVM内存模型与GC算法

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、JVM运行时数据区


┌─────────────────────────────────────────────────────────────┐
│                    JVM 运行时数据区                           │
├────────────────────────────┬────────────────────────────────┤
│      线程私有              │        线程共享                 │
├────────────────────────────┼────────────────────────────────┤
│                            │                                │
│  ┌──────────────────┐      │  ┌──────────────────────────┐  │
│  │   程序计数器       │      │  │       堆(Heap)         │  │
│  │ (PC Register)    │      │  │                          │  │
│  │ 当前执行的字节码   │      │  │  ┌────────┬───────────┐ │  │
│  │ 行号/地址         │      │  │  │  Young  │    Old    │ │  │
│  │ 唯一不会OOM的区域  │      │  │  │ ┌────┐ │           │ │  │
│  └──────────────────┘      │  │  │ │Eden│ │           │ │  │
│                            │  │  │ ├────┤ │           │ │  │
│  ┌──────────────────┐      │  │  │ │S0/S1│ │           │ │  │
│  │   虚拟机栈        │      │  │  │ └────┘ │           │ │  │
│  │ (VM Stack)       │      │  │  └────────┴───────────┘ │  │
│  │ 每个方法=栈帧      │      │  │                          │  │
│  │ 局部变量表/操作栈   │      │  │  GC主要工作区域          │  │
│  │ 动态链接/返回地址   │      │  └──────────────────────────┘  │
│  │ StackOverflowError │     │                                │
│  │ OutOfMemoryError   │     │  ┌──────────────────────────┐  │
│  └──────────────────┘      │  │    方法区(MetaSpace)    │  │
│                            │  │  类信息/常量/静态变量      │  │
│  ┌──────────────────┐      │  │  JDK 8后用本地内存        │  │
│  │   本地方法栈       │      │  │  OutOfMemoryError        │  │
│  │ (Native Stack)   │      │  └──────────────────────────┘  │
│  │ 为Native方法服务   │      │                                │
│  └──────────────────┘      │                                │
│                            │                                │
└────────────────────────────┴────────────────────────────────┘

五大区域速记:

区域线程存储异常
程序计数器私有当前字节码指令地址唯一不会OOM
虚拟机栈私有栈帧(局部变量表、操作栈、动态链接、返回地址)SOF/OOM
本地方法栈私有Native方法调用SOF/OOM
堆共享对象实例、数组OOM
方法区共享类信息、常量池、静态变量OOM(Metaspace)

二、堆的分代结构


堆内存分代(默认 Young:Old = 1:2):

┌────────────────────────────────────────────────────────┐
│                      堆(Heap)                        │
│                                                        │
│  Young Generation(约1/3)     Old Generation(约2/3)  │
│  ┌──────────────────────┐    ┌──────────────────────┐  │
│  │  ┌───────┬────┬────┐ │    │                      │  │
│  │  │ Eden  │ S0 │ S1 │ │    │    Tenured           │  │
│  │  │ 80%   │10% │10% │ │    │                      │  │
│  │  └───────┴────┴────┘ │    │                      │  │
│  └──────────────────────┘    └──────────────────────┘  │
│                                                        │
│  Minor GC: Young区GC(频繁、快速)                      │
│  Major GC: Old区GC(CMS的Full GC)                     │
│  Full GC:  全堆GC + MetaSpace(STW、慢)               │
└────────────────────────────────────────────────────────┘

对象分配流转:
  1. 新对象优先在Eden分配
  2. Eden满 → Minor GC(复制算法:Eden+S0 → S1 或 Eden+S1 → S0)
  3. 存活对象年龄+1,达到阈值(默认15,CMS默认6) → 晋升Old区
  4. 大对象(超过-XX:PretenureSizeThreshold)直接进入Old区
  5. Old区满 → Full GC(整个堆+方法区)

为什么分代?
  - 99%对象朝生夕死(集中在Young区)
  - 分代后可以只GC Young区(Minor GC),不用每次全堆GC
  - 不同代用不同算法(Young用复制、Old用标记整理)

三、GC四大基础算法


1. 标记-清除(Mark-Sweep)
   ┌───────────────────────┐
   │ 标记前:                │
   │ [A][B][ ][C][ ][D][E] │
   │                        │
   │ 标记后: 清除B, D       │
   │ [A][ ][ ][C][ ][ ][E] │
   └───────────────────────┘
   优点:实现简单
   缺点:内存碎片多,分配大对象时触发Full GC

2. 标记-整理(Mark-Compact)
   ┌───────────────────────┐
   │ 标记前:                │
   │ [A][B][ ][C][ ][D][E] │
   │                        │
   │ 整理后: 清除B,D,移动   │
   │ [A][C][E][ ][ ][ ][ ] │
   └───────────────────────┘
   优点:无碎片
   缺点:移动对象需要更新引用,耗时

3. 复制算法(Copying)
   ┌──────────┬──────────┐
   │ From     │ To       │
   │ [A][B][C]│ [空]     │
   │          │          │
   │ GC后:    │          │
   │ [空]     │ [A][C]   │  B被回收
   │          │          │
   │ 交换角色: │          │
   │ [A][C]   │ [空]     │  From和To互换
   └──────────┴──────────┘
   优点:无碎片,效率高(只拷贝存活对象)
   缺点:浪费一半空间
   → 实际Young区Eden:S0:S1=8:1:1,只浪费10%

4. 分代收集(Generational)
   Young区:复制算法(对象存活率低)
   Old区:标记-清除 或 标记-整理(对象存活率高)

四、CMS回收器(Concurrent Mark Sweep)


CMS目标:最短停顿时间(STW尽量短)
算法:标记-清除

CMS四个阶段:

  ┌─────────────────────────────────────────────────────────┐
  │  1. 初始标记(STW)        ← 极快,只标记GC Roots直接引用 │
  │     │                                                   │
  │  2. 并发标记(Concurrent) ← 和用户线程并发执行           │
  │     │   遍历整个对象图                                    │
  │     │                                                   │
  │  3. 重新标记(STW)        ← 修正并发标记期间的变动        │
  │     │   使用写屏障+增量更新                               │
  │     │                                                   │
  │  4. 并发清除(Concurrent) ← 和用户线程并发执行           │
  │         标记-清除算法回收                                  │
  └─────────────────────────────────────────────────────────┘

CMS的缺点(必知):
  1. 浮动垃圾:并发清除阶段产生的新垃圾,本次无法回收
     → 需要预留空间给用户线程(-XX:CMSInitiatingOccupancyFraction,默认92%)
  2. 内存碎片:标记-清除不压缩,长期运行后碎片化
     → 可配置 -XX:+UseCMSCompactAtFullCollection(Full GC时压缩)
  3. Concurrent Mode Failure:
     如果Old区在CMS回收完之前就被填满 → 退化为Serial Old(单线程Full GC)
     → 停顿时间极长!
  4. CPU敏感:并发阶段占用CPU(默认启动(核数+3)/4个GC线程)

JDK参数:
  -XX:+UseConcMarkSweepGC      // 启用CMS
  -XX:CMSInitiatingOccupancyFraction=75  // Old区75%时触发CMS
  -XX:+UseCMSCompactAtFullCollection     // Full GC时压缩
  -XX:CMSFullGCsBeforeCompaction=5       // 5次Full GC后压缩一次

五、G1回收器(Garbage First)


G1目标:可预测的停顿时间(-XX:MaxGCPauseMillis=200ms)
算法:分Region + 复制算法(整体看是标记-整理)

Region分区(关键创新):
  ┌────┬────┬────┬────┬────┬────┬────┬────┐
  │ E  │ S  │ O  │ H  │ E  │ O  │ E  │ O  │ ...
  └────┴────┴────┴────┴────┴────┴────┴────┘
  E = Eden区    S = Survivor区
  O = Old区     H = Humongous(大对象,占多个Region)
  
  - 每个Region大小 = 堆大小 / 2048(1~32MB)
  - Region角色动态变化(E→S→O,不是固定的)
  - 回收价值 = Region中垃圾占比(垃圾越多优先回收 → "Garbage First")

G1回收模式:
  1. Young GC:回收所有Eden+Survivor Region
  2. Mixed GC:回收所有Young Region + 部分垃圾最多的Old Region
     → 这是G1的核心优势:选择性地回收Old区
  3. Full GC:退化为单线程(Serial),性能极差(应避免)

Mixed GC触发条件:
  -XX:InitiatingHeapOccupancyPercent=45(默认堆使用率达45%触发)
  → 并发标记 → Mixed GC(回收垃圾最多的N个Old Region)

G1三阶段(简化):
  ┌─────────────────────────────────────────────────────────┐
  │  1. 全局并发标记(和CMS类似)                              │
  │     初始标记(STW) → 并发标记 → 重新标记(STW) → 筛选回收   │
  │                                                         │
  │  2. 筛选回收(STW但可控)                                 │
  │     根据回收价值排序Region,选择回收收益最高的N个           │
  │     使用复制算法(存活对象拷贝到新Region,旧Region整体回收) │
  │                                                         │
  │  3. 停顿时间控制                                         │
  │     根据 MaxGCPauseMillis 动态决定回收多少个Region         │
  └─────────────────────────────────────────────────────────┘

G1 vs CMS:
  ┌──────────┬──────────────────┬──────────────────┐
  │          │ CMS              │ G1               │
  ├──────────┼──────────────────┼──────────────────┤
  │ 算法     │ 标记-清除         │ 复制(Region级别) │
  │ 碎片     │ 有               │ 无               │
  │ 停顿     │ 较短但不可控      │ 可预测可控       │
  │ 堆大小   │ 适合<6GB         │ 适合>6GB         │
  │ 大对象   │ 直接进Old区       │ Humongous Region │
  │ 调优难度 │ 参数多           │ 相对简单         │
  └──────────┴──────────────────┴──────────────────┘

六、ZGC(了解)


ZGC目标:亚毫秒级停顿(< 1ms),与堆大小无关
JDK 11引入,JDK 15生产可用

核心创新:着色指针(Colored Pointers)
  64位对象指针中用几位存储GC元数据:

  ┌──────────────────────────────────────────────────┐
  │  63  44 43 42 41 40 39                           0 │
  │ [unused][R][F][M][R] [  对象地址                ] │
  │         │  │  │  │                                │
  │         │  │  │  └── Remapped(是否已重映射)      │
  │         │  │  └──── Marked1(标记位1)             │
  │         │  └─────── Marked0(标记位0)             │
  │         └────────── Finalizable(终待处理)        │
  └──────────────────────────────────────────────────┘

ZGC特点:
  1. STW时间 < 1ms(只扫描GC Roots)
  2. 支持TB级堆(最大16TB)
  3. 并发标记 + 并发转移(对象移动也并发!)
  4. 读屏障(Load Barrier)保证指针正确性
  5. 无分代(JDK 21前无分代,JDK 21引入分代ZGC)

读屏障示例:
  Object o = obj.field;  // 读取引用
  // ZGC在读之后插入屏障:
  // if (指针颜色 != 当前颜色) → 修正指针(slow path)

七、面试追问与回答

Q1: 对象一定分配在堆上吗?

不一定。JIT的逃逸分析如果发现对象没有被方法外部引用,可能直接分配在栈上(标量替换),避免GC压力。

Q2: 什么情况下对象会直接进入老年代?

(1) 大对象超过-XX:PretenureSizeThreshold;(2) 长期存活的对象(年龄达到阈值,默认15,CMS为6);(3) 动态年龄判断:Survivor中相同年龄对象总大小超过Survivor空间一半,年龄>=该年龄的直接晋升。

Q3: Full GC的触发条件?

(1) 调用System.gc()(建议但不强制);(2) Old区空间不足;(3) MetaSpace空间不足;(4) CMS的Concurrent Mode Failure;(5) G1的Evacuation Failure(to-space耗尽)。

Q4: 如何选择垃圾回收器?

单机小内存(<2GB):Serial;中内存(2-6GB):CMS;大内存(>6GB):G1;超大内存或超低延迟:ZGC。JDK 9+默认G1。

Q5: Minor GC和Full GC的区别?

Minor GC只清理Young区,频率高速度快(通常10-50ms);Full GC清理整个堆+方法区,频率低但速度慢(可能数百ms到数秒)。应尽量减少Full GC。

面试速记卡(考前30秒速看)

练习题(自测)

1. 画出JVM运行时数据区结构图,标注哪些线程私有、哪些共享,各自的异常类型。

2. 解释Minor GC的完整过程:Eden满→GC Roots→复制存活对象到Survivor→年龄+1→晋升Old区。

3. 对比CMS和G1的优缺点,什么场景下选择G1而不是CMS?

4. 什么是浮动垃圾?CMS为什么会产生浮动垃圾?如何缓解?

5. G1的Mixed GC是如何选择回收哪些Old Region的?和-XX:MaxGCPauseMillis有什么关系?

学习资料