深入理解单例模式

单例模式---
同时在内存中，只有一个对象存在。单例模式有两种实现方式：
1：懒汉式(延迟加载) 2：饿汉式
首先介绍恶汉模式， 基本上不会用,初始化太多。
public class Student1 {

   // 2：成员变量初始化本身对象
   private static Student1 student = new Student1();

   // 构造私有
   private Student1() {}

   // 3：对外提供公共方法获取对象
   public static Student1 getSingletonInstance() {
      return student;
   }

   public void sayHello(String name) {
      System.out.println("hello," + name);
   }
}

细品 懒汉模式

第一种 ：存在线程安全问题，10个线程同时执行到红色 就会产生线程问题
public class Student2 {
   //1：构造私有
   private Student2(){}
   //2：定义私有静态成员变量，先不初始化
   private static Student2 student = null;
   //3：定义公开静态方法，获取本身对象
   public static Student2 getSingletonInstance(){
      //没有对象，再去创建
      if (student == null) {
         student = new Student2();
      }
      //有对象就返回已有对象
      return student;
   }
}
b)
第二种：synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降
public class Student3 {
   private Student3(){}
   private static Student3 student = null;
   // 此处考验对synchronized知识点的掌握情况
   public static synchronized Student3 getSingletonInstance(){
      if (student == null) {
         student = new Student3();
      }
      return student;
   }
}
第三种：似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，
只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。
先看 JVM中的对象创建过程
            Student student = new Student();// 高级语言
            a）new关键字会触发Student类的类加载（如果已加载，则此步骤作废）
            b）根据Class对象中的信息，去开辟相应大小的内存空间。
            c）初始化Student对象，就是完成成员变量的初始化操作（到这一步，我们才能说该对象是可用的）
            d）将开辟出来的内存空间地址，赋值给栈空间的变量student
如果两行代码的执行顺序交换之后，不会影响最终的程序执行结果，那么JIT即时编译器会根据情况去进行指令重排序。
也就是说 c和d有可能发生先执行d再执行c。多线程下有可能会发生错误
public class Student4 {
   private static Student4 student = null;
   private Student4() {}
   // 此处考验对synchronized知识点的掌握情况
   public static Student4 getSingletonInstance() {
      if (student == null) {
         // 采用这种方式，对于对象的选择会有问题
         // JVM优化机制：先分配内存空间，再初始化
         synchronized (Student4.class) {
            if (student == null) {
               student = new Student4();
               //student.setName("ss")
               //new ---- 开辟JVM中堆空间---产生堆内存地址保存到栈内存的student引用中---创建对象
               // 存在的问题：
            }
         }
      }
      return student;
   }
第四种：终极版本堪称完美版本
volatile关键字的作用：
                一个是禁止指令重排序。
                另一个作用是禁止使用CPU缓存。
public class Student5 {
   private volatile static Student5 student;
   private Student5() {
   }
   public static Student5 getSingletonInstance() {
      if (student == null) {
         // B线程检测到student不为空
         synchronized (Student5.class) {
            if (student == null) {
               student = new Student5();
               // A线程被指令重排了，刚好先赋值了；但还没执行完构造函数。
            }
         }
      }
      return student;// 后面B线程执行时将引发：对象尚未初始化错误。
   }
}