【单例模式】饿汉式、懒汉式、静态内部类--简单例子

单例模式是⼀个单例类在任何情况下都只存在⼀个实例，构造⽅法必须是私有的、由⾃⼰创建⼀个静态变量存储实例，对外提供⼀个静态公有⽅法获取实例。

一、单例模式

饿汉式

静态内部类

懒汉式

反射可以破坏单例

道高一尺魔高一丈

枚举

一、单例模式

饿汉式

类⼀加载就创建对象，这种⽅式⽐较常用，但容易产⽣垃圾对象，浪费内存空间。

// 饿汉式
public class HungryMan {
  private HungryMan(){}

  private final static HungryMan HUNGRY = new HungryMan();

  public static HungryMan getInstance(){
    return HUNGRY;
  }
}

那么它是如何保证线程安全的呢？它是基于类加载机制避免了多线程的同步问题，但是如果类被不同的类加载器加载就会创建不同的实例。

优点：线程安全，没有加锁，执⾏效率较⾼。
缺点：不是懒加载，类加载时就初始化，浪费内存空间。

静态内部类

使用静态内部类来实现单例模式是一种非常优雅且线程安全的方式。

这种方法利用了Java类加载机制的特性，即静态内部类只有在被引用时才会被加载和初始化，从而实现了延迟加载的效果。同时，由于Java虚拟机在类加载的过程中，是单线程的，所以静态内部类初始化过程中的线程安全性得到了保证。

// 静态内部类
public class Holder {
  private Holder(){}

  public static class Inner{
    private static final Holder HOLDER = new Holder();
  }

  public static Holder getInstance(){
    return Inner.HOLDER;
  }
}

在这个例子中，Holder 类是我们要实现单例的类。我们将其构造函数私有化，以防止外部代码直接通过 new Holder () 来创建实例。然后，我们创建了一个私有的静态内部类 Inner ，它包含一个静态的 Holder 实例。外部代码无法直接访问这个内部类，但是可以通过调用 Holder .getInstance() 方法来获取单例实例。

当 Holder .getInstance() 方法被调用时，Inner 类会被加载和初始化（如果尚未加载的话），这个过程是由Java虚拟机在单线程环境中完成的，因此是线程安全的。在 Inner 类被初始化的过程中，静态变量 INSTANCE 会被创建，并且只会被创建一次。因此，Holder .getInstance() 方法总是返回同一个 Holder 实例，从而实现了单例模式。

懒汉式

懒汉式是一种单例模式的实现方式。这种方式的核心思想是延迟加载，也就是在真正需要使用到实例对象时才进行创建，而不是在程序启动时就创建。这种方式可以节省系统资源，提高程序的运行效率。

在懒汉式单例模式中，会将对象的创建过程放到一个静态方法中，并在这个方法中进行同步控制，以保证在多线程环境下仍然只创建一个实例。当程序第一次调用该方法时，会检查实例是否已经创建，如果没有，则进行创建；如果已经创建，则直接返回已经创建的实例。

// 懒汉式
public class LayMan {
  private LayMan(){}

  private static volatile LayMan layMan;

  // 双层检测锁模式
  public static LayMan getInstance(){
    if(layMan == null){
      synchronized (LayMan.class){
        if(layMan == null){
          layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间
        }
      }
    }
    return layMan;
  }

  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      new Thread(()->{
        LayMan.getInstance();
      }).start();
    }
  }
}

那么它是如何保证线程安全呢？通过 synchronized 关键字加锁保证线程安全， synchronized 可以添加在⽅法上⾯，也可以添加在代码块上⾯，存在的问题是每⼀次调⽤ getInstance 获取实例时都需要加锁和释放锁，这样是⾮常影响性能的。

在单线程下使⽤没有问题，但是，对于多线程是⽆法保证单例的

懒汉式单例模式的主要优点是它的延迟加载特性，可以在系统启动时减少不必要的资源消耗。然而，由于需要进行同步控制，懒汉式单例模式在多线程环境下的性能可能会受到一定影响。此外，如果实现不当，懒汉式单例模式也可能会存在线程安全问题。

---》优点：懒加载，缺点：线程不安全

但是还是不安全，可以通过反射来破坏单例。

反射可以破坏单例

反射破坏单例模式的方式主要是通过访问并调用类的私有构造函数来创建新的实例。在单例模式中，通常会将构造函数设为私有，以防止外部代码创建类的多个实例。然而，使用Java反射API，可以绕过这些访问限制。

具体来说，反射破坏单例模式的步骤如下：

获取单例类的Class对象。这可以通过调用Class.forName()方法或使用.class语法来完成。
使用Class对象的getDeclaredConstructor()方法来获取私有构造函数的Constructor对象。这个方法可以访问类中的所有构造函数，无论它们是公有还是私有。
调用Constructor.setAccessible(true)方法来允许访问私有构造函数。这将取消Java语言的访问检查，使得即使构造函数是私有的，也可以被调用。
最后，使用Constructor.newInstance()方法来创建单例类的新实例。

这样，即使单例类的构造函数是私有的，也可以通过反射来创建多个实例，从而破坏单例模式的约束。

（1）

import java.lang.reflect.Constructor;

// 懒汉式
public class LayMan {
  private LayMan(){}

  private static volatile LayMan layMan;

  // 双层检测锁模式
  public static LayMan getInstance(){
    if(layMan == null){
      synchronized (LayMan.class){
        if(layMan == null){
          layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间
        }
      }
    }
    return layMan;
  }

  public static void main(String[] args) throws Exception {
    LayMan instance1 = LayMan.getInstance();
    Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    LayMan instance2 = declaredConstructor.newInstance();

    System.out.println(instance1);
    System.out.println(instance2);

  }
}

从代码运行结果可以看的，拿到了两个不同的实例：

（2）

import java.lang.reflect.Constructor;

// 懒汉式
public class LayMan {
  private LayMan(){}

  private static volatile LayMan layMan;

  // 双层检测锁模式
  public static LayMan getInstance(){
    if(layMan == null){
      synchronized (LayMan.class){
        if(layMan == null){
          layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间
        }
      }
    }
    return layMan;
  }

  public static void main(String[] args) throws Exception {
    Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    LayMan instance2 = declaredConstructor.newInstance();
    LayMan instance3 = declaredConstructor.newInstance();

    System.out.println(instance3);
    System.out.println(instance2);

  }
}

从代码运行结果可以看的，拿到了两个不同的实例：

道高一尺魔高一丈

（1）为了防止反射破坏单例模式，可以采取一些防御措施。例如，在构造函数中添加检查，如果已经存在实例，则抛出异常。

import java.lang.reflect.Constructor;

// 懒汉式
public class LayMan {
  private LayMan(){
    synchronized (LayMan.class){
      if(layMan != null){
        throw new RuntimeException("不用试图使用反射破坏单例");
      }
    }
  }

  private static volatile LayMan layMan;

  // 双层检测锁模式
  public static LayMan getInstance(){
    if(layMan == null){
      synchronized (LayMan.class){
        if(layMan == null){
          layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间
        }
      }
    }
    return layMan;
  }

  public static void main(String[] args) throws Exception {
    LayMan instance1 = LayMan.getInstance();
    Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    LayMan instance2 = declaredConstructor.newInstance();

    System.out.println(instance1);
    System.out.println(instance2);

  }
}

（2）但是，简单的在构造方法里判断layMan是否是null，如果是通过反射创建的2个实例，就可以通过反射进行破坏了。

import java.lang.reflect.Constructor;

// 懒汉式
public class LayMan {
  private LayMan(){
    synchronized (LayMan.class){
      if(layMan != null){
        throw new RuntimeException("不用试图使用反射破坏单例");
      }
    }
  }

  private static volatile LayMan layMan;

  // 双层检测锁模式
  public static LayMan getInstance(){
    if(layMan == null){
      synchronized (LayMan.class){
        if(layMan == null){
          layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间
        }
      }
    }
    return layMan;
  }

  public static void main(String[] args) throws Exception {
    Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    LayMan instance2 = declaredConstructor.newInstance();
    LayMan instance3 = declaredConstructor.newInstance();

    System.out.println(instance3);
    System.out.println(instance2);

  }
}

从代码运行结果可以看的，拿到了两个不同的实例：

（3）红绿灯方法：设置一个标志位flag

但是，简单的在构造方法里判断l标志位flag是否被修改过，也可以通过反射进行破坏。

import java.lang.reflect.Constructor;

// 懒汉式
public class LayMan {
  private static boolean flag = false;

  private LayMan(){
    synchronized (LayMan.class){
      if(flag == false){
        flag = true;
      } else {
        throw new RuntimeException("不用试图使用反射破坏单例");
      }
    }
  }

  private static volatile LayMan layMan;

  // 双层检测锁模式
  public static LayMan getInstance(){
    if(layMan == null){
      synchronized (LayMan.class){
        if(layMan == null){
          layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间
        }
      }
    }
    return layMan;
  }

  public static void main(String[] args) throws Exception {
//    LayMan instance1 = LayMan.getInstance();
    Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    LayMan instance2 = declaredConstructor.newInstance();
    LayMan instance3 = declaredConstructor.newInstance();

    System.out.println(instance3);
    System.out.println(instance2);

  }
}

（4）相应的，我们也可以通过反射对这个标志位flag进行修改。

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

// 懒汉式
public class LayMan {
  private static boolean flag = false;

  private LayMan(){
    synchronized (LayMan.class){
      if(flag == false){
        flag = true;
      } else {
        throw new RuntimeException("不用试图使用反射破坏单例");
      }
    }
  }

  private static volatile LayMan layMan;

  // 双层检测锁模式
  public static LayMan getInstance(){
    if(layMan == null){
      synchronized (LayMan.class){
        if(layMan == null){
          layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间
        }
      }
    }
    return layMan;
  }

  public static void main(String[] args) throws Exception {
//    LayMan instance1 = LayMan.getInstance();

    Field f = LayMan.class.getDeclaredField("flag");
    f.setAccessible(true);

    Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    LayMan instance2 = declaredConstructor.newInstance();
    f.set(instance2, false);
    LayMan instance3 = declaredConstructor.newInstance();

    System.out.println(instance3);
    System.out.println(instance2);

  }
}

从代码运行结果可以看的，拿到了两个不同的实例：

枚举

另外，还可以通过枚举类来实现单例，因为枚举类在Java中是天然的单例，且能够抵御反射攻击。

import java.lang.reflect.Constructor;

public enum EnumSingle {
  INSTANCE;

  public EnumSingle getInstance(){
    return INSTANCE;
  }
}


class Test{
  public static void main(String[] args) {
    EnumSingle instance1 = EnumSingle.INSTANCE;
    EnumSingle instance2 = EnumSingle.INSTANCE;
    System.out.println(instance1);
    System.out.println(instance2);


    Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
    declaredConstructor.setAccessible(true);
    EnumSingle instance3 = declaredConstructor.newInstance();
    System.out.println(instance3);

  }
}

从代码运行结果可以看的，拿到了两个不同的实例：

并且也可以看到，枚举类里是没有一个无参构造方法的。

在Java中，枚举类保证单例的方式是通过Java语言规范和Java虚拟机（JVM）的内部机制来实现的。具体来说，有以下几点保证了枚举类的单例特性：

语言级别的保障：Java枚举类型在设计时就被定义为单例的。Java语言规范中明确指出，枚举常量在Java中是由静态final字段表示的，它们在第一次被使用时初始化，并且由于它们是静态的，因此只会被初始化一次。

线程安全：枚举常量的加载和初始化是由JVM在类加载的过程中完成的，这个过程是线程安全的。由于Java虚拟机提供了类加载机制的安全性，因此不需要额外的同步措施来确保枚举常量的线程安全初始化。

反射的限制：即使使用Java反射API，也无法创建枚举的额外实例。尝试通过反射来调用枚举的构造函数会抛出异常，因为JVM不允许这样做。

序列化的安全性：枚举类默认实现了Serializable接口，并且在序列化时有着特殊的处理。即使枚举实例被序列化后再反序列化，也不会创建新的实例，而是返回已经存在的枚举常量。

单一实例的保证：由于枚举类型的特性，每个枚举常量在JVM中只有一个实例，不可能通过任何方式创建出第二个相同的实例。

因此，使用枚举实现单例模式是一种非常可靠的方法，它自动处理了多线程环境下的同步问题，并且防止了反射和序列化可能导致的单例破坏。