为什么需要double check

一、提出问题：

我们不使用double check时候的单例模式，真的访问的实例就是一致的吗？

（1）单例常见的不严谨写法

//懒汉式加载
public class Singleton {
    private static Singleton instance;

    private Singleton (){}
	
	//获取实例
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

（2）多线程测试代码

public class Test {
    public static void main(String[] args) {
        TestSingle one = new TestSingle();
        TestSingle two = new TestSingle();
        TestSingle three = new TestSingle();
        new Thread(one).start();
        new Thread(two).start();
        new Thread(three).start();
        System.out.println("one和two的比较："+(one.getSingle() == two.getSingle()));
        System.out.println("one和的比较："+(one.getSingle() == three.getSingle()));
        System.out.println("two和three的比较："+(two.getSingle() == three.getSingle()));
    }
}

class TestSingle implements Runnable {
    private static Singleton single;

    @Override
    public void run() {
    	//让线程多执行一会，否则不容易得到错误的结果
        int count = 0;
        while(count < 10000){
            count++;
        }
        single = Singleton.getInstance();
    }

    public static Singleton getSingle () {
        while(true){
            if(single!=null)break;
        }
        return single;
    }
}

（3）测试结果

（4）问题分析

1）出现false说明了什么问题？
分析：
我们知道内存地址比较的是指针变量的哈希值，哈希值不等说明对象必然不相同

2） 那么是什么原因导致的呢？
问题现象：
我们知道Java的多线程是开启线程资源，每一个线程是通过抢占CPU时间片执行的，当线程一通过判断进入到获取实例的代码中的时候还没执行赋值的时候，这时候线程二正好拿到时间片执行发现这个实例为空，于是它也进入到了创建实例的代码块中，所以创建了两个对象，从而导致创建了两个不同的对象。
根本：java对象创建的机制
（1）指令重排序
（2）划分堆内存空间
（3）创建引用
（4）初始化对象
因为指令重排序，创建对象的时候因为创建引用是串行的，同时创建多个对象就会消耗很多时间，java为了提高性能，就先进行了划分空间，所以上述问题的原因本质是两个线程都进行了划分空间的操作，最后创建了不同的引用，使得我们获取的实例不一定是单例的。

解决办法

（1）通过double check进行更为严谨的检查，代码如下：

//懒汉式加载
public class Singleton {
    private static volatile Singleton instance;

    private Singleton (){}
	
	//获取实例
    public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
            	if(instance == null){
					instance = new Singleton();
				}
            }
        }
        return instance;
    }
}

（2）饿汉式，加载类的时候就创建，能保证获取实例的唯一性

//懒汉式加载
public class Singleton {
    private static volatile Singleton instance = new Singleton();

    private Singleton (){}
	
	//获取实例
    public static Singleton getInstance(){
        return instance;
    }
}

注意：
使用volatile关键字的主要目的是防止指令重排序，因为第一个线程还没初始化，第二个线程可能发现不为空了，就将实例返回，造成空指针异常。

希望本片文章能给大家带来一些帮助~~~