单例模式为什么使用volatile，以及双重检查&单例模式的一些思考

单例模式核心思想

​ 构造器私有使得外界无法通过构造器实例化Singleton类，要取得实例只能通过getInstance()方法。

一、一般的单例模式

class Singleton{
    private static Singleton singleton;
    private Singleton(){}
 
    public static Singleton getInstance(){
        if(singleton == null){           // 代码A：判断检查
            singleton = new Singleton(); // 代码B：创建实例
        }
        return singleton;
    }
}

问题

• 该方法在单线程下能够正常运行，但是在多线程环境下会出现由于没有同步措施而导致产生多个单例对象的情况。

原因分析

​ 多线程中，当有两个线程1和2同时执行到 if 条件判断语句**【代码A处】，线程1判断singleton为空，在准备执行new对象时【代码B】** 时让出了CPU时间片，此时由于线程1未执行new对象操作，线程2也判断singleton为空，接着执行 执行new对象时【代码B】，此时创建了一个实例对象；A获取了CPU时间片后接着执行执行new对象时【代码B】，也创建了实例对象，这就导致多个单例对象的情况

二、加入synchronized关键字，解决一中的同步问题

class Singleton{
    private static Singleton singleton;
    private Singleton(){}
 
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton(); //代码B：创建实例
        }
        return singleton;
    }
}

通过synchronized关键字可解决多线程并发的问题，但是却带来了效率问题：

​ 我们的目的是只创建一个实例，即**【代码B】**处代码只会执行一次，也正是这个地方才需要同步，后面创建了实例之后，singleton非空就会直接返回对象引用，而不用每次都在同步代码块中进行非空验证。

三、更改synchronized加锁位置，解决二中的效率问题

class Singleton{
    private static Singleton singleton;
    private Singleton(){}
 
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                singleton = new Singleton(); //代码B：创建实例
            }
        }
        return singleton;
    }
}

问题

• 存在和**【一般单例模式】**中同样的问题，即多个线程同时执行到条件判断语句时，会创建多个实例。

原因

• 同**【一般单例模式】**的原因一样

四、引入二次检查，解决三中的同步问题

class Singleton{
    private static Singleton singleton;
    private Singleton(){}
 
    public static Singleton getInstance(){
        if(singleton == null){                    //代码A：初次校验
            synchronized(Singleton.class){        //代码B：加锁同步
                if(singleton == null){            //代码C：二次校验
                    singleton = new Singleton();  //代码D：创建实例
                }
 
            }
        }
        return singleton;
    }
}

流程

• 当线程1和线程2同时通过了初次校验【代码A】时，会通过synchronized关键字，根据获取锁的先后顺序来进行之后的逻辑。
• 假设线程1优先通过【代码B】拿到了锁，线程2则阻塞等待。
• 线程1执行【代码C】和【代码D】，生成对象后，释放锁。
• 此时线程2获取锁，执行二次校验【代码C】，发现此时singleton已经不为空，固不再执行【代码D】

思考

或许有同学会有疑问，这种结构下，如果把最外层的**初次校验【代码A】给去掉，**也能实现当前效果。

解答

• 把最外层的初次校验【代码A】给去掉后，其代码结构就和**【二】**中的代码逻辑一样了，相当于对整个方法都进行了加锁。
• 不管是否当前对象为空，收到new对象的请求后，都会去做加锁、释放锁的操作。
• 固初次校验【代码A】的作用就是，在单例对象不为空时，直接返回单例对象

五、引入volatile关键字

到这里已经很完美了，看起来没有问题。No！！！因为这种双重检测机制在JDK1.5之前是有问题的，问题还是出在（//创建实例），由**【指令重排机制】**引起的。

问题

一般来讲，当实例化一个对象的时候，会经历（这个记录一下我个人的理解：初始化指的是类，加在家class文件，解析class文件；实例化指的是对象，即以下三步：）

//a. 内存分配
memory = allocate();
//b. 执行实例化对象的初始化
ctorInstance(memory);
//c. 返回引用:将内存空间的地址赋值给对应的引用，并返回
instance = memory;

这种方式产生的对象是一个完整的对象，可以正常使用。但是Java的**【指令重排机制】**可能会造成顺序的颠倒，即

a. 内存分配

b. 返回对象引用

c. 执行实例化对象的初始化

分析

• 线程1获取synchronized锁后，执行new Singleton()实例化对象

• 在 new对象 时，发生了【指令重排】 ，实际执行的代码逻辑为

  • a. 内存分配：划分内存空间
  • b. 返回对象引用：将引用该内存地址对应的引用返回

• 在还没有执行步骤c时，又来了一个线程2执行到了初始校验【代码A】处

• 因为此时线程1已经将引用返回，固线程2没有通过初始校验【代码A】，直接****返回线程1中的引用

• 但是此时的引用，指向的内存地址的对象为空，就会抛出异常

六、最终volatile + 双重检测机制的单例模式

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

单例模式的一些思考

单例模式的一些问题思考

public class A {
    private volatile static   A a;
    private A(){

    }

    public static A getInstance(){
      if(a ==null){
          synchronized (A.class){
              if(a==null){
                  a = new A();
              }
          }
      }
      return a;
    }

}

1.为什么synchronized 不加在方法上？

答案：细化锁，有可能获取实例的时候会在这上面写一些业务代码，这些业务代码不需要加锁，因此尽量少的锁定同步范围。

2 为什么要两次判断a == null

1.1 第一次判断为空，是为了提高效率，如果a不为空就直接返回对象，不用进行锁的竞争，提高了效率。
1.2 第二次判断为空，假如A线程和B线程同时进入了 A == null 这个if条件里面，然后A线程获得了A.class的锁，完成了初始化，这时候A释放锁，因为A已经执行完同步代码块了，释放锁，然后B开始执行了，如果没有里面的A==null判断，也去执行一次new A()，这时候就有两个对象了，就不是单例模式了。因此需要两次为空判断。

3.为什么要加volatile 变量

不加volatile变量，要理解这个问题需要知道，new Object，这个操作分为三个指令，1 分配内存空间，2. 初始化类的属性等

3. 建立类的属性引用, 如果A线程在进行new A（）这个操作的同时，发生了指令重排序，意思就是1–>2–>3的这个操作变成了3 --> 2–>1，B线程这时候进来了，进入if (A == null)的判断，因为你3先执行了，这时候A==null是false，就直接去拿到A这个对象了，但是这个对象有个问题，就是没有完全的完成类的初始化，如果你B线程取A对象的值的时候，有可能取到为空的属性值。这时候，单例模式就有问题了。因此要加上volatile变量，禁止指令重排序，从而禁止你提前取对象，总结就是一句话，加这个属性的含义是禁止你拿到半成品对象，导致业务异常。

为什么是双重校验锁实现单例模式呢？

第一次校验：

也就是第一个if（singleton==null），这个是为了代码提高代码执行效率，由于单例模式只要一次创建实例即可，所以当创建了一个实例之后，再次调用getInstance方法就不必要进入同步代码块，不用竞争锁。直接返回前面创建的实例即可。

第二次校验：

也就是第二个if（singletonnull），这个校验是防止二次创建实例，假如有一种情况，当singleton还未被创建时，线程t1调用getInstance方法，由于第一次判断singletonnull，此时线程t1准备继续执行，但是由于资源被线程t2抢占了，此时t2页调用getInstance方法，同样的，由于singleton并没有实例化，t2同样可以通过第一个if，然后继续往下执行，同步代码块，第二个if也通过，然后t2线程创建了一个实例singleton。此时t2线程完成任务，资源又回到t1线程，t1此时也进入同步代码块，如果没有这个第二个if，那么，t1就也会创建一个singleton实例，那么，就会出现创建多个实例的情况，但是加上第二个if，就可以完全避免这个多线程导致多次创建实例的问题。

所以说：两次校验都必不可少。

还有，这里的代码

private static volatile Singleton singleton = null;

中的volatile也必不可少，volatile关键字可以防止jvm指令重排优化，因为 singleton = new Singleton() 这句话可以分为三步：

1、为 singleton 分配内存空间；
2、初始化 singleton；
3、将 singleton 指向分配的内存空间。

但是由于JVM具有指令重排的特性，执行顺序有可能变成1-3-2。指令重排在单线程下不会出现问题，但是在多线程下会导致一个线程获得一个未初始化的实例。例如：线程T1执行了1和3，此时T2调用getInstance()后发现singleton 不为空，因此返回singleton，但是此时的singleton 还没有被初始化。

使用volatile会禁止JVM指令重排，从而保证在多线程下也能正常执行。

这里还说一下volatile关键字的第二个作用，保证变量在多线程运行时的可见性：

在JDK1.2之前，Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的Java内存模型下，线程可以把变量保存本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就 可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。要解决这个问题，就需要把变量声明为volatile，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。