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

时间 2020-07-20

标签面试讲解模式竖起大拇指栏目快乐工作繁體版

原文原文链接

单例模式相信你们都有所听闻，甚至也写过很多了，在面试中也是考得最多的其中一个设计模式，面试官经常会要求写出两种类型的单例模式而且解释其原理，废话很少说，咱们开始学习如何很好地回答这一道面试题吧。java

什么是单例模式

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

单例模式是指在内存中只会建立且仅建立一次对象的设计模式。在程序中屡次使用同一个对象且做用相同时，为了防止频繁地建立对象使得内存飙升，单例模式可让程序仅在内存中建立一个对象，让全部须要调用的地方都共享这一单例对象。设计模式

单例模式的类型

单例模式有两种类型：安全

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

懒汉式建立单例对象

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

根据上面的流程图，就能够写出下面的这段代码并发

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 在保证最终结果正确的状况下，能够不按照程序编码的顺序执行语句，尽量提升程序的性能

在这三步中，第二、3 步有可能会发生指令重排现象，建立对象的顺序变为 1-3-2，会致使多个线程获取对象时，有可能线程 A 建立对象的过程当中，执行了一、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;
    }
    
}
复制代码

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

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

利用反射破坏单例模式

下面是一段使用反射破坏单例模式的例子

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
}
复制代码

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

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

下面是一种使用序列化和反序列化破坏单例模式的例子

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() 方法读入对象时它一定会返回一个新的对象实例，必然指向新的内存地址。

让面试官鼓掌的枚举实现

咱们已经掌握了懒汉式与饿汉式的常见写法了，一般状况下到这里已经足够了。可是，追求极致的咱们，怎么可以止步于此，在《Effective Java》书中，给出了终极解决方法，话很少说，学完下面，真的不虚面试官考你了。

在 JDK 1.5 后，使用 Java 语言实现单例模式的方式又多了一种：枚举

枚举实现单例模式完整代码以下：

public enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        System.out.println("这是枚举类型的单例模式！");
    }
}
复制代码

使用枚举实现单例模式较其它两种实现方式的优点有 3 点，让咱们来细品。

优点 1 ：一目了然的代码

代码对比饿汉式与懒汉式来讲，更加地简洁。最少只须要3行代码，就能够完成一个单例模式：

public enum Test {
    INSTANCE;
}
复制代码

咱们从最直观的地方入手，第一眼看到这3行代码，就会感受到少，没错，就是少，虽然这优点有些牵强，但写的代码越少，越不容易出错。

优点 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
复制代码