简单的单例模式：（懒汉式）
package com.zcp.juc.single;
/**
* @author zcp
* @description
* @created by 2020-03-26 22:50
*/
public final class Singleton {
private static Singleton INSTANCE=null;
private Singleton(){
}
public static Singleton getInstance(){
if(INSTANCE==null){
INSTANCE=new Singleton();
}
return INSTANCE;
}
}
通俗讲：单例=单个实例，即每次获取相同的对象实例，因为java中创建对象需要消耗资源，单例模式正好解决了对象的频繁创建。那么懒汉式是什么呢？懒呗，我就是不想那么早初始化，有需要我再初始化。
很多人都以为懒汉式写到这，可是在多线程环境下呢？上述代码完了吗？
没有！！！
问题来了：
有两个线程T1、T2，当线程T1执行到if条件判断时，发现INSTANCE==null,还没创建实例呢，T2线程也走到了这个if条件判断，发现INSTANCE==null，那么两条线程继续向下执行，就会导致new了两个对象，这显然不符合单例模式，不是我们想要的结果。
怎么办的？
在有可能发生问题的地方加锁，不知道在哪？没关系，把整个方法都加上锁
package com.zcp.juc.single;
/**
* @author zcp
* @description
* @created by 2020-03-26 22:50
*/
public final class Singleton {
private static Singleton INSTANCE=null;
private Singleton(){
}
public static synchronized Singleton getInstance(){
if(INSTANCE==null){
INSTANCE=new Singleton();
}
return INSTANCE;
}
}
在静态方法上加锁，相当于对类对象加锁
上述代码等价于
package com.zcp.juc.single;
/**
* @author zcp
* @description
* @created by 2020-03-26 22:50
*/
public final class Singleton {
private static Singleton INSTANCE=null;
private Singleton(){
}
public static Singleton getInstance(){
synchronized (Singleton.class) {
if (INSTANCE == null) {
INSTANCE = new Singleton();
}
return INSTANCE;
}
}
}
线程安全问题解决了，还有什么问题呢？
问题来了：T1线程先拿到锁，T2线程阻塞，T1线程同步代码块执行完毕，成功创建了对象，释放了锁，此时T2线程拿到锁，再执行if判断，发现实例已经被初始化，大家不觉得很麻烦吗？为什么不直接告诉T2对象已经被创建了，直接获取就是了，还要加一次锁，大哥啊，加锁不要钱啊？
怎么办呢？
那么传说中双重判断来了,在加锁前判断一次INSTANCE是否等于null，不等于直接就返回实例了，这样也不用再加锁判断了。(也就是首次访问需要同步，而之后就没有synchronized了)，这样做还有问题吗？
biao急啊？
go on..
package com.zcp.juc.single;
/**
* @author zcp
* @description
* @created by 2020-03-26 22:50
*/
public final class Singleton {
private static Singleton INSTANCE=null;
private Singleton(){
}
public static Singleton getInstance(){
if(INSTANCE==null) {
synchronized (Singleton.class) {
if (INSTANCE == null) {
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
什么问题呢？
看字节码（重点看17~24行字节码指令）
0: getstatic #2 // 获取静态变量INSTANCE
3: ifnonnull 37 //判断INSTANCE是不是Null 如果不是Null就跳转执行37行
6: ldc #3 // 获得了类对象
8: dup //把类对象的引用指针复制了一份
9: astore_0 //然后临时存储了复制的一份，是为了将来解锁用
10: monitorenter //开始执行同步代码块
11: getstatic #2 // 拿到静态变量
14: ifnonnull 27 //如果不为Null，执行27行
17: new #3 // 为Null，继续执行，创建对象，将对象的引用入栈
20: dup // 复制一份这个对象的引用（引用地址）
21: invokespecial #4 // 利用对象的引用来调用构造方法（根据引用地址调用）
24: putstatic #2 // 原来的这一份的引用对应赋值操作，把他赋值给静态变量
27: aload_0 //把临时存储的类对象取出来
28: monitorexit //解锁，退出同步代码块
29: goto 37 //跳转到37行
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // 获取静态变量
40: areturn //返回结果
Exception table:
from to target type
11 29 32 any
32 35 32 any
_
17: new #3 // 创建对象，将对象的引用入栈 new Singleton()
20: dup // 复制一份这个对象的引用（引用地址）
21: invokespecial #4 // 利用对象的引用来调用构造方法（根据引用地址调用）
24: putstatic #2 // 利用一份对象引用赋值给static Instance
jvm虚拟机在执行时有可能做优化（指令重排序优化），也就是可能先执行24，再执行21，那么会导致什么问题呢？synchronized只可能保证同步代码块内原子性（注：synchronized代码块内的代码仍可能发生有序性问题，即指令重排序），但是无法保证外面if判断。啥意思呢？
当T1线程执行到同步代码块内，发生了指令重排序，先调用了24行的指令，将对象的引用赋值给了static Instance，那么此时T2执行到同步代码块外面的if判断，就会发现Instance不为Null,就继续执行返回，可返回的时候，T1还未将构造方法初始完毕。
总结：
- 关键在于0:getstatic在monitor外面，就好像不守规矩的人，他可以越过monitor读取Instance变量的值
- T1还未完全将构造方法初始完毕，如果构造方法内要执行很多初始化操作，那么T2拿走的将是一个未初始化完毕的实例
- 对Instance使用volatile修饰即可，可以禁止指令重排序。
最终完全的代码：
package com.zcp.juc.single;
/**
* @author zcp
* @description
* @created by 2020-03-26 22:50
*/
public final class Singleton {
private static volatile Singleton INSTANCE=null;
private Singleton(){
}
public static Singleton getInstance(){
if(INSTANCE==null) {
synchronized (Singleton.class) {
if (INSTANCE == null) {
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
