本章目标
- 用 12 个可复现的反直觉案例,暴露 Java 认知中最常见的断层;
- 每个案例都往下挖一层:语言规则 → 字节码 → JVM 机制;
- 每个案例都给出 Kotlin 对照:语言如何消灭这个坑,或者把它换成了什么新坑;
- 建立本书的核心方法论:不要背结论,要能推理。
1.0 引子:一道题的三层深度
Integer a = 127, b = 127;
Integer c = 128, d = 128;
System.out.println((a == b) + " " + (c == d)); // true false
第一层(背答案):Integer 有缓存,-128~127 返回同一对象,所以 a == b 为 true;128 超出范围,新建对象,所以 false。
大多数人的知识到此为止。但这一层是最没用的——它无法迁移,也无法解释任何新现象。
第二层(挖机制):为什么有缓存?看字节码:
javap -c Box.java # JDK 27,javac 生成 class file major version 71
0: bipush 127
2: invokestatic #7 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: astore_1
6: bipush 127
8: invokestatic #7 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
11: astore_2
12: bipush 128 // 注意:128 也走 valueOf
...
关键发现:自动装箱不是语法糖,而是一次真实的方法调用 Integer.valueOf(int)。缓存发生在 IntegerCache 这个私有静态内部类里:
// java.lang.Integer(JDK 27 源码节选)
private static class IntegerCache {
static final int low = -128;
static final int high; // 由启动参数决定
static final Integer[] cache;
static {
int h = 127;
String s = VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
// ... 解析并夹在 [127, Integer.MAX_VALUE - 128] 区间
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for (int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++); // 静态初始化时就全部建好
}
}
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
🧪 实验 1-1:亲手把缓存上界改掉
java -XX:AutoBoxCacheMax=1000 BoxTest # 或 -Djava.lang.Integer.IntegerCache.high=1000
现在 c == d 变成 true 了。这个结论是可以用一行命令证伪的——这才是"学会"。
📌 顺带纠正两个常见误传:
Long/Short/Byte也有-128~127缓存,但上界不可调;Character缓存0~127;Boolean只有TRUE/FALSE。Float和Double没有缓存。因为浮点值域稠密,缓存无意义。所以Double x = 1.0, y = 1.0; x == y恒为false。
第三层(挖到 JVM):a == b 比较的是两个引用,即两个堆地址。那"地址"到底是什么?在 JDK 27 上,如果开启了压缩指针(默认,堆 < 32GB 时),一个 Integer 对象的内存布局是:
偏移 0 偏移 8 偏移 12 偏移 16
┌────────────┬────────────┬───────────┬─────────┐
│ 对象头 │ 填充/字段 │ int value │ padding │ → 共 16 字节
│ (8 bytes) │ │ (4 bytes) │ │
└────────────┴────────────┴───────────┴─────────┘
↑ 紧凑对象头(JEP 534,JDK 27 默认):
31 bit identity hash | 4 bit age | 2 bit lock
| 22 bit 压缩类指针 | 1 bit self-forwarded | 4 bit Valhalla 预留
一个装 127 的 Integer,真实占用 16 字节,而 int 只要 4 字节。这就是"装箱代价"的物理来源,也是第 27 章(对象内存布局)和第 22 章(value class / Valhalla)要展开的话题。
💡 本题的方法论:一个"知识点",往下挖三层,就从"背诵"变成了"理解"。本书的每一章都会这样挖。
1.1 陷阱一:== 的语义,你其实并不清楚
Java 侧
== 在 Java 里的规则只有一条:基本类型比值,引用类型比地址。所有的"反直觉"都源于此,加上两个额外因素:
- 装箱会把"值比较"偷偷变成"地址比较";
- 常量池/缓存会让"地址比较"偶尔碰巧等于"值比较"。
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = "hel" + "lo"; // 编译期常量折叠
String s5 = "hel"; String s6 = s5 + "lo"; // 运行期拼接
System.out.println(s1 == s2); // true —— 同一常量池对象
System.out.println(s1 == s3); // false —— new 出堆上新对象
System.out.println(s1 == s4); // true —— 编译期就折叠成 "hello"
System.out.println(s1 == s5); // true —— 编译期折叠
System.out.println(s1 == s6); // false —— 运行期 StringBuilder 拼接,新对象
System.out.println(s1 == s6.intern()); // true
🔬 s4 为什么是 true? 因为 "hel" + "lo" 的两个操作数都是编译期常量(JLS §15.28),javac 直接折叠:
javap -c -p StringPoolTest | grep -A2 ldc
# ldc #8 // String hello ← 没有 StringBuilder,没有 append
📌 而 JDK 9 之后,运行期的字符串拼接不再用 StringBuilder,改用 invokedynamic + StringConcatFactory(JEP 280):
invokedynamic #9, 0 // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;)Ljava/lang/String;
好处是拼接策略可以在运行期由 JVM 选择(甚至未来能优化成精确长度的单次分配),坏处是堆栈里会看到 StringConcatFactory 生成的隐藏类,很多新手排查内存问题时被它吓一跳。
Kotlin 侧
Kotlin 从语言层面把这个问题消灭了:
val s1 = "hello"
val s3 = String(charArrayOf('h','e','l','l','o'))
println(s1 == s3) // true —— == 等价于 equals(含 null 安全处理)
println(s1 === s3) // false —— === 才是引用比较(identityEquals)
Kotlin 的 == 编译成什么?
// s1 == s3 的字节码(Kotlin 2.4.21 / jvmTarget 27)
aload s1
aload s3
invokestatic Intrinsics.areEqual(Ljava/lang/Object;Ljava/lang/Object;)Z
Intrinsics.areEqual 的实现是 a == null ? b == null : a.equals(b)——一次静态方法调用 + 空判断。
⚠️ 代价:这次调用虽然会被 JIT 内联掉(几乎零成本),但它意味着 Kotlin 的 == 对基本类型也会走 equals 吗? 不会。对于 Int、Long 等非空基本类型,编译器直接生成 if_icmpne 等原语比较指令,不装箱、不调用。只有引用类型和可空类型才走 areEqual。
🧪 实验 1-2:把下面两行分别编译,对比字节码。
fun f1(a: Int, b: Int) = a == b // if_icmpne,零装箱
fun f2(a: Int?, b: Int?) = a == b // Intrinsics.areEqual + Integer 装箱
这就是本书要训练的能力:从语言现象,推到字节码,再推到成本。
1.2 陷阱二:null —— 你写过的每个方法都在悄悄做防御
public String getUserCity(User u) {
return u.getAddress().getCity().getName().toUpperCase();
}
这行代码有四层潜在的 NPE。Java 的类型系统对此完全沉默——编译器不会给你任何警告。于是整个行业发明了一整套"防御性仪式":
if (u != null && u.getAddress() != null && u.getAddress().getCity() != null) { ... }
Optional.ofNullable(u).map(User::getAddress).map(Address::getCity).map(City::getName)...
@Nullable / @NonNull 注解 + 静态检查工具
这些方案的共同问题:它们都是"约定",而不是"保证"。约定可以被绕过(注解可以不加、Optional 可以被 .get()),而绕过时编译器不会报错。
Kotlin 的解法:把 null 提升为类型信息
fun getUserCity(u: User?): String? =
u?.address?.city?.name?.uppercase()
fun getUserCityStrict(u: User): String =
u.address.city.name.uppercase() // 编译器保证不可能 NPE
关键在于:User 和 User? 是两个不同的类型,就像 int 和 Integer 是两个不同的类型一样。函数签名一旦写了 User,调用方就无法传入 null——不是靠约定,而是靠类型检查。
🔬 但这只是编译期保证吗?运行时呢? 看字节码:
fun greet(name: String) = println("Hi, $name")
public static final void greet(@NotNull String name) {
0: aload_0
1: invokestatic #12 // Method kotlin/jvm/internal/Intrinsics.checkNotNullParameter:(Ljava/lang/Object;Ljava/lang/String;)V
4: ...
}
Kotlin 在每个公开函数的入口插入了一次参数非空检查。这意味着:
- Java 代码调用 Kotlin 函数传 null,会抛
NullPointerException(Kotlin 1.4 起从IllegalArgumentException改为 NPE,更符合直觉); - 这次检查有成本,但
checkNotNullParameter会被 JIT 内联成一个if (x == null) throw,热路径上成本可忽略; - 方法上还有
@NotNull注解,供 IDE 和静态分析工具使用。
📌 这三条会在第 7 章(空安全)和第 21 章(空安全的字节码真相)详细展开,包括 JSpecify 如何逐步取代零散的 @Nullable 注解体系。
1.3 陷阱三:集合的"不可变"是个谎言
List<Integer> src = new ArrayList<>(List.of(1, 2, 3));
List<Integer> ro = Collections.unmodifiableList(src);
src.add(4);
System.out.println(ro); // [1, 2, 3, 4] ← "只读"列表变了!
Collections.unmodifiableList 返回的是视图(view),不是副本。它的"不可变"只是"你不能通过这个引用改",而不是"这个数据不会变"。
那 List.of(1,2,3) 呢?它是真不可变(JDK 9,JEP 269),但代价是:
- 不允许
null元素(List.of(null)抛 NPE); - 不允许重复元素的
Set.of; - 序列化格式特殊;
- 实现类是
ImmutableCollections.ListN,小列表有专门的List12优化。
Kotlin 侧:一个更微妙的谎言
val list = listOf(1, 2, 3) // 类型是 List<Int>,"只读"
⚠️ 但 List<T> 在 JVM 上就是 java.util.List<T>。Kotlin 的"只读"是编译期的接口视图:List 只暴露读方法,MutableList 额外暴露写方法。运行期它们是同一个类。
🧪 实验 1-3:戳穿这个谎言(这个实验会让很多人震惊)
fun main() {
val list: List<Int> = listOf(1, 2, 3)
// 1) 强转能不能成功?
val mutable = list as? MutableList<Int>
println("cast 成功? ${mutable != null}")
// 2) 如果能,改得动吗?
mutable?.let { it[0] = 99 }
println(list)
}
在 JVM 上运行,你会发现:listOf(1,2,3) 底层是 java.util.Arrays.asList(...) 返回的 Arrays$ArrayList——它支持 set,不支持 add/remove。所以强转成功,且 list[0] = 99 真的改了!
而 listOf(1) 返回 Collections.singletonList,set 会抛 UnsupportedOperationException;listOf() 返回 Kotlin 自己的 EmptyList。
📌 三元素、一元素、零元素的行为不一致。这是 Kotlin/JVM 实现细节,属于"你不该依赖但必须知道"的知识——因为它解释了一个真实的生产事故模式:
fun process(items: List<Item>) {
(items as? MutableList<Item>)?.removeIf { it.expired } // 有人这么写,且"能跑"
}
val original = mutableListOf(a, b, c)
process(original) // 调用方的 original 被改了!
🚀 生产建议:
- 跨模块边界传递时,若需要真不可变,用
toList()(会复制成新的ArrayList,虽然仍可被强转,但至少切断了与源集合的联系); - 需要严格保证时用
java.util.List.copyOf(list)(JDK 10+),它返回的ImmutableCollections无法被强转成可修改类型; - 在 code review 中把
as MutableList列为禁用模式,可用 Detekt 自定义规则拦截。
第 16 章会系统讲集合,包括 Sequence 的惰性代价与 toList() 的分配次数。
1.4 陷阱四:HashMap 你以为你懂
面试常问:"HashMap 什么时候转红黑树?" 标准答案"8"是不完整的。
// java.util.HashMap(JDK 27)
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64; // ← 关键的第二条件
final void treeifyBin(Node<K,V>[] tab, int hash) {
if (tab == null || tab.length < MIN_TREEIFY_CAPACITY)
resize(); // 表太小就扩容,而不是树化!
else if (/* 链表长度 >= 8 */) { ... }
}
完整答案:单个桶内链表长度达到 8 且 数组长度 ≥ 64 时才树化;若数组长度 < 64,则优先扩容。反向退化阈值是 6(不是 8,留出缓冲避免频繁转换)。
为什么是 8?源码注释里给了:理想散列下,桶内元素数服从参数 0.5 的泊松分布,达到 8 的概率约 0.00000006(六千万分之一)。所以树化本质是防御 hash 碰撞攻击的兜底,不是常规路径。
⚠️ 更值得警惕的三个"以为":
(1) "JDK 8 修好了并发问题" —— 只修了一半。JDK 7 的头插法在并发扩容时会形成环形链表,导致 get 死循环 CPU 100%。JDK 8 改尾插 + 高低位拆链,消除了死循环,但依然不是线程安全:并发 put 会丢数据、size 会算错、扩容期间读会读到不一致状态。
(2) "0.0 和 -0.0 是同一个 key" —— 错。
Map<Double, String> m = new HashMap<>();
m.put(0.0, "zero");
System.out.println(m.get(-0.0)); // null !
System.out.println(0.0 == -0.0); // true !
因为 Double.hashCode(0.0) == 0 而 Double.hashCode(-0.0) == -2147483648,且 Double.equals 区分二者(equals 用 doubleToLongBits,== 用 IEEE 754 语义)。== 和 equals 在浮点上不一致,这是个能造成真实 bug 的细节。
(3) "HashMap 的 null key 在 0 号桶" —— 对,但要知道 hash(null) == 0 是特判出来的,且 ConcurrentHashMap/Hashtable 直接禁止 null key(因为 get 返回 null 时无法区分"不存在"还是"值就是 null")。
📌 Kotlin 侧:Kotlin 没有自己的 HashMap,mutableMapOf 就是 LinkedHashMap,mapOf 小尺寸时会用 java.util.Collections.emptyMap()/singletonMap() 等优化。所有 Java HashMap 的坑,Kotlin 原封不动继承。
📌 Kotlin 2.4.0 实验性引入了 Map fallback 函数,专门用于区分"key 不存在"和"value 是 null"——正是上面第 (3) 点的语言级解法。
1.5 陷阱五:synchronized 锁的到底是什么
public class Counter {
private int n = 0;
public synchronized void inc() { n++; } // 锁 this
public static synchronized void reset() { } // 锁 Counter.class
public void block() { synchronized (this) { } } // 锁 this,与 inc() 互斥
public void other() { synchronized (Counter.class) { } } // 与 reset() 互斥
}
四句话,四种锁对象。字节码上:
// synchronized 方法:靠方法访问标志 ACC_SYNCHRONIZED,由 JVM 隐式加锁
// synchronized 块:显式的 monitorenter / monitorexit(且有两个 exit 处理异常路径)
monitorenter
...
monitorexit ← 正常路径
astore_1
aload_1
monitorexit ← 异常路径(由 Exception table 保护)
athrow
🔬 可重入的实现:monitor 记录 owner 线程 + 计数。同一线程再次进入,计数 +1,不阻塞。
📌 锁升级:老八股已经过时了。
流传最广的说法是"无锁 → 偏向锁 → 轻量级锁 → 重量级锁"。但在 JDK 27 上:
- 偏向锁(Biased Locking)已被移除。JEP 374(JDK 15)将其默认禁用并废弃,理由是:现代应用大量使用并发库(
java.util.concurrent),偏向锁的收益消失,而它的撤销(revocation)需要 safepoint,代价高昂,且给 HotSpot 同步子系统带来了巨大复杂度。 - JDK 27 上实际路径是:无锁 → 轻量级锁(CAS + 线程 lock stack)→ 重量级锁(ObjectMonitor,涉及 OS mutex 与线程挂起)。
- 📌 紧凑对象头(JEP 534,JDK 27 默认)改变了锁的存储方式:锁位从原来的 2 bit 状态机 + 内联数据,变为 2 bit 标志 + 指向线程 lock stack 中锁记录的指针。对象头不再需要为"膨胀后的锁"预留空间。
JDK 21 传统对象头(无锁 / 轻量级 / 重量级)
Mark Word (64bit) | 锁标志位
─────────────────────────────────────────┼──────────
unused:25 | hash:31 | unused:1 | age:4 | 0 01 无锁
ptr_to_lock_record:62 | 00 轻量级
ptr_to_heavyweight_monitor:62 | 10 重量级
thread:54 | epoch:2 | unused:1 | age:4 | 1 01 偏向锁(已移除)
JDK 27 紧凑对象头(64bit 单一字段)
┌──────────────┬──────┬──────────┬─────────────────────┬────────┬──────────┐
│ identity hash│ age │ lock bits│ compressed klass ptr │ self- │ Valhalla │
│ 31 bit │ 4bit │ 2 bit │ 22 bit │ fwd 1b │ 4 bit │
└──────────────┴──────┴──────────┴─────────────────────┴────────┴──────────┘
合计 64 bit = 8 字节
第 27 章会逐位拆解,第 33 章会讲锁的完整生命周期与 ObjectMonitor 的等待队列。
1.6 陷阱六:volatile 保证可见性,但不保证原子性——以及 DCL 为什么非它不可
volatile int count = 0;
// 100 个线程各 count++ 一万次,结果几乎必然 < 1000000
因为 count++ 是三条指令:getfield → iadd → putfield。volatile 只保证每次读都从主内存读、每次写都刷回主内存,不保证这三条的原子性。
那经典的**双重检查锁(DCL)**为什么必须 volatile?
class Holder {
private static volatile Holder INSTANCE; // 少了 volatile 就是 bug
static Holder get() {
if (INSTANCE == null) { // 第一次检查(无锁)
synchronized (Holder.class) {
if (INSTANCE == null) { // 第二次检查(有锁)
INSTANCE = new Holder(); // ← 问题在这一行
}
}
}
return INSTANCE;
}
}
INSTANCE = new Holder() 在字节码层面是三步:
1. new #2 // 分配内存
2. dup
3. invokespecial #3 // <init>:初始化字段
4. putstatic #4 // 把引用赋给 INSTANCE
JIT 编译器和 CPU 允许把 3 和 4 重排序(在单线程语义等价的前提下)。重排后:引用先被赋值(指向一块尚未初始化完成的内存),另一个线程在第一次检查时看到 INSTANCE != null,直接返回并使用——读到了半初始化的对象。
volatile 通过插入内存屏障禁止这种重排。
🔬 但这里有个更深的知识点,很多人不知道:JSR-133(JDK 5)之后,final 字段有安全发布保证。如果对象的所有字段都是 final,且在构造过程中 this 没有逃逸,那么其他线程即使拿到了未完全同步的引用,也保证能看到正确的 final 字段值。
所以下面这个写法不需要 volatile(这叫"不可变持有者模式"):
class Holder {
private static class Box { static final Holder H = new Holder(); } // 静态 final
static Holder get() { return Box.H; } // 类初始化由 JVM 保证线程安全
}
📌 JDK 26 的 JEP 500「Prepare to Make Final Mean Final」把这件事推到了新高度:既然 JIT 可以依赖 final 做常量折叠,那么用 Deep Reflection 偷偷改 final 字段就是在破坏 JVM 的优化前提。JDK 26 起会对反射修改 final 字段发出警告:
WARNING: Final field value in class Box has been mutated reflectively by class ... in unnamed module
WARNING: Mutating final fields will be blocked in a future release unless final field mutation is enabled
可用 --illegal-final-field-mutation=allow|warn|debug|deny 控制,deny 时抛 IllegalAccessException。JFR 事件 jdk.FinalFieldMutation 可定位是谁在改。第 22 章和第 30 章详解。
Kotlin 侧
object Holder // ← 单例,JVM 类初始化机制保证线程安全
class Service {
companion object {
@Volatile private var instance: Service? = null // @Volatile 注解
fun get(): Service = instance ?: synchronized(this) {
instance ?: Service().also { instance = it }
}
}
}
⚠️ Kotlin 的 ?: + synchronized 双检查写法依然需要 @Volatile,原因与 Java 完全相同。语言变了,JMM 没变。 这是本书反复强调的一句话。
🚀 实际项目中,优先用 object 或 lazy:
val service by lazy { Service() } // 默认 LazyThreadSafetyMode.SYNCHRONIZED
lazy 的默认模式内部用了 synchronized + 双检查,且已正确使用了 volatile 语义的字段(Lazy 的实现里 _value 是 @Volatile)。第 13 章会剖析它的四种模式与各自的成本。
1.7 陷阱七:内存区域——"方法区就是永久代"是错的
| 概念 | 属于 | JDK 8 之前 | JDK 8+ | JDK 27 |
|---|---|---|---|---|
| 方法区(Method Area) | JVM 规范定义的逻辑区域 | — | — | 规范概念,不是实现 |
| 永久代(PermGen) | HotSpot 实现 | 方法区的实现,在 JVM 内存中 | 已移除 | 不存在 |
| 元空间(Metaspace) | HotSpot 实现 | — | 方法区的实现,在本地内存 | 默认无上限,受 -XX:MaxMetaspaceSize 约束 |
| 运行时常量池 | 方法区的一部分 | 在永久代 | 在元空间 | 在元空间 |
| 字符串常量池 | 堆的一部分(JDK 7 起) | JDK 6 在永久代 | 在堆中 | 在堆中 |
| 直接内存(Direct Memory) | 堆外 | -XX:MaxDirectMemorySize | 同 | 同,属 NMT 的 Internal/Other 区 |
🔬 为什么字符串池要从永久代搬到堆? 因为永久代的 GC 效率极低(Full GC 才回收),而字符串是海量临时对象;搬到堆后可以随 Young GC 回收,大幅降低 OOM: PermGen space 的概率。
⚠️ 两个高频错误认知:
- "元空间不会 OOM" —— 会。
java.lang.OutOfMemoryError: Metaspace。动态生成类的场景(CGLIB、Groovy、Kotlin 的 lambda 隐藏类、大量ClassLoader)都可能触发。 - "直接内存不算 JVM 内存" —— 它不在堆里,但受 JVM 管理、计入进程 RSS、可通过
-XX:NativeMemoryTracking=summary观测。Netty 的PooledByteBufAllocator内存泄漏排查全靠这个。
🧪 实验 1-4:亲眼看到 Metaspace
java -XX:NativeMemoryTracking=summary -Xlog:gc+metaspace=info YourApp
jcmd <pid> VM.native_memory summary
- Class (reserved=1105280KB, committed=25344KB)
(classes #4521)
( instance classes #4210, array classes #311)
(malloc=512KB #6234)
(mmap: reserved=1048576KB, committed=20480KB)
( Metadata: used=24320KB, capacity=25088KB, committed=25344KB)
Kotlin 侧完全一样——因为Kotlin 没有自己的内存模型,它跑在同一个 JVM 上。这就是本书的核心命题之一。
1.8 陷阱八:GC 的四个误解
(1) "System.gc() 会立即回收"
它是建议(hint),不是命令。JVM 可以忽略。而且:
- 使用 G1 时,
System.gc()默认触发 Full GC(单线程串行压缩),这是巨大的性能杀手; - 加
-XX:+ExplicitGCInvokesConcurrent可让它走并发周期; - RMI 默认每小时调一次
System.gc()(历史包袱),可用-Dsun.rmi.dgc.server.gcInterval调整。
(2) "finalize() 可以用来释放资源"
📌 Object.finalize() 自 JDK 18 起被标记为 deprecated for removal(JEP 421)。原因:执行时机不确定、可能复活对象、严重影响 GC 性能(需要两轮标记)、异常被吞掉。用 try-with-resources + AutoCloseable,或者 Cleaner。
(3) "对象不可达就立刻被回收" 不一定,取决于引用类型:
| 引用 | 回收时机 | 典型用途 |
|---|---|---|
| 强引用(Strong) | 永不(只要可达) | 普通对象 |
| 软引用(Soft) | 内存不足时(OOM 前) | 内存敏感缓存 |
| 弱引用(Weak) | 下次 GC | WeakHashMap、ThreadLocal 的 key |
| 虚引用(Phantom) | 随时,且 get() 恒为 null | 配合 ReferenceQueue 做堆外内存清理(DirectByteBuffer 的 Cleaner 就是它) |
⚠️ ThreadLocal 内存泄漏的经典成因:ThreadLocalMap.Entry 的 key 是弱引用,value 是强引用。线程池里线程长期存活,key 被回收后 value 仍在,形成"key 为 null 的僵尸 entry"。所以用完必须 remove()。
(4) "GC Roots 就是静态变量和栈上引用" 不完整。GC Roots 包括:
- 虚拟机栈(栈帧局部变量表)中引用的对象;
- 方法区/元空间中类的静态字段引用的对象;
- 方法区中常量引用的对象(如字符串池里的引用);
- 本地方法栈中 JNI 引用;
- JVM 内部引用(
Class对象、ClassLoader、系统类、预分配异常对象如NullPointerException); - 所有被
synchronized持有的对象; - JFR/GC 相关的临时根。
📌 分代假设与记忆集:Young GC 时不可能扫全堆找根,所以用卡表(Card Table)+ 写屏障记录"老年代到新生代的引用"。这就是第 31 章的核心内容,也是"G1 的 Remembered Set 为什么占内存"的答案。
1.9 陷阱九:finally 与 return 的纠缠
static int test() {
int x = 1;
try {
return x; // ← 这里已经把 x 的值存进了"返回值槽"
} finally {
x = 2; // 改的是局部变量,不影响已保存的返回值
}
}
// 返回 1
但如果 finally 里有 return,它会覆盖并吞掉异常:
static int test2() {
try { return 1; } finally { return 2; } // 返回 2,try 里的 return 被丢弃
}
🔬 字节码层面,try-finally 会被编译成多份 finally 代码副本(正常路径一份、每个异常路径一份),这就是为什么带 finally 的方法字节码看起来"重复"。
try-with-resources 的抑制异常
try (Resource r = new Resource()) { // close() 也抛异常时
throw new RuntimeException("body");
}
// 最终抛出的是 body 异常,close 的异常被 addSuppressed 挂上去
getSuppressed() 能拿到。这是 JDK 7 的重要设计,但大量开发者从未看过 suppressed 异常,导致排查"明明日志里有堆栈却找不到根因"。
Kotlin 的 use
Resource().use { r ->
throw RuntimeException("body")
}
⚠️ 一个真实的历史坑:Kotlin 早期 use 的内联实现依赖 Throwable.addSuppressed,而 Android 低版本 API 没有这个方法,导致行为差异。现在标准库已处理,但在 Android 上使用 use 仍需注意 minSdk。
📌 Kotlin 没有 finally 覆盖 return 的问题吗?有,一模一样:
fun test(): Int {
try { return 1 } finally { return 2 } // 编译器警告,但仍返回 2
}
Kotlin 会给 'return' is not allowed here 警告,但语义与 Java 一致。因为最终都编译成同样的字节码结构。
1.10 陷阱十:泛型擦除的三个后果
List<String> ls = new ArrayList<>();
List<Integer> li = new ArrayList<>();
System.out.println(ls.getClass() == li.getClass()); // true!都是 ArrayList.class
后果一:运行期无法 instanceof List<String>(编译报错),只能 instanceof List<?>。
后果二:不能 new T[]、不能 T.class、不能 catch (T e)。
后果三:桥方法(Bridge Method)。
class Node<T> { public void set(T t) {} }
class StrNode extends Node<String> {
@Override public void set(String s) {} // 你写的
// 编译器额外生成:public void set(Object o) { set((String)o); } ← 桥方法
}
因为擦除后父类是 set(Object),子类是 set(String),签名不同不构成重写,多态会失效。所以 javac 生成桥方法保证正确性。
javap -c -p StrNode | grep -A5 "public void set"
# public void set(java.lang.String);
# public void set(java.lang.Object); ← 桥方法,带 ACC_BRIDGE | ACC_SYNTHETIC
⚠️ 桥方法会带来一个隐蔽问题:反射遍历方法时会看到两个同名方法,getDeclaredMethods() 返回的数组里包含桥方法,做注解扫描时必须过滤 method.isBridge()。这是无数自研 DI/ORM 框架踩过的坑。
Kotlin 的解法:reified
inline fun <reified T> Any.isA() = this is T
val x: Any = "hello"
println(x.isA<String>()) // true —— 编译期就把 T 替换成 String
🔬 reified 不是魔法,也不是"保留了泛型信息"。它只对 inline 函数有效:因为内联会把函数体复制到调用点,此时 T 已经被具体类型替换,所以 is T 变成了 is String——一个编译期就确定的具体检查。
// x.isA<String>() 内联后的字节码
aload x
instanceof #12 // class java/lang/String ← T 消失了,只剩具体类型
ifeq ...
⚠️ 代价:
- 只能用于
inline函数,不能用于类、属性、非内联函数; - 不能从 Java 调用(内联函数对 Java 不可见其泛型实参);
- 二进制兼容问题:修改 inline 函数体,调用方必须重新编译才能生效——这是 Kotlin 库维护者最头疼的问题之一,第 20 章和第 47 章(二进制兼容验证器)详谈。
1.11 陷阱十一:类加载与初始化的时机
class Parent { static { System.out.println("Parent clinit"); } }
class Child extends Parent { static { System.out.println("Child clinit"); } }
new Child();
// Parent clinit
// Child clinit
触发初始化(<clinit>)的六种情况(JVM 规范定义的"主动引用"):
new、getstatic/putstatic(读写非static final编译期常量)、invokestatic;- 反射调用(
Class.forName默认会初始化); - 初始化子类时,父类未初始化则先初始化父类;
- 启动类(含
main的类); MethodHandle/invokedynamic解析到 REF_getStatic 等;- 接口中定义了 default 方法时,其实现类初始化会触发接口初始化。
不触发初始化的"被动引用":
- 通过子类引用父类的静态字段 → 只初始化父类;
SomeClass[] arr = new SomeClass[10]→ 不初始化SomeClass;- 引用编译期常量(
static final int X = 5这种字面量)→ 常量已内联进调用方的常量池,甚至不需要该类被加载。
🔬 Class.forName vs ClassLoader.loadClass:
Class<?> c1 = Class.forName("com.Foo"); // 加载 + 链接 + 初始化
Class<?> c2 = Class.forName("com.Foo", false, loader); // 只加载,不初始化
Class<?> c3 = loader.loadClass("com.Foo"); // 只加载,不初始化
JDBC 的 Class.forName("com.mysql.cj.jdbc.Driver") 依赖的正是初始化时执行静态块注册 Driver。而 JDBC 4.0 之后有 SPI(ServiceLoader + META-INF/services),已经不需要手写这行了。
📌 双亲委派在 2026 年还成立吗? 大方向成立,但早已被多处"合法破坏":
- JDBC/JNDI:核心接口在
java.base,实现在应用 classpath,需要**线程上下文类加载器(TCCL)**反向委派; - OSGi:网状委派;
- Tomcat:每个 webapp 一个
WebappClassLoader,优先加载自己(隔离),违反双亲委派; - JPMS(JDK 9+):模块化后,
ClassLoader之上多了一层模块解析,双亲委派语义被Layer/Module重新定义; - AOT 缓存(JEP 483/514/516):类可以在 JVM 启动前就被"预加载 + 预链接",直接从 AOT 缓存映射进堆,跳过常规的加载流程。
第 25 章会用一个自研 ClassLoader 实验把这套机制彻底讲透。
1.12 陷阱十二:static 初始化顺序与线程安全
class Config {
static final Config INSTANCE = new Config(); // ①
static final int VALUE = compute(); // ②
private static int compute() { return INSTANCE != null ? 42 : 0; }
}
顺序是源码文本顺序,且父类先于子类。把 ①② 交换,compute() 里 INSTANCE 就是 null。
🔬 类初始化是线程安全的:JVM 规范保证 <clinit> 在多线程环境下被正确加锁——只有一个线程执行,其他线程阻塞等待。这就是"静态内部类单例"能成立的根本原因,也是 object 在 Kotlin 中天然线程安全的原因。
⚠️ 但它会带来死锁:如果类 A 的 <clinit> 触发类 B 的加载,而 B 的 <clinit> 又触发 A,且分别由两个线程并发执行,就可能死锁。生产上表现为"应用启动卡死,jstack 显示两个线程都在 ClassLoader.loadClass"。
1.13 汇总:Kotlin 消灭了哪些坑,又带来了哪些新坑
被 Kotlin 从语言层面消灭或大幅缓解的
| Java 陷阱 | Kotlin 的解法 | 彻底程度 |
|---|---|---|
| NPE | 空安全类型系统 T? | ✅ 编译期强保证(对纯 Kotlin 代码) |
== vs equals | == 即 equals,=== 才是引用比较 | ✅ 彻底 |
忘记写 equals/hashCode | data class 自动生成 | ✅ |
| 冗长样板 | 属性、默认参数、类型推断、when 表达式 | ✅ |
switch 漏 case | when 对 sealed/enum 强制穷尽性检查(2.2+ 数据流穷尽) | ✅ |
泛型无法 instanceof T | reified + inline | 🔶 有限场景 |
接口默认方法的 DefaultImpls 混乱 | 2.2.0 起改用 JVM default method | 🔶 版本相关 |
| 单例的线程安全写法 | object | ✅ |
| 资源未关闭 | use {} | 🔶 语义等价于 twr |
构造器中 super() 必须第一句 | 主构造器 + 次构造器委托模型 | ✅ |
Kotlin 原封不动继承的(因为它们是 JVM 的,不是 Java 的)
HashMap的全部行为与坑;volatile/synchronized/JMM 的全部规则(DCL 依然需要@Volatile);- GC、内存区域、类加载、初始化时机;
- 泛型擦除(
reified只在 inline 场景绕过); - 装箱开销(
Int?会装箱成Integer,List<Int>会装箱!); finally覆盖return;- 字符串常量池行为。
这句话值得抄下来:换语言不换虚拟机,JVM 的规则一条都不会变。
Kotlin 新引入的坑(后续章节展开)
| 新坑 | 章节 |
|---|---|
平台类型:Java 返回的 String! 既不是 String 也不是 String?,检查被推迟到运行时 | Ch7 / Ch23 |
集合的"只读"是编译期视图,as MutableList 可以突破 | Ch16 |
data class 的 copy() 是浅拷贝,且不会调用 init/次构造器 | Ch12 |
data class 继承自 Any 的 equals 不比较父类字段 | Ch12 |
inline 函数的二进制兼容性:改函数体,调用方不重编译就不生效 | Ch9 / Ch20 |
lazy 默认带锁,热路径上可能是性能瓶颈 | Ch13 |
协程的取消是协作式的,while(true) 不会自动停 | Ch38 / Ch42 |
suspend 函数的"颜色"传染,与阻塞 API 混用需要 runBlocking,容易死锁 | Ch37 / Ch42 |
Int? 装箱、List<Int> 装箱,在数值密集场景性能骤降 | Ch6 / Ch22 |
object 单例的序列化/反射破坏 | Ch12 |
默认参数 + @JvmOverloads:Java 侧看到的重载可能与预期不符 | Ch20 |
扩展函数是静态方法,不参与多态,null 接收者行为需特别注意 | Ch10 / Ch20 |
1.14 本章小结
- 知识点不等于理解。
Integer缓存这种题,背下来只能应付一次面试;挖到valueOf→IntegerCache→ 装箱字节码 → 对象内存布局,才获得了可迁移的推理能力。 - 语言是皮,JVM 是骨。Kotlin 消灭了一批 Java 的语法级陷阱(NPE、
==、样板),但所有 JVM 级规则原封不动:JMM、GC、类加载、擦除、装箱。 - Kotlin 也带来了新的陷阱,主要来自"编译期抽象与运行期现实的落差"(只读集合、平台类型、inline 二进制兼容、协程取消)。
- 老八股在 JDK 27 上大量失效:偏向锁没了、对象头变 8 字节了、默认 GC 在所有环境都是 G1 了、
finalize要被移除了、final字段不许反射改了、启动可以走 AOT 缓存了。 - 本书的方法论:现象 → 字节码 → JVM 机制 → 生产影响 → 可验证的实验。
1.15 练习题
基础题(检验是否读懂)
1-1. 下列代码输出什么?为什么?(JDK 27)
Long a = 127L, b = 127L;
Long c = 128L, d = 128L;
System.out.println((a == b) + " " + (c == d));
答案要点
true false。Long.valueOf 同样缓存 -128~127(LongCache),但上界不可通过 AutoBoxCacheMax 调整——那个参数只对 Integer 生效。这是与 Integer 的关键区别,也是常见的"知识迁移错误"。
1-2. 用 Kotlin 写出等价代码,并说明 == 和 === 分别输出什么。
答案要点
val a: Long? = 127; val b: Long? = 127
val c: Long? = 128; val d: Long? = 128
println(a == b) // true (equals)
println(a === b) // true (装箱走 Long.valueOf 缓存,同一对象)
println(c == d) // true (equals 比值)
println(c === d) // false (新建对象)
注意:Long? 一定会装箱(非空的 Long 才是原生 long)。
1-3. 为什么 HashMap 树化需要同时满足"链表长度 ≥ 8"和"数组长度 ≥ 64"?只满足前者会怎样?
答案要点
只满足前者会优先扩容(resize)而非树化。设计意图:链表长往往是因为表太小导致的碰撞,扩容比树化更能解决问题;树化是防御极端碰撞(如 hash 攻击)的兜底手段,成本更高(TreeNode 的体积约是 Node 的两倍)。
进阶题(检验是否能推理)
1-4. 下面这段 Kotlin 代码,在什么情况下会抛 NPE?如何修改才能在编译期就杜绝?
fun process(user: User) = user.name.length
答案要点
当 user 来自 Java 且 Java 侧传入 null 时:Kotlin 会在函数入口的 Intrinsics.checkNotNullParameter 处抛 NullPointerException(不是在 user.name 处)。若 user.name 是 Java 返回的平台类型 String!,则 length 调用处抛 NPE。
修改方案:
- 参数改为
User?并用?.处理; - 在 Java 侧加
@NotNull(或迁移到 JSpecify)并开启 Kotlin 的-Xjsr305=strict,让平台类型在编译期就变为非空类型; - 逐步把 Java 接口 Kotlin 化。
1-5. 解释为什么 DCL 需要 @Volatile,而"静态内部类单例"不需要。并说明 object 属于哪一类。
答案要点
DCL 中 instance = new X() 的"初始化"与"赋引用"可能被重排,导致其他线程读到半初始化对象;volatile 禁止该重排。
静态内部类单例依赖 JVM 对类初始化的线程安全保证(<clinit> 加锁执行),且 static final 字段的赋值发生在类初始化阶段,不存在"先赋引用后初始化"的窗口,因此无需 volatile。
Kotlin 的 object 编译为带 static final INSTANCE 字段的类,字段在 <clinit> 中赋值——等价于静态内部类单例,天然线程安全。
1-6.(🧪 动手)写一段代码,让 JVM 抛出 OutOfMemoryError: Metaspace。给出你的 JVM 参数,并解释为什么堆内存充足却仍然 OOM。
答案要点
用 CGLIB/ByteBuddy 或 Kotlin 的动态代理不断生成新类,配合 -XX:MaxMetaspaceSize=64m。Metaspace 在本地内存,与堆(-Xmx)是两个独立预算;堆充足但类元数据超出 MaxMetaspaceSize 依然 OOM。排查手段:jcmd <pid> VM.metaspace、-Xlog:class+load=info、NMT。
挑战题
1-7. JDK 27 默认开启紧凑对象头后,一个只含单个 int 字段的对象占用多少字节?请给出推导过程,并设计一个实验验证你的答案(提示:可用 jhsdb 或 JOL)。
答案要点
推导:对象头 8 字节 + int 字段 4 字节 = 12 字节;但对象需按 8 字节对齐(-XX:ObjectAlignmentInBytes=8),向上取整到 16 字节。
验证方式:
- 用 OpenJDK JOL(
GraphLayout.parseInstance(obj).totalSize()); jhsdb clhsdb --pid <pid>+inspect <address>看对象大小;- 分配大量对象后对比
-XX:+UseCompactObjectHeaders开/关时的堆占用(jcmd <pid> GC.heap_info),预期下降 10–20%。
对比:JDK 26 及之前(未开启紧凑头)= 12(头,含 4 字节压缩类指针)+ 4 + 填充 = 16 字节——巧合相同;但对含引用字段的对象差异会更明显。
1.16 面试题精选(含答题框架)
答题原则:结论先行 → 机制解释 → 版本差异 → 生产影响 → 举例验证。这五步能把一道 2 分的题答成 10 分。
Q1:Integer a = 127; Integer b = 127; a == b 结果是什么?请深入讲讲。
答题框架:
- 结论:
true;128 则为false。 - 机制:自动装箱 =
Integer.valueOf(int);IntegerCache静态缓存-128~127;==比引用。 - 深度:缓存上界可通过
-XX:AutoBoxCacheMax调整(仅 Integer);Long/Short/Byte/Character有类似缓存但上界固定;Float/Double无缓存。 - 生产影响:装箱开销(16 字节 vs 4 字节)、GC 压力;数值密集场景应用原生数组或
IntArray(Kotlin)避免装箱。 - 前瞻:Valhalla value class 将从根本上消除装箱;Kotlin
value class是其语言侧的近似方案。
Q2:volatile 和 synchronized 的区别?
答题框架:
- 三性对照表:原子性(volatile ✗ / synchronized ✓)、可见性(都 ✓)、有序性(都 ✓,机制不同)。
- 机制:volatile 靠内存屏障(StoreStore/StoreLoad/LoadLoad/LoadStore)+ 缓存一致性协议;synchronized 靠 monitor(
monitorenter/monitorexit或ACC_SYNCHRONIZED)。 - 成本:volatile 读几乎无成本,写有 StoreLoad 屏障(禁止重排,开销较大);synchronized 有锁竞争与可能的线程挂起。
- 版本差异:📌 偏向锁在 JDK 15 起禁用(JEP 374),"锁升级四阶段"说法已过时;紧凑对象头改变了锁信息存储方式。
- 举例:DCL 为什么需要 volatile(重排序 + 半初始化对象);
AtomicInteger用volatile value+ CAS。
Q3:HashMap 为什么线程不安全?ConcurrentHashMap 怎么解决的?
答题框架:
- JDK 7:头插法并发扩容成环 →
get死循环;JDK 8:尾插 + 高低位拆链,消除死循环但仍会丢数据、size 不准。 - CHM JDK 8+:
CAS写空桶 +synchronized锁桶头节点(锁粒度 = 单个桶);size用baseCount+CounterCell[]分散热点(类似LongAdder);扩容支持多线程协助迁移(transfer+ForwardingNode)。 - 权衡:CHM 的
get无锁(靠volatile),put有细粒度锁;弱一致性迭代器(不抛ConcurrentModificationException)。 - 生产:不要用
Collections.synchronizedMap(全表锁 + 迭代需手动同步)。
Q4:JVM 内存区域划分?哪些会 OOM?
答题框架:
- 规范层面:堆、方法区、虚拟机栈、本地方法栈、程序计数器。
- HotSpot 实现:堆(新生代 Eden/S0/S1 + 老年代)、元空间(本地内存)、线程栈、直接内存。
- OOM 类型:
Java heap space、Metaspace、GC overhead limit exceeded、unable to create native thread(栈过多/线程数超限)、Direct buffer memory。 - 版本差异:📌 JDK 8 移除永久代;字符串池 JDK 7 起在堆中;📌 JDK 25 移除 32 位 x86 端口(JEP 503)。
- 排查工具:
jcmd VM.native_memory、-Xlog:gc*、jhsdb、MAT/YourKit 分析 heap dump。
Q5:谈谈你对 Kotlin 空安全的理解,它比 Java 的 @Nullable 强在哪?
答题框架:
- 类型系统层面:
T与T?是不同类型,检查发生在编译期且不可绕过;@Nullable只是注解约定,需要额外工具(Checker Framework、IDE 检查)才有约束力。 - 运行期层面:Kotlin 在公开函数入口插入
Intrinsics.checkNotNullParameter,对 Java 调用方提供fail-fast;JIT 内联后开销可忽略。 - 边界问题:平台类型
T!是妥协——Java 代码无 nullability 信息时,Kotlin 把检查推迟到运行时。解法是 Java 侧加注解(JSpecify /@NotNull)+-Xjsr305=strict。 - 生产影响:
!!应视为 code smell;用?.、?:、requireNotNull、checkNotNull表达意图;数据类反序列化时的 null 处理需特别注意。
下一章预告:第 2 章《JVM 全景:规范、实现与生态版图》——我们会厘清一个绝大多数人混淆的概念:JVM 规范、Java SE 平台、OpenJDK、HotSpot、Oracle JDK、GraalVM、OpenJ9、ART、JetBrains Runtime 到底是什么关系,以及为什么"在 GraalVM 上跑得好的代码在 HotSpot 上可能很慢"。