[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"$f1b300lqgtfmoj":3,"$f250wz8h39yydc":8,"$f3e13fn86h0z0l":29,"$f1tmzc20p7l0cb":37,"$f2e7rc8akdlnf7":72,"toc--2114137461-5-5":76},{"description":4,"domain":5,"id":6,"keywords":4,"title":7},"","api.kongjs.com",1,"默认",[9,20,24],{"children":10,"icon":4,"id":11,"linkType":12,"linkUrl":13,"parentId":14,"sort":15,"status":16,"target":17,"title":18,"visible":19},null,"447369447469600768","URL","\u002F","0",0,"1","_self","首页",true,{"children":10,"icon":4,"id":21,"linkType":12,"linkUrl":22,"parentId":14,"sort":15,"status":16,"target":17,"title":23,"visible":19},"447369693859794944","\u002Fnotes","笔记",{"children":10,"icon":4,"id":25,"linkType":26,"linkUrl":27,"parentId":14,"sort":15,"status":16,"target":17,"title":28,"visible":19},"447369977960976384","PAGE","\u002Fabout","关于我",{"category":30,"categoryId":31,"cover":10,"description":4,"fileId":10,"id":34,"publishAt":10,"tags":35,"title":36},{"articleCount":10,"children":10,"cover":10,"description":4,"fileId":10,"icon":4,"id":31,"parentId":14,"slug":32,"sort":15,"title":33},"453164732518506496","back-end","后端","453165633773772800",[],"Java面试核心知识",[38,41,44,48,52,56,60,64,68],{"children":10,"description":4,"id":39,"noteId":34,"parentId":14,"sort":15,"status":16,"title":40},"453165775620939776","Java基础核心全集（数据类型、拆箱装箱、克隆、对象结构、字符串、包装类、序列化）",{"children":10,"description":4,"id":42,"noteId":34,"parentId":14,"sort":6,"status":16,"title":43},"453166088570544128","JVM原理（JDK8~25）内存结构、分代模型、GC算法、垃圾收集器、元空间、双亲委派机制",{"children":10,"description":4,"id":45,"noteId":34,"parentId":14,"sort":46,"status":16,"title":47},"453166295265845248",2,"Java8至25 对象创建全过程及各版本底层演进差异",{"children":10,"description":4,"id":49,"noteId":34,"parentId":14,"sort":50,"status":16,"title":51},"453166545573519360",3,"Java集合全套原理（List+Map底层、扩容机制、线程安全集合对比）",{"children":10,"description":4,"id":53,"noteId":34,"parentId":14,"sort":54,"status":16,"title":55},"453166809651093504",4,"Java线程原理、六大状态流转、线程结束判断、安全中断、核心方法区别",{"children":10,"description":4,"id":57,"noteId":34,"parentId":14,"sort":58,"status":16,"title":59},"453167023724175360",5,"Java线程池原理、使用规范、常用并发异步工具类",{"children":10,"description":4,"id":61,"noteId":34,"parentId":14,"sort":62,"status":16,"title":63},"453167209447956480",6,"Java 虚拟线程与平台线程：原理、区别与实战使用",{"children":10,"description":4,"id":65,"noteId":34,"parentId":14,"sort":66,"status":16,"title":67},"453167452423987200",7,"CAS与AQS 底层原理、核心流程、面试最全详解",{"children":10,"description":4,"id":69,"noteId":34,"parentId":14,"sort":70,"status":16,"title":71},"453168570885480448",8,"线上服务器CPU飙升 Java代码 完整定位排查流程",{"content":73,"contentType":74,"description":4,"title":43,"wordCount":75},"# JVM完整原理（JDK8\\~25）内存结构、分代模型、GC算法、垃圾收集器、元空间、双亲委派机制\n\n本文覆盖**JVM整体结构、运行时数据区、JDK8内存大改版、分代模型、四大GC核心算法、主流垃圾收集器、元空间原理、双亲委派机制\\+破双亲委派**，适配JDK8至最新JDK25版本特性，全部为一线面试高频原题，可直接背诵。\n\n## 一、JVM整体架构（四大核心模块）\n\nJava虚拟机是跨平台执行引擎，整体分为四大核心模块，所有Java代码运行都依赖该体系，整体结构如下：\n\n```plain\nJVM整体架构\n├─ 类加载子系统 → 加载、验证、准备、解析、初始化（双亲委派）\n├─ 运行时数据区 → 线程私有+线程共享内存区域\n├─ 执行引擎     → 解释器 + JIT即时编译 + 本地方法执行\n└─ GC垃圾回收子系统 → 内存分代、GC算法、垃圾收集器、内存回收\n```\n\n1. **类加载子系统**：加载class文件、验证、准备、解析、初始化，双亲委派机制核心载体\n\n2. **运行时数据区**：内存模型（堆、栈、元空间等），线程私有\u002F共享内存分区\n\n3. **执行引擎**：解释器、JIT即时编译器、本地方法栈，执行字节码指令\n\n4. **垃圾回收子系统**：内存分代、GC算法、垃圾收集器、内存回收、内存优化\n\n---\n\n## 二、JVM运行时数据区（JDK8\\+ 最终版内存结构）\n\n```plain\nJVM运行时数据区（JDK8+）\n├─ 线程私有（线程销毁自动释放）\n│  ├─ 程序计数器（无OOM）\n│  ├─ 虚拟机栈（栈帧、方法执行）\n│  └─ 本地方法栈（Native方法执行）\n└─ 线程共享（全局常驻、GC管理）\n   ├─ 堆 Heap（对象\u002F数组、GC主战场）\n   └─ 元空间 Metaspace（本地内存、存类元数据）\n```\n\n### 1\\. 线程私有（线程隔离、线程销毁自动释放）\n\n- **程序计数器 PC寄存器**：唯一无OOM的区域，记录当前线程执行字节码行号，多线程切换恢复现场\n\n- **虚拟机栈 JVM Stack**：存储栈帧（局部变量表、操作数栈、动态链接、方法出口），方法调用入栈、执行完出栈，栈深度溢出报StackOverflowError\n\n- **本地方法栈 Native Stack**：执行native本地方法（C\u002FC\\+\\+），底层线程、IO、CAS依赖此区域\n\n### 2\\. 线程共享（全局共享、GC管理核心）\n\n- **堆 Heap**：所有对象、数组实例存储区域，**GC唯一主战场**，分年轻代、老年代\n\n- **元空间 Metaspace（JDK8全新）**：替代永久代，存储类元数据、方法信息、常量池，使用本地内存，无固定大小限制\n\n### 3\\. JDK8 史诗级内存改动（必考）\n\n- **JDK7及以前**：存在永久代 PermGen，堆内存一部分，固定大小，极易OOM\n\n- **JDK8 彻底移除永久代，替换为元空间 Metaspace**\n\n- 字符串常量池、静态变量从永久代迁移至**堆内存**\n\n- 元空间使用**操作系统本地内存**，不再占用堆内存，默认动态扩容，大幅降低OOM概率\n\n---\n\n## 三、JVM分代模型（JDK8\\~25 统一分代）\n\n为什么需要分代？**不同对象生命周期不同，针对性GC，提升回收效率**。90%对象朝生夕灭，只需频繁回收新生代，老年代低频回收。\n\n```plain\n堆内存分代结构\n├─ 年轻代（占堆1\u002F3）\n│  ├─ Eden区（80%）→ 新对象默认存放\n│  ├─ Survivor0（10%）\n│  └─ Survivor1（10%）→ S0\u002FS1始终一空一用\n└─ 老年代（占堆2\u002F3）→ 长期存活对象、大对象、晋升对象\n\n对象晋升链路：Eden → Survivor循环存活15次 → 老年代\n```\n\n为什么需要分代？**不同对象生命周期不同，针对性GC，提升回收效率**。90%对象朝生夕灭，只需频繁回收新生代，老年代低频回收。\n\n### 1\\. 年轻代（Young Generation）\n\n- 占堆内存 1\u002F3，分为 **Eden区 \\+ Survive0 \\+ Survive1**\n\n- 比例默认：**8:1:1**\n\n- Eden：新建对象默认存放区域\n\n- S0\u002FS1：存活对象复制区，始终空出一块作为备份\n\n- GC类型：**Minor GC**，频繁执行、速度快\n\n### 2\\. 老年代（Old Generation）\n\n- 占堆内存 2\u002F3\n\n- 存放长期存活对象、大对象、多次GC存活对象\n\n- GC类型：**Major GC \u002F Full GC**，耗时久、频率低、尽量避免\n\n### 3\\. 对象晋升机制\n\n- 对象在新生代经历 **15次Minor GC存活**，晋升老年代（可通过JVM参数调整）\n\n- 大对象直接进入老年代，避免新生代复制开销\n\n- 新生代空间不足，存活对象提前晋升老年代\n\n---\n\n## 四、四大GC核心算法（底层原理）\n\n```plain\nGC算法适配结构图\n├─ 标记清除：标记存活 → 清空死亡 → 产生内存碎片\n├─ 标记复制：标记存活 → 复制新区域 → 清空原区域（无碎片、耗空间）\n├─ 标记整理：标记存活 → 压缩规整 → 清空末端（无碎片、速度慢）\n└─ 分代收集（综合最优）\n   ├─ 年轻代 → 标记复制算法\n   └─ 老年代 → 标记清除 + 标记整理算法\n```\n\n### 1\\. 标记清除算法（Mark\\-Sweep）\n\n- 流程：标记存活对象 → 清除死亡对象\n\n- 优点：无需移动对象，速度较快\n\n- 缺点：产生**大量内存碎片**，大对象无法分配，容易触发Full GC\n\n### 2\\. 标记复制算法（Mark\\-Copy）\n\n- 流程：标记存活对象 → 复制到空闲区域 → 清空原区域\n\n- 优点：**无内存碎片**，内存规整\n\n- 缺点：浪费一半内存空间，适合存活对象少的区域\n\n- 适用：**年轻代默认算法**（存活对象少、回收频繁）\n\n### 3\\. 标记整理算法（Mark\\-Compact）\n\n- 流程：标记存活对象 → 向一端整理压缩 → 清空末端内存\n\n- 优点：无内存碎片、不浪费空间\n\n- 缺点：需要移动对象，效率低\n\n- 适用：**老年代默认算法**（存活对象多、不适合复制）\n\n### 4\\. 分代收集算法（GC综合算法）\n\n- JVM终极算法，整合以上三种\n\n- 年轻代：标记复制\n\n- 老年代：标记清除 \\+ 标记整理\n\n---\n\n## 五、主流垃圾收集器（JDK8\\~25 版本迭代）\n\n```plain\n垃圾收集器迭代演进 & 特性\n├─ Parallel GC（JDK8默认）→ 高吞吐、长停顿、后台批量任务\n├─ CMS（JDK8废弃\u002FJDK14移除）→ 低并发停顿、碎片多、浮动垃圾\n├─ G1 GC（JDK9默认）→ 分区回收、吞吐延迟平衡、大堆适配\n└─ ZGC\u002FShenandoah（JDK11+）→ 毫秒级低延迟、超大堆、高并发首选\n```\n\n### 1\\. Parallel GC（JDK8 默认）\n\n- 多线程并行回收，追求**高吞吐量**\n\n- 适合后台业务、批量任务\n\n- 停顿时间较长，不适合低延迟服务\n\n### 2\\. CMS 并发收集器（JDK8废弃、JDK14移除）\n\n- 追求低停顿，并发回收\n\n- 缺点：内存碎片多、并发浮动垃圾、CPU占用高\n\n### 3\\. G1 GC（JDK9默认，JDK8可指定）\n\n- 分区回收，将堆划分为多个Region\n\n- 兼顾吞吐量与低延迟，可设置最大停顿时间\n\n- 适用于大内存堆服务\n\n### 4\\. ZGC \u002F Shenandoah（JDK11\\+ 超低延迟）\n\n- 毫秒级停顿，几乎不卡顿\n\n- 超大堆适配，JDK17、JDK25持续优化\n\n- 互联网高并发、低延迟服务首选\n\n### 5\\. GC迭代总结（版本演进）\n\n**ParallelGC\\(吞吐\\) → CMS\\(并发低延迟\\) → G1\\(平衡\\) → ZGC\\(极致低延迟\\)**\n\n---\n\n## 六、元空间 Metaspace 深度原理（JDK8核心）\n\n```plain\nJDK8内存重大更替\n永久代PermGen（JDK7及以前）\n├─ 归属：堆内存一部分\n├─ 特点：固定大小、容量小、极易OOM\n└─ 存储：类元数据、常量池、静态变量\n\n元空间Metaspace（JDK8+ 全覆盖）\n├─ 归属：操作系统本地内存\n├─ 特点：动态扩容、无固定上限、无OOM风险\n└─ 存储：类\u002F方法\u002F字段元数据、运行时动态类信息\n```\n\n### 1\\. 永久代与元空间核心区别\n\n- **永久代PermGen**：属于堆内存、固定大小、易OOM、JDK7及以前使用\n\n- **元空间Metaspace**：操作系统本地内存、动态扩容、无固定上限、JDK8\\+全覆盖\n\n### 2\\. 元空间存储内容\n\n- 类、接口、注解、枚举的元数据信息\n\n- 方法代码、字段信息、常量池\n\n- 运行时动态生成的类（Spring CGLIB、动态代理）\n\n### 3\\. 元空间优势\n\n- 彻底解决永久代OOM问题\n\n- 本地内存不占用堆空间，堆内存利用率更高\n\n- 动态伸缩，适配动态类加载场景\n\n---\n\n## 七、双亲委派机制（类加载核心）\n\n```plain\n类加载器层级 & 双亲委派流程\n加载层级（从上至下）\n├─ BootstrapClassLoader 启动类加载器（顶层）\n├─ ExtClassLoader 扩展类加载器\n└─ AppClassLoader 应用类加载器（底层）\n\n执行流程：向上委托，向下加载\n1. AppClassLoader 接收加载请求\n2. 逐级向上委托至 Bootstrap\n3. 上级无法加载，逐级下放由本级加载\n```\n\n### 1\\. 三大类加载器（层级结构）\n\n1. **启动类加载器 BootstrapClassLoader**：顶层，加载JDK核心rt\\.jar等系统类\n\n2. **扩展类加载器 ExtClassLoader**：加载JDK扩展包类\n\n3. **应用类加载器 AppClassLoader**：加载项目自定义class、第三方依赖包\n\n### 2\\. 双亲委派核心流程（必背）\n\n**向上委托、向下加载**\n\n1. 应用类加载器收到加载请求，不直接加载，向上委托给扩展类加载器\n\n2. 扩展类加载器继续向上委托给启动类加载器\n\n3. 启动类加载器无法加载，向下逐层返回，由下层加载器加载\n\n### 3\\. 核心作用（面试满分答案）\n\n- **沙箱安全机制**：防止恶意代码覆盖JDK核心类（如自定义java\\.lang\\.String）\n\n- **类全局唯一**：保证核心类只加载一次，避免重复加载、类冲突\n\n### 4\\. 打破双亲委派机制（高频追问）\n\n双亲委派是**默认规则，非强制机制**，可重写loadClass方法打破\n\n#### 经典打破场景\n\n- **Tomcat**：自定义类加载器，隔离不同web应用包冲突\n\n- **JDBC SPI机制**：线程上下文类加载器，加载厂商实现类\n\n- **Spring、OSGI**：热部署、动态加载类，打破双亲委派\n\n---\n\n## 八、GC核心概念区分（面试坑点）\n\n- **Minor GC**：新生代GC，频繁、速度快、无停顿或短停顿\n\n- **Major GC**：老年代GC，耗时较长\n\n- **Full GC**：整堆GC（新生代\\+老年代\\+元空间），STW全局暂停，**线上绝对避免**\n\n- **STW**：Stop\\-The\\-World，GC期间暂停所有用户线程，是卡顿的根本原因\n\n---\n\n## 九、终极面试背诵总结（极简版）\n\n- **JVM结构**：类加载、运行时数据区、执行引擎、GC四大模块\n\n- **内存分区**：线程三私两共，JDK8废除永久代，改用本地内存元空间\n\n- **分代模型**：新生代8:1:1复制算法，老年代标记整理算法，对象随GC次数晋升\n\n- **GC算法**：清除有碎片、复制耗空间、整理无碎片效率低，分代收集综合最优\n\n- **收集器迭代**：Parallel吞吐、G1平衡、ZGC超低延迟\n\n- **双亲委派**：向上委托保证安全和类唯一，Tomcat\u002FSPI可打破实现隔离与动态加载","markdown",5204,{"frontmatter":77,"meta":78,"nodes":185},{},{"title":79,"description":80,"toc":81},"JVM完整原理（JDK8~25）内存结构、分代模型、GC算法、垃圾收集器、元空间、双亲委派机制","本文覆盖JVM整体结构、运行时数据区、JDK8内存大改版、分代模型、四大GC核心算法、主流垃圾收集器、元空间原理、双亲委派机制+破双亲委派，适配JDK8至最新JDK25版本特性，全部为一线面试高频原题，可直接背诵。",{"title":4,"searchDepth":58,"depth":58,"links":82},[83,86,99,112,128,147,160,179,182],{"id":84,"depth":46,"text":85},"jvm","一、JVM整体架构（四大核心模块）",{"id":87,"depth":46,"text":88,"children":89},"jvmjdk8","二、JVM运行时数据区（JDK8+ 最终版内存结构）",[90,93,96],{"id":91,"depth":50,"text":92},"jvmjdk8-_1","1. 线程私有（线程隔离、线程销毁自动释放）",{"id":94,"depth":50,"text":95},"jvmjdk8-_2-gc","2. 线程共享（全局共享、GC管理核心）",{"id":97,"depth":50,"text":98},"jvmjdk8-_3-jdk8","3. JDK8 史诗级内存改动（必考）",{"id":100,"depth":46,"text":101,"children":102},"jvmjdk825","三、JVM分代模型（JDK8~25 统一分代）",[103,106,109],{"id":104,"depth":50,"text":105},"jvmjdk825-_1-young-generation","1. 年轻代（Young Generation）",{"id":107,"depth":50,"text":108},"jvmjdk825-_2-old-generation","2. 老年代（Old Generation）",{"id":110,"depth":50,"text":111},"jvmjdk825-_3","3. 对象晋升机制",{"id":113,"depth":46,"text":114,"children":115},"gc","四、四大GC核心算法（底层原理）",[116,119,122,125],{"id":117,"depth":50,"text":118},"gc-_1-mark-sweep","1. 标记清除算法（Mark-Sweep）",{"id":120,"depth":50,"text":121},"gc-_2-mark-copy","2. 标记复制算法（Mark-Copy）",{"id":123,"depth":50,"text":124},"gc-_3-mark-compact","3. 标记整理算法（Mark-Compact）",{"id":126,"depth":50,"text":127},"gc-_4-gc","4. 分代收集算法（GC综合算法）",{"id":129,"depth":46,"text":130,"children":131},"jdk825","五、主流垃圾收集器（JDK8~25 版本迭代）",[132,135,138,141,144],{"id":133,"depth":50,"text":134},"jdk825-_1-parallel-gcjdk8","1. Parallel GC（JDK8 默认）",{"id":136,"depth":50,"text":137},"jdk825-_2-cms-jdk8jdk14","2. CMS 并发收集器（JDK8废弃、JDK14移除）",{"id":139,"depth":50,"text":140},"jdk825-_3-g1-gcjdk9jdk8","3. G1 GC（JDK9默认，JDK8可指定）",{"id":142,"depth":50,"text":143},"jdk825-_4-zgc-shenandoahjdk11","4. ZGC \u002F Shenandoah（JDK11+ 超低延迟）",{"id":145,"depth":50,"text":146},"jdk825-_5-gc","5. GC迭代总结（版本演进）",{"id":148,"depth":46,"text":149,"children":150},"metaspace-jdk8","六、元空间 Metaspace 深度原理（JDK8核心）",[151,154,157],{"id":152,"depth":50,"text":153},"metaspace-jdk8-_1","1. 永久代与元空间核心区别",{"id":155,"depth":50,"text":156},"metaspace-jdk8-_2","2. 元空间存储内容",{"id":158,"depth":50,"text":159},"metaspace-jdk8-_3","3. 元空间优势",{"id":4,"depth":46,"text":161,"children":162},"七、双亲委派机制（类加载核心）",[163,166,169,172],{"id":164,"depth":50,"text":165},"-_1","1. 三大类加载器（层级结构）",{"id":167,"depth":50,"text":168},"-_2","2. 双亲委派核心流程（必背）",{"id":170,"depth":50,"text":171},"-_3","3. 核心作用（面试满分答案）",{"id":173,"depth":50,"text":174,"children":175},"-_4","4. 打破双亲委派机制（高频追问）",[176],{"id":177,"depth":54,"text":178},"-_4-","经典打破场景",{"id":180,"depth":46,"text":181},"gc-1","八、GC核心概念区分（面试坑点）",{"id":183,"depth":46,"text":184},"-1","九、终极面试背诵总结（极简版）",[186,190,199,202,205,214,242,245,247,252,255,276,278,296,298,324,326,328,335,340,344,346,373,375,389,391,406,408,410,415,417,432,434,456,458,475,477,488,490,492,497,499,513,515,523,525,536,538,549,551,556,558,560,565,567,581,583,594,596,607,609,611,616,618,638,640,645,656,658,672,674,681,684,704,706,708,736,738,740],[187,188,79],"h1",{"id":189},"jvmjdk825gc",[191,192,193,194,198],"p",{},"本文覆盖",[195,196,197],"strong",{},"JVM整体结构、运行时数据区、JDK8内存大改版、分代模型、四大GC核心算法、主流垃圾收集器、元空间原理、双亲委派机制+破双亲委派","，适配JDK8至最新JDK25版本特性，全部为一线面试高频原题，可直接背诵。",[200,201,85],"h2",{"id":84},[191,203,204],{},"Java虚拟机是跨平台执行引擎，整体分为四大核心模块，所有Java代码运行都依赖该体系，整体结构如下：",[206,207,209],"pre",{"language":208},"plain",[210,211,213],"code",{"class":212},"language-plain","JVM整体架构\n├─ 类加载子系统 → 加载、验证、准备、解析、初始化（双亲委派）\n├─ 运行时数据区 → 线程私有+线程共享内存区域\n├─ 执行引擎     → 解释器 + JIT即时编译 + 本地方法执行\n└─ GC垃圾回收子系统 → 内存分代、GC算法、垃圾收集器、内存回收",[215,216,217,224,230,236],"ol",{},[218,219,220,223],"li",{},[195,221,222],{},"类加载子系统","：加载class文件、验证、准备、解析、初始化，双亲委派机制核心载体",[218,225,226,229],{},[195,227,228],{},"运行时数据区","：内存模型（堆、栈、元空间等），线程私有\u002F共享内存分区",[218,231,232,235],{},[195,233,234],{},"执行引擎","：解释器、JIT即时编译器、本地方法栈，执行字节码指令",[218,237,238,241],{},[195,239,240],{},"垃圾回收子系统","：内存分代、GC算法、垃圾收集器、内存回收、内存优化",[243,244],"hr",{},[200,246,88],{"id":87},[206,248,249],{"language":208},[210,250,251],{"class":212},"JVM运行时数据区（JDK8+）\n├─ 线程私有（线程销毁自动释放）\n│  ├─ 程序计数器（无OOM）\n│  ├─ 虚拟机栈（栈帧、方法执行）\n│  └─ 本地方法栈（Native方法执行）\n└─ 线程共享（全局常驻、GC管理）\n   ├─ 堆 Heap（对象\u002F数组、GC主战场）\n   └─ 元空间 Metaspace（本地内存、存类元数据）",[253,254,92],"h3",{"id":91},[256,257,258,264,270],"ul",{},[218,259,260,263],{},[195,261,262],{},"程序计数器 PC寄存器","：唯一无OOM的区域，记录当前线程执行字节码行号，多线程切换恢复现场",[218,265,266,269],{},[195,267,268],{},"虚拟机栈 JVM Stack","：存储栈帧（局部变量表、操作数栈、动态链接、方法出口），方法调用入栈、执行完出栈，栈深度溢出报StackOverflowError",[218,271,272,275],{},[195,273,274],{},"本地方法栈 Native Stack","：执行native本地方法（C\u002FC++），底层线程、IO、CAS依赖此区域",[253,277,95],{"id":94},[256,279,280,290],{},[218,281,282,285,286,289],{},[195,283,284],{},"堆 Heap","：所有对象、数组实例存储区域，",[195,287,288],{},"GC唯一主战场","，分年轻代、老年代",[218,291,292,295],{},[195,293,294],{},"元空间 Metaspace（JDK8全新）","：替代永久代，存储类元数据、方法信息、常量池，使用本地内存，无固定大小限制",[253,297,98],{"id":97},[256,299,300,306,311,317],{},[218,301,302,305],{},[195,303,304],{},"JDK7及以前","：存在永久代 PermGen，堆内存一部分，固定大小，极易OOM",[218,307,308],{},[195,309,310],{},"JDK8 彻底移除永久代，替换为元空间 Metaspace",[218,312,313,314],{},"字符串常量池、静态变量从永久代迁移至",[195,315,316],{},"堆内存",[218,318,319,320,323],{},"元空间使用",[195,321,322],{},"操作系统本地内存","，不再占用堆内存，默认动态扩容，大幅降低OOM概率",[243,325],{},[200,327,101],{"id":100},[191,329,330,331,334],{},"为什么需要分代？",[195,332,333],{},"不同对象生命周期不同，针对性GC，提升回收效率","。90%对象朝生夕灭，只需频繁回收新生代，老年代低频回收。",[206,336,337],{"language":208},[210,338,339],{"class":212},"堆内存分代结构\n├─ 年轻代（占堆1\u002F3）\n│  ├─ Eden区（80%）→ 新对象默认存放\n│  ├─ Survivor0（10%）\n│  └─ Survivor1（10%）→ S0\u002FS1始终一空一用\n└─ 老年代（占堆2\u002F3）→ 长期存活对象、大对象、晋升对象\n\n对象晋升链路：Eden → Survivor循环存活15次 → 老年代",[191,341,330,342,334],{},[195,343,333],{},[253,345,105],{"id":104},[256,347,348,354,360,363,366],{},[218,349,350,351],{},"占堆内存 1\u002F3，分为 ",[195,352,353],{},"Eden区 + Survive0 + Survive1",[218,355,356,357],{},"比例默认：",[195,358,359],{},"8:1:1",[218,361,362],{},"Eden：新建对象默认存放区域",[218,364,365],{},"S0\u002FS1：存活对象复制区，始终空出一块作为备份",[218,367,368,369,372],{},"GC类型：",[195,370,371],{},"Minor GC","，频繁执行、速度快",[253,374,108],{"id":107},[256,376,377,380,383],{},[218,378,379],{},"占堆内存 2\u002F3",[218,381,382],{},"存放长期存活对象、大对象、多次GC存活对象",[218,384,368,385,388],{},[195,386,387],{},"Major GC \u002F Full GC","，耗时久、频率低、尽量避免",[253,390,111],{"id":110},[256,392,393,400,403],{},[218,394,395,396,399],{},"对象在新生代经历 ",[195,397,398],{},"15次Minor GC存活","，晋升老年代（可通过JVM参数调整）",[218,401,402],{},"大对象直接进入老年代，避免新生代复制开销",[218,404,405],{},"新生代空间不足，存活对象提前晋升老年代",[243,407],{},[200,409,114],{"id":113},[206,411,412],{"language":208},[210,413,414],{"class":212},"GC算法适配结构图\n├─ 标记清除：标记存活 → 清空死亡 → 产生内存碎片\n├─ 标记复制：标记存活 → 复制新区域 → 清空原区域（无碎片、耗空间）\n├─ 标记整理：标记存活 → 压缩规整 → 清空末端（无碎片、速度慢）\n└─ 分代收集（综合最优）\n   ├─ 年轻代 → 标记复制算法\n   └─ 老年代 → 标记清除 + 标记整理算法",[253,416,118],{"id":117},[256,418,419,422,425],{},[218,420,421],{},"流程：标记存活对象 → 清除死亡对象",[218,423,424],{},"优点：无需移动对象，速度较快",[218,426,427,428,431],{},"缺点：产生",[195,429,430],{},"大量内存碎片","，大对象无法分配，容易触发Full GC",[253,433,121],{"id":120},[256,435,436,439,446,449],{},[218,437,438],{},"流程：标记存活对象 → 复制到空闲区域 → 清空原区域",[218,440,441,442,445],{},"优点：",[195,443,444],{},"无内存碎片","，内存规整",[218,447,448],{},"缺点：浪费一半内存空间，适合存活对象少的区域",[218,450,451,452,455],{},"适用：",[195,453,454],{},"年轻代默认算法","（存活对象少、回收频繁）",[253,457,124],{"id":123},[256,459,460,463,466,469],{},[218,461,462],{},"流程：标记存活对象 → 向一端整理压缩 → 清空末端内存",[218,464,465],{},"优点：无内存碎片、不浪费空间",[218,467,468],{},"缺点：需要移动对象，效率低",[218,470,451,471,474],{},[195,472,473],{},"老年代默认算法","（存活对象多、不适合复制）",[253,476,127],{"id":126},[256,478,479,482,485],{},[218,480,481],{},"JVM终极算法，整合以上三种",[218,483,484],{},"年轻代：标记复制",[218,486,487],{},"老年代：标记清除 + 标记整理",[243,489],{},[200,491,130],{"id":129},[206,493,494],{"language":208},[210,495,496],{"class":212},"垃圾收集器迭代演进 & 特性\n├─ Parallel GC（JDK8默认）→ 高吞吐、长停顿、后台批量任务\n├─ CMS（JDK8废弃\u002FJDK14移除）→ 低并发停顿、碎片多、浮动垃圾\n├─ G1 GC（JDK9默认）→ 分区回收、吞吐延迟平衡、大堆适配\n└─ ZGC\u002FShenandoah（JDK11+）→ 毫秒级低延迟、超大堆、高并发首选",[253,498,134],{"id":133},[256,500,501,507,510],{},[218,502,503,504],{},"多线程并行回收，追求",[195,505,506],{},"高吞吐量",[218,508,509],{},"适合后台业务、批量任务",[218,511,512],{},"停顿时间较长，不适合低延迟服务",[253,514,137],{"id":136},[256,516,517,520],{},[218,518,519],{},"追求低停顿，并发回收",[218,521,522],{},"缺点：内存碎片多、并发浮动垃圾、CPU占用高",[253,524,140],{"id":139},[256,526,527,530,533],{},[218,528,529],{},"分区回收，将堆划分为多个Region",[218,531,532],{},"兼顾吞吐量与低延迟，可设置最大停顿时间",[218,534,535],{},"适用于大内存堆服务",[253,537,143],{"id":142},[256,539,540,543,546],{},[218,541,542],{},"毫秒级停顿，几乎不卡顿",[218,544,545],{},"超大堆适配，JDK17、JDK25持续优化",[218,547,548],{},"互联网高并发、低延迟服务首选",[253,550,146],{"id":145},[191,552,553],{},[195,554,555],{},"ParallelGC(吞吐) → CMS(并发低延迟) → G1(平衡) → ZGC(极致低延迟)",[243,557],{},[200,559,149],{"id":148},[206,561,562],{"language":208},[210,563,564],{"class":212},"JDK8内存重大更替\n永久代PermGen（JDK7及以前）\n├─ 归属：堆内存一部分\n├─ 特点：固定大小、容量小、极易OOM\n└─ 存储：类元数据、常量池、静态变量\n\n元空间Metaspace（JDK8+ 全覆盖）\n├─ 归属：操作系统本地内存\n├─ 特点：动态扩容、无固定上限、无OOM风险\n└─ 存储：类\u002F方法\u002F字段元数据、运行时动态类信息",[253,566,153],{"id":152},[256,568,569,575],{},[218,570,571,574],{},[195,572,573],{},"永久代PermGen","：属于堆内存、固定大小、易OOM、JDK7及以前使用",[218,576,577,580],{},[195,578,579],{},"元空间Metaspace","：操作系统本地内存、动态扩容、无固定上限、JDK8+全覆盖",[253,582,156],{"id":155},[256,584,585,588,591],{},[218,586,587],{},"类、接口、注解、枚举的元数据信息",[218,589,590],{},"方法代码、字段信息、常量池",[218,592,593],{},"运行时动态生成的类（Spring CGLIB、动态代理）",[253,595,159],{"id":158},[256,597,598,601,604],{},[218,599,600],{},"彻底解决永久代OOM问题",[218,602,603],{},"本地内存不占用堆空间，堆内存利用率更高",[218,605,606],{},"动态伸缩，适配动态类加载场景",[243,608],{},[200,610,161],{"id":4},[206,612,613],{"language":208},[210,614,615],{"class":212},"类加载器层级 & 双亲委派流程\n加载层级（从上至下）\n├─ BootstrapClassLoader 启动类加载器（顶层）\n├─ ExtClassLoader 扩展类加载器\n└─ AppClassLoader 应用类加载器（底层）\n\n执行流程：向上委托，向下加载\n1. AppClassLoader 接收加载请求\n2. 逐级向上委托至 Bootstrap\n3. 上级无法加载，逐级下放由本级加载",[253,617,165],{"id":164},[215,619,620,626,632],{},[218,621,622,625],{},[195,623,624],{},"启动类加载器 BootstrapClassLoader","：顶层，加载JDK核心rt.jar等系统类",[218,627,628,631],{},[195,629,630],{},"扩展类加载器 ExtClassLoader","：加载JDK扩展包类",[218,633,634,637],{},[195,635,636],{},"应用类加载器 AppClassLoader","：加载项目自定义class、第三方依赖包",[253,639,168],{"id":167},[191,641,642],{},[195,643,644],{},"向上委托、向下加载",[215,646,647,650,653],{},[218,648,649],{},"应用类加载器收到加载请求，不直接加载，向上委托给扩展类加载器",[218,651,652],{},"扩展类加载器继续向上委托给启动类加载器",[218,654,655],{},"启动类加载器无法加载，向下逐层返回，由下层加载器加载",[253,657,171],{"id":170},[256,659,660,666],{},[218,661,662,665],{},[195,663,664],{},"沙箱安全机制","：防止恶意代码覆盖JDK核心类（如自定义java.lang.String）",[218,667,668,671],{},[195,669,670],{},"类全局唯一","：保证核心类只加载一次，避免重复加载、类冲突",[253,673,174],{"id":173},[191,675,676,677,680],{},"双亲委派是",[195,678,679],{},"默认规则，非强制机制","，可重写loadClass方法打破",[682,683,178],"h4",{"id":177},[256,685,686,692,698],{},[218,687,688,691],{},[195,689,690],{},"Tomcat","：自定义类加载器，隔离不同web应用包冲突",[218,693,694,697],{},[195,695,696],{},"JDBC SPI机制","：线程上下文类加载器，加载厂商实现类",[218,699,700,703],{},[195,701,702],{},"Spring、OSGI","：热部署、动态加载类，打破双亲委派",[243,705],{},[200,707,181],{"id":180},[256,709,710,715,721,730],{},[218,711,712,714],{},[195,713,371],{},"：新生代GC，频繁、速度快、无停顿或短停顿",[218,716,717,720],{},[195,718,719],{},"Major GC","：老年代GC，耗时较长",[218,722,723,726,727],{},[195,724,725],{},"Full GC","：整堆GC（新生代+老年代+元空间），STW全局暂停，",[195,728,729],{},"线上绝对避免",[218,731,732,735],{},[195,733,734],{},"STW","：Stop-The-World，GC期间暂停所有用户线程，是卡顿的根本原因",[243,737],{},[200,739,184],{"id":183},[256,741,742,748,754,760,766,772],{},[218,743,744,747],{},[195,745,746],{},"JVM结构","：类加载、运行时数据区、执行引擎、GC四大模块",[218,749,750,753],{},[195,751,752],{},"内存分区","：线程三私两共，JDK8废除永久代，改用本地内存元空间",[218,755,756,759],{},[195,757,758],{},"分代模型","：新生代8:1:1复制算法，老年代标记整理算法，对象随GC次数晋升",[218,761,762,765],{},[195,763,764],{},"GC算法","：清除有碎片、复制耗空间、整理无碎片效率低，分代收集综合最优",[218,767,768,771],{},[195,769,770],{},"收集器迭代","：Parallel吞吐、G1平衡、ZGC超低延迟",[218,773,774,777],{},[195,775,776],{},"双亲委派","：向上委托保证安全和类唯一，Tomcat\u002FSPI可打破实现隔离与动态加载"]