单例，大家肯定都不陌生，这是Java中很重要的一个设计模式。其实单例模式看上去简单，实际上却有很多容易被忽视的地方，因为他涉及到一些线程安全的问题，稍不留神就可能入坑。

本文，就通过一次面试经历来深入介绍下和单例有关的那点事儿！本文的第一人称是面试候选人！

之所以会聊到单例，是因为面试者的简历上写了"熟悉常用的设计模式"，面试官在问他熟悉哪种设计模式的时候，我回答"自己对单例比较了解"，但是面试没等结束，我就发现我还是太年轻了。

Q：你日常开发中都是怎么实现单例的呀？

A：我一般使用懒汉模式实现单例的。

Q：你用的懒汉方式实现的单例是线程安全的吗？

A：(这我知道，我用的肯定是线程安全的)我使用的时候，用了synchronized，所以我的实现是线程安全的。

懒汉模式

所谓"懒汉"，指的是并不会事先初始化出单例对象，而是在第一次使用的时候再进行初始化，懒汉模式有两种写法，分别是线程安全的和非线程安全的。

线程不安全的懒汉模式：

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

线程安全的懒汉模式：

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

Q：那你知道懒汉模式有什么优缺点吗？

A：(这还能难倒我么？)懒汉模式可以在第一次真正用到的时候再实例化，避免了创建无效的对象。但是缺点是第一次使用的时候需要耗费时间进行对象的初始化。

这个时候我已经有点窃喜了，感觉面试官问的问题完全在我的射程范围内，哈哈哈...

Q：那除了懒汉模式，饿汉你有了解吗？

A：(我就猜到他会问这个，其实在回答懒汉的时候我已经知道了)我知道的，饿汉就是在类初始化的时候创建单例对象。

Q：具体是怎么实现的呢？如何在类初始化时创建对象？

A：(刚问的时候我稍微有点懵，不过很快反应过来了)就是使用static定义全局对象，在对象声明的时候直接new一个对象，或者使用静态代码块。

饿汉模式

所谓"饿汉"，是指等不及要赶紧创建单例对象，即在类加载的过程中就进行单例对象的创建。具体实现方式也有多种。

饿汉模式：

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

饿汉模式变种：

public class Singleton {    private Singleton instance = null;    static {    instance = new Singleton();    }    private Singleton (){}    public static Singleton getInstance() {    return this.instance;    }}

Q：那饿汉模式是线程安全的吗？

A：额....应该是吧，嗯，(我要坚定，不能让面试官看出我不会)是的，是线程安全的。

Q：为什么饿汉模式是线程安全的呢？怎么实现的呢？

A：(回答上一个问题的时候我就有点发慌了，果然还是逃不过去)应该是类加载的时候线程安全的吧？(这个我真的是不太确定，也是有点紧张，没回答好)

饿汉如何保证线程安全

通过定义静态的成员变量，以保证单例对象可以在类初始化的过程中被实例化。

这其实是利用了ClassLoader的线程安全机制。ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字。

所以， 除非被重写，这个方法默认在整个装载过程中都是线程安全的。所以在类加载过程中对象的创建也是线程安全的。

Q：好的，没关系，那双重校验锁这种单例你有了解吗？

A：知道一点，就是通过同步代码块代替了懒汉模式中的同步方法，来减小锁的粒度，减少阻塞。但是避免并发，需要进行两次非空判断，所以叫做双重锁校验。

双重校验锁实现单例：

public class Singleton {    private volatile static Singleton singleton;    private Singleton (){}    public static Singleton getSingleton() {    if (singleton == null) {        synchronized (Singleton.class) {            if (singleton == null) {                singleton = new Singleton();            }        }    }    return singleton;    }}

Q：那你知道为什么已经用到了synchronized进行了同步，还需要使用volatile对单例对象进行修饰吗？

A：(这个我还真的没有注意过，只是胡乱回答了一堆volatile不能保证原子性之类的。但是面试官不是很满意，后来我自己查了一下)

双重锁校验的单例中为什么要使用volatile

因为编译器有可能进行指令重排优化，使得singleton对象在未完成初始化之前就对其进行了赋值，这样其他人拿到的对象就可能是个残缺的对象了。使用volatile的目的是避免指令重排。保证先进性初始化，然后进行赋值

Q：那你听说过指令重排吗？

A：(当时我回答没听说过，后来才知道，原来面试官在引导回答上一个问题，可惜自己太傻了，这里看出面试官还是比较友善的。)

慌张，除了慌张还是慌张...

Q：OK ，没关系的，那你还知道有其他方式可以实现单例吗？

A：好像是使用枚举可以实现单例

枚举实现单例：

public enum Singleton {    INSTANCE;    public void whateverMethod() {    }}

Q：知道枚举实现单例有什么好处吗？

A：写法简单，几行代码就能搞定了。

Q：还有呢？

A：(还好我看过枚举的实现)枚举其实底层是依赖Enum类实现的，这个类的成员变量都是static类型的，并且在静态代码块中实例化的，和饿汉有点像， 所以他天然是线程安全的。

Q：还有呢？

A：(我的天，怎么还有？)还有的我就不是很清楚了。

枚举实现单例的好处

除了写法简单，线程安全以外，枚举还有一个好处，那就是"枚举可以解决反序列化会破坏单例的问题"

在枚举序列化的时候，Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过java.lang.Enum的valueOf方法来根据名字查找枚举对象。同时，编译器是不允许任何对这种序列化机制的定制的，因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。

普通的Java类的反序列化过程中，会通过反射调用类的默认构造函数来初始化对象。所以，即使单例中构造函数是私有的，也会被反射给破坏掉。由于反序列化后的对象是重新new出来的，所以这就破坏了单例。

但是，枚举的反序列化并不是通过反射实现的。所以，也就不会发生由于反序列化导致的单例破坏问题。

Q：好的，那我还有最后一个问题，如果不让你使用synchronized和lock，你知道怎么实现一个线程安全的单例吗？

A：(这个问题很有意思，我根据我自己的理解回答了好几种，但是好像都不是面试官想要的答案，这是另外一个话题了，下次再单独分享吧。)