你真的了解单例吗

又到了一个老生常谈的话题，单例模式，可能在面试时我们也经常会遇到，但是看似很简单的问题，却能看出一个人对单例理解的深度。要写一个单例，首先需要让构造器私有，还需要对外提供一个可以获取单例的一个入口，通常我们可能会这样写：

第一种：

public class SingleTon {

private static SingleTon instance = new SingleTon();

private SingleTon(){}

public static SingleTon get(){
    return instance;
}

}
这种方式简单直接，实例随着类加载而加载，很方便，但是却不友好，有时候我们虽然加载了类，却没有使用该类实例的时候，会造成内存的浪费，不能达到懒加载的能力。所以我们可以改进成下面这样：

第二种：

public class SingleTon {

private static SingleTon instance = null;

private SingleTon(){}

public static SingleTon get(){
    if (instance == null){
        instance =new SingleTon();
    }
    return instance;
}

}
这样可以达到懒加载，需要的时候在初始化，但是如果在多线程的情况下是不完全的，那我们会这样写：

public class SingleTon {

private static SingleTon instance = null;

private SingleTon(){}

public static synchronized SingleTon get(){
    if (instance == null){
        instance =new SingleTon();
    }
    return instance;
}

}
虽然这样安全了，但是锁的粒度还是比较大，所以为了减小锁的粒度我们还会这样写：

public class SingleTon {

private static SingleTon instance = null;

private SingleTon() {
}

public static SingleTon get() {
    if (instance == null) {
        synchronized (SingleTon.class) {
            if (instance == null) {
                instance = new SingleTon();
            }
        }
    }
    return instance;
}

}
如果我们写到这里就以为很满足了，那么我只能说太天真了，看似一切完美，但是我们还是要问自己，这样就绝对的会线程安全吗？
要回答这个问题，这就不得不说一说对象的创建过程和java虚拟机的无序性。首先在我们new对象的时候，首先需要在方法区中去寻找该类的符号引用，如果找不到，说明类还没有被加载进虚拟机，所以需要通过类加载器先装载该类，通过加载，验证，准备，解析，初始化等操作，然后为对象在堆上开辟内存空间（1），对象初始化操作（2），然后在将栈上的引用指向该对象内存地址（3）。重点就在这，由于虚拟机的无序性，可能会造成执行的顺序并不是按照123进行的，也可能是按照132的执行顺序，结果就是引用先指向对象地址，然后对象在进行初始化等操作，这是由于线程的可见性造成的，所以为了保证变量instance的线程之间的可见性，我们需要将instance变量进行volatile修饰来解决instance的可见性问题。（关于java虚拟机的无序性和volatile的内存语义，涉及到了java内存模型的层面，这里暂时不过多分析，后面会单独进行讲解）。

所以正确的写法是这样：

public class SingleTon {

private static volatile SingleTon instance = null;

private SingleTon() {
}

public static SingleTon get() {
    if (instance == null) {
        synchronized (SingleTon.class) {
            if (instance == null) {
                instance = new SingleTon();
            }
        }
    }
    return instance;
}

}
我们还可以改成成一个类，专门生成单例：

public abstract class Singleton<T> {
private volatile T mInstance;

protected abstract T create();

public final T get() {
    synchronized (this) {
        if (mInstance == null) {
            mInstance = create();
        }
        return mInstance;
    }
}

}
那么到此我们就可以满足了吗？当然不能。

这里不可避免的需要对volatile进行解释一下了，volatile在《深入理解java虚拟机》中有一下几层含义：

1，被volatile修饰的变量，保证了该变量对其他线程的可见性,；

2，禁止指令重排序，虚拟机会通过插入很多读写内存屏障，来保证处理器不会乱序执行，但是也会造成编译器不会对代码进行优化（java内存模型会最大限度的保证程序并行执行），对效率有一定影响。

那么我们在不使用volatile的前提下如何优化呢，下面给出某大牛的写法：

public class SingleTon {

private static SingleTon instance = null;

private SingleTon() {
}

public static SingleTon get() {
    if (instance == null) {
        synchronized (SingleTon.class) {
            if (instance == null) {
                SingleTon temp = null;
                try {
                    temp = new SingleTon();
                } catch (Exception e) {

                }
                if (temp != null)
                    instance = temp;
        }
    }
    return instance;
}

}
看似无用的代码却大有用处，try的存在虚拟机无法优化temp是否为空，instance在赋值之前保证了对象已经初始化完成。看到这里明显感觉到水很深啊。

   前面其实大概分为两种，饿汉式和懒汉式，那有没有既线程安全写法简单，又能懒加载呢？

第三种：

public class SingleTon {

private SingleTon() {
}

private static class SingleHolder {
    private static SingleTon instance = new SingleTon();
}

public static SingleTon get() {
    return SingleHolder.instance;
}

}
这里我们通过静态内部类来完成，是不是很妙，我们无需枷锁，外部类的加载不会造成内部类同时加载的，只有调用了get方法时才会加载内部类，创建对象，集前两种方法的优点于一身。

但是到这里我们又要分析了，以上写法到底完全不，如果通过反射或者反序列化还能保证是单例吗？

当然不可能，在反射面前，一切都是小儿科了，这种写法可阻止不了反射，反序列化也不行，你必须重写readReslove方法，返回当前实例，不然就是多个实例了，

那到底有没有绝对安全的单例啊，我们是不是都快绝望了，别急，放大招：

public enum SingleTon {
intstance;
}
是不是有点意外了，居然最简单最安全的是枚举，至于枚举是如何做到反射和反序列化时依然安全的可以看链接：

https://blog.csdn.net/gavin_dyson/article/details/70832185

好了，单例到此介绍完毕，看完这些你对单例模式真的了解了吗？

你真的了解单例吗

推荐阅读更多精彩内容