单例模式与多线程安全

2017-06-15 本文已影响0人 wa1terwen

单例模式简介

想要唯一的创建一个对象，我们不通过约定，而是通过制定约束的方式去限制。虽然我们可以建立一个全局变量。

public singleton{
    private Singleton() {}
}

通过构造方法私有化可以避免外部实例化，不过这样我们也无法获得实例，我们继续改造代码。

public Singleton{
    private static Singleton singletonInstance; 
    private Singleton() {}
    public static Singleton getInstance() {
        if(singletonInstance == null) {
            singletonInstance = new Singleton();
        } 
        return singletonInstance;
    }
}

通过静态方法我们就可以通过类名去调用getInstance()来获得实例啦，这样比全局变量的好处就是延迟实例化，也叫懒汉模式，只有在用这个实例调用方法的时候，方法才被加入到内存中，当对象不用的时候，gc会将方法回收。既拥有全局变量的优点又避免了全局变量的缺点。

没那么完美

看起来好像大功告成了，但仔细考虑，当多线程执行这段代码的时候，可能会出现这样的问题：

首先线程A首次访问getInstance()判断实例为null，线程A停止执行，线程B获得时间片。
线程B首次访问getInstance()，此刻线程A还未执行实例化语句，也判断是null。
线程A、B都将创建一个Singleton。

分析原因

原因就在于getInstance方法并不是同步的，当线程A进入方法时，线程B也可以进入，于是我们可以给getInstance()方法上锁，加上synchronized关键字，这样问题就解决了。

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

局部加锁还是方法上锁

好像已经很完美了吧，但是加了锁之后效率非常低，我们观察，其实只需要在第一次没有创建对象的时候上锁就可以了，当创建对象之后，不需要进行同步。那么我们只需要判断当对象为空的时候，给创建对象代码块加锁就可以了，当对象不为空的时候我们直接返回对象。

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

a. 首先线程A首次访问getInstance()判断实例为null，假设线程A停止执行，线程B获得时间片。
b. 线程B首次访问getInstance()，此刻线程A还未执行实例化语句，也判断是null。
c. 假设线程A获得时间片，线程A获得锁，线程B无法进入，再次判断是否为null，是则创建对象。线程A释放锁，线程A运行结束。
d. 线程B获得时间片，线程B获得锁，再次判断是否为null，结果为否，则不创建对象，线程B释放锁，线程B运行结束。
这种方式叫做double-checked locking(简称DCL，双重检查加锁机制)。

volatile禁止重排序

由于JIT编译器为了提高性能，可能在 singletonInstance = new Singleton();发生重排序，伪代码为：

memory = allocate(); //1：分配对象的内存空间
ctorInstance(memory); //2：初始化对象
instance = memory; //3：设置instance指向刚分配的内存地址

其中，2和3步骤可能会重排序，2和3得顺序可能会跌倒。所以有这样一种可能，当线程A实例对象时，执行顺序为132，线程B进入代码后看到instance得内存地址认为对象不为null，便返回实例，但是此刻线程A的初始化对象还没有执行，所以返回得是空值。

解决方案

不允许2和3重排序；
允许2和3重排序，但不允许其他线程“看到”这个重排序。
当声明对象的引用为volatile后，“问题的根源”的三行伪代码中的2和3之间的重排序，在多线程环境中将会被禁止。
详细请参考http://www.infoq.com/cn/articles/double-checked-locking-with-delay-initialization

饿汉模式

除了DCL方法和方法上锁以外，我们还可以在类加载器加载时在静态初始化器直接创建，此方法也叫饿汉模式（对比懒汉是先甭管你需不需要直接创建）。(如果使用多个类加载器可能导致单件失效)

 public Singleton{
    private static Singleton singletonInstance = new Singleton(); 
    private Singleton() {}
    public static Singleton getInstance() {
        return singletonInstance;
    }
}

其他方案

使用static代码块实现单例模式
使用enum枚举实现单例模式

总结

单例模式的主流方案有：

懒汉模式
饿汉模式
DCL双检查机制
对于懒汉模式是非线程安全的，所以我们进行改进，先是通过同步方法的方式，然后因为效率的问题，我们采用了DCL双检查机制，其中还要考虑到此处的volatile关键字并非是保证线程可见性而是避免可重性的问题，另外，在序列化与反序列话的的过程中，要保证单例需要使用readResolve()方法进行保护。