序:你真的学会 Java 了吗?

34 阅读7分钟

序:你真的学会 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。

这才是"精通"的含义。