饿汉模式

先看代码

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

这是一种典型的空间换时间的方式。类中static变量，当且仅当类加载的时候初始化。那么类什么时候加载，正常类JVM启动的时候加载。（区别静态内部类，静态内部类在使用时加载）。

这种方式没有任何问题！

懒汉模式

最简单的

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

有什么问题？
并发情况下，可能两个线程同时 到达1这行，都判断为null，都new了对象，相当于new了两个对象，虽然句柄指向了一个。

稍微优化一丢丢

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

在getInstance方法上加了synchronized。这时，并发情况下，多个线程只有一个能进入，也就只有一个线程能new对象了。

有什么问题？？
并发初始化new对象时是没问题了。但，new完对象之后呢，每次getInstance都要加锁，并发效率太低了。

再优化一丢丢

public class Singleton {    
    private static Singleton instance;    
    private Singleton (){}    
    
    public static Singleton getInstance() {    
       if (instance == null) {         // 第一次检查
          synchronized(Singleton.class) { // 加锁
            if (instance == null) {     // 第二次检查
                instance = new Singleton(); // 问题所在
            }
          }    
       }    
       return instance;    
    }    
}  

这个代码就是：双重检查锁定。
第一次检查是为了：对象new完了之后的并发场景，没有锁，直接return对象了。
加锁是在对象初始化的时候，两个请求过来了，抢锁，之后一个线程能进来。
那为什呢要第二次检查呢？？？？
这个问题卡了我很久。10个进程进来了，都过了第一次检查这一关，只有一个线程拿到了锁，new了对象。释放锁。其他9个线程，就会有一个拿到锁，又进来了，就必须要再检查一下了，instance已经有了，直接返回就行了。如果不二次检查，就又new了一个对象了。

这种方式看起来没有什么问题。但并发的情况下还是不行。
有什么问题呢？？？
问题在这一行：instance = new Singleton();
这一行可以分解为如下3行伪代码：

memory = allocate(); //1：分配对象的内存空间
ctorInstance(memory); //2：初始化对象
instance = memory;   //3：设置instance指向刚分配的内存地址

2和3，可能会出现重排序

memory = allocate(); //1：分配对象的内存空间

instance = memory;   //3：设置instance指向刚分配的内存地址
                   // 注意：这个时候对象还没有初始化了

ctorInstance(memory); //2：初始化对象

这个时候，一个线程进来，第一次检查的时候，instance非空，返回了对象，而这个对象是还没有初始化的，马上用这个对象去.。就崩了。

---

最终方案一

那不让他重排序不就好了嘛。对喽。所以volatile出场。

public class Singleton {    
    private volatile static Singleton instance;    
    private Singleton (){}    
    
    public static Singleton getInstance() {    
       if (instance == null) {         // 第一次检查
          synchronized(Singleton.class) { // 加锁
            if (instance == null) {     // 第二次检查
                instance = new Singleton(); // instance是volatile变量，没有问题了
            }
          }    
       }    
       return instance;    
    }    
}  

最终方案二

既然自己实现new有那么多的坑，那依靠java的某个机制来实现对象只能初始化一次不就可以了嘛。对的。这个机制就是java中static只会触发一次初始化。饿汉模式就是利用了这个原理。这里对饿汉模式进行改进，就变成了懒汉模式。走着

public class Singleton {

    private static class SingletonaInner {
       public static Singleton instance = new Singleton(); 
    }
       
    private Singleton (){} 
    
    public static Singleton getInstance() {    
       return SingletonaInner.instance; // 加载内部类 
    }    
}   

饿汉模式是把instance的初始化放在类static变量中。类加载时初始化。
懒汉模式的改造，把instance的初始化放在static内部类的static变量中。利用static在java中的加载时初始化一次来满足单例。那么，static内部类什么时候加载呢？？
答案是，在第一次调用的时候。就是getInstance的时候。高并发的情况加，多个线程都打到getInstance方法，java内部会保证只能初始化一次。

完美。