我向面试官讲解了单例模式，他对我竖起了大拇指

2301_76348206

于 2024-05-03 11:36:04 发布

阅读量955

点赞数 19

分类专栏：程序员文章标签：单例模式

本文链接：https://blog.csdn.net/2301_76348206/article/details/138412688

版权

程序员专栏收录该内容

189 篇文章 0 订阅

订阅专栏

单例模式有两种类型：

懒汉式：在真正需要使用对象时才去创建该单例类对象
饿汉式：在类加载时已经创建好该单例对象，等待被程序使用

懒汉式创建单例对象

懒汉式创建对象的方法是在程序使用对象前，先判断该对象是否已经实例化（判空），若已实例化直接返回该类对象。否则则先执行实例化操作。

在这里插入图片描述

根据上面的流程图，就可以写出下面的这段代码

public class Singleton {

private static Singleton singleton;

private Singleton(){}

public static Singleton getInstance() {

if (singleton == null) {

singleton = new Singleton();

}

return singleton;

}

没错，这里我们已经写出了一个很不错的单例模式，不过它不是完美的，但是这并不影响我们使用这个“单例对象”。

以上就是懒汉式创建单例对象的方法，我会在后面解释这段代码在哪里可以优化，存在什么问题。

饿汉式创建单例对象

饿汉式在类加载时已经创建好该对象，在程序调用时直接返回该单例对象即可，即我们在编码时就已经指明了要马上创建这个对象，不需要等到被调用时再去创建。

关于类加载，涉及到JVM的内容，我们目前可以简单认为在程序启动时，这个单例对象就已经创建好了。

在这里插入图片描述

public class Singleton{

private static final Singleton singleton = new Singleton();

private Singleton(){}

public static Singleton getInstance() {

return singleton;

}

注意上面的代码在第3行已经实例化好了一个Singleton对象在内存中，不会有多个Singleton对象实例存在

类在加载时会在堆内存中创建一个Singleton对象，当类被卸载时，Singleton对象也随之消亡了。

懒汉式如何保证只创建一个对象

我们再来回顾懒汉式的核心方法

public static Singleton getInstance() {

if (singleton == null) {

singleton = new Singleton();

}

return singleton;

}

这个方法其实是存在问题的，试想一下，如果两个线程同时判断 singleton 为空，那么它们都会去实例化一个Singleton 对象，这就变成多例了。所以，我们要解决的是线程安全问题。

在这里插入图片描述

最容易想到的解决方法就是在方法上加锁，或者是对类对象加锁，程序就会变成下面这个样子

public static synchronized Singleton getInstance() {

if (singleton == null) {

singleton = new Singleton();

}

return singleton;

}

// 或者

public static Singleton getInstance() {

synchronized(Singleton.class) {

if (singleton == null) {

singleton = new Singleton();

}

return singleton;

}

这样就规避了两个线程同时创建Singleton对象的风险，但是引来另外一个问题：每次去获取对象都需要先获取锁，并发性能非常地差，极端情况下，可能会出现卡顿现象。

接下来要做的就是优化性能：目标是如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例

所以直接在方法上加锁的方式就被废掉了，因为这种方式无论如何都需要先获取锁

public static Singleton getInstance() {

if (singleton == null) { // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton

synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化

if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支

singleton = new Singleton();

}

return singleton;

}

上面的代码已经完美地解决了并发安全 + 性能低效问题：

第 2 行代码，如果 singleton 不为空，则直接返回对象，不需要获取锁；而如果多个线程发现 singleton 为空，则进入分支；
第 3 行代码，多个线程尝试争抢同一个锁，只有一个线程争抢成功，第一个获取到锁的线程会再次判断singleton 是否为空，因为 singleton 有可能已经被之前的线程实例化
其它之后获取到锁的线程在执行到第 4 行校验代码，发现 singleton 已经不为空了，则不会再 new 一个对象，直接返回对象即可
之后所有进入该方法的线程都不会去获取锁，在第一次判断 singleton 对象时已经不为空了

因为需要两次判空，且对类对象加锁，该懒汉式写法也被称为：Double Check（双重校验） + Lock（加锁）

完整的代码如下所示：

public class Singleton {

private static Singleton singleton;

private Singleton(){}

public static Singleton getInstance() {

if (singleton == null) { // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton

synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化

if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支

singleton = new Singleton();

}

return singleton;

}

上面这段代码已经近似完美了，但是还存在最后一个问题：指令重排

使用 volatile 防止指令重排

创建一个对象，在 JVM 中会经过三步：

（1）为 singleton 分配内存空间

（2）初始化 singleton 对象

（3）将 singleton 指向分配好的内存空间

指令重排序是指：JVM 在保证最终结果正确的情况下，可以不按照程序编码的顺序执行语句，尽可能提高程序的性能

在这三步中，第 2、3 步有可能会发生指令重排现象，创建对象的顺序变为 1-3-2，会导致多个线程获取对象时，有可能线程 A 创建对象的过程中，执行了 1、3 步骤，线程 B 判断 singleton 已经不为空，获取到未初始化的singleton 对象，就会报 NPE 异常。文字较为晦涩，可以看流程图：

在这里插入图片描述