第 1 章 十二个"我以为我会"的陷阱

27 阅读30分钟

本章目标

  1. 用 12 个可复现的反直觉案例,暴露 Java 认知中最常见的断层;
  2. 每个案例都往下挖一层:语言规则 → 字节码 → JVM 机制;
  3. 每个案例都给出 Kotlin 对照:语言如何消灭这个坑,或者把它换成了什么新坑;
  4. 建立本书的核心方法论:不要背结论,要能推理。

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 里的规则只有一条:基本类型比值,引用类型比地址。所有的"反直觉"都源于此,加上两个额外因素:

  1. 装箱会把"值比较"偷偷变成"地址比较";
  2. 常量池/缓存会让"地址比较"偶尔碰巧等于"值比较"。
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 在每个公开函数的入口插入了一次参数非空检查。这意味着:

  1. Java 代码调用 Kotlin 函数传 null,会抛 NullPointerException(Kotlin 1.4 起从 IllegalArgumentException 改为 NPE,更符合直觉);
  2. 这次检查有成本,但 checkNotNullParameter 会被 JIT 内联成一个 if (x == null) throw,热路径上成本可忽略;
  3. 方法上还有 @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 被改了!

🚀 生产建议:

  1. 跨模块边界传递时,若需要真不可变,用 toList()(会复制成新的 ArrayList,虽然仍可被强转,但至少切断了与源集合的联系);
  2. 需要严格保证时用 java.util.List.copyOf(list)(JDK 10+),它返回的 ImmutableCollections 无法被强转成可修改类型;
  3. 在 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 的概率。

⚠️ 两个高频错误认知:

  1. "元空间不会 OOM" —— 会。java.lang.OutOfMemoryError: Metaspace。动态生成类的场景(CGLIB、Groovy、Kotlin 的 lambda 隐藏类、大量 ClassLoader)都可能触发。
  2. "直接内存不算 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)下次 GCWeakHashMap、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 ...

⚠️ 代价:

  1. 只能用于 inline 函数,不能用于类、属性、非内联函数;
  2. 不能从 Java 调用(内联函数对 Java 不可见其泛型实参);
  3. 二进制兼容问题:修改 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 规范定义的"主动引用"):

  1. new、getstatic/putstatic(读写非 static final 编译期常量)、invokestatic;
  2. 反射调用(Class.forName 默认会初始化);
  3. 初始化子类时,父类未初始化则先初始化父类;
  4. 启动类(含 main 的类);
  5. MethodHandle/invokedynamic 解析到 REF_getStatic 等;
  6. 接口中定义了 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/hashCodedata class 自动生成✅
冗长样板属性、默认参数、类型推断、when 表达式✅
switch 漏 casewhen 对 sealed/enum 强制穷尽性检查(2.2+ 数据流穷尽)✅
泛型无法 instanceof Treified + 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 本章小结

  1. 知识点不等于理解。Integer 缓存这种题,背下来只能应付一次面试;挖到 valueOf → IntegerCache → 装箱字节码 → 对象内存布局,才获得了可迁移的推理能力。
  2. 语言是皮,JVM 是骨。Kotlin 消灭了一批 Java 的语法级陷阱(NPE、==、样板),但所有 JVM 级规则原封不动:JMM、GC、类加载、擦除、装箱。
  3. Kotlin 也带来了新的陷阱,主要来自"编译期抽象与运行期现实的落差"(只读集合、平台类型、inline 二进制兼容、协程取消)。
  4. 老八股在 JDK 27 上大量失效:偏向锁没了、对象头变 8 字节了、默认 GC 在所有环境都是 G1 了、finalize 要被移除了、final 字段不许反射改了、启动可以走 AOT 缓存了。
  5. 本书的方法论:现象 → 字节码 → 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。

修改方案:

  1. 参数改为 User? 并用 ?. 处理;
  2. 在 Java 侧加 @NotNull(或迁移到 JSpecify)并开启 Kotlin 的 -Xjsr305=strict,让平台类型在编译期就变为非空类型;
  3. 逐步把 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 字节。

验证方式:

  1. 用 OpenJDK JOL(GraphLayout.parseInstance(obj).totalSize());
  2. jhsdb clhsdb --pid <pid> + inspect <address> 看对象大小;
  3. 分配大量对象后对比 -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 上可能很慢"。