运用volatile创建安全的多线程下的单例模式

首先看一下单线程下的单例模式

public class SingletonDemo {
    private static SingletonDemo instance = null;
    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法SingletonDemo");
    }
    public static SingletonDemo getInstance(){
        if (instance == null){
        	instance = new SingletonDemo();
        }
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
    }
}

但是这种单例模式在多线程下会出问题。

public class SingletonDemo {
    private static SingletonDemo instance = null;
    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法SingletonDemo");
    }
    public static SingletonDemo getInstance(){
        if (instance == null){
        	instance = new SingletonDemo();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

运行结果有可能是这样的：

多线程下的单例模式

全局加锁

public class SingletonDemo {
    private static SingletonDemo instance = null;
    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName()+"\t 我是构造方法SingletonDemo");
    }
    public synchronized static SingletonDemo getInstance(){
        if (instance == null){
        	instance = new SingletonDemo();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

这样虽然可以保证多线程下的单例模式，但是为了获取单例，将整个方法用synchronized锁住，没有必要，大大影响多线程的效率。

方法内加锁

public class SingletonDemo {
    private static SingletonDemo instance = null;

    private SingletonDemo() {
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo");
    }

    public static SingletonDemo getInstance() {
        if (instance == null){
            synchronized (SingletonDemo.class){
                if (instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

这样上锁，看似没有什么问题，但是可能有很小很小很小的几率出问题，分析如下：
原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。
instance = new SingletonDemo();可以分为以下3步完成(伪代码)
memory = allocate(); //1.分配对象内存空间
instance(memory); //2. 初始化对象
instance = memory; //3. 设置instance指向刚分配的内存地址，此时instance! =null
步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。
memory = allocate(); //1.分配对象内存空间
instance = memory; //3. 设置instance指向刚分配的内存地址，此时instance! =null, 但是对象还没有初始化完成！
instance(memory); //2.初始化对象
但是指令重排只会保证串行语义的执行的一致性(单线程)， 但并不会关心多线程间的语义一致性。
所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。

下面就对上面所说打一个比方：
步骤1就好比，老师上课时候，说1排1座现在没有人，我们在1小时候会安排同学“张三”坐到这里。
步骤2就好比，张三已经办完入学手续，坐到1排1座。
步骤3就好比，同学们的目光被1排1座吸引，看到了坐在1排1座上的张三。
由于存在指令重排，可能步骤是1-3-2，这就好比老师上课时候，说1排1座现在没有人，我们在1小时候会安排同学“张三”坐到这里。但是有些同学反应比较快，立刻看向1排1座，看到了空位置，心里想到，哦，这就是张三。然后1小时候张三办完入学手续，来到1排1座，其他同学看向1排1座，看到了真正的张三。

在实际中，就是虽然为对象创建了内存地址，但是还没有创建实例，就拿来用，有可能会得到null。

volatile的运用

以上，我们需要在单例模式中，禁止系统自动指令重排来保证实例安全性。
具体代码如下：

public class SingletonDemo {
    private static volatile SingletonDemo instance = null;
    private SingletonDemo() {
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo");
    }
    public static SingletonDemo getInstance() {
        if (instance == null){
            synchronized (SingletonDemo.class){
                if (instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}