设计模式 --＞ 单例模式

单例模式：一个类只会有一个实例。

懒汉模式

延迟加载，在真正要使用的时候才开始实例化。

• 线程安全问题（synchronized)

• double check 加锁优化

• 编译器（JIT），cpu有可能对指令进行重新排序，导致赋值了初始化未完成的null实例，可以添加volatile关键字进行修饰。（volatile修饰的字段，可以防止指令重排）

  //懒汉模式
  class LazySingleton{
       
      private volatile static LazySingleton instance;
  
      public LazySingleton() {
       
      }
  
      public static LazySingleton getInstance() {
       
          //双层检查之一
          if(instance==null){
       
              //没有实例已创建的时候才加锁创建实例
              synchronized (LazySingleton.class){
       
                  //双层检查之一，防止在其他锁中已经创建了单例
                  if(instance==null){
       
                      instance = new LazySingleton();
                  //在字节码层指令正常执行顺序为，但jit并不一定按序执行
                  //1.分配空间
                  //2.初始化
                  //3.引用赋值
                  }
              }
          }
          return instance;
      }
  }
  

饿汉模式

基于jvm类加载机制，保证线程安全（实例的唯一性）。

类加载过程：

1. 类的二进制数据加载的内存中，生成对应的Class数据结构

2. 连接，a.验证（class文件是不是符合jvm的规范） ，b.准备 （给类的静态成员变量赋默认值），c.解析（比如将符号引用转为直接引用）

3. 初始化：给类的静态变量赋初值（只有到使用类的时候，才会触发初始化）

jvm保证上述三个操作只会完成一次。

//测试类
public class HungrySingletonTest {
   
    public static void main(String[] args) {
   
        HungrySingleton instance = HungrySingleton.getInstance();
        HungrySingleton instance1 = HungrySingleton.getInstance();
        System.out.println(instance == instance1); //true

    }
}
//饿汉模式
class HungrySingleton{
   
    private static HungrySingleton instance = new HungrySingleton();
    private HungrySingleton(){
   

    }

    public static HungrySingleton getInstance() {
   
        return instance;
    }
}

静态内部类

• 本质上利用了类的加载机制来保证线程安全

• 只有在加载内部类或者说调用getInstance()方法时，才会创建实例，也是一种特殊的懒汉模式

  //测试类