DCL双检查锁机制实现线程安全的单例设计模式

古城微笑少年丶 2021-12-05 15:27 349阅读 0赞

**实现线程安全的单例设计模式的三种方式**：

*  DCL双检查锁机制实现线程安全
 *  [使用静态内置类实现线程安全][Link 1]
 *  [使用static代码块实现线程安全][static]

\---------------------------------------------------------------------------------------------------------------

1、普通（懒汉式）单例模式，在多线程情况下会存在被多次实例化问题

public class MyObject {
        private static MyObject myObject;
    
        private MyObject(){
        }
    
        public static MyObject getInstance() {
            if (myObject == null) {
               myObject = new MyObject();
            }
            return myObject;
        }
    }

2、对getInstance()方法进行加锁，防止多个线程同时进入，解决了线程安全问题，但是效率太低

public class MyObject {
        private static MyObject myObject;
    
        private MyObject(){
        }
    
        synchronized public static MyObject getInstance() {
            if (myObject == null) {
               myObject = new MyObject();
            }
            return myObject;
        }
    }

3、“不安全的”双检查锁机制实现，存在对象部分构造问题

public class MyObject {
        private static MyObject myObject;
    
        private MyObject(){
        }
    
        public static MyObject getInstance() {
            if (myObject == null) {
                synchronized (MyObject.class) {
                    if (myObject == null) {
                        myObject = new MyObject();
                    }
                }
            }
            return myObject;
        }
    }

代码中一个线程正在实例化对象，但是还没有完全完成初始化，这时候另外一个线程进来，得到的判断是myObject != null,拿到myObject后去执行下面的逻辑，此种情况下会出现空指针异常

出现部分构造问题是因为JVM无序写入造成的。

一个对象的创建过程是：

（1）、分配对象内存空间。

（2）、调用Singleton的构造方法进行构造函数初始化

（3）、将instance指向分配的内存空间

（4）、访问interface引用的对象

但是因为JVM乱序执行上面2、3步骤，有可能2、3，有可能3、2，如果3、2，则就有可能会出现问题，因为执行3时，对象已经为非null了，假设此时有两个线程A、B，A执行到1、3，2还未执行，此时B线程访问此对象，得到对象已非空，但是实际上A线程中的对象还未创建完。

4、使用“volatile”关键字的解决方案

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

volatile可以阻止程序的乱序执行，因为volatile会给程序添加内存屏障从而阻止编译器或者处理器对代码的乱序执行，从而使双重检验锁在多线程下具有正确执行。

[Link 1]: https://blog.csdn.net/weixin_41846320/article/details/96353845
[static]: https://blog.csdn.net/weixin_41846320/article/details/96355579