17370845950

静态内部类方式最实用，兼顾性能与安全。通过类加载机制保证线程安全，实现懒加载，代码简洁且无需显式同步，适用于多数单例场景。

在Java中，延迟初始化（Lazy Initialization）是指将对象的创建推迟到第一次使用时才进行。这种方式可以提高程序启动性能，节省内存资源，尤其适用于重量级对象或不一定会被使用的对象。以下是几种常见的实现方式。

1. 使用同步方法实现线程安全的延迟初始化

最简单直接的方式是通过同步方法来确保多线程环境下的安全初始化。

public class LazyInitWithSync {
    private static Instance instance;

    public static synchronized Instance getInstance() {
        if (instance == null) {
            instance = new Instance();
        }
        return instance;
    }
}

这种方式线程安全，但每次调用 getInstance() 都会加锁，影响性能。

2. 使用双重检查锁定（Double-Checked Locking）

优化同步范围，在实例已创建后避免不必要的同步开销。

public class LazyInitDoubleCheck {
    private static volatile Instance instance;

    public static Instance getInstance() {
        if (instance == null) {
            synchronized (LazyInitDoubleCheck.class) {
                if (instance == null) {
                    instance = new Instance();
                }
            }
        }
        return instance;
    }
}

注意：volatile 关键字防止指令重排序，确保多线程环境下正确性。

3. 使用静态内部类（推荐）

利用类加载机制保证线程安全，同时实现懒加载。

public class LazyInitInnerClass {
    private static class Holder {
        static final Instance INSTANCE = new Instance();
    }

    public static Instance getInstance() {
        return Holder.INSTANCE;
    }
}

内部类在第一次被引用时才会加载，JVM 保证类初始化的线程安全，无需显式同步，性能好且代码简洁。

4. 使用 Java 8 的 Supplier 辅助延迟初始化

适用于非单例场景，按需创建对象。

import java.util.function.Supplier;

public class LazySupplier {
    private Supplier lazyInstance = () -> new Instance();
    private Instance instance;

    public Instance getInstance() {
        if (instance == null) {
            instance = lazyInstance.get();
        }
        return instance;
    }
}

适合需要灵活控制创建逻辑的情况，但需自行处理线程安全。

基本上就这些。静态内部类方式在多数单例延迟初始化场景下最实用，兼顾性能与安全。