序:你真的学会 Java 了吗?
一个让我沉默了很久的面试现场
那是几年前的一次面试。候选人有七年经验,简历上写着"精通 Java 并发与 JVM 调优"。
我问他:"Integer a = 127; Integer b = 127; a == b 的结果是什么?"
他答:"false,因为 == 比较的是引用。"
我追问:"那 Integer a = 127; Integer b = 127; 呢?"
他愣了一下,说:"也是 false 吧,它们是两个不同的对象。"
答案是 true。因为 Integer.valueOf 对 -128 到 127 做了缓存。
但这个知识点本身毫无价值。真正让我沉默的是接下来发生的事:我把同一段逻辑用 Kotlin 写了一遍——
val a: Int? = 127
val b: Int? = 127
println(a === b) // true —— 因为 Int? 装箱后仍走 Integer.valueOf 缓存
println(a == b) // true —— 因为 Kotlin 的 == 就是 equals
他看着 === 和 == 两个符号,问我:"Kotlin 里为什么有两个等号?"
这一刻我意识到:他不是不懂 Java,他是从来没有被要求去理解"语言"和"虚拟机"是两件事。
在他的心智模型里,== 就是"比较值",装箱就是"变成对象",缓存就是"优化"。这些碎片化的直觉,在 Java 这一个语言内部勉强能自洽运转;可一旦换一门跑在同一个 JVM 上的语言,整个模型立刻崩塌。
这本书要解决的问题
我相信绝大多数 Java 开发者都处于同一种状态,包括曾经的我:
- 能写出正确的业务代码,但说不清它为什么正确;
- 背得住"JVM 分堆和栈",但不知道元空间到底在哪、直接内存算不算堆;
- 知道"要用线程池",但不知道核心线程数该怎么定、虚拟线程出现后这套经验还成不成立;
- 用过
synchronized,但没看过 Mark Word,不知道锁升级在 JDK 15 之后已经变了; - 听说过"泛型擦除",但解释不了桥方法从哪来、为什么 Kotlin 的
reified能绕过它。
原因是:我们学的是 Java,而 Java 只是一层皮。皮下面那台机器叫 JVM,它有自己的规则、自己的历史包袱、自己的性能模型。 只学皮,你得到的是一堆无法迁移的"经验";学透了机器,你得到的是一套可以套用到任何 JVM 语言上的推理能力。
而 Kotlin 是最好的那把解剖刀。
为什么是 Kotlin?
不是因为 Kotlin"更简洁"。简洁只是结果,不是理由。
理由一:Kotlin 强迫你把隐含假设显式化。
Java 允许 String s = null;,于是每个方法都要在脑子里跑一遍"这里会不会 NPE"的模拟。Kotlin 把这个假设提到类型系统里:String 与 String? 是两个不同的类型。一旦你开始区分它们,你就会被迫思考:我原来那些 Java 代码里,null 到底代表了"没有值"、"未初始化"、"查询无结果"还是"参数可选"?
这不是语法糖,这是逼迫你重新审视数据建模。
理由二:Kotlin 的每个特性都能反查到一条 JVM 契约。
inline函数 → 为什么 Kotlin 能在编译期"消除" Lambda 而 Java 的 Lambda 要indy 调用点?data class→equals/hashCode/toString/copy生成的字节码长什么样?为什么copy()是浅拷贝?value class→ 它和 JDK 的record、和 Valhalla 的 value class 是什么关系?suspend函数 → CPS 变换、状态机、Continuation对象,最终编译成什么?List<T>→ 为什么 Kotlin 的"只读列表"在 JVM 上还是java.util.List?为什么这不安全?
每学一个 Kotlin 特性,你就被迫向下钻一层字节码。 这是 Java 教程给不了的训练强度。
理由三:Kotlin 让你在并发上直面两种范式。
2026 年的 JVM 上同时存在两套并发模型:虚拟线程(Project Loom,JDK 21 稳定) 和 协程(kotlinx.coroutines)。前者是"线程很便宜,同步写法就行";后者是"挂起是显式的,suspend 是一种颜色"。
这两套模型跑在同一个 JVM上,共享同一套 Java 内存模型,但编程范式截然不同。理解它们的差异,等于同时理解了:JVM 的线程模型、栈帧与挂起的本质、编译器变换的边界、以及"为什么 ThreadLocal 在虚拟线程下有问题、Scoped Values 怎么解决"。
这是任何一个只学 Java 或只学 Kotlin 的人都不会主动去搞清楚的深水区。
理由四:Kotlin 自己也在踩 JVM 的坑,而且踩得很公开。
Kotlin 编译产物里的 Intrinsics.checkNotNullParameter、DefaultImpls 静态接口方法、@JvmStatic 与 @JvmOverloads、kotlin.jvm.internal 包……这些不是为了好看,而是为了在一台为 Java 设计的虚拟机上实现一门更现代的语言所必须付出的代价。
看懂这些代价,你就看懂了 JVM 的设计边界。
这本书怎么讲
我坚持三条写作原则。
原则一:每个原理都从一个"你会犯的错"开始
我不打算从"JVM 由类加载子系统、运行时数据区、执行引擎组成"这种教科书定义开篇。那种写法的问题是:读完之后你依然不知道它跟你有什么关系。
本书的每一章,都会先给你一个会出 bug 的代码或一个反直觉的输出,让你产生"为什么会这样"的疑问,然后再往下拆。带着问题读,和背结论,效率差十倍。
原则二:所有结论都必须可验证
书里每一个关于字节码、内存布局、GC 行为、JIT 优化的断言,都配套:
- 一段可运行的代码;
- 一条可以复制粘贴的命令(
javap、jcmd、jhsdb、-XX:+PrintCompilation、JFR、async-profiler); - 一段真实输出。
如果某个结论我无法给出验证手段,我会明确标注"这是实现细节,不同 JVM/版本可能不同",而不是假装它是真理。
⚠️ 特别地:大量流传的"JVM 八股"在 2026 年已经是错的。比如"锁升级:无锁 → 偏向锁 → 轻量级锁 → 重量级锁"——偏向锁自 JDK 15 起被禁用并废弃(JEP 374),在 JDK 27 上你根本观察不到它。再比如"对象头 12 字节"——JDK 27 起紧凑对象头(JEP 534)默认开启,是 8 字节。这类修正会集中在第 27 章、第 33 章,并且全书用 📌 标记。
原则三:深浅交替,允许跳读
鸿篇不等于劝退。本书的结构设计成可分层阅读:
- 只想快速上手 Kotlin:读第 6–13 章 + 第 16 章 + 第 42 章。
- 要面试 JVM:读第 25–35 章 + 附录 B/C/D。
- 要做技术选型/架构:读第 1–5 章 + 第 23 章 + 第 34/36/39 章 + 第 43/47/49 章。
- 想成为真正的高手:顺序通读,并且把每一个 🧪 实验都跑一遍。
关于书名的一点私心
"你真的学会 Java 了吗"这句话,我第一次用在技术分享上时,台下有人不太高兴,觉得是在否定他的经验。
我想澄清一下:这本书的立场恰恰相反。
我写它,是因为我自己在写了多年 Java 之后,通过学习 Kotlin 才第一次真正看懂了 Java。那些我曾经背下来的"知识点",在 Kotlin 的对照下突然连成了一张网——我终于知道 final 为什么能给 JIT 提供常量折叠的机会(这也是 JDK 26 JEP 500 "让 final 真的 final" 的动机),知道 volatile 为什么和 synchronized 不是一回事,知道为什么 Java 的 List 和 Kotlin 的 List 是同一个类却有不同的契约。
所以这本书不是来告诉你"你不会 Java"的,而是想陪你走完我走过的那段路:从"会用"到"看懂",从"看懂"到"能推理"。
推理能力一旦建立,JDK 从 8 升到 27,Kotlin 从 1.9 升到 2.4,Spring Boot 从 2 升到 4,你都不需要重新学——你只需要用已有的模型去读它的 release notes。
这才是"精通"的含义。