单例模式（狂神版）

参考

狂神
我给面试官讲解了单例模式后，他对我竖起了大拇指！

单例模式

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

单例模式有两种类型：
懒汉式：在真正需要使用对象时才去创建该单例类对象
饿汉式：在类加载时已经创建好该单例对象，等待被程序使用

饿汉式：

public class Singleton {
    private static final Singleton singleton = new Singleton();
    private Singleton(){}
    public static Singleton getSingleton(){
        return singleton;
    }
}

懒汉式:

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

懒汉式方法其实是存在问题的，试想一下，如果两个线程同时判断singleton为空，那么它们都会去实例化一个Singleton对象，这就变成双例了。所以，我们要解决的是线程安全问题。
最容易想到的解决方法就是在方法上加锁，或者是对类对象加锁，程序就会变成下面这个样子

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

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

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

因为需要两次判空，且对类对象加锁，该懒汉式写法也被称为：Double Check（双重校验） + Lock（加锁），也就是DCL。

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

使用volatile防止指令重排

创建一个对象，在JVM中会经过三步：

（1）为singleton分配内存空间

（2）初始化singleton对象

（3）将singleton指向分配好的内存空间

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

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

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

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

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

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

无论是完美的懒汉式还是饿汉式，终究敌不过反射和序列化，它们俩都可以把单例对象破坏掉（产生多个对象）。
1.演示利用反射破坏单例模式

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Singleton singleton = Singleton.getSingleton();
        Constructor<Singleton> declaredConstructor = Singleton.class.getDeclaredConstructor();
        // 可访问私有构造器
        declaredConstructor.setAccessible(true);
        // 利用反射构造新对象
        Singleton singleton1 = declaredConstructor.newInstance();
        System.out.println(singleton);
        System.out.println(singleton1);
    }

对于上述的放射破坏，可以在构造器加判断

    private Singleton(){
        synchronized (Singleton.class){
            if(singleton!=null){
                throw new RuntimeException("不要用放射破坏单例,kuso");
            }
        }
    }

再对于上述反破解，可以不用原始的构造，直接用放射得到的构造器来构造，代码如下

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<Singleton> declaredConstructor = Singleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Singleton singleton1 = declaredConstructor.newInstance();
        Singleton singleton2 = declaredConstructor.newInstance();
        System.out.println(singleton1);
        System.out.println(singleton2);
    }

对上述的方法，可以用标志位解决：

    private static boolean flag = false;
    private Singleton(){
        synchronized (Singleton.class){
            if(flag==false){
                flag=true;
            }else {
                throw new RuntimeException("不要用放射破坏单例,kuso");
            }
        }
    }

对上面这种，如果知道名字，就可以改写他的值

        Constructor<Singleton> declaredConstructor = Singleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Field flag = Singleton.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Singleton singleton1 = declaredConstructor.newInstance();
        flag.set(singleton1,false);
        Singleton singleton2 = declaredConstructor.newInstance();
        System.out.println(singleton1);
        System.out.println(singleton2);

道高一尺魔高一丈

2：利用序列化与反序列化破坏单例模式（要加序列化关键字implements Serializable）：

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》书中，给出了终极解决方法。

在 JDK1.5 后，使用 Java 语言实现单例模式的方式又多了一种：枚举
我们先来看看枚举如何实现单例模式的，如下代码：

public enum  EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance1 = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instance1);
    }
}

错误：

java.lang.NoSuchMethodException: EnumSingle.()
它说没有无参构造；

分析

用反编译查看枚举的代码，发现确实有无参构造，欺骗老子

再用更专业的反编译软件查看，就能发现

实际构造方法是有参的，string和int，还得是你啊，tieme
再写破坏的代码

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance1 = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instance1);
    }

报错：Cannot reflectively create enum objects

这段来自declaredConstructor.newInstance()里面的代码：

        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");

反反射破坏原理：

反序列化破坏原理：

在读入Singleton对象时，每个枚举类型和枚举名字都是唯一的，所以在序列化时，仅仅只是对枚举的类型和变量名输出到文件中，在读入文件反序列化成对象时，利用 Enum 类的 valueOf(String name) 方法根据变量的名字查找对应的枚举对象。
所以，在序列化和反序列化的过程中，只是写出和读入了枚举类型和名字，没有任何关于对象的操作。

小总结：

（1）Enum 类内部使用Enum 类型判定防止通过反射创建多个对象

（2）Enum 类通过写出（读入）对象类型和枚举名字将对象序列化（反序列化），通过 valueOf() 方法匹配枚举名找到内存中的唯一的对象实例，防止通过反序列化构造多个对象

（3）枚举类不需要关注线程安全、破坏单例和性能问题，因为其创建对象的时机与饿汉式单例有异曲同工之妙。

总结

优势1：代码对比饿汉式与懒汉式来说，更加地简洁
其次，既然是实现单例模式，那这种写法必定满足单例模式的要求，而且使用枚举实现时，没有做任何额外的处理。

优势2：它不需要做任何额外的操作去保证对象单一性与线程安全性
我写了一段测试代码放在下面，这一段代码可以证明程序启动时仅会创建一个 Singleton 对象，且是线程安全的。

优势3：使用枚举可以防止调用者使用反射、序列化与反序列化机制强制生成多个单例对象，破坏单例模式。

大总结

（1）单例模式常见的写法有两种：懒汉式、饿汉式

（2）懒汉式：在需要用到对象时才实例化对象，正确的实现方式是：Double Check + Lock，解决了并发安全和性能低下问题

（3）饿汉式：在类加载时已经创建好该单例对象，在获取单例对象时直接返回对象即可，不会存在并发安全和性能问题。

（4）在开发中如果对内存要求非常高，那么使用懒汉式写法，可以在特定时候才创建该对象；

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

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

（7）最优雅的实现方式是使用枚举，其代码精简，没有线程安全问题，且 Enum 类内部防止反射和反序列化时破坏单例。