基于DoubleCheck的懒汉式单例--指令重排

传统方式的懒汉式单例

public class Singleton {
    //构造私有
    private Singleton (){};

    private static  Singleton instance = null;

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

当处于多线程环境中，这样的加锁方式虽然可以保证线程的，但是锁是加载方法上的，也就是每次线程进入都需要涉及锁操作，这样的性能是十分低的。多线程环境下保证单例，只有创建对象的时候需要加锁保证安全，后续的操作都不需要加锁。

DoubleCheck-Singleton

public class DoubleCheckSingleton {
    //构造私有
    private DoubleCheckSingleton(){};

    private static  DoubleCheckSingleton instance = null;

    public  static DoubleCheckSingleton getInstance(){ //第一次检查
        if(instance == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) { //第二次检查
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

如果第一个检查（if判断）为真进入获取锁对象，在进行一次判断，如果成立创建对象并赋值。

将锁加在判断语句上，而不加在整个方法上。只有第一个条件判断为真的情况下才会加锁，如果不成立直接返回，这样做的效率明显提高了。

但是这样做有坑，如果有指令重排的情况下，就无法保证线程安全。

指令重排

在计算机执行指令的顺序在经过程序编译器编译之后形成的指令序列，一般而言，这个指令序列是会输出确定的结果；以确保每一次的执行都有确定的结果。但是，一般情况下，CPU和编译器为了提升程序执行的效率，会按照一定的规则允许进行指令优化。也就是说在一定情况下会改变指令执行的顺序。

  instance = new DoubleCheckSingleton();

这一行代码，做了三件事情。

1、为对象分配内存空间

2、初始化

3、将对象指向刚分配的内存空间地址

其中步骤2、3的顺序可能会发生改变，这样在多线程环境下就可能造成对象没有被初始化。

为了保存线程安全，我们可以禁止线程1进行指令重排。即通过关键字 volitile 防止指令重排。

修改后的代码如下:

public class DoubleCheckSingleton {
    //构造私有
    private DoubleCheckSingleton(){};

    private volatile static  DoubleCheckSingleton instance = null;

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

彩蛋

 

初此之外还有一种利用静态内部类的无锁的单例模式。

public class Singleton {
    private Singleton(){};

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

静态内部类的特性是只有在其被第一次引用的时候才会被加载，所以可以保证其线程安全性。而且无法通过反射技术通过外部类获取内部类的属性。所以说这种方式可以防止反射入侵破坏单例。