【单例模式】DCL的问题和解决方法

Java基础

浏览数:223

2020-6-15

1.传统的例子

非常经典的例子,基本上对java有了解的同学都可以写出来,我们的例子,可能存在一个BUG,这个BUG的原因是,JMM出于对效率的考虑,是在happens-before原则内(out-of-order)乱序执行。

public class LazySingleton {
    private int id;
    private static LazySingleton instance;
    private LazySingleton() {
        this.id= new Random().nextInt(200)+1;                 // (1)
    }
    public static LazySingleton getInstance() {
        if (instance == null) {                               // (2)
            synchronized(LazySingleton.class) {               // (3)
                if (instance == null) {                       // (4)
                    instance = new LazySingleton();           // (5)
                }
            }
        }
        return instance;                                      // (6)
    }
    public int getId() {
        return id;                                            // (7)
    }
}

2. 简单的原理性介绍。

我们初始化一个类,会产生多条汇编指令,然而总结下来,是执行下面三个事情:

1.给LazySingleton 的实例分配内存。
2.初始化LazySingleton 的构造器
3.将instance对象指向分配的内存空间(注意到这步instance就非null了)

Java编译器允许处理器乱序执行(out-of-order),我们有可能是1->2->3也有可能是1->3->2。即我们有可能在先返回instance实例,然后执行构造方法。

即:double-check-locking可能存在线程拿到一个没有执行构造方法的对象。

3.一个简单可能出错的执行顺序。

线程A、B执行getInstance().getId()

在某一时刻,线程A执行到(5),并且初始化顺序为:1->3->2,当执行完将instance对象指向分配空间时。此时线程B执行(1),发现instance!=null,继续执行,最后调用getId()返回0。此时切换到线程B对构造方法初始化。

4. 解决方案

方案一:利用静态内部类

利用类第一次使用才加载,加载时同步的特性。
优点是:官方推荐,可以可以保证实现懒汉模式。代码少。
缺点是:第一次加载比较慢,而且多了一个类多了一个文件,总觉得不爽。

public class SingletonKerriganF {     
      
    private static class SingletonHolder {     
        static final SingletonKerriganF INSTANCE = new SingletonKerriganF();     
    }     
      
    public static SingletonKerriganF getInstance() {     
        return SingletonHolder.INSTANCE;     
    }     
}    

方案二:利用volatile关键字

volatile禁止了指令重排序,所以确保了初始化顺序一定是1->2->3,所以也就不存在拿到未初始化的对象引用的情况。
优点:保持了DCL,比较简单
确定:volatile这个关键字多少会带来一些性能影响吧。

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

方案三:初始化完后赋值

通过一个temp,来确定初始化结束后其他线程才能获得引用。
同时注意,JIT可能对这一部分优化,我们必须阻止JTL这部分的”优化”。

缺点是有点难理解,优点是:可以不用volatile关键字,又可以用DLC,岂不妙哉。

public class Singleton {    
    
    private static Singleton singleton; // 这类没有volatile关键字    
    
    private Singleton() {    
    }    
    
    public static Singleton getInstance() {    
        // 双重检查加锁    
        if (singleton == null) {    
            synchronized (Singleton.class) {    
                // 延迟实例化,需要时才创建    
                if (singleton == null) {    
                        
                    Singleton temp = null;  
                    try {  
                        temp = new Singleton();    
                    } catch (Exception e) {  
                    }  
                    if (temp != null)    //为什么要做这个看似无用的操作,因为这一步是为了让虚拟机执行到这一步的时会才对singleton赋值,虚拟机执行到这里的时候,必然已经完成类实例的初始化。所以这种写法的DCL是安全的。由于try的存在,虚拟机无法优化temp是否为null  
                        singleton = temp; 
                }    
            }    
        }    
        return singleton;    
    }  
}  

作者:孙华栋