被面试官怼了之后我才发现，我几乎对单例模式一无所知！

以下文章来源于公众号程序员面试现场，作者面试现场

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

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

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

Q：你日常开发中都是怎么实现单例的呀？
A：我一般使用懒汉模式实现单例的。
Q：你用的懒汉方式实现的单例是线程安全的吗？
A：（这我知道，我用的肯定是线程安全的）我使用的时候，用了synchronized，所以我的实现是线程安全的。

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

线程不安全的懒汉模式：

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

    public static 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：（这个问题很有意思，我根据我自己的理解回答了好几种，但是好像都不是面试官想要的答案，这是另外一个话题了，下次再单独分享吧。）