1. 什么是单例模式

面试官问什么是单例模式时&＃xff0c;千万不要答非所问&＃xff0c;给出单例模式有两种类型之类的回答&＃xff0c;要围绕单例模式的定义去展开。

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时&＃xff0c;为了防止频繁地创建对象使得内存飙升&＃xff0c;单例模式可以让程序仅在内存中创建一个对象&＃xff0c;让所有需要调用的地方都共享这一单例对象。

2. 单例模式的类型

单例模式有两种类型&＃xff1a;

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

懒汉式创建单例对象

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

根据上面的流程图&＃xff0c;就可以写出下面的这段代码

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


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

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

饿汉式创建单例对象

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

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

public class Singleton{private static final Singleton singleton &＃61; new Singleton();private Singleton(){}public static Singleton getInstance() {return singleton;}
}


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

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

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

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

public static Singleton getInstance() {if (singleton &＃61;&＃61; null) {singleton &＃61; new Singleton();}return singleton;
}


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

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

public static synchronized Singleton getInstance() {if (singleton &＃61;&＃61; null) {singleton &＃61; new Singleton();}return singleton;
}
// 或者
public static Singleton getInstance() {synchronized(Singleton.class) { if (singleton &＃61;&＃61; null) {singleton &＃61; new Singleton();}}return singleton;
}


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

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

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

public static Singleton getInstance() {if (singleton &＃61;&＃61; null) { // 线程A和线程B同时看到singleton &＃61; null&＃xff0c;如果不为null&＃xff0c;则直接返回singletonsynchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化if (singleton &＃61;&＃61; null) { // 其中一个线程进入该分支&＃xff0c;另外一个线程则不会进入该分支singleton &＃61; new Singleton();}}}return singleton;
}


上面的代码已经完美地解决了并发安全&＃43;性能低效问题&＃xff1a;

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

 

因为需要两次判空&＃xff0c;且对类对象加锁&＃xff0c;该懒汉式写法也被称为&＃xff1a;Double Check&＃xff08;双重校验&＃xff09; &＃43; Lock&＃xff08;加锁&＃xff09;

​完整的代码如下所示&＃xff1a;

public class Singleton {private static Singleton singleton;private Singleton(){}public static Singleton getInstance() {if (singleton &＃61;&＃61; null) { // 线程A和线程B同时看到singleton &＃61; null&＃xff0c;如果不为null&＃xff0c;则直接返回singletonsynchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化if (singleton &＃61;&＃61; null) { // 其中一个线程进入该分支&＃xff0c;另外一个线程则不会进入该分支singleton &＃61; new Singleton();}}}return singleton;}}


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

4. 使用volatile防止指令重排

创建一个对象&＃xff0c;在JVM中会经过三步&＃xff1a;

&＃xff08;1&＃xff09;为singleton分配内存空间

&＃xff08;2&＃xff09;初始化singleton对象

&＃xff08;3&＃xff09;将singleton指向分配好的内存空间

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

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

使用volatile关键字可以防止指令重排序&＃xff0c;​其原理较为复杂&＃xff0c;这篇博客不打算展开&＃xff0c;可以这样理解&＃xff1a;使用volatile关键字修饰的变量&＃xff0c;可以保证其指令执行的顺序与程序指明的顺序一致&＃xff0c;不会发生顺序变换&＃xff0c;这样在多线程环境下就不会发生NPE异常了。

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

最终的代码如下所示&＃xff1a;

public class Singleton {private static volatile Singleton singleton;private Singleton(){}public static Singleton getInstance() {if (singleton &＃61;&＃61; null) { // 线程A和线程B同时看到singleton &＃61; null&＃xff0c;如果不为null&＃xff0c;则直接返回singletonsynchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化if (singleton &＃61;&＃61; null) { // 其中一个线程进入该分支&＃xff0c;另外一个线程则不会进入该分支singleton &＃61; new Singleton();}}}return singleton;}}


5. 总结

&＃xff08;1&＃xff09;单例模式有两种&＃xff1a;懒汉式、饿汉式

&＃xff08;2&＃xff09;懒汉式&＃xff1a;在需要用到对象时才实例化对象&＃xff0c;正确的实现方式是&＃xff1a;Double Check &＃43; Lock&＃xff0c;解决了并发安全和性能低下问题

&＃xff08;3&＃xff09;饿汉式&＃xff1a;在类加载时已经创建好该单例对象&＃xff0c;在获取单例对象时直接返回对象即可&＃xff0c;不会存在并发安全和性能问题。

&＃xff08;4&＃xff09;在开发中如果对内存要求非常高&＃xff0c;那么使用懒汉式写法&＃xff0c;可以在特定时候才创建该对象&＃xff1b;

&＃xff08;5&＃xff09;如果对内存要求不高使用饿汉式写法&＃xff0c;因为简单不易出错&＃xff0c;且没有任何并发安全和性能问题

&＃xff08;6&＃xff09;为了防止多线程环境下&＃xff0c;因为指令重排序导致变量报NPE&＃xff0c;需要在单例对象上添加volatile关键字防止指令重排序