单例模式并没有那么简单!

ParkJun 1年前 ⋅ 1332 阅读

标题上红牛标志预示着它并不简单

先说下单例模式,由于频繁创建对象比较浪费资源,就考虑将所有用到某个类的实例时,公用同一个实例,于是就有了单例模式。

单例模式写法有很多,于是我看到了这么一种写法: public class SingletonTest {

    private SingletonTest() {
    }

    private static SingletonTest singletonTest = null;

    public static SingletonTest getSingletonTest() {
        if (singletonTest == null) {
            // 若singletonTest为空,则加锁,再进一步判空
            synchronized (SingletonTest.class) {
                // 再判断一次是否为null
                if (singletonTest == null) {
                    //若为空,则创建一个新的实例
                    singletonTest = new SingletonTest();
                }
            }
        }
        return SingletonTest;
    }
}

这种写法算是一个考虑比较得当的设计了 为了防止多线程调用产生多个实例,采用了同步锁 加锁位置得当,尽可能降低了加锁对性能的影响 但是在这个示例下方,有指出可能会由于指令重排的影响,导致代码执行错误,只是概率很低。

我不由得重新审视着这段代码,难道看似稳的一逼的代码如此不堪一击? 于是,我大致了解了下指令重排: 指令重排序是JVM为了优化指令,提升程序运行效率,在不影响单线程程序执行结果的前提下,尽可能地提升并行度。 也就是说,JVM为了执行效率会将指令进行重新排序,但是这种重新排序不会对单线程程序产生影响。

首先,JVM是如何保证单线程下的指令在重新排序后执行结果不受影响的呢?

happens-before

Java内存模型中的happens-before是什么?为什么会有这东西的存在?

今天我们来说说happens-before。

happens-before字面翻译过来就是先行发生,A happens-before B 就是A先行发生于B?

不准确!在Java内存模型中,happens-before 应该翻译成:前一个操作的结果可以被后续的操作获取。讲白点就是前面一个操作把变量a赋值为1,那后面一个操作肯定能知道a已经变成了1。

我们再来看看为什么需要这几条规则?

因为我们现在电脑都是多CPU,并且都有缓存,导致多线程直接的可见性问题。详情可以看我之前的文章面试官:你知道并发Bug的源头是什么吗?

所以为了解决多线程的可见性问题,就搞出了happens-before原则,让线程之间遵守这些原则。编译器还会优化我们的语句,所以等于是给了编译器优化的约束。不能让它优化的不知道东南西北了!

程序次序规则:在一个线程内一段代码的执行结果是有序的。就是还会指令重排,但是随便它怎么排,结果是按照我们代码的顺序生成的不会变!

管程锁定规则:就是无论是在单线程环境还是多线程环境,对于同一个锁来说,一个线程对这个锁解锁之后,另一个线程获取了这个锁都能看到前一个线程的操作结果!(管程是一种通用的同步原语,synchronized就是管程的实现)

volatile变量规则:就是如果一个线程先去写一个volatile变量,然后一个线程去读这个变量,那么这个写操作的结果一定对读的这个线程可见。

线程启动规则:在主线程A执行过程中,启动子线程B,那么线程A在启动子线程B之前对共享变量的修改结果对线程B可见。

线程终止规则:在主线程A执行过程中,子线程B终止,那么线程B在终止之前对共享变量的修改结果在线程A中可见。

线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程代码检测到中断事件的发生,可以通过Thread.interrupted()检测到是否发生中断。

传递规则:这个简单的,就是happens-before原则具有传递性,即A happens-before B , B happens-before C,那么A happens-before C。

对象终结规则:这个也简单的,就是一个对象的初始化的完成,也就是构造函数执行的结束一定 happens-before它的finalize()方法。

这几条规则就是面向我们这些开发人员的,掌握了这几条规则能让我们更好的开发出符合我们预期的并发程序的代码!

一张经典的图:

KR[V3D@W61F(4A]KB@))7$B.png

最后,再分析下文章开头的单例代码

public static SingletonTest getSingletonTest() {
     if (singletonTest == null) {
         // 若singletonTest为空,则加锁,再进一步判空
         synchronized (SingletonTest.class) {
             // 再判断一次是否为null
             if (singletonTest == null) {
                 //若为空,则创建一个新的实例
                 singletonTest = new SingletonTest();
             }
         }
     }
     return SingletonTest;
 }

由于singletonTest = new SingletonTest()操作并不是一个原子性指令,会被分为多个指令:

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

但是经过重排序后如下:

memory = allocate(); //1:分配对象的内存空间
instance = memory; //3:设置instance指向刚分配的内存地址,此时对象还没被初始化
ctorInstance(memory); //2:初始化对象

若有A线程进行完重排后的第二步,且未执行初始化对象。 此时B线程来取singletonTest时,发现singletonTest不为空,于是便返回该值,但由于没有初始化完该对象,此时返回的对象是有问题的。这也就是为什么说看似稳的一逼的代码,实则不堪一击。

将singletonTest声明为volatile类型即可(内存屏障)。

本文归作者所有,未经作者允许,不得转载