设计模式：创建型模式--单例模式（Singleton Pattern）

设计模式：创建型模式–单例模式（Singleton Pattern）

此文章仅作为自己学习过程中的记录和总结。

1. 概念

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

2. 组成结构

单例模式的组成主要包含以下角色：

• 单例类：只能创建一个实例的类。
• 访问类：使用单例类。

3. 实现方式

单例模式主要分为以下两种：

• 饿汉式 (hurry Singleton)：类加载就会导致该单实例对象被创建。
• 懒汉式 (lazy Singleton)：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建。

3.1 饿汉式

饿汉式 (hurry Singleton)：在类加载时，该单实例对象就被创建。

3.1.1 静态变量

通过声明静态变量的方式实现单例模式。

/**
 * @author zzay
 * @className Singleton
 * @description 创建者模式-单例模式：饿汉式（静态成员变量）
 * @create 2022/02/25 21:26
 */
public class Singleton {

    // 1.私有构造方法（单例的前提）
    private Singleton() {}

    // 2.创建本类对象（静态变量在JVM中只有一份）
    private static Singleton instance = new Singleton();

    // 3.提供公共的访问入口
    public static Singleton getInstance() {
        return instance;
    }

}

• 不足：

  该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

3.1.2 静态代码块

通过静态代码块初始化的方式实现单例模式。

/**
 * @author zzay
 * @className Singleton
 * @description 创建者模式-单例模式：饿汉式（静态代码块）
 * @create 2022/02/25 21:33
 */
public class Singleton {

    // 1.私有构造方法（单例的前提）
    private Singleton() {}

    // 2.声明Singleton类型的变量
    private static Singleton instance;

    // 3.在静态代码块中赋值
    static {
        instance = new Singleton();
    }

    // 4.对外提供公共访问入口
    public static Singleton getInstance() {
        return instance;
    }

}

• 不足：

  该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

3.1.3 枚举方式

枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式。

枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

/**
 * @author zzay
 * @enumClassName Singleton
 * @description 创建者模式-单例模式：饿汉式（枚举方式）
 * @create 2022/02/25 23:56
 */
public enum Singleton {
    INSTANCE;
}

3.2 懒汉式

懒汉式 (lazy Singleton)：在类加载时不会导致该单实例对象被创建，而是首次使用该对象时才会创建。

3.2.1 非线程安全

单例模式懒汉式实现的非线程安全版本。

/**
 * @author zzay
 * @className Singleton
 * @description 创建者模式-单例模式：懒汉式（线程不安全）
 * @create 2022/02/25 23:33
 */
public class Singleton {

    // 1.私有化Singleton构造函数
    private Singleton() {}

    // 2.创建Singleton对象
    private static Singleton instance;

    // 3.提供公共访问入口
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

• 不足：

  此种情况下，对象是什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。因此，我们可以进行相应的改进。

3.2.2 线程安全

单例模式懒汉式实现的线程安全版本。实际上，对比非线程安全版本，仅仅在访问入口函数处多添加synchronized修饰符。

/**
 * @author zzay
 * @className Singleton
 * @description 创建者模式-单例模式：懒汉式（线程安全）
 * @create 2022/02/25 23:46
 */
public class Singleton {

    // 1.私有化构造方法
    private Singleton() {}

    // 2.创建Singleton对象
    private static Singleton instance;

    // 3.提供公共访问入口
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

• 不足：

  该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。

  然而，从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。因此，我们可以进一步改进。

3.2.3 双重检查锁

通过双重检查锁来判断是否应该参与抢锁，以及是否进行首次的分配。

/**
 * @author zzay
 * @className Singleton
 * @description 创建者模式-单例模式：懒汉式（双重检查锁）
 * @create 2022/02/25 23:49
 */
public class Singleton {

    // 1.私有化Singleton构造方法
    private Singleton() {}

    // 2.创建Singleton对象
    private static Singleton instance;

    // 3.提供公共访问入口
    public static Singleton getInstance() {
        // 首次判断，若instance不为null，则不参与抢锁阶段，直接返回实例
        if (instance == null) {
            synchronized (Singleton.class) {
                // 抢到锁之后再次判断是否为null
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

• 不足：

  双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

  要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

 // 2.创建Singleton对象
 private static volatile Singleton instance;

3.2.4 静态内部类

静态内部类单例模式中实例由内部类创建。由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。 静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance()时，JVM才会加载SingletonHolder，并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。

/**
 * @author zzay
 * @className Singleton
 * @description 创建者模式-单例模式：懒汉式（静态内部类）
 * @create 2022/02/25 23:57
 */
public class Singleton {

    // 私有化构造方法
    private Singleton() {
    }

    // 提供公共访问入口
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    /**
     * 持有单例的静态内部类。
     * JVM在加载外部类的过程中，不会加载静态内部类。
     * 只有内部类的属性或方法被调用时才会被加载，并初始化其静态属性。
     */
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

}

静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

4. 存在问题

然而，对于以上的多种Singleton实现方式，我们仍能够做到破坏单例模式，即使上面定义的单例类可以创建多个对象（枚举方式除外）。其中有两种方式，分别是：

1. 利用序列化。
2. 利用反射机制。

4.1 序列化反序列化

• 问题演示：

  /**
   * @author zzay
   * @className Test
   * @description 创建者模式-破坏单例模式：序列化
   * @create 2022/02/26 00:05
   */
  public class Test {
  
      public static void main(String[] args) throws Exception {
          // 向文件中写Singleton对象
          writeObjectToFile();
          // 从文件中读取Singleton对象
          Singleton s1 = readObjectFromFile();
          Singleton s2 = readObjectFromFile();
          // 判断是否为同一对象
          System.out.println(s1 == s2);
      }
  
      /**
       * 将Singleton对象写入到文件中。
       */
      public static void writeObjectToFile() throws Exception {
          // 获取Singleton对象
          Singleton instance = Singleton.getInstance();
          // 创建对象输出流
          ObjectOutputStream oos = new ObjectOutputStream(
                  new FileOutputStream("singleton.txt"));
          // 将Singleton对象写出到文件中
          oos.writeObject(instance);
      }
  
      /**
       * 从文件中读取Singleton对象。
       */
      private static Singleton readObjectFromFile() throws Exception {
          // 创建对象输入流对象
          ObjectInputStream ois = new ObjectInputStream(
                  new FileInputStream("singleton.txt"));
          // 第一次读取Singleton对象
          Singleton instance = (Singleton) ois.readObject();
          return instance;
      }
  
  }
  

• 解决方案：

  在Singleton类中添加readResolve()方法，在反序列化时被反射调用。

  如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

  /**
   * @author zzay
   * @className Singleton
   * @description 创建者模式-破坏单例模式：序列化
   * @create 2022/02/26 00:16
   */
  public class Singleton implements Serializable {
  
      // ...
  
      /**
       * 为了解决序列化反序列化破解单例模式。
       */
      private Object readResolve() {
          return SingletonHolder.INSTANCE;
      }
  
  }
  

4.2 反射机制

• 问题演示：

  /**
   * @author zzay
   * @className Test
   * @description 创建者模式-破坏单例模式：反射
   * @create 2022/02/26 00:19
   */
  public class Test {
  
      public static void main(String[] args) throws Exception {
          // 获取Singleton类的字节码对象
          Class singletonClass = Singleton.class;
          // 获取Singleton类的私有无参构造方法对象
          Constructor constructor = singletonClass.getDeclaredConstructor();
          // 强行取消访问权限检查
          constructor.setAccessible(true);
          // 创建两个Singleton对象
          Singleton s1 = (Singleton) constructor.newInstance();
          Singleton s2 = (Singleton) constructor.newInstance();
          // 判断通过反射创建的两个Singleton对象是否相同
          System.out.println(s1 == s2);
      }
  
  }
  

• 解决方案：

  当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。

  /**
   * @author zzay
   * @className Singleton
   * @description 创建者模式-破坏单例模式：反射
   * @create 2022/02/26 00:23
   */
  public class Singleton {
  
      // 私有化Singleton构造方法
      private Singleton() {
          // 解决通过反射破坏单例模式的问题
          if (instance != null) {
              throw new RuntimeException();
          }
      }
  
      // ..
  
  }