告别 Volatile 与繁琐 DCL！JDK 26 LazyConstant 重构 Java 延迟加载，性能碾压手动双检锁

在多线程环境下，延迟加载（Lazy Initialization）一直是衡量一个 Java 工程师基本功的试金石。

为了实现“单例”或者“按需初始化”，我们最常用的套路就是 双重检查锁定（Double-Checked Locking, DCL）。

为了防止指令重排，我们不得不祭出 volatile 关键字：

// 经典的 DCL 模式，你可能已经写了十年
privatevolatile Config config;

public Config getConfig() {
    Config result = config;
    if (result == null) {
        synchronized(this) {
            result = config;
            if (result == null) {
                config = result = loadConfig();
            }
        }
    }
    return result;
}

这段代码虽然经典，但它有两个挥之不去的痛点：

1. 样板代码冗余： 逻辑极其绕，稍微漏写个 volatile 或内层判断，就是个难以排查的并发 Bug。
2. 性能天花板： 由于字段是 volatile 且非 final，JVM 的 JIT 编译器不敢对其进行深度优化（如常量折叠），每次读取都要走一遍内存屏障。

JEP 526 LazyConstants

在 JDK 26 中，Java 官方终于看不下去了，直接在底层库里塞进了一个“标准答案”：LazyConstant<T>。

现在的写法是这样的：

// 注：代码瞬间清爽，且支持 final 语义
private final LazyConstant<Config> config = LazyConstant.of(() -> loadConfig());

public Config getConfig() {
    return config.get(); // 线程安全，官方保证只执行一次
}

为什么 LazyConstant 远强于 volatile？

很多同学会问：不就是封装了一层吗？我自己写个工具类不也一样？还真不一样。

LazyConstant 在 JVM 层面做了三件硬核的事：

1. 真正的“常量”性能（@Stable）

LazyConstant 内部使用了 JVM 的私有注解 @Stable。

• volatile： 告诉 CPU 每次都要看一眼内存，怕别人改了。
• LazyConstant： 告诉 JIT 编译器，这玩意儿初始化完就是死值，你可以直接把它内联到调用处。这种“常量折叠”优化在频繁调用的热点代码中，性能提升是降维打击。

2. 容错与重试机制

以前的 DCL，如果 loadConfig() 抛出异常，你的代码逻辑往往会陷入尴尬：是缓存这个异常？还是下次再试？LazyConstant 设定了计算失败不缓存。如果第一次初始化崩了，下个线程进来会再次尝试，直到成功为止。这对于加载数据库连接、网络配置等不稳定资源简直是福音。

3. 强制非空（Null-Safety）

LazyConstant 不允许初始化返回 null。它在工程实践层面强制你规避掉 NullPointerException 的隐患，让代码更健壮。

进阶：集合的“懒加载”化

除了单个对象，JDK 26 还配套推出了：

• List.ofLazy(() -> loadList())
• Map.ofLazy(() -> loadMap())

这意味着你可以定义一个巨大的配置 Map，但在应用启动时零开销，只有当你真正 get(“key”) 的那一刻，对应的元素才会被计算出来。

// List
class Application {

    // 旧:
    // static final OrderController ORDERS = new OrderController();

    // 新:
    staticfinal List<OrderController> ORDERS
        = List.ofLazy(POOL_SIZE, _ -> new OrderController());

    public static OrderController orders() {
        long index = Thread.currentThread().threadId() % POOL_SIZE;
        return ORDERS.get((int)index);
    }

}

// Map
class Application {

    // 旧:
    staticfinal Map<String, OrderController> ORDERS
        = Map.ofLazy(Set.of("Customers", "Internal", "Testing"),
                     _ -> new OrderController());

    // 新:
    public static OrderController orders() {
        String threadName = Thread.currentThread().getName();
        return ORDERS.get(threadName);
    }

}

总结

作为开发工程师，我们要看到 Java 进化的脉络：从“手动挡”向“自动挡”进化。

• JDK 8 引入了 Lambda，解放了匿名内部类；
• JDK 21 引入了虚拟线程，解放了线程池的管理压力；
• JDK 26 的 LazyConstant，则是要解放并发编程中的状态管理。

以上关于告别 Volatile 与繁琐 DCL！JDK 26 LazyConstant 重构 Java 延迟加载，性能碾压手动双检锁的文章就介绍到这了，更多相关内容请搜索码云笔记以前的文章或继续浏览下面的相关文章，希望大家以后多多支持码云笔记。