第 2 章 JVM 全景:规范、实现与生态版图
本章目标
- 彻底厘清一组被混用十年的名词:JVM 规范 / Java SE 平台 / OpenJDK / HotSpot / Oracle JDK / 各种发行版;
- 建立"JVM 是一台抽象机器,HotSpot 只是它最流行的一个实现"的心智模型;
- 认识 2026 年真实存在的 JVM 家族:HotSpot、GraalVM、OpenJ9、ART,以及国内主流发行版;
- 学会用命令行确认"我现在跑的到底是哪个 JVM、它支持什么"。
2.1 一个必须先纠正的常识错误
打开搜索引擎输入"JVM 内存结构",90% 的结果会给你这张图:
┌─────────────────────────────────────────────┐
│ JVM │
│ ┌───────────────────┐ ┌────────────────┐ │
│ │ 堆 (Heap) │ │ 方法区 │ │
│ │ ┌─────┬─────┐ │ │ (永久代) │ │
│ │ │新生代│老年代│ │ │ │ │
│ │ └─────┴─────┘ │ │ │ │
│ └───────────────────┘ └────────────────┘ │
│ ┌───────────────────────────────────────┐ │
│ │ 虚拟机栈 │ 本地方法栈 │ 程序计数器 │ │
│ └───────────────────────────────────────┘ │
└─────────────────────────────────────────────┘
这张图有三处错误,而且每一处都会在真实工作中咬你一口:
-
"方法区 = 永久代" ❌ 方法区(Method Area)是 JVM 规范定义的抽象概念(JVMS §2.5.4);永久代(PermGen)是 HotSpot 在 JDK 7 及之前的实现方式。JDK 8 起永久代被移除,实现改为元空间(Metaspace),位于本地内存,不属于堆。
👉 后果:
-XX:PermSize在 JDK 8+ 上被静默忽略(只打印一条 warning);OOM 信息从PermGen space变成Metaspace。 -
"程序计数器/虚拟机栈/本地方法栈是 JVM 的一部分,和堆并列" —— 说法不严谨。 规范里,堆和方法区是所有线程共享的,而虚拟机栈、本地方法栈、程序计数器是线程私有的、随线程创建销毁。把它们画在同一层会让人误以为它们是全局资源,从而无法理解"为什么线程开太多会
unable to create native thread"。 -
图里缺了三块真实存在且经常出问题的内存:
- 直接内存(Direct Memory):
ByteBuffer.allocateDirect分配,Netty/NIO 大量使用,不在堆内但计入进程 RSS; - 代码缓存(CodeCache):JIT 编译后的机器码存放处,满了会停止 JIT 编译(
CodeCache is full. Compiler has been disabled.),性能断崖式下跌; - 线程栈内存:每个线程默认 1MB(
-Xss),1000 个线程就是 1GB 本地内存。
- 直接内存(Direct Memory):
📌 正确的分层视角(本书后续章节都基于这张图):
┌──────────────────────────────────────────────────────────────────────┐
│ JVM 规范层(JVMS / JLS / Java SE 27 API) │
│ —— 定义"必须做什么":class 文件格式、字节码语义、内存区域概念、 │
│ 类加载流程、JMM(在 JLS 第 17 章) │
└──────────────────────────────────────────────────────────────────────┘
▲ 实现
┌──────────────────────────────────────────────────────────────────────┐
│ HotSpot VM 实现层(OpenJDK 的 src/hotspot/) │
│ │
│ ┌─────────────┐ ┌────────────────────────────────────────────────┐ │
│ │ 类加载子系统 │ │ 运行时数据区(HotSpot 实现) │ │
│ │ ClassLoader │ │ ┌──────────────────────┐ ┌──────────────────┐ │ │
│ │ + JPMS 模块 │ │ │ Java Heap(GC 管理) │ │ Metaspace │ │ │
│ │ 层 │ │ │ Young: Eden/S0/S1 │ │ (本地内存, │ │ │
│ │ │ │ │ Old │ │ 类元数据+常量池)│ │ │
│ │ │ │ └──────────────────────┘ └──────────────────┘ │ │
│ │ │ │ ┌────────────────────────────────────────────┐ │ │
│ │ │ │ │ 线程私有:Java Stack | Native Stack | PC │ │ │
│ │ │ │ └────────────────────────────────────────────┘ │ │
│ │ │ │ ┌──────────────┐ ┌───────────────┐ ┌─────────┐│ │
│ │ │ │ │ CodeCache │ │ Direct Memory │ │ GC 结构 ││ │
│ │ │ │ │ (JIT 机器码) │ │ (NIO/Netty) │ │ (卡表等) ││ │
│ │ │ │ └──────────────┘ └───────────────┘ └─────────┘│ │
│ └─────────────┘ └────────────────────────────────────────────────┘ │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ 执行引擎:解释器(Template) + C1 + C2(或 Graal)+ 分层编译 │ │
│ │ GC:G1(默认) / ZGC / Shenandoah / Parallel / Serial / Epsilon │ │
│ │ 服务:JFR / JVMTI / JMX / NMT / AOT Cache / Safepoint │ │
│ └────────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────────┘
▲ 打包 + 商业支持 + 平台适配
┌──────────────────────────────────────────────────────────────────────┐
│ 发行版层:Oracle JDK / Temurin / Corretto / Zulu / Liberica / │
│ Microsoft Build / Red Hat / Dragonwell / Kona / 毕昇 / │
│ Semeru(OpenJ9) / GraalVM / JetBrains Runtime │
└──────────────────────────────────────────────────────────────────────┘
2.2 规范、平台、实现、发行版:四层关系
第一层:规范(Specification)
| 文档 | 内容 | 现状 |
|---|---|---|
| JVMS《Java Virtual Machine Specification, Java SE 27 Edition》 | class 文件格式、字节码指令集与语义、运行时数据区、类加载与链接、异常处理 | 每版 Java SE 同步更新,JSR 402 对应 SE 27 |
| JLS《Java Language Specification》 | Java 语言语法与语义;第 17 章是 Java 内存模型(JMM) | 与 JVMS 配套 |
| Java SE API 规范 | java.* / javax.* 的 API 契约 | 通过 JCP(JSR)管理 |
🔬 一个关键认知:JMM 定义在 JLS 里,不在 JVMS 里。它是语言级规范,但因为 Kotlin/Scala 也编译到同一 JVM,所以它们共享同一套 JMM。这就是第 1 章说的"换语言不换虚拟机,规则一条不变"的法律依据。
⚠️ 字节码不等于 JVM 规范的全部。规范只定义了"合法 class 文件的行为",而没有定义:
- GC 算法(规范里根本没有"垃圾回收器"的概念,只要求"自动存储管理");
- JIT 编译(规范甚至不要求存在编译器,纯解释器也是合法实现);
- 对象内存布局(规范完全没有规定对象头!Mark Word、压缩指针全是 HotSpot 的实现细节);
- 线程如何映射到 OS 线程。
👉 这解释了一个重要现象:为什么"对象头 12 字节"这种知识不是 Java 知识,而是 HotSpot 知识。换到 OpenJ9 或 Native Image,布局完全不同。第 27 章会展开。
第二层:OpenJDK(参考实现的源码)
OpenJDK 是一个开源项目,它产出的就是 Java SE 的参考实现(RI)。JDK 27 的 RI 于 2026-09-15 GA。
关键事实:
- 自 JDK 11 起,Oracle JDK 与 OpenJDK 在功能上完全一致(Oracle 把商业特性如 Java Flight Recorder、Mission Control 全部开源了)。差异只剩许可证与支持周期。
- Oracle JDK 从 JDK 17 起采用 NFTC 许可(生产免费),从 JDK 21 起改为 OTN + NFTC 组合,具体条款随版本变化,企业使用前务必让法务确认。
- 📌 这就是为什么绝大多数公司用 Eclipse Temurin(原 AdoptOpenJDK,由 Eclipse Adoptium 工作组维护):GPLv2+CE 许可,无商业风险,TCK 认证通过。
第三层:JVM 实现
HotSpot 是 OpenJDK 中默认且几乎唯一的 JVM 实现(历史上还有 Zero/Shark 用于无 JIT 的平台移植,现已边缘化)。
其他实现:
| 实现 | 维护方 | 特点 | 2026 状态 |
|---|---|---|---|
| HotSpot | OpenJDK | 分层编译(C1+C2)、G1/ZGC/Shenandoah、JFR、Leyden AOT | 绝对主流 |
| Eclipse OpenJ9 | Eclipse(源自 IBM J9) | 内存占用更小、启动更快、共享类缓存(SCC)、多种 GC(gencon/balanced/metronome) | 用于 IBM Semeru Runtime;社区活跃度低于 HotSpot |
| GraalVM (HotSpot + Graal JIT) | Oracle | 用 Java 写的 JIT 编译器,通过 JVMCI 替换 C2 | 活跃 |
| GraalVM Native Image (SubstrateVM) | Oracle | AOT 编译成原生可执行文件,无 JIT,启动毫秒级 | 活跃,云原生首选之一 |
| ART | Google/Android | 运行 DEX 而非 class;解释 + JIT + Profile-Guided AOT(安装时/空闲时编译);分代 GC | Android 唯一 |
| JamVM / Cacao / Jikes RVM / MaxineVM | 学术/社区 | 研究型 JVM | 基本不用于生产 |
| Apache Harmony | 已终止 | Android 早期类库来源,引发 Oracle v. Google 诉讼 | 历史 |
🔬 GraalVM 的两种形态必须分清(这是最常见的混淆):
GraalVM
├── 形态 A:GraalVM for JDK(一个 JDK 发行版)
│ ├── HotSpot VM(还是 HotSpot!)
│ ├── Graal 编译器(Java 写的 JIT,通过 JVMCI 插入,替换 C2)
│ ├── Truffle(语言实现框架,可跑 JS/Python/Ruby/R)
│ └── 完整 JIT 能力,可以运行任何 Java 程序
│
└── 形态 B:Native Image(一个 AOT 编译工具)
├── 编译期做**封闭世界假设**:静态分析所有可达代码
├── 产出**独立可执行文件**,不需要 JVM
├── 运行时是 SubstrateVM(含 Serial GC 或 G1)
├── 启动 ~20ms,内存 ~30MB
└── ❌ 无 JIT(峰值性能通常低于 HotSpot 长跑)
❌ 反射/动态代理/资源需要配置(reachability-metadata)
❌ 不支持运行时动态类加载
📌 GraalVM 的发布节奏在 2026 年有调整(与 JDK 版本对齐策略变化),使用前请查 graalvm.org/downloads。
"在 GraalVM 上跑得快,在 HotSpot 上慢"是真的吗? 是真的,但需要精确表述:
- Graal JIT 用 Java 写,代码可维护性远好于 C++ 的 C2,能做更激进的优化(部分逃逸分析、更好的内联策略);在长时运行、计算密集场景可能优于 C2。
- 但 C2 经过 20 年打磨,在许多常见模式上依然极强,且 Graal JIT 本身的编译开销更大(用 Java 编译 Java)。
- Native Image 完全是另一个故事:启动快 10–100 倍,内存省 5 倍,但峰值吞吐通常低于充分预热的 HotSpot(无 JIT,无 Profile 驱动的优化)。
👉 第 29 章(JIT 与 AOT)会用同一份基准代码,在 HotSpot C2 / Graal JIT / Native Image 三种模式下实测对照,并给出选型决策树。
第四层:发行版(Distribution)
同一个 OpenJDK 源码,不同厂商构建出的产品:
| 发行版 | 厂商 | 许可 | 特色 |
|---|---|---|---|
| Eclipse Temurin | Eclipse Adoptium | GPLv2+CE | 社区标准,TCK 认证,多平台(含 aarch64、Windows、macOS、Alpine musl) |
| Oracle JDK | Oracle | NFTC/OTN | 官方,长期支持政策明确 |
| Oracle GraalVM | Oracle | NFTC | 含 Native Image,免费生产使用 |
| Amazon Corretto | AWS | GPLv2+CE | AWS 生态优化,长期免费支持,含 Corretto 特有补丁 |
| Azul Zulu / Azul Prime | Azul | GPLv2+CE / 商业 | Prime(原 Zing)含 C4 无暂停 GC 与 ReadyNow!(AOT 编译缓存),金融/低延迟场景 |
| BellSoft Liberica | BellSoft | GPLv2+CE | 提供 Liberica Native Image Kit(Nik)、桌面版含 JavaFX |
| Microsoft Build of OpenJDK | Microsoft | GPLv2+CE | Azure 优化 |
| Red Hat build of OpenJDK | Red Hat | GPLv2+CE | RHEL/OpenShift 集成 |
| IBM Semeru | IBM | GPLv2+CE / 商业 | 有 OpenJ9 版和 HotSpot 版两种 |
| Alibaba Dragonwell | 阿里 | GPLv2+CE | Wisp 协程(早于 Loom 的用户态线程)、JWarmup(提前编译)、ElasticHeap |
| Tencent Kona | 腾讯 | GPLv2+CE | 云原生优化 |
| Huawei 毕昇 JDK | 华为 | GPLv2+CE | aarch64 深度优化、AOT 加速 |
| JetBrains Runtime (JBR) | JetBrains | GPLv2+CE | IntelliJ/Android Studio 自带,含 JCEF(内嵌 Chromium)、渲染优化 |
🚀 选型建议(2026):
- 通用服务端:Temurin 或 Corretto(免费、稳定、社区大);
- 需要 Native Image:Oracle GraalVM 或 Liberica Nik;
- 极低延迟(<10ms 停顿)金融交易:Azul Prime(C4 GC)或 HotSpot + 分代 ZGC;
- 国产化/aarch64:毕昇 JDK 或 Dragonwell;
- 内存极度敏感的 Serverless:Native Image 或 OpenJ9 + SCC。
2.3 class 文件版本:一个能立刻用上的知识
每个 .class 文件开头 8 个字节:
CAFEBABE 0000 0045
↑ ↑ ↑
魔数 次版本 主版本(major version)
major version = JDK 版本号 + 44:
| JDK | major | 十六进制 | JDK | major | 十六进制 |
|---|---|---|---|---|---|
| 1.1 | 45 | 0x2D | 17 | 61 | 0x3D |
| 5 | 49 | 0x31 | 21 | 65 | 0x41 |
| 6 | 50 | 0x32 | 24 | 68 | 0x44 |
| 7 | 51 | 0x33 | 25 | 69 | 0x45 |
| 8 | 52 | 0x34 | 26 | 70 | 0x46 |
| 11 | 55 | 0x37 | 27 | 71 | 0x47 |
| 15 | 59 | 0x3B |
🧪 实验 2-1:不用 javap,直接读魔数
# Kotlin 编译产物
kotlinc Hello.kt -d out -jvm-target 27
xxd out/HelloKt.class | head -1
# 00000000: cafe babe 0000 0047 ... ← 0x47 = 71 = JDK 27
# 改 jvm-target
kotlinc Hello.kt -d out8 -jvm-target 1.8
xxd out8/HelloKt.class | head -1
# 00000000: cafe babe 0000 0034 ... ← 0x34 = 52 = JDK 8
⚠️ Unsupported class file major version 71 是升级 JDK 后最常见的错误。它意味着某个工具(Gradle 插件、字节码库、APM agent)不认识新版本字节码。解决顺序:
- 升级 Gradle(9.x 才完整支持 JDK 27);
- 升级 ASM / ByteBuddy / CGLIB(它们必须显式支持新 major version);
- 升级 APM/Agent(SkyWalking、Pinpoint、Arthas 等);
- 实在不行,临时把
jvmTarget降到 21(LTS),字节码向下兼容,JDK 27 能跑 21 的 class。
📌 注意 jvmTarget 与 --release 的区别(第 5 章详谈):
jvmTarget = 27:只影响字节码版本,编译时仍可能引用 JDK 28 的 API;javac --release 27:同时约束字节码版本 + API 签名,跨版本编译更安全。- Kotlin 2.4 起 Maven 会自动对齐两者,Gradle 需要手动配置。
2.4 JVM 启动到底发生了什么
java -jar app.jar 这条命令背后:
1. shell 执行 java(一个原生 C 程序:jdk/src/java.base/share/native/launcher/main.c)
│
2. launcher 解析命令行参数,分成三类:
├── 标准参数(-cp, -jar, -D, -X*)
├── -X 非标准参数(-Xmx, -Xss)—— 不保证跨实现
└── -XX 不稳定参数 —— 随时可能变更/移除
│
3. 定位并加载 libjvm.so / jvm.dll
│
4. 调用 JNI_CreateJavaVM()
├── 解析所有 -XX flag,初始化全局配置
├── 初始化 GC(选择 G1,创建堆,划分 Region)
├── 初始化 Metaspace、CodeCache、线程结构
├── 创建主线程(JavaThread)
├── 初始化 java.lang 核心类(Object/Class/String/System/Thread...)
│ ← 这些是"引导类",由 JVM 内部直接创建,不走常规类加载
├── 创建三层 ClassLoader:Bootstrap / Platform / Application
└── 📌 若存在 AOT 缓存(-XX:AOTCache=app.aot),
直接从缓存 mmap 类元数据与堆对象(JEP 483/514/516)
│
5. 加载主类,执行链接(验证、准备、解析)
│
6. 初始化主类(执行 <clinit>)
│
7. 调用 main 方法
├── 📌 JDK 25+(JEP 512):main 可以是实例方法、可以无参数、
│ 类可以是"紧凑源文件"(无 class 声明、无 package)
│
8. 解释器开始逐条执行字节码
│
9. 方法调用计数 + 回边计数超过阈值 → 分层编译介入
├── Level 0:解释执行
├── Level 1:C1,无 Profile(简单方法)
├── Level 2:C1,有限 Profile
├── Level 3:C1,完整 Profile(为 C2 收集数据)
└── Level 4:C2,基于 Profile 的激进优化
│
10. 应用运行;JFR/JMX/JVMTI 提供服务
🧪 实验 2-2:观察你的 JVM 的真实身份与配置
# 方式一:启动参数
java -XX:+PrintFlagsFinal -version | head -30
java -XX:+PrintFlagsFinal -version | grep -E "^\s+(bool|intx|uintx|size_t).*(UseG1GC|UseCompressedOops|UseCompactObjectHeaders|MaxHeapSize|ReservedCodeCacheSize|TieredCompilation)"
# 方式二:运行中查询(最全面)
jcmd <pid> VM.info # HotSpot 的详细状态
jcmd <pid> VM.flags # 生效的 flag
jcmd <pid> VM.command_line # 启动命令
jcmd <pid> VM.version
# 方式三:程序内查询
import java.lang.management.ManagementFactory
fun main() {
val rt = ManagementFactory.getRuntimeMXBean()
println("VM name : ${System.getProperty("java.vm.name")}")
println("VM version : ${System.getProperty("java.vm.version")}")
println("VM vendor : ${System.getProperty("java.vm.vendor")}")
println("Spec ver : ${System.getProperty("java.vm.specification.version")}")
println("输入参数 : ${rt.inputArguments}")
println("ClassPath : ${rt.classPath}")
println("BootClassPath 支持? ${rt.isBootClassPathSupported}")
}
预期输出(Temurin 27):
VM name : OpenJDK 64-Bit Server VM
VM version : 27+37-LTS (mixed mode, sharing)
Spec ver : 27
🔍 注意 mixed mode, sharing:
mixed mode= 解释器 + JIT 混合执行(对应-Xmixed,默认);sharing= CDS(Class Data Sharing)已启用,java.base的类元数据从共享归档classes.jsa映射进来,加速启动;-Xint是纯解释模式(调试用,慢 10–100 倍);-Xcomp是纯编译模式(几乎从不用,因为失去了 Profile 驱动的优化)。
🧪 实验 2-3:感受 CDS 与 AOT 缓存的威力
# 基线:关闭 CDS
java -Xshare:off -version
# 默认:CDS 开启
java -Xshare:on -version
# 创建 AOT 缓存(JDK 24+ 的简化流程,JEP 514)
java -XX:CacheDataStore=app.aot -cp app.jar com.example.Main --some-warmup-args
java -XX:AOTCache=app.aot -cp app.jar com.example.Main
📌 JDK 25/26 的 Leyden 进展:
- JEP 514(25):把"训练运行 → 生成缓存 → 使用缓存"简化成
-XX:CacheDataStore/-XX:AOTCache两个参数; - JEP 515(25):AOT Method Profiling——把训练运行收集的方法 Profile 也存进缓存,让 JVM 启动后立刻就能做 C2 级别的优化,大幅缩短"预热期";
- JEP 516(26):AOT Object Caching with Any GC——之前缓存里的堆对象布局与 GC 绑定(压缩指针、ZGC 染色指针、紧凑对象头都会改变布局),现在解耦了,任意 GC 都能用同一个缓存。
👉 这对 Spring Boot / Kotlin 服务端意义重大:启动时间可从秒级降到百毫秒级,是 Native Image 之外的另一条路。第 25 章和第 43 章会做完整实测对比。
2.5 JVM 参数的三个等级
这个知识在排查问题时极其有用:
| 等级 | 前缀 | 保证 | 例子 |
|---|---|---|---|
| 标准参数 | 无 | 所有实现必须支持,向后兼容 | -cp -jar -D -verbose:gc -version |
| 非标准参数 | -X | HotSpot 特有,可能变更 | -Xmx -Xms -Xss -Xmn |
| 不稳定参数 | -XX | 随时可能移除或改变默认值 | -XX:+UseG1GC -XX:MaxMetaspaceSize |
🧪 实验 2-4:列出所有 -XX 参数
java -XX:+PrintFlagsFinal -version | wc -l # JDK 27 上通常 800+ 个
java -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal -version | wc -l # 加上诊断参数,1000+
java -XX:+UnlockExperimentalVMOptions -XX:+PrintFlagsFinal -version | wc -l
⚠️ -XX 参数的默认值随版本变化是大量"升级后性能变差"的根因。典型例子:
| 参数 | 变化 |
|---|---|
UseG1GC | JDK 9 起服务端默认;📌 JDK 27 起在所有环境默认(JEP 523),包括小内存容器 |
UseCompactObjectHeaders | 📌 JDK 25 引入(需手动开);JDK 27 默认 true(JEP 534) |
UseBiasedLocking | JDK 15 起默认 false 并废弃(JEP 374),后续版本移除 |
UseCompressedClassPointers | 📌 JDK 25 起废弃(紧凑对象头下类指针内联进对象头) |
ZGenerational | 分代 ZGC 成为唯一形态后,此参数失去意义 |
MaxRAMPercentage | 容器环境推荐用它而非 -Xmx(默认 25%,建议调到 50–75%) |
🚀 升级 JDK 的必做动作:在旧版本和新版本上分别跑 jcmd <pid> VM.flags,diff 一遍。这比读一百篇升级指南都管用。
2.6 字节码:JVM 生态的真正基石
"JVM 语言"的准确定义是:能编译成合法 class 文件的语言。
┌──────────────────────────┐
Kotlin ──────────►│ │
Java ────────────►│ │
Scala ───────────►│ JVM Bytecode │──► 任何 JVM 实现
Groovy ─────────►│ (.class, JVMS 定义) │ (HotSpot / GraalVM /
Clojure ────────►│ │ OpenJ9 / ...)
JRuby/Jython ───►│ │
Ceylon/Fantom ──►│ │
└──────────────────────────┘
▲
字节码操作库(运行时生成)
ASM / ByteBuddy / Javassist / CGLIB
这个"一层抽象"带来两个巨大后果:
后果一:所有 JVM 语言共享同一套运行时规则
Kotlin 的 @Volatile 和 Java 的 volatile 编译成同一个字段访问标志 ACC_VOLATILE,JVM 用同一套内存屏障处理。所以:
- Kotlin 的 DCL 单例必须加
@Volatile; - Kotlin 的
HashMap就是java.util.HashMap,所有并发问题一模一样; - Kotlin 的 GC 行为完全由 JVM 决定,语言层无能为力。
🔬 验证方法:把 Kotlin 编译产物用 IDEA 的 Show Kotlin Bytecode → Decompile 反编译回 Java,你会发现它几乎就是一份等价的 Java 代码。这是本书最常用的分析手段,第 20 章会系统使用。
后果二:字节码操作是 JVM 生态的隐形地基
你每天用的框架,几乎都在改字节码:
| 技术 | 用途 | 底层 |
|---|---|---|
| Spring AOP | 事务、缓存、安全 | CGLIB(子类化)/ JDK 动态代理 |
| Hibernate | 懒加载实体 | ByteBuddy 生成代理类 |
| Mockito/MockK | 单元测试 mock | ByteBuddy / Java Agent |
| Lombok | 编译期生成 getter/setter | 注解处理器 + javac AST 侵入(不是字节码) |
| Kotlin kapt/KSP | 注解处理 | kapt 走 javac stub 生成;KSP 直接分析 Kotlin 符号,快 2–5 倍 |
| APM Agent(SkyWalking/Arthas) | 无侵入监控 | JVMTI + Java Instrumentation API,运行时 retransform 字节码 |
| Jacoco | 覆盖率 | 字节码插桩 |
| R8/ProGuard | Android 优化 | dex 层面的缩减/混淆/优化 |
⚠️ JPMS 与这些技术的冲突:JDK 9 引入模块系统后,--illegal-access=permit 一度让反射访问 JDK 内部继续工作;JDK 16 改为 deny(JEP 396),JDK 17 起强封装成为默认且不可关闭(JEP 403)。于是所有依赖 Deep Reflection 的框架都必须显式声明:
--add-opens java.base/java.lang=ALL-UNNAMED
--add-opens java.base/java.util=ALL-UNNAMED
📌 JDK 26 的 JEP 500 又收紧了一步:反射修改 final 字段开始报警告,未来默认禁止。依赖此行为的序列化框架(部分老版本 Kryo、Hessian)需要迁移到 sun.reflect.ReflectionFactory。
👉 这一条线索串起了三章:第 19 章(注解与反射)、第 22 章(Kotlin 与现代 JVM 特性)、第 25 章(类加载与模块)。
2.7 Android 上的 Kotlin:ART 不是 JVM
Kotlin 在 Android 上是一等公民(Google 2019 年宣布 Kotlin-first),但 Android 的运行时不是 JVM:
| 维度 | JVM (HotSpot) | ART (Android Runtime) |
|---|---|---|
| 输入格式 | .class | .dex(多个 class 合并,常量池共享) |
| 构建流程 | kotlinc → class → jar | kotlinc → class → D8/R8 → dex → apk |
| 执行方式 | 解释 + C1/C2 JIT | 解释 + JIT + Profile-Guided AOT(安装时/充电时空闲编译成 .oat) |
| 内存管理 | 分代 GC,堆可调 | 分代 GC,堆上限由设备决定(ActivityManager.getMemoryClass(),常见 128–512MB) |
| 方法数限制 | 无 | 单个 dex 65536 个方法引用(MultiDex 解决;minSdk 21+ 原生支持) |
| 标准库 | java.* 完整 | Android SDK 提供子集(java.* 大部分可用,但无 java.awt、部分 NIO 缺失;核心库来自 OpenJDK,历史上来自 Apache Harmony) |
| 反射/动态代理 | 完整 | 有限(R8 会裁剪未引用的类,需 keep 规则) |
| 虚拟线程 | ✅ JDK 21+ | ❌ 不支持(ART 没有 Loom) |
🚀 对 Kotlin 服务端开发者的三个提醒:
kotlinx.coroutines在 Android 与 JVM 上是同一套 API,但底层调度不同。Android 有Dispatchers.Main(基于Handler),JVM 上没有(除非引入kotlinx-coroutines-android)。- Android 上没有虚拟线程,所以"协程 vs 虚拟线程"的选型问题只存在于服务端。Android 上协程是唯一现代选择。
- R8 会内联、重命名、移除代码,导致基于反射的库(Gson 的老式反射、部分 DI 框架)失效。Android 上应优先使用 KSP + kotlinx.serialization,而非运行时反射。
2.8 Kotlin 跑在哪些目标上
Kotlin 不只是 JVM 语言。2026 年的 Kotlin 是一个多后端语言:
Kotlin 源码 (.kt)
│
┌───────┴────────┐
│ K2 编译器 │
│ FIR(前端 IR) │
└───────┬────────┘
┌───────────┬───────────┼───────────┬────────────┬──────────┐
▼ ▼ ▼ ▼ ▼ ▼
JVM 后端 JS 后端 Wasm 后端 Native 后端 (Cljs 等)
│ │ │ │
.class 文件 .js 文件 .wasm 文件 LLVM IR → 机器码
│ │ │ │
任何 JVM Node/浏览器 浏览器(WasmGC) iOS/macOS/Linux/
+ Component Android NDK/
Model(实验) 嵌入式
| 后端 | 目标 | 成熟度(2026-10) | 关键事实 |
|---|---|---|---|
| Kotlin/JVM | 服务端、Android、桌面 | ✅ Stable | 本书主线 |
| Kotlin/JS | 浏览器、Node.js | ✅ Stable | IR 编译器;可导出 TypeScript 定义 |
| Kotlin/Wasm | WebAssembly | 🔶 Beta | 📌 2.2 分离 Wasm 目标;2.3 默认启用新异常处理提案与全限定名;2.4 默认开启增量编译 + 支持 Component Model;依赖浏览器 WasmGC 支持 |
| Kotlin/Native | iOS/macOS/Linux/Windows/嵌入式 | ✅ Stable | 基于 LLVM;📌 2.2 升到 LLVM 19;📌 2.4 起 CMS GC 默认启用(取代旧的 Stop-the-world Mark & Concurrent Sweep);Swift Export 在 2.4 转 Alpha;2.4 支持直接依赖 Swift Package |
| Kotlin Multiplatform (KMP) | 跨平台共享代码 | ✅ Stable(1.9.20 起) | expect/actual 机制;📌 Compose Multiplatform 1.10 支持 iOS/桌面/Web |
📌 Kotlin/Native 的 GC 是个有趣话题:它不是 JVM 的 GC,而是 Kotlin 自己实现的。演进路线是:旧的 MM(Stop-the-world mark + concurrent sweep)→ 并行标记(2.0.20)→ CMS GC(2.4 默认)。所以"JVM 原理"这部分知识不能直接迁移到 Kotlin/Native——这也是第 48 章要专门提醒的。
2.9 一个实用技能:快速判断"我在哪个 JVM 上"
生产排查时,第一件事永远是确认运行时环境。这段代码值得存进你的工具箱:
package book.ch02
import java.lang.management.ManagementFactory
import java.lang.management.MemoryType
object JvmProbe {
fun report(): String = buildString {
val rt = ManagementFactory.getRuntimeMXBean()
val os = ManagementFactory.getOperatingSystemMXBean()
val comp = ManagementFactory.getCompilationMXBean()
appendLine("═".repeat(64))
appendLine(" JVM 身份")
appendLine("═".repeat(64))
appendLine(" java.vm.name : ${System.getProperty("java.vm.name")}")
appendLine(" java.vm.vendor : ${System.getProperty("java.vm.vendor")}")
appendLine(" java.vm.version : ${System.getProperty("java.vm.version")}")
appendLine(" java.version : ${System.getProperty("java.version")}")
appendLine(" 规范版本 : ${System.getProperty("java.vm.specification.version")}")
appendLine(" JIT 编译器 : ${comp?.name ?: "无(解释模式)"}")
appendLine(" 运行模式 : ${rt.inputArguments.filter { it.startsWith("-X") }}")
appendLine()
appendLine(" 运行环境")
appendLine("─".repeat(64))
appendLine(" OS / Arch : ${os.name} ${os.version} / ${os.arch}")
appendLine(" 可用处理器 : ${os.availableProcessors}")
appendLine(" 容器内? : ${isInContainer()}")
appendLine(" PID / Uptime : ${rt.pid()} / ${rt.uptime / 1000}s")
appendLine()
appendLine(" 内存池")
appendLine("─".repeat(64))
ManagementFactory.getMemoryPoolMXBeans()
.sortedBy { it.type }
.forEach { pool ->
val t = if (pool.type == MemoryType.HEAP) "HEAP " else "NONHEAP"
appendLine(" [$t] ${pool.name.padEnd(28)} " +
"used=${mb(pool.usage.used)} max=${mb(pool.usage.max)}")
}
appendLine()
appendLine(" 垃圾回收器")
appendLine("─".repeat(64))
ManagementFactory.getGarbageCollectorMXBeans().forEach { gc ->
appendLine(" ${gc.name.padEnd(28)} count=${gc.collectionCount} time=${gc.collectionTime}ms")
}
appendLine("═".repeat(64))
}
private fun mb(bytes: Long): String =
if (bytes < 0) "unlimited" else "${bytes / 1024 / 1024}MB"
/** 检测容器:cgroup 限制 或 /.dockerenv 存在 */
private fun isInContainer(): Boolean {
if (java.io.File("/.dockerenv").exists()) return true
return runCatching {
val cg = java.io.File("/proc/1/cgroup").readText()
cg.contains("docker") || cg.contains("kubepods") || cg.contains("containerd")
}.getOrDefault(false)
}
}
fun main() {
println(JvmProbe.report())
// Kotlin 侧信息
println(" Kotlin 版本 : ${KotlinVersion.CURRENT}")
println(" Kotlin 是否支持 : isAtLeast(2,4) = ${KotlinVersion.CURRENT.isAtLeast(2, 4)}")
}
🧪 实验 2-5:在容器中观察 CPU 感知
# 限制 2 核 1GB
docker run --cpus=2 -m 1g --rm -v $PWD:/app -w /app eclipse-temurin:27-jdk \
java -cp app.jar book.ch02.JvmProbeKt
📌 容器感知(JDK 10+,JEP 304 相关系列):JVM 会读 cgroup 而不是 /proc/cpuinfo,所以 availableProcessors() 返回的是配额而非宿主机核数。这直接影响:
- GC 并行线程数(
ParallelGCThreads) ForkJoinPool.commonPool大小 → 影响协程的Dispatchers.Default(第 39 章)- 虚拟线程的调度器并行度(第 34 章)
- 默认堆大小(
MaxRAMPercentage× 容器内存限制)
⚠️ 一个真实的生产事故模式:JDK 8u131 之前不识别 cgroup,容器分配 2GB 但宿主机 256GB,JVM 按宿主机算默认堆 → 启动即 OOMKilled。今天虽然已修复,但很多人还在脚本里硬编码 -Xmx,这在弹性伸缩环境下反而是反模式(应该用 -XX:MaxRAMPercentage=70)。
2.10 本章小结
- JVM 规范 ≠ HotSpot 实现。对象头、GC 算法、JIT 策略、内存布局全是实现细节,规范一概不管。你学的大部分"JVM 知识"其实是"HotSpot 知识"。
- 规范只管三件事:class 文件格式、字节码语义、类加载与链接流程(加上 JLS 第 17 章的 JMM)。
- JDK 8 起方法区的实现是元空间(本地内存),永久代已不存在;此外还有代码缓存和直接内存两块常被忽略的区域。
- GraalVM 有两种形态:JIT 版(还是 HotSpot)和 Native Image 版(AOT,完全不同的运行时)。别把它们混为一谈。
- class 文件 major version = JDK 版本 + 44;JDK 27 = 71。升级 JDK 后第一件事是确认工具链(Gradle/ASM/Agent)是否认识它。
-XX参数默认值随版本变化是升级踩坑的头号原因;升级时务必 diffjcmd VM.flags。- Project Leyden 的 AOT 缓存(JEP 483→514→515→516)正在让 JVM 启动性能逼近 Native Image,同时保留 JIT 的峰值性能——这是 2026 年 JVM 最重要的变化之一。
- Android 的 ART 不是 JVM:dex 格式、PGC AOT、64K 方法数限制、没有虚拟线程。Kotlin 在两个平台上的运行时约束差异很大。
2.11 练习题
2-1. 判断对错并说明理由:
(a) 方法区就是永久代。
(b) 字符串常量池在方法区。
(c) JIT 编译后的机器码存放在堆中。
(d) Direct Memory 属于堆外内存,不受 JVM 管理。
答案要点
(a) ❌ 方法区是规范概念,永久代是 HotSpot 在 JDK 7 及之前的实现;JDK 8+ 实现为元空间。
(b) ❌ JDK 7 起字符串池移入堆(便于随 Young GC 回收);运行时常量池仍在元空间。
(c) ❌ 存放在 CodeCache(-XX:ReservedCodeCacheSize,默认 240MB 左右,分层编译开启时),属于非堆内存。CodeCache 满会导致 JIT 停止。
(d) 🔶 部分对:它不在堆里,但由 JVM 通过 Bits 计数与限制(-XX:MaxDirectMemorySize),通过 Cleaner(虚引用)在 DirectByteBuffer 被回收时释放 native 内存,并计入 NMT。说"不受 JVM 管理"是错的。
2-2. 你的服务从 JDK 21 升级到 JDK 27 后,同样的 -Xmx4g,堆占用监控显示明显下降,吞吐略有提升。给出至少两个可能的技术原因,并说明如何验证。
答案要点
原因一:紧凑对象头默认开启(JEP 534),对象头 12→8 字节,小对象密集的应用堆占用下降 10–20%,缓存局部性提升带来吞吐改善。
原因二:G1 吞吐优化(JEP 522,JDK 26) 减少同步开销。
原因三:JIT/内联策略改进、final 字段常量折叠机会增加(JEP 500 的副产品)。
验证:
java -XX:-UseCompactObjectHeaders关闭后对比 → 隔离变量一;-Xlog:gc*对比 GC 频率与停顿;- JFR 录制对比
jdk.GCHeapSummary、jdk.CompilerStatistics; jcmd <pid> GC.class_histogram+ JOL 抽查典型对象的实际大小。
2-3.(🧪 动手)写一个脚本,输出当前 JVM 的:major version、是否启用压缩指针、是否启用紧凑对象头、默认 GC、CodeCache 使用量。
答案要点
#!/usr/bin/env bash
PID=$1
echo "class 版本 : $(javap -v -cp . book.ch02.JvmProbeKt 2>/dev/null | grep -m1 'major version')"
jcmd $PID VM.flags | tr ' ' '\n' | grep -E "UseCompressedOops|UseCompactObjectHeaders|UseG1GC|UseZGC|ReservedCodeCacheSize"
jcmd $PID Compiler.codecache
jcmd $PID GC.heap_info
或程序内:ManagementFactory.getMemoryPoolMXBeans().first { it.name == "CodeCache" }.usage。
2-4. 为什么 Kotlin 的 value class 无法完全等价于未来的 Valhalla value class?
答案要点
Kotlin value class 是编译期的内联/包装优化:在能静态确定的位置直接内联底层值(如把 UserId(String) 内联成 String),但在需要对象身份的位置(泛型 T、集合、跨方法边界、可空 UserId?)仍需装箱成真实对象,且它仍然是一个正常的引用类型,有对象头。
Valhalla value class 是JVM 层面的新类型:"fields, not objects"——没有对象头、没有身份(identity)、可以扁平化(flattening)内联到数组和字段中。它能真正做到 ValueClass[] 数组连续存储、List<ValueClass> 不装箱。
关键差异:Kotlin value class 保留身份语义(可以 === 比较、可以做 IdentityHashMap 的 key),Valhalla value class 放弃身份。这是语义层面的根本不同,不是实现优化能弥补的。详见第 22 章。
2.12 面试题精选
Q1:JVM、JDK、JRE 的区别?
答题框架:
- JVM:运行字节码的抽象机器(规范)+ 具体实现(HotSpot 等)。
- JRE:JVM + 核心类库,只能运行不能开发。JDK 11 起 Oracle 不再单独提供 JRE,改用
jlink自定义运行时镜像。 - JDK:JRE + 编译器(javac)+ 工具(javap/jcmd/jfr/jlink/jpackage…)+ 源码。
- 加分:提到 📌
jlink可以裁剪出只含所需模块的运行时(几十 MB),这是容器化的最佳实践;提到jpackage可打包原生安装包。
Q2:JDK 8 到 JDK 27,你认为最重要的变化有哪些?
答题框架(按影响力排序,答出 5 条即为优秀):
- 虚拟线程(21)—— 并发编程范式变革;
- 模块系统 JPMS(9)—— 强封装,改变了反射生态;
- GC 革命:G1 成默认(9)→ ZGC/Shenandoah 生产可用(15/12)→ 分代 ZGC(21/23)→ 分代 Shenandoah(25)→ 📌 G1 在所有环境默认(27,JEP 523);
- 紧凑对象头(25 引入,📌 27 默认)—— 堆占用降 10–20%;
- Project Leyden AOT 缓存(24–26)—— 启动性能数量级提升;
- 语言特性:records(16)、sealed(17)、pattern matching(16–21)、switch 表达式(14)、文本块(15)、📌 Flexible Constructor Bodies(25)、Compact Source Files(25)、Module Import(25);
- 移除历史包袱:Nashorn(15)、32 位 x86(25)、Applet API(26)、偏向锁(15 废弃)、CMS(14 移除);
- Panama FFM API(22 稳定)—— 替代 JNI 调用本地代码。
Q3:GraalVM 的 Native Image 适合什么场景?有什么代价?
答题框架:
- 适合:Serverless/FaaS(冷启动敏感)、CLI 工具、Sidecar、边缘计算、内存受限环境、需要极小镜像。
- 不适合:长时运行的高吞吐服务(无 JIT,峰值性能通常低 10–30%)、大量运行时动态类加载的场景、依赖复杂反射且难以配置元数据的框架。
- 代价:封闭世界假设 → 反射/资源/JNI/动态代理需
reachability-metadata;构建慢(分钟级);构建期内存大;调试困难;部分库不兼容。 - 📌 补充:Leyden AOT 缓存正在提供"保留 JIT 但加速启动"的中间路线,2026 年后很多场景不再需要 Native Image。
Q4:如何确认线上服务运行在哪个 JVM、用了什么 GC、堆多大?
答题框架:给出四类手段体现工程素养。
- 命令行:
jcmd <pid> VM.flags / VM.command_line / VM.info、jinfo -flags <pid>; - 程序内:
RuntimeMXBean、GarbageCollectorMXBean、MemoryPoolMXBean; - 日志:
-Xlog:gc*,safepoint:file=gc.log:time,uptime,level,tags; - 平台:JFR + JMC、Prometheus JMX Exporter、APM。
- 加分:容器环境注意 cgroup 感知与
-XX:MaxRAMPercentage;不要硬编码-Xmx。
下一章预告:第 3 章《从 Java 到 Kotlin:设计哲学、演进史与迁移决策》——Kotlin 为什么要重新设计一门 JVM 语言?它做了哪些和 Java 相反的取舍?以及最实际的:你的项目该不该迁移,怎么迁移,会踩哪些坑。