寂然解读设计模式 - 单例模式（中）

2021-07-29 14:30:59

I walk very slowly, but I never walk backwards

设计模式 - 单例模式（中）

寂然

大家好~，我是寂然，本节课呢，我们把重点放在单例模式的实现方式 - 双重检查机制，他的写法分析，可能存在的问题和解决方案，同时会对volatile，线程切换相关的知识进行扩展，达到融会贯通，那我们启程吧

双重检查机制

上一节我们聊到，第五种写法懒汉式同步代码块的时候，并没有保证线程安全，所以在里面创建实例对象的时候，进行同步没有实际意义，所以实际开发中不能使用上述方式，那我们来看第六种，双重检查机制，示例代码如下，我们先验证其正确性，然后对该写法进行解析

//单例 双重检查机制
class Singleton{

    private Singleton(){

    }

    //后续还要加volatile关键字
    private static Singleton singleton;

    //提供一个静态的公共方法获取实例，加入双重检查
    //解决线程安全问题，同时解决懒加载的问题
    //注意，同步的效率很低
    public static Singleton getInstance(){

        if (singleton == null){

            synchronized (Singleton.class){
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

public class DoubleCheckDemo {

    public static void main(String[] args) {

        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
    }
}

写法分析

Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null){ ... }检查，同时，在实际开发中，也推荐使用这种单例设计模式，因为有如下三个优点

一，线程安全

假设现在有A，B两个线程，同时进入外层 if (singleton == null){ ... }的检查，里面我们进行了加锁处理，假设A线程拿到锁，执行代码，创建实例对象，结束后B线程拿到锁进来，此时实例已经被创建，所以直接 return 实例化对象，加锁后进行判断，解决了线程安全问题

二，延迟加载

起到了延迟加载的效果，不会造成内存浪费，实例需要使用到的时候，调用getInstance()方法才会创建

三，效率较高

同步的效率很低，我们不同步方法，当判断外层if (singleton == null){ ... }为空时才会加锁，这样的话，实例化代码执行一次后，后续直接return，避免同步方法后，同时只能有一个线程进入方法效率太低的问题

为什么要双重检查？

这里有的小伙伴要问了，为什么要双重检查？去掉外面的一层，不是同样可以解决线程安全问题嘛？

是的，可以解决线程安全问题，但是我们外层加上判断，如果不为空，就不需要加锁，直接return，可以大幅度提升效率，这样，实例化代码只用执行一次

可能出现的问题

上述双重检查的写法，线程安全、符合延迟加载，效率较高，我们说实际开发中推荐使用这种方式，这是OK的，但是，在new Singleton()的操作中却可能带来空指针的异常问题，下面我们着重来聊下

我们认为的 new Singleton() 操作

1）分配内存地址 M

2）在内存 M 上初始化Singleton 对象

3）将M的地址赋值给 instance 对象

JVM编译优化后可能的 new Singleton() 操作

1）分配内存地址 M

2）将M的地址赋值给instance变量

3）在内存M上初始化 Singleton 对象

异常发生过程

如下图，JVM创建new Instance()对象时先赋值再初始化

线程A先执行getInstance()方法，当线程A在执行完变量的内存地址赋值（尚未初始化）时，发生线程切换，线程B获得CPU的执行权
线程B在执行第一个判断，发现 instance == null条件不成立，直接返回instance，但此时instance并没有初始化，此时访问instance对象的成员变量就可能发生空指针异常

解决方式

上述问题出现的本质原因是(线程切换带来的原子性问题)，JVM在编译时的指令重排序造成的，所以只要禁止指令重排序，就可以解决这个问题，所以需要在 Singleton 对象的成员变量 singleton 前加 volatile 关键字

   private volatile static Singleton singleton;

扩展 - Volatile

volatile是Java虚拟机提供的轻量级同步机制，轻量级可以理解为低配版，因为没有保证原子性

volatile有三大特性，保证可见性，不保证原子性，禁止指令重排

保证可见性

例其中一个线程修改了主内存变量值，并写回主程序，及时通知其他线程

各个线程对主内存共享变量的操作都会拷贝到自己的工作内存去操作，一个线程同理在自己工作内存中修改了共享变量的值，还未写回主内存，另一个线程也要修改同一个变量，但是此时它对上一个线程正在修改不知情，即A线程*享变量的值对B线程不可见，这种工作内存与主内存同步延迟现象即可见性问题

不保证原子性

即不可分割性，完整性，即某个线程执行某个具体任务时，中间不可以被加塞或者分割，要整体完整，即整体要么同时成功，要么同时失败

禁止指令重排

volatile能够实现禁止指令重排，避免在多线程环境下出现乱序执行的情况，和底层内存屏障有关

指令重排

计算机在执行程序时为了提高性能，底层编译器和处理器，内存都会对指令进行重排

单线程里面确保程序最终执行结果，会与程序顺序执行结果一致

底层编译器的处理器在指令重排时，一定会考虑指令间的数据依赖性

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保持一致是无法确定的

扩展-线程切换

操作系统允许某个进程执行一小段时间，如50ms，过了50ms操作系统会重新选择一个进程来执行（任务切换），这个50ms称为时间片，Java并发是基于多线程的，大多数的并发bug都是由于线程切换造成的

Java的一条语句对应的cpu指令可能是多条，其中任意一条cpu指令在执行完都可能发生线程切换

如：count += 1，对应cpu 指令如下：

1）将变量count从内存加载到cpu寄存器

2）寄存器中 +1

3）将结果写入内存（缓存机制写入的可能是cpu而不是内存）

大家可以参考如下示例图，加深理解

下节预告

OK，由于篇幅的限制，本节内容就先到这里，下一节，我们接着来聊单例模式的后两种写法，包括静态内部类，枚举，同时会带大家阅读JDK源码中单例模式的应用，以及对单例模式的注意事项进行总结，最后，希望大家在学习的过程中，能够感觉到设计模式的有趣之处，高效而愉快的学习，那我们下期见~

码农公寓