第 2 章 JVM 全景:规范、实现与生态版图

69 阅读18分钟

第 2 章 JVM 全景:规范、实现与生态版图

本章目标

  1. 彻底厘清一组被混用十年的名词:JVM 规范 / Java SE 平台 / OpenJDK / HotSpot / Oracle JDK / 各种发行版;
  2. 建立"JVM 是一台抽象机器,HotSpot 只是它最流行的一个实现"的心智模型;
  3. 认识 2026 年真实存在的 JVM 家族:HotSpot、GraalVM、OpenJ9、ART,以及国内主流发行版;
  4. 学会用命令行确认"我现在跑的到底是哪个 JVM、它支持什么"。

2.1 一个必须先纠正的常识错误

打开搜索引擎输入"JVM 内存结构",90% 的结果会给你这张图:

┌─────────────────────────────────────────────┐
│                  JVM                        │
│  ┌───────────────────┐  ┌────────────────┐  │
│  │  堆 (Heap)         │  │  方法区         │  │
│  │  ┌─────┬─────┐    │  │  (永久代)       │  │
│  │  │新生代│老年代│    │  │                │  │
│  │  └─────┴─────┘    │  │                │  │
│  └───────────────────┘  └────────────────┘  │
│  ┌───────────────────────────────────────┐  │
│  │ 虚拟机栈 │ 本地方法栈 │ 程序计数器      │  │
│  └───────────────────────────────────────┘  │
└─────────────────────────────────────────────┘

这张图有三处错误,而且每一处都会在真实工作中咬你一口:

  1. "方法区 = 永久代" ❌ 方法区(Method Area)是 JVM 规范定义的抽象概念(JVMS §2.5.4);永久代(PermGen)是 HotSpot 在 JDK 7 及之前的实现方式。JDK 8 起永久代被移除,实现改为元空间(Metaspace),位于本地内存,不属于堆。

    👉 后果:-XX:PermSize 在 JDK 8+ 上被静默忽略(只打印一条 warning);OOM 信息从 PermGen space 变成 Metaspace。

  2. "程序计数器/虚拟机栈/本地方法栈是 JVM 的一部分,和堆并列" —— 说法不严谨。 规范里,堆和方法区是所有线程共享的,而虚拟机栈、本地方法栈、程序计数器是线程私有的、随线程创建销毁。把它们画在同一层会让人误以为它们是全局资源,从而无法理解"为什么线程开太多会 unable to create native thread"。

  3. 图里缺了三块真实存在且经常出问题的内存:

    • 直接内存(Direct Memory):ByteBuffer.allocateDirect 分配,Netty/NIO 大量使用,不在堆内但计入进程 RSS;
    • 代码缓存(CodeCache):JIT 编译后的机器码存放处,满了会停止 JIT 编译(CodeCache is full. Compiler has been disabled.),性能断崖式下跌;
    • 线程栈内存:每个线程默认 1MB(-Xss),1000 个线程就是 1GB 本地内存。

📌 正确的分层视角(本书后续章节都基于这张图):

┌──────────────────────────────────────────────────────────────────────┐
│  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 状态
HotSpotOpenJDK分层编译(C1+C2)、G1/ZGC/Shenandoah、JFR、Leyden AOT绝对主流
Eclipse OpenJ9Eclipse(源自 IBM J9)内存占用更小、启动更快、共享类缓存(SCC)、多种 GC(gencon/balanced/metronome)用于 IBM Semeru Runtime;社区活跃度低于 HotSpot
GraalVM (HotSpot + Graal JIT)Oracle用 Java 写的 JIT 编译器,通过 JVMCI 替换 C2活跃
GraalVM Native Image (SubstrateVM)OracleAOT 编译成原生可执行文件,无 JIT,启动毫秒级活跃,云原生首选之一
ARTGoogle/Android运行 DEX 而非 class;解释 + JIT + Profile-Guided AOT(安装时/空闲时编译);分代 GCAndroid 唯一
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 TemurinEclipse AdoptiumGPLv2+CE社区标准,TCK 认证,多平台(含 aarch64、Windows、macOS、Alpine musl)
Oracle JDKOracleNFTC/OTN官方,长期支持政策明确
Oracle GraalVMOracleNFTC含 Native Image,免费生产使用
Amazon CorrettoAWSGPLv2+CEAWS 生态优化,长期免费支持,含 Corretto 特有补丁
Azul Zulu / Azul PrimeAzulGPLv2+CE / 商业Prime(原 Zing)含 C4 无暂停 GC 与 ReadyNow!(AOT 编译缓存),金融/低延迟场景
BellSoft LibericaBellSoftGPLv2+CE提供 Liberica Native Image Kit(Nik)、桌面版含 JavaFX
Microsoft Build of OpenJDKMicrosoftGPLv2+CEAzure 优化
Red Hat build of OpenJDKRed HatGPLv2+CERHEL/OpenShift 集成
IBM SemeruIBMGPLv2+CE / 商业有 OpenJ9 版和 HotSpot 版两种
Alibaba Dragonwell阿里GPLv2+CEWisp 协程(早于 Loom 的用户态线程)、JWarmup(提前编译)、ElasticHeap
Tencent Kona腾讯GPLv2+CE云原生优化
Huawei 毕昇 JDK华为GPLv2+CEaarch64 深度优化、AOT 加速
JetBrains Runtime (JBR)JetBrainsGPLv2+CEIntelliJ/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:

JDKmajor十六进制JDKmajor十六进制
1.1450x2D17610x3D
5490x3121650x41
6500x3224680x44
7510x3325690x45
8520x3426700x46
11550x3727710x47
15590x3B

🧪 实验 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)不认识新版本字节码。解决顺序:

  1. 升级 Gradle(9.x 才完整支持 JDK 27);
  2. 升级 ASM / ByteBuddy / CGLIB(它们必须显式支持新 major version);
  3. 升级 APM/Agent(SkyWalking、Pinpoint、Arthas 等);
  4. 实在不行,临时把 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
非标准参数-XHotSpot 特有,可能变更-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 参数的默认值随版本变化是大量"升级后性能变差"的根因。典型例子:

参数变化
UseG1GCJDK 9 起服务端默认;📌 JDK 27 起在所有环境默认(JEP 523),包括小内存容器
UseCompactObjectHeaders📌 JDK 25 引入(需手动开);JDK 27 默认 true(JEP 534)
UseBiasedLockingJDK 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单元测试 mockByteBuddy / 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/ProGuardAndroid 优化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 → jarkotlinc → 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 服务端开发者的三个提醒:

  1. kotlinx.coroutines 在 Android 与 JVM 上是同一套 API,但底层调度不同。Android 有 Dispatchers.Main(基于 Handler),JVM 上没有(除非引入 kotlinx-coroutines-android)。
  2. Android 上没有虚拟线程,所以"协程 vs 虚拟线程"的选型问题只存在于服务端。Android 上协程是唯一现代选择。
  3. 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✅ StableIR 编译器;可导出 TypeScript 定义
Kotlin/WasmWebAssembly🔶 Beta📌 2.2 分离 Wasm 目标;2.3 默认启用新异常处理提案与全限定名;2.4 默认开启增量编译 + 支持 Component Model;依赖浏览器 WasmGC 支持
Kotlin/NativeiOS/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 本章小结

  1. JVM 规范 ≠ HotSpot 实现。对象头、GC 算法、JIT 策略、内存布局全是实现细节,规范一概不管。你学的大部分"JVM 知识"其实是"HotSpot 知识"。
  2. 规范只管三件事:class 文件格式、字节码语义、类加载与链接流程(加上 JLS 第 17 章的 JMM)。
  3. JDK 8 起方法区的实现是元空间(本地内存),永久代已不存在;此外还有代码缓存和直接内存两块常被忽略的区域。
  4. GraalVM 有两种形态:JIT 版(还是 HotSpot)和 Native Image 版(AOT,完全不同的运行时)。别把它们混为一谈。
  5. class 文件 major version = JDK 版本 + 44;JDK 27 = 71。升级 JDK 后第一件事是确认工具链(Gradle/ASM/Agent)是否认识它。
  6. -XX 参数默认值随版本变化是升级踩坑的头号原因;升级时务必 diff jcmd VM.flags。
  7. Project Leyden 的 AOT 缓存(JEP 483→514→515→516)正在让 JVM 启动性能逼近 Native Image,同时保留 JIT 的峰值性能——这是 2026 年 JVM 最重要的变化之一。
  8. 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 的副产品)。

验证:

  1. java -XX:-UseCompactObjectHeaders 关闭后对比 → 隔离变量一;
  2. -Xlog:gc* 对比 GC 频率与停顿;
  3. JFR 录制对比 jdk.GCHeapSummary、jdk.CompilerStatistics;
  4. 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 条即为优秀):

  1. 虚拟线程(21)—— 并发编程范式变革;
  2. 模块系统 JPMS(9)—— 强封装,改变了反射生态;
  3. GC 革命:G1 成默认(9)→ ZGC/Shenandoah 生产可用(15/12)→ 分代 ZGC(21/23)→ 分代 Shenandoah(25)→ 📌 G1 在所有环境默认(27,JEP 523);
  4. 紧凑对象头(25 引入,📌 27 默认)—— 堆占用降 10–20%;
  5. Project Leyden AOT 缓存(24–26)—— 启动性能数量级提升;
  6. 语言特性:records(16)、sealed(17)、pattern matching(16–21)、switch 表达式(14)、文本块(15)、📌 Flexible Constructor Bodies(25)、Compact Source Files(25)、Module Import(25);
  7. 移除历史包袱:Nashorn(15)、32 位 x86(25)、Applet API(26)、偏向锁(15 废弃)、CMS(14 移除);
  8. 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、堆多大?

答题框架:给出四类手段体现工程素养。

  1. 命令行:jcmd <pid> VM.flags / VM.command_line / VM.info、jinfo -flags <pid>;
  2. 程序内:RuntimeMXBean、GarbageCollectorMXBean、MemoryPoolMXBean;
  3. 日志:-Xlog:gc*,safepoint:file=gc.log:time,uptime,level,tags;
  4. 平台:JFR + JMC、Prometheus JMX Exporter、APM。
  5. 加分:容器环境注意 cgroup 感知与 -XX:MaxRAMPercentage;不要硬编码 -Xmx。

下一章预告:第 3 章《从 Java 到 Kotlin:设计哲学、演进史与迁移决策》——Kotlin 为什么要重新设计一门 JVM 语言?它做了哪些和 Java 相反的取舍?以及最实际的:你的项目该不该迁移,怎么迁移,会踩哪些坑。