设计模式之单例模式（创建型）

light05-25

已于 2022-06-28 08:40:43 修改

阅读量677

点赞数 2

分类专栏：设计模式文章标签：单例模式设计模式 java

于 2022-06-23 13:08:05 首次发布

本文链接：https://blog.csdn.net/qq_43013511/article/details/125420200

版权

设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

一、什么是单例模式

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。
在这里插入图片描述
单例模式的三个要素：

私有构造方法
指向自己实例的私有静态变量
对外的静态公共访问方法

二、单例模式的类型

懒汉式：在真正需要使用对象时才去创建该单例类对象。
饿汉式：在类加载时已经创建好该单例对象，等待被程序使用。（类何时加载主要由JVM决定，换句话而言和JDK版本有关，这里不做探讨）

1、懒汉式创建单例对象

原理：在程序使用对象前，先判断该对象是否已经实例化（判空），若已实例化直接返回该类对象，否则则先执行实例化操作。

在这里插入图片描述

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

这个代码暂时还存在一些问题，后面进行解释优化。

2、饿汉式创建单例对象

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

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

public class Singleton{
    
    private static final Singleton singleton = new Singleton();
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        return singleton;
    }
}

在类加载时提前声明提前声明一个静态对象在堆内存中，当类被卸载时，该对象也随之消失。

三、代码优化

1、并发安全

这里先回顾一下懒汉式的核心方法：

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;
}

2、并发性能

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

解决方法：
如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例。所以直接在方法上加锁的方式就被废掉了，因为这种方式无论如何都需要先获取锁。

原因：
如果把锁直接加在方法上，那么无论是否已经创建过该类的实例，所有线程都只能一个一个的依次执行整个方法体，会造成大量的阻塞时间。

另外，我们之所以要处理线程安全问题，只是因为在getInstance（）方法前几次被并发执行时，可能会有多个线程得到“single == null”为“true”的结果，从而有可能出现创建多个对象的情况。而一旦有线程完成了创建实例的操作，那么在不考虑其他修改方法的情况下，对于getInstance（）这种只读操作，其方法内部就不再存在线程安全问题。

所以，如果对象已经创建，我们完全可以让其他所有线程都并行执行getInstance（）方法，于是便有了了这种“为创建对象时同步执行，已创建对象后异步执行”的优化方式：采用在代码块上加锁的方式进行优化。

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;
}

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

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

强化理解

如果理解不了为什么要判断两次为null的情况，请看下面这个代码：

package threadTest;
 
public class Singleton {
 
    private static volatile Singleton singleton;
 
    private Singleton(){}
 
    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
        	System.err.println(Thread.currentThread().getName()+"抢到线程check");
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
            	System.err.println(Thread.currentThread().getName()+"进入代码块");
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                	System.err.println(Thread.currentThread().getName()+"创建实例");
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

如果有A、B两个线程，都执行到第一个if，都是null，那么他们都会执行同步代码块，假设A先执行，A执行完已经有实例了，如果不加里面那个if就会造成B再次实例化一次，这样单例就失效了。

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

3、指令重排

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

（1）为singleton分配内存空间

（2）初始化singleton对象

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

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

在这三步中，第2、3步有可能会发生指令重排现象，创建对象的顺序变为1-3-2，会导致多个线程获取对象时，有可能线程A创建对象的过程中，执行了1、3步骤，线程B判断singleton已经不为空，获取到未初始化的singleton对象，就会报NPE异常。文字较为晦涩，可以看流程图：
在这里插入图片描述
使用volatile关键字可以防止指令重排序，其原理较为复杂，这篇博客不打算展开，可以这样理解：使用volatile关键字修饰的变量，可以保证其指令执行的顺序与程序指明的顺序一致，不会发生顺序变换，这样在多线程环境下就不会发生NPE异常了。

volatile还有第二个作用：使用volatile关键字修饰的变量，可以保证其内存可见性，即每一时刻线程读取到该变量的值都是内存中最新的那个值，线程每次操作该变量都需要先读取该变量。

最终的代码如下所示：

public class Singleton {
    
    private static volatile 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;
    }
}

四、破坏懒汉式单例与饿汉式单例

无论是完美的懒汉式还是饿汉式，终究敌不过反射和序列化，它们俩都可以把单例对象破坏掉（产生多个对象）。

1、利用反射破坏单例模式

public static void main(String[] args) {
    // 获取类的显式构造器
    Constructor<Singleton> construct = Singleton.class.getDeclaredConstructor();
    // 可访问私有构造器
    construct.setAccessible(true); 
    // 利用反射构造新对象
    Singleton obj1 = construct.newInstance(); 
    // 通过正常方式获取单例对象
    Singleton obj2 = Singleton.getInstance(); 
    System.out.println(obj1 == obj2); // false
}

上述的代码一针见血了：利用反射，强制访问类的私有构造器，去创建另一个对象

2、利用序列化与反序列化破坏单例模式

public static void main(String[] args) {
    // 创建输出流
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.file"));
    // 将单例对象写到文件中
    oos.writeObject(Singleton.getInstance());
    // 从文件中读取单例对象
    File file = new File("Singleton.file");
    ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
    Singleton newInstance = (Singleton) ois.readObject();
    // 判断是否是同一个对象
    System.out.println(newInstance == Singleton.getInstance()); // false
}

两个对象地址不相等的原因是：readObject() 方法读入对象时，它必定会返回一个新的对象实例，必然指向新的内存地址。

五、枚举实现

public class Singleton {

    private Singleton(){}

    //定义一个枚举类
    private enum SingletonEnum {
        //创建一个枚举实例
        INSTANCE;

        private Singleton singleton;

        //在枚举类的构造方法内实例化单例类
        SingletonEnum(){
            singleton = new Singleton();
        }

        private Singleton getInstance(){
            return singleton;
        }
    }

    public static Singleton getInstance(){
        //获取singleton实例
        return SingletonEnum.INSTANCE.getInstance();
    }
}

需要思考：使用枚举实现单例模式的优势在哪里？
我们从最直观的地方入手，第一眼看到这几行代码，就会感觉到“少”，没错，就是少，虽然这优势有些牵强，但写的代码越少，越不容易出错。

**优势1：**代码对比饿汉式与懒汉式来说，更加地简洁

其次，既然是实现单例模式，那这种写法必定满足单例模式的要求，而且使用枚举实现时，没有做任何额外的处理。

优势2：它不需要做任何额外的操作去保证对象单一性与线程安全性

我写了一段测试代码放在下面，这一段代码可以证明程序启动时仅会创建一个 Singleton 对象，且是线程安全的。

我们可以简单地理解枚举实现单例的过程：在程序启动时，会调用Singleton的空参构造器，实例化好一个Singleton对象赋给INSTANCE，之后再也不会实例化

public enum Singleton {
    INSTANCE;
    Singleton() { System.out.println("枚举创建对象了"); }
    public static void main(String[] args) { /* test(); */ }
    public void test() {
        Singleton t1 = Singleton.INSTANCE;
        Singleton t2 = Singleton.INSTANCE;
        System.out.print("t1和t2的地址是否相同：" + t1 == t2);
    }
}
// 枚举创建对象了
// t1和t2的地址是否相同：true