设计模式了解吗，知道什么是饿汉式和懒汉式吗？

当然了解，设计模式是软件设计中针对常见问题的通用、可复用的解决方案。它能让代码更易于维护、扩展和复用。

饿汉式和懒汉式是单例模式的两种经典实现方式。

核心概念：单例模式

• 目的：确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。
• 应用场景：比如数据库连接池、线程池、日志对象、应用的配置类等。这些对象在程序中只需要一个实例即可，创建多个实例会浪费资源或导致行为异常。

饿汉式

核心思想：“饿”，顾名思义，很饥饿，所以在类加载的时候就已经创建好实例，不管后面用不用，先创建了再说。

特点：

• 线程安全：因为实例的创建是在类加载阶段完成的，这个阶段由JVM保证线程安全。
• 加载慢，获取快：类一加载就初始化实例，可能会稍微拖慢启动速度，但获取实例对象的速度非常快。

代码示例：

public class SingletonEager {
    // 1. 私有静态实例，在类加载时就直接创建
    private static final SingletonEager INSTANCE = new SingletonEager();

    // 2. 私有构造函数，防止外部通过 new 关键字创建实例
    private SingletonEager() {}

    // 3. 公共的静态方法，用于获取唯一实例
    public static SingletonEager getInstance() {
        return INSTANCE;
    }
}

优点：实现简单，绝对线程安全。
缺点：如果这个实例非常耗费资源，但在整个程序运行过程中又可能用不到，就会造成资源的浪费。

懒汉式

核心思想：“懒”，很懒惰，所以只有在第一次被用到的时候才创建实例。

特点：

• 资源利用率高：只有在需要的时候才创建，避免了不必要的资源消耗。
• 加载快，获取慢（第一次）：类加载时不初始化，第一次调用 getInstance() 时才创建，所以第一次获取会稍慢。

基础版（非线程安全）

这个版本在多线程环境下会出问题。

public class SingletonLazy {
    private static SingletonLazy instance; // 不直接初始化

    private SingletonLazy() {}

    public static SingletonLazy getInstance() {
        // 判断如果实例为空，则创建
        if (instance == null) {
            instance = new SingletonLazy(); // 问题所在：多个线程可能同时进入这里
        }
        return instance;
    }
}

改进版（线程安全，使用 synchronized）

通过给方法加锁来解决线程安全问题，但效率较低。

public class SingletonLazySync {
    private static SingletonLazySync instance;

    private SingletonLazySync() {}

    // 使用 synchronized 关键字，保证同时只有一个线程能进入该方法
    public static synchronized SingletonLazySync getInstance() {
        if (instance == null) {
            instance = new SingletonLazySync();
        }
        return instance;
    }
}

最优版（双重检查锁 DCL）

为了兼顾线程安全和效率，我们只在实例还没创建的时候进行同步。

public class SingletonLazyDCL {
    // 使用 volatile 关键字，防止指令重排，保证可见性
    private static volatile SingletonLazyDCL instance;

    private SingletonLazyDCL() {}

    public static SingletonLazyDCL getInstance() {
        // 第一次检查，如果实例已存在，则直接返回，避免进入同步块，提高效率。
        if (instance == null) {
            // 加锁，确保只有一个线程能进入同步块
            synchronized (SingletonLazyDCL.class) {
                // 第二次检查，防止在等待锁的过程中，已有其他线程创建了实例。
                if (instance == null) {
                    instance = new SingletonLazyDCL();
                }
            }
        }
        return instance;
    }
}

为什么用 volatile？
instance = new SingletonLazyDCL(); 这行代码不是一个原子操作，它分为三步：

1. 分配内存空间
2. 初始化对象
3. 将 instance 指向分配的内存地址

如果没有 volatile，JVM 可能会进行指令重排序，导致步骤 3 在步骤 2 之前执行。这样另一个线程可能在第一次检查时看到 instance 不为 null（已经指向了内存地址），但对象还没有初始化完成，从而拿到一个不完整的对象。volatile 可以禁止这种重排序。

总结对比

特性	饿汉式	懒汉式（基础版）	懒汉式（双重检查锁）
创建时机	类加载时	第一次调用 getInstance()时	第一次调用 getInstance()时
线程安全	是	否	是
资源利用	差，可能浪费	好	好
性能	获取实例快	（线程不安全，无意义）	第一次稍慢，之后快
实现难度	简单	简单	复杂

在现代 Java 开发中，还有更简洁的实现单例的方式，比如使用 枚举（Enum），它天生就是单例的，并且能防止反射和反序列化攻击，是《Effective Java》作者强烈推荐的方式。

public enum SingletonEnum {
    INSTANCE; // 这就是单例的实例

    public void doSomething() {
        // ... 业务方法
    }
}
// 使用：SingletonEnum.INSTANCE.doSomething();