Java懒汉模式和饿汉模式有什么区别

Java单例模式的核心目标是保证一个类在全局只有一个实例，并提供一个全局访问点，懒汉模式和饿汉模式是两种最基础的实现方式，二者的核心差异体现在实例初始化的时机和设计逻辑上。

饿汉模式的实现与特点

饿汉模式的实例在类加载阶段就会完成初始化，不管后续是否会被使用，实例都已经准备就绪。它的实现逻辑比较简单，代码如下：

// 饿汉模式单例实现
public class HungrySingleton {
    // 类加载时就初始化实例
    private static final HungrySingleton instance = new HungrySingleton();
    
    // 私有构造方法，防止外部实例化
    private HungrySingleton() {}
    
    // 提供全局访问点
    public static HungrySingleton getInstance() {
        return instance;
    }
}

饿汉模式的优势是天然线程安全，因为类加载过程由JVM保证线程安全，不会出现多个线程同时创建实例的问题。缺点是如果实例初始化比较耗时，或者后续根本不会被使用，会造成不必要的资源浪费。

懒汉模式的实现与特点

懒汉模式的实例不会在类加载时初始化，而是在第一次调用获取实例的方法时才去创建，也就是延迟加载。最基础的懒汉模式实现如下：

// 基础懒汉模式单例实现
public class LazySingleton {
    // 先不初始化实例
    private static LazySingleton instance;
    
    // 私有构造方法
    private LazySingleton() {}
    
    // 第一次调用时才创建实例
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

这种基础实现存在线程安全问题，如果多个线程同时调用getInstance()方法，可能会创建多个实例，破坏了单例的特性。如果要保证线程安全，可以加上synchronized关键字，修改后的代码如下：

// 线程安全的懒汉模式实现
public class SafeLazySingleton {
    private static SafeLazySingleton instance;
    
    private SafeLazySingleton() {}
    
    // 加上同步锁保证线程安全
    public static synchronized SafeLazySingleton getInstance() {
        if (instance == null) {
            instance = new SafeLazySingleton();
        }
        return instance;
    }
}

这种加锁的方式虽然保证了线程安全，但是每次调用getInstance()方法都需要获取锁，性能开销比较大。实际开发中更常用的是双重检查锁的实现方式，既保证线程安全，又减少锁的开销：

// 双重检查锁懒汉模式实现
public class DCLLazySingleton {
    // 用volatile关键字防止指令重排
    private static volatile DCLLazySingleton instance;
    
    private DCLLazySingleton() {}
    
    public static DCLLazySingleton getInstance() {
        if (instance == null) {
            synchronized (DCLLazySingleton.class) {
                if (instance == null) {
                    instance = new DCLLazySingleton();
                }
            }
        }
        return instance;
    }
}

二者的核心区别对比

我们可以通过下面的表格更直观地看到两种模式的差异：

场景选择建议

如果单例实例的初始化成本低，且大概率会被使用，优先选择饿汉模式，实现简单且稳定。如果单例实例初始化成本高，或者不确定是否会被使用，优先选择双重检查锁实现的懒汉模式，避免不必要的资源浪费。另外如果涉及序列化场景，还需要额外重写readResolve()方法防止反序列化破坏单例，这一点两种模式都需要注意。

Java单例模式懒汉模式饿汉模式修改时间：2026-06-17 00:48:24