【Spring】单例模式的创建方式（Bean解析）

在Java中，单例模式（Singleton Pattern）确保一个类只有一个实例，并提供全局访问点。以下是实现单例的五种常见方式：懒汉式 、饿汉式 、双重检查锁 、静态内部类 和枚举，包括代码示例和优缺点分析。

---

1. 懒汉式（Lazy Initialization）

• 特点：延迟加载，实例在第一次使用时创建。

• 线程安全：基本实现非线程安全，需加锁优化。

• 代码示例 ：

  public class Singleton {
      private static Singleton instance;
  
      private Singleton() {} // 私有构造，防止外部实例化
  
      public static Singleton getInstance() {
          if (instance == null) {
              instance = new Singleton();
          }
          return instance;
      }
  }

  • 线程安全版 （加锁）：

    public class Singleton {
        private static Singleton instance;
    
        private Singleton() {}
    
        public static synchronized Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

• 优点 ：

  • 延迟加载，节省内存（只有在使用时才创建实例）。

• 缺点 ：

  • 基本版线程不安全。
  • 线程安全版使用synchronized方法锁，性能较低（每次调用都加锁）。

• 适用场景：单线程环境或实例创建开销小、对性能要求不高的场景。

---

2. 饿汉式（Eager Initialization）

• 特点：类加载时就创建实例，急切初始化。

• 线程安全：天然线程安全，依赖JVM类加载机制。

• 代码示例 ：

  public class Singleton {
      private static final Singleton instance = new Singleton();
  
      private Singleton() {}
  
      public static Singleton getInstance() {
          return instance;
      }
  }

• 优点 ：

  • 实现简单，线程安全（由JVM类加载保证）。
  • 无需加锁，性能较高。

• 缺点 ：

  • 非延迟加载，类加载时即创建实例，可能浪费内存（如果实例未被使用）。
  • 如果构造方法有复杂逻辑，类加载可能变慢。

• 适用场景：实例创建开销小、确定会被使用的场景。

---

3. 双重检查锁（Double-Checked Locking, DCL）

• 特点：结合懒汉式的延迟加载和线程安全，减少锁粒度。

• 线程安全 ：通过volatile和双重检查确保线程安全。

• 代码示例 ：

  public class Singleton {
      private static volatile Singleton instance;
  
      private Singleton() {}
  
      public static Singleton getInstance() {
          if (instance == null) { // 第一次检查（无锁）
              synchronized (Singleton.class) {
                  if (instance == null) { // 第二次检查（有锁）
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }

• 关键点 ：

  • volatile防止指令重排序，确保实例初始化完成前不被其他线程访问。
  • 双重检查减少锁竞争，仅在实例未创建时加锁。

• 优点 ：

  • 延迟加载，节省内存。
  • 线程安全，性能较高（锁粒度小）。

• 缺点 ：

  • 实现较复杂，需理解volatile和指令重排序。
  • 早期Java版本（1.4及之前）可能有DCL失效问题（现已解决）。

• 适用场景：需要延迟加载且高并发的场景。

---

4. 静态内部类（Static Inner Class）

• 特点：利用JVM类加载机制实现延迟加载和线程安全。

• 线程安全：由JVM保证静态内部类加载时的线程安全。

• 代码示例 ：

  public class Singleton {
      private Singleton() {}
  
      private static class SingletonHolder {
          private static final Singleton INSTANCE = new Singleton();
      }
  
      public static Singleton getInstance() {
          return SingletonHolder.INSTANCE;
      }
  }

• 原理 ：

  • 静态内部类SingletonHolder在getInstance()调用时才加载，触发INSTANCE初始化。
  • JVM确保类加载过程线程安全，无需额外同步。

• 优点 ：

  • 延迟加载，节省内存。
  • 线程安全，无需加锁，性能高。
  • 实现优雅，代码简洁。

• 缺点 ：

  • 无法传递参数给构造方法（除非通过其他方式）。

• 适用场景：需要延迟加载且要求高性能的场景，推荐使用。

---

5. 枚举（Enum）

• 特点：使用Java枚举类型实现单例，简洁且天然线程安全。

• 线程安全：由JVM保证枚举实例的单例性。

• 代码示例 ：

  public enum Singleton {
      INSTANCE;
  
      // 可添加方法
      public void doSomething() {
          System.out.println("Singleton method called");
      }
  }

  • 使用方式：

    Singleton.INSTANCE.doSomething();

• 优点 ：

  • 实现最简单，代码极少。
  • 线程安全，由JVM保证。
  • 防止反射攻击和序列化问题（枚举天生防止反序列化创建新实例）。
  • 支持添加方法，功能灵活。

• 缺点 ：

  • 非延迟加载，枚举类加载时即创建实例。
  • 不支持复杂构造逻辑（枚举构造较为固定）。

• 适用场景：需要绝对线程安全、防止反射/序列化问题、逻辑简单的场景。

---

6. 对比总结

方式	延迟加载	线程安全	性能	复杂性	防止反射/序列化	适用场景
懒汉式	是	否/是（加锁）	低（锁）	低	需额外处理	单线程或低并发
饿汉式	否	是	高	低	需额外处理	确定使用、无内存限制
双重检查锁	是	是	高	高	需额外处理	高并发、延迟加载
静态内部类	是	是	高	中	需额外处理	高性能、延迟加载，推荐
枚举	否	是	高	低	天然支持	简单逻辑、防反射/序列化，推荐

---

7. 注意事项

• 私有构造：所有实现都需私有构造方法，防止外部实例化。

• 反射攻击 ：除枚举外，其他方式可能通过反射创建实例，需在构造方法中加防护：

  private Singleton() {
      if (instance != null) {
          throw new RuntimeException("Instance already exists!");
      }
  }

• 序列化问题 ：除枚举外，单例实现序列化时需实现readResolve方法：

  private Object readResolve() {
      return instance;
  }

• Spring中的单例：Spring的单例是容器级别的，生命周期由Spring管理，通常无需手动实现单例模式。

---

8. 推荐方式

• 首选 ：静态内部类（延迟加载、线程安全、实现优雅）。
• 次选 ：枚举（最简单、防反射/序列化，适合简单场景）。
• 高并发 ：双重检查锁 （需确保正确使用volatile）。
• 确定使用 ：饿汉式（简单直接）。
• 避免 ：懒汉式（除非单线程或加锁优化）。