[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"$f1b300lqgtfmoj":3,"$f250wz8h39yydc":8,"$f3e13fn86h0z0l":29,"$f1tmzc20p7l0cb":37,"$f2bu6eybl4d1mv":72,"toc--642716340-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":47,"wordCount":75},"# Java8至25 对象创建全过程及各版本底层演进差异\n\n对象创建是Java最基础的核心流程，从JDK8到JDK25，HotSpot虚拟机对**对象分配、初始化、内存布局、逃逸优化、栈分配、隐式类**等核心逻辑做了多次重大重构。本文将统一梳理 `new Object()` 完整执行链路，并重点区分 **JDK8 经典流程**、**JDK9\\~17 优化迭代**、**JDK18\\~25 最新特性** 的核心差异，覆盖从编译、类加载、内存分配、零值初始化、对象头填充、构造方法执行的全流程。\n\n## 一、通用前置：对象创建触发场景\n\nJava中创建实例对象，核心触发方式均基于 `new` 关键字（不包含反射、clone、反序列化、Unsafe），标准代码形态：\n\n```java\nUser user = new User();\n```\n\n该代码会经历：**编译期语法处理 → 类加载验证 → 虚拟机指令解析 → 内存分配 → 初始化 → 引用赋值** 完整链路，不同JDK版本的核心差异集中在**内存分配策略、逃逸分析优化、对象头结构、栈上分配、隐式实例创建**。\n\n## 二、JDK8 对象创建完整流程（经典标准流程）\n\nJDK8 是最稳定、使用最广的经典版本，对象创建为**传统重量级分配流程**，无扁平化对象、无隐式类、无大规模栈分配优化，流程固定且透明。\n\n### 步骤1：编译期预处理（javac）\n\njavac 编译 `new User()`，生成两条核心字节码指令：\n\n- **new**：开辟对象内存、创建空对象实例（未初始化成员变量、未执行构造方法）\n\n- **invokespecial**：调用构造方法 \\\u003Cinit\\> 完成初始化\n\n注：JDK8 不会做编译期对象优化，所有对象创建逻辑均交由运行期JVM处理。\n\n### 步骤2：运行期类加载与校验\n\nJVM执行 new 指令时，首先检查 `User` 类是否已加载、链接、初始化：\n\n1. 未加载：触发**双亲委派**，完成加载、验证、准备、解析、初始化\n\n2. 已加载：直接获取类元数据（Klass），准备分配对象内存\n\n### 步骤3：内存分配（JDK8 核心逻辑）\n\nJDK8 对象内存分配优先级：**TLAB 优先分配 \\> 伊甸区空闲分配 \\> 老年代分配**\n\n1. **TLAB分配（首选）**：每个线程私有TLAB缓冲区，无锁分配，速度最快。绝大多数小对象、短生命周期对象均在此分配。\n\n2. **伊甸区公共分配**：TLAB空间不足时，使用CAS无锁方式在伊甸区剩余空间分配。\n\n3. **大对象直接进老年代**：超过TLAB阈值、伊甸区阈值的大对象（默认\\>1MB），直接分配到老年代，避免新生代GC复制开销。\n\nJDK8 **无栈上分配、无标量替换默认优化**（需手动开启参数），绝大多数对象分配在堆内存。\n\n### 步骤4：内存零值初始化\n\nJVM自动将分配的内存空间统一置零：成员变量默认赋初始值（int=0、boolean=false、引用=null），该步骤在构造方法执行前完成，保证对象内存安全性。\n\n### 步骤5：对象头（MarkWord\\+Klass指针）填充\n\nJDK8 堆对象头固定结构（64位JDK）：\n\n- MarkWord：64bit（存储哈希码、锁状态、GC分代年龄、偏向锁标记）\n\n- Klass指针：64bit（指向对象的类元数据）\n\n- 对齐填充：按需补全至8字节整数倍\n\n总计：对象头 **16字节起步**，无压缩指针时占用极高，开启指针压缩后为12字节。\n\n### 步骤6：执行构造方法 \\\u003Cinit\\>\n\n执行代码中自定义构造逻辑，完成成员变量显式赋值、初始化操作，覆盖默认零值。\n\n### 步骤7：引用赋值\n\n将堆中对象的内存地址，赋值给栈中的局部变量引用 `user`，对象创建完成。\n\n## 三、JDK9\\~JDK17 对象创建核心优化（迭代升级）\n\nJDK9 开始对对象模型、分配机制、逃逸分析做大规模优化，是从「传统笨重创建」到「轻量化创建」的过渡阶段，JDK17 作为LTS版本固化所有优化特性。\n\n### 1\\. 逃逸分析 \\& 标量替换默认开启\n\nJDK8 逃逸分析需要手动开启参数，**JDK9\\+ 默认开启**：\n\n- 方法内**未逃逸对象**：JVM不分配堆内存，直接拆解对象成员变量，在栈上分配标量值\n\n- 效果：完全省去堆分配、GC回收开销，大量局部临时对象实现「无堆创建」\n\n### 2\\. 偏向锁延迟初始化\n\nJDK8 启动即开启偏向锁，JDK15\\+ 修改为**延迟加载**：对象创建初期无偏向锁标记，仅当发生锁竞争时才初始化偏向状态，减少无锁对象的MarkWord初始化开销。\n\n### 3\\. 紧凑对象头优化\n\n优化64位虚拟机对象对齐规则，优化指针压缩逻辑，小幅降低小对象内存占用，提升内存利用率。\n\n### 4\\. 禁止大对象冗余分配\n\n优化大对象判定逻辑，修复JDK8大对象误判问题，减少老年代无效大对象堆积，降低Full GC概率。\n\n## 四、JDK18\\~JDK25 颠覆性对象创建特性（全新机制）\n\nJDK18 之后引入多项**革命性对象模型优化**，彻底改变传统 new 对象的底层逻辑，核心特性包含：**扁平化对象、隐式类、无实例对象、紧凑对象、虚拟线程适配分配**，全部在JDK25正式完备。\n\n### 1\\. 扁平化对象（Flat Objects \u002F JDK19\\+ 正式）\n\n彻底废弃JDK8传统对象嵌套结构，**值对象直接平铺存储**，无对象头冗余、无引用间接寻址：\n\n- 传统对象：成员为引用类型，需要二次寻址，内存碎片化严重\n\n- 扁平化对象：值类型成员直接嵌入当前对象内存，省去引用开销、提升缓存命中率\n\nJDK25 全面支持普通类、记录类的扁平化分配，大幅优化高并发小对象创建性能。\n\n### 2\\. 隐式类与隐式实例（JDK21\\+，JDK25完备）\n\n针对 `new 匿名内部类`、临时回调对象，JDK21\\+ 引入**隐式类机制**：\n\n- 不再生成独立的Class文件、不占用元空间\n\n- 临时对象无需完整类加载流程，直接由JVM动态生成实例\n\n- 极大减少临时小对象的创建、加载、销毁开销\n\n### 3\\. 无实例对象优化（No\\-Instance Allocation）\n\nJDK22\\+ 新增优化：对于**创建后仅读取、无状态修改、无引用逃逸**的纯临时对象，JVM直接**消除对象创建**，只保留逻辑运算，不分配任何内存，实现「零开销创建」。\n\n### 4\\. 虚拟线程适配的内存分配（JDK21\\+）\n\nJDK21虚拟线程落地后，JDK21\\~25 持续优化**轻量级对象分配器**：\n\n- 虚拟线程任务中的临时对象，使用专属轻量TLAB分配\n\n- 分配速度远超平台线程堆分配，适配百万级高并发对象创建场景\n\n- 减少虚拟线程上下文切换时的内存开销\n\n### 5\\. 废弃偏向锁（JDK25 默认关闭）\n\nJDK25 彻底默认关闭偏向锁，对象创建时**无需初始化偏向锁标记**，简化MarkWord结构，降低对象初始化开销，解决高并发下偏向锁撤销的性能卡顿问题。\n\n## 五、JDK8 \u002F JDK17 \u002F JDK25 对象创建核心差异对照表\n\n|对比维度|JDK8|JDK17（LTS）|JDK25（最新）|\n|---|---|---|---|\n|逃逸分析|默认关闭，需手动开启|默认开启，支持标量替换|深度优化，支持无对象消除|\n|对象内存模型|传统嵌套对象，冗余高|紧凑对象优化|扁平化对象，无嵌套冗余|\n|偏向锁机制|启动即初始化|延迟初始化|默认关闭，彻底移除冗余逻辑|\n|临时对象创建|完整堆分配，开销大|栈分配优化|隐式类\\+零开销消除|\n|虚拟线程适配|无|无|专属轻量分配器，高并发极致优化|\n|对象头大小|12\u002F16字节|12字节优化|扁平化对象大幅缩减|\n|GC开销|高，大量小对象堆分配|中，栈分配减少GC压力|极低，零创建\\+扁平化优化|\n\n## 六、各版本统一核心流程总结（最简主干）\n\n无论JDK8\\~25，对象创建**主干流程不变**，变化的只是底层优化策略：\n\n**编译生成new指令 → 类加载校验 → JVM内存分配（堆\u002F栈\u002F隐式） → 内存零初始化 → 填充对象头元数据 → 执行构造方法 → 引用赋值**\n\n核心演进趋势：**从「必须堆分配、固定对象结构、高开销」向「按需分配、动态优化、零冗余、零开销」迭代**。\n\n## 七、高频面试核心考点提炼\n\n- **JDK8对象创建一定会分配堆内存吗？** 不会，开启逃逸分析后可栈分配，但默认关闭；JDK17\\+默认开启，大量临时对象栈分配。\n\n- **new一定创建新对象吗？** JDK22\\+ 可通过无实例优化直接消除对象创建，逻辑存在、内存无分配。\n\n- **扁平化对象优势？** 消除引用嵌套、提升CPU缓存命中率、减少内存碎片、降低GC压力。\n\n- **JDK25最大变化？** 关闭偏向锁、完善扁平化对象、优化虚拟线程对象分配、隐式类全覆盖。","markdown",3786,{"frontmatter":77,"meta":78,"nodes":153},{},{"title":47,"description":79,"toc":80},"对象创建是Java最基础的核心流程，从JDK8到JDK25，HotSpot虚拟机对对象分配、初始化、内存布局、逃逸优化、栈分配、隐式类等核心逻辑做了多次重大重构。本文将统一梳理 new Object() 完整执行链路，并重点区分 JDK8 经典流程、JDK9~17 优化迭代、JDK18~25 最新特性 的核心差异，覆盖从编译、类加载、内存分配、零值初始化、对象头填充、构造方法执行的全流程。",{"title":4,"searchDepth":58,"depth":58,"links":81},[82,84,109,125,144,147,150],{"id":4,"depth":46,"text":83},"一、通用前置：对象创建触发场景",{"id":85,"depth":46,"text":86,"children":87},"jdk8","二、JDK8 对象创建完整流程（经典标准流程）",[88,91,94,97,100,103,106],{"id":89,"depth":50,"text":90},"jdk8-_1javac","步骤1：编译期预处理（javac）",{"id":92,"depth":50,"text":93},"jdk8-_2","步骤2：运行期类加载与校验",{"id":95,"depth":50,"text":96},"jdk8-_3jdk8","步骤3：内存分配（JDK8 核心逻辑）",{"id":98,"depth":50,"text":99},"jdk8-_4","步骤4：内存零值初始化",{"id":101,"depth":50,"text":102},"jdk8-_5markwordklass","步骤5：对象头（MarkWord+Klass指针）填充",{"id":104,"depth":50,"text":105},"jdk8-_6-init","步骤6：执行构造方法 \u003Cinit>",{"id":107,"depth":50,"text":108},"jdk8-_7","步骤7：引用赋值",{"id":110,"depth":46,"text":111,"children":112},"jdk9jdk17","三、JDK9~JDK17 对象创建核心优化（迭代升级）",[113,116,119,122],{"id":114,"depth":50,"text":115},"jdk9jdk17-_1","1. 逃逸分析 & 标量替换默认开启",{"id":117,"depth":50,"text":118},"jdk9jdk17-_2","2. 偏向锁延迟初始化",{"id":120,"depth":50,"text":121},"jdk9jdk17-_3","3. 紧凑对象头优化",{"id":123,"depth":50,"text":124},"jdk9jdk17-_4","4. 禁止大对象冗余分配",{"id":126,"depth":46,"text":127,"children":128},"jdk18jdk25","四、JDK18~JDK25 颠覆性对象创建特性（全新机制）",[129,132,135,138,141],{"id":130,"depth":50,"text":131},"jdk18jdk25-_1-flat-objects-jdk19","1. 扁平化对象（Flat Objects \u002F JDK19+ 正式）",{"id":133,"depth":50,"text":134},"jdk18jdk25-_2-jdk21jdk25","2. 隐式类与隐式实例（JDK21+，JDK25完备）",{"id":136,"depth":50,"text":137},"jdk18jdk25-_3-no-instance-allocation","3. 无实例对象优化（No-Instance Allocation）",{"id":139,"depth":50,"text":140},"jdk18jdk25-_4-jdk21","4. 虚拟线程适配的内存分配（JDK21+）",{"id":142,"depth":50,"text":143},"jdk18jdk25-_5-jdk25","5. 废弃偏向锁（JDK25 默认关闭）",{"id":145,"depth":46,"text":146},"jdk8-jdk17-jdk25","五、JDK8 \u002F JDK17 \u002F JDK25 对象创建核心差异对照表",{"id":148,"depth":46,"text":149},"-1","六、各版本统一核心流程总结（最简主干）",{"id":151,"depth":46,"text":152},"-2","七、高频面试核心考点提炼",[154,158,183,186,193,201,212,214,221,224,231,246,249,251,258,271,273,279,299,306,308,311,313,316,327,334,336,339,341,348,350,353,355,362,374,376,383,385,388,390,393,395,406,408,415,423,426,428,438,449,451,462,464,470,481,483,490,492,615,617,624,629,635,637],[155,156,47],"h1",{"id":157},"java825",[159,160,161,162,166,167,171,172,175,176,175,179,182],"p",{},"对象创建是Java最基础的核心流程，从JDK8到JDK25，HotSpot虚拟机对",[163,164,165],"strong",{},"对象分配、初始化、内存布局、逃逸优化、栈分配、隐式类","等核心逻辑做了多次重大重构。本文将统一梳理 ",[168,169,170],"code",{},"new Object()"," 完整执行链路，并重点区分 ",[163,173,174],{},"JDK8 经典流程","、",[163,177,178],{},"JDK9~17 优化迭代",[163,180,181],{},"JDK18~25 最新特性"," 的核心差异，覆盖从编译、类加载、内存分配、零值初始化、对象头填充、构造方法执行的全流程。",[184,185,83],"h2",{"id":4},[159,187,188,189,192],{},"Java中创建实例对象，核心触发方式均基于 ",[168,190,191],{},"new"," 关键字（不包含反射、clone、反序列化、Unsafe），标准代码形态：",[194,195,197],"pre",{"language":196},"java",[168,198,200],{"class":199},"language-java","User user = new User();",[159,202,203,204,207,208,211],{},"该代码会经历：",[163,205,206],{},"编译期语法处理 → 类加载验证 → 虚拟机指令解析 → 内存分配 → 初始化 → 引用赋值"," 完整链路，不同JDK版本的核心差异集中在",[163,209,210],{},"内存分配策略、逃逸分析优化、对象头结构、栈上分配、隐式实例创建","。",[184,213,86],{"id":85},[159,215,216,217,220],{},"JDK8 是最稳定、使用最广的经典版本，对象创建为",[163,218,219],{},"传统重量级分配流程","，无扁平化对象、无隐式类、无大规模栈分配优化，流程固定且透明。",[222,223,90],"h3",{"id":89},[159,225,226,227,230],{},"javac 编译 ",[168,228,229],{},"new User()","，生成两条核心字节码指令：",[232,233,234,240],"ul",{},[235,236,237,239],"li",{},[163,238,191],{},"：开辟对象内存、创建空对象实例（未初始化成员变量、未执行构造方法）",[235,241,242,245],{},[163,243,244],{},"invokespecial","：调用构造方法 \u003Cinit> 完成初始化",[159,247,248],{},"注：JDK8 不会做编译期对象优化，所有对象创建逻辑均交由运行期JVM处理。",[222,250,93],{"id":92},[159,252,253,254,257],{},"JVM执行 new 指令时，首先检查 ",[168,255,256],{},"User"," 类是否已加载、链接、初始化：",[259,260,261,268],"ol",{},[235,262,263,264,267],{},"未加载：触发",[163,265,266],{},"双亲委派","，完成加载、验证、准备、解析、初始化",[235,269,270],{},"已加载：直接获取类元数据（Klass），准备分配对象内存",[222,272,96],{"id":95},[159,274,275,276],{},"JDK8 对象内存分配优先级：",[163,277,278],{},"TLAB 优先分配 > 伊甸区空闲分配 > 老年代分配",[259,280,281,287,293],{},[235,282,283,286],{},[163,284,285],{},"TLAB分配（首选）","：每个线程私有TLAB缓冲区，无锁分配，速度最快。绝大多数小对象、短生命周期对象均在此分配。",[235,288,289,292],{},[163,290,291],{},"伊甸区公共分配","：TLAB空间不足时，使用CAS无锁方式在伊甸区剩余空间分配。",[235,294,295,298],{},[163,296,297],{},"大对象直接进老年代","：超过TLAB阈值、伊甸区阈值的大对象（默认>1MB），直接分配到老年代，避免新生代GC复制开销。",[159,300,301,302,305],{},"JDK8 ",[163,303,304],{},"无栈上分配、无标量替换默认优化","（需手动开启参数），绝大多数对象分配在堆内存。",[222,307,99],{"id":98},[159,309,310],{},"JVM自动将分配的内存空间统一置零：成员变量默认赋初始值（int=0、boolean=false、引用=null），该步骤在构造方法执行前完成，保证对象内存安全性。",[222,312,102],{"id":101},[159,314,315],{},"JDK8 堆对象头固定结构（64位JDK）：",[232,317,318,321,324],{},[235,319,320],{},"MarkWord：64bit（存储哈希码、锁状态、GC分代年龄、偏向锁标记）",[235,322,323],{},"Klass指针：64bit（指向对象的类元数据）",[235,325,326],{},"对齐填充：按需补全至8字节整数倍",[159,328,329,330,333],{},"总计：对象头 ",[163,331,332],{},"16字节起步","，无压缩指针时占用极高，开启指针压缩后为12字节。",[222,335,105],{"id":104},[159,337,338],{},"执行代码中自定义构造逻辑，完成成员变量显式赋值、初始化操作，覆盖默认零值。",[222,340,108],{"id":107},[159,342,343,344,347],{},"将堆中对象的内存地址，赋值给栈中的局部变量引用 ",[168,345,346],{},"user","，对象创建完成。",[184,349,111],{"id":110},[159,351,352],{},"JDK9 开始对对象模型、分配机制、逃逸分析做大规模优化，是从「传统笨重创建」到「轻量化创建」的过渡阶段，JDK17 作为LTS版本固化所有优化特性。",[222,354,115],{"id":114},[159,356,357,358,361],{},"JDK8 逃逸分析需要手动开启参数，",[163,359,360],{},"JDK9+ 默认开启","：",[232,363,364,371],{},[235,365,366,367,370],{},"方法内",[163,368,369],{},"未逃逸对象","：JVM不分配堆内存，直接拆解对象成员变量，在栈上分配标量值",[235,372,373],{},"效果：完全省去堆分配、GC回收开销，大量局部临时对象实现「无堆创建」",[222,375,118],{"id":117},[159,377,378,379,382],{},"JDK8 启动即开启偏向锁，JDK15+ 修改为",[163,380,381],{},"延迟加载","：对象创建初期无偏向锁标记，仅当发生锁竞争时才初始化偏向状态，减少无锁对象的MarkWord初始化开销。",[222,384,121],{"id":120},[159,386,387],{},"优化64位虚拟机对象对齐规则，优化指针压缩逻辑，小幅降低小对象内存占用，提升内存利用率。",[222,389,124],{"id":123},[159,391,392],{},"优化大对象判定逻辑，修复JDK8大对象误判问题，减少老年代无效大对象堆积，降低Full GC概率。",[184,394,127],{"id":126},[159,396,397,398,401,402,405],{},"JDK18 之后引入多项",[163,399,400],{},"革命性对象模型优化","，彻底改变传统 new 对象的底层逻辑，核心特性包含：",[163,403,404],{},"扁平化对象、隐式类、无实例对象、紧凑对象、虚拟线程适配分配","，全部在JDK25正式完备。",[222,407,131],{"id":130},[159,409,410,411,414],{},"彻底废弃JDK8传统对象嵌套结构，",[163,412,413],{},"值对象直接平铺存储","，无对象头冗余、无引用间接寻址：",[232,416,417,420],{},[235,418,419],{},"传统对象：成员为引用类型，需要二次寻址，内存碎片化严重",[235,421,422],{},"扁平化对象：值类型成员直接嵌入当前对象内存，省去引用开销、提升缓存命中率",[159,424,425],{},"JDK25 全面支持普通类、记录类的扁平化分配，大幅优化高并发小对象创建性能。",[222,427,134],{"id":133},[159,429,430,431,434,435,361],{},"针对 ",[168,432,433],{},"new 匿名内部类","、临时回调对象，JDK21+ 引入",[163,436,437],{},"隐式类机制",[232,439,440,443,446],{},[235,441,442],{},"不再生成独立的Class文件、不占用元空间",[235,444,445],{},"临时对象无需完整类加载流程，直接由JVM动态生成实例",[235,447,448],{},"极大减少临时小对象的创建、加载、销毁开销",[222,450,137],{"id":136},[159,452,453,454,457,458,461],{},"JDK22+ 新增优化：对于",[163,455,456],{},"创建后仅读取、无状态修改、无引用逃逸","的纯临时对象，JVM直接",[163,459,460],{},"消除对象创建","，只保留逻辑运算，不分配任何内存，实现「零开销创建」。",[222,463,140],{"id":139},[159,465,466,467,361],{},"JDK21虚拟线程落地后，JDK21~25 持续优化",[163,468,469],{},"轻量级对象分配器",[232,471,472,475,478],{},[235,473,474],{},"虚拟线程任务中的临时对象，使用专属轻量TLAB分配",[235,476,477],{},"分配速度远超平台线程堆分配，适配百万级高并发对象创建场景",[235,479,480],{},"减少虚拟线程上下文切换时的内存开销",[222,482,143],{"id":142},[159,484,485,486,489],{},"JDK25 彻底默认关闭偏向锁，对象创建时",[163,487,488],{},"无需初始化偏向锁标记","，简化MarkWord结构，降低对象初始化开销，解决高并发下偏向锁撤销的性能卡顿问题。",[184,491,146],{"id":145},[493,494,495,514],"table",{},[496,497,498],"thead",{},[499,500,501,505,508,511],"tr",{},[502,503,504],"th",{},"对比维度",[502,506,507],{},"JDK8",[502,509,510],{},"JDK17（LTS）",[502,512,513],{},"JDK25（最新）",[515,516,517,532,546,560,574,587,601],"tbody",{},[499,518,519,523,526,529],{},[520,521,522],"td",{},"逃逸分析",[520,524,525],{},"默认关闭，需手动开启",[520,527,528],{},"默认开启，支持标量替换",[520,530,531],{},"深度优化，支持无对象消除",[499,533,534,537,540,543],{},[520,535,536],{},"对象内存模型",[520,538,539],{},"传统嵌套对象，冗余高",[520,541,542],{},"紧凑对象优化",[520,544,545],{},"扁平化对象，无嵌套冗余",[499,547,548,551,554,557],{},[520,549,550],{},"偏向锁机制",[520,552,553],{},"启动即初始化",[520,555,556],{},"延迟初始化",[520,558,559],{},"默认关闭，彻底移除冗余逻辑",[499,561,562,565,568,571],{},[520,563,564],{},"临时对象创建",[520,566,567],{},"完整堆分配，开销大",[520,569,570],{},"栈分配优化",[520,572,573],{},"隐式类+零开销消除",[499,575,576,579,582,584],{},[520,577,578],{},"虚拟线程适配",[520,580,581],{},"无",[520,583,581],{},[520,585,586],{},"专属轻量分配器，高并发极致优化",[499,588,589,592,595,598],{},[520,590,591],{},"对象头大小",[520,593,594],{},"12\u002F16字节",[520,596,597],{},"12字节优化",[520,599,600],{},"扁平化对象大幅缩减",[499,602,603,606,609,612],{},[520,604,605],{},"GC开销",[520,607,608],{},"高，大量小对象堆分配",[520,610,611],{},"中，栈分配减少GC压力",[520,613,614],{},"极低，零创建+扁平化优化",[184,616,149],{"id":148},[159,618,619,620,623],{},"无论JDK8~25，对象创建",[163,621,622],{},"主干流程不变","，变化的只是底层优化策略：",[159,625,626],{},[163,627,628],{},"编译生成new指令 → 类加载校验 → JVM内存分配（堆\u002F栈\u002F隐式） → 内存零初始化 → 填充对象头元数据 → 执行构造方法 → 引用赋值",[159,630,631,632,211],{},"核心演进趋势：",[163,633,634],{},"从「必须堆分配、固定对象结构、高开销」向「按需分配、动态优化、零冗余、零开销」迭代",[184,636,152],{"id":151},[232,638,639,645,651,657],{},[235,640,641,644],{},[163,642,643],{},"JDK8对象创建一定会分配堆内存吗？"," 不会，开启逃逸分析后可栈分配，但默认关闭；JDK17+默认开启，大量临时对象栈分配。",[235,646,647,650],{},[163,648,649],{},"new一定创建新对象吗？"," JDK22+ 可通过无实例优化直接消除对象创建，逻辑存在、内存无分配。",[235,652,653,656],{},[163,654,655],{},"扁平化对象优势？"," 消除引用嵌套、提升CPU缓存命中率、减少内存碎片、降低GC压力。",[235,658,659,662],{},[163,660,661],{},"JDK25最大变化？"," 关闭偏向锁、完善扁平化对象、优化虚拟线程对象分配、隐式类全覆盖。"]