参考：https://www.cnblogs.com/jing-an-feng-shao/p/7495048.html

1 单例模式

《Head First 设计模式》：确保一个类只有一个实例，并提供一个全局访问点
其目的在于减少系统对于同一个对象的创建和销毁，从而减少内存的开销。

2 实现方法

饿汉模式
懒汉模式
静态内部类模式
静态代码块模式
单元素枚举类模式
登记模式

2.1 饿汉模式

思想：
　　饿汉模式是最常提及的2种单例模式之一，其核心思想，是类持有一个自身的 instance 属性，并且在申明的同时立即初始化。
　　同时，类将自身的构造器权限设为 private，防止外部代码创建对象，对外只提供一个静态的 getInstance() 方法，作为获取单例的唯一入口。

public class EagerSingleton {
    
    private final static EagerSingleton instance = new EagerSingleton();
    
    private EagerSingleton () {
        if(instance != null) {  //使构造器只能被调用一次
            throw new IllegalStateException();
        }
    }
    
    public static EagerSingleton getInstance() {
        return instance;
    }
    
}

三个要点：

构造器为私有，使用公共静态方法获取实例
类持有持有一个自身的成员变量并且声明时立即初始化
构造器内部添加if(instance != null)(throw new IllegalStateException();)来限定构造方法只被调用一次，这样反射在调用构造方法时就会报错

测试Demo如下：

public class DemoSingleton {
    
    public static void main(String[] args) {
        EagerSingleton e1 = EagerSingleton.getInstance();
        EagerSingleton e2 = EagerSingleton.getInstance();
        System.out.println(e1 == e2); //结果为true
        
        //使用方式调用构造器新建实例
        try {
            Class eagerSingletonClass = Class.forName("EagerSingleton");
            Constructor declaredConstructorBook = eagerSingletonClass.getDeclaredConstructor();
            declaredConstructorBook.setAccessible(true);
            Object e = declaredConstructorBook.newInstance(); //调用构造器返回IllegalStateException异常
            System.out.println(e == e1); //如果构造器没限定代码会打印出false，说明没有限定代码反射可以打破单例
        } catch (ClassNotFoundException | InstantiationException 
                | IllegalAccessException | NoSuchMethodException 
                | SecurityException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

}

为什么在私有构造器中加入对 instance 属性的空校验？
为了阻止反射的入侵，从而打破单例。
多线程的情况下会不会打破单例？
不会，因为 EagerSingleton 是在加载类的同时进行对象的创建，所以即使在多线程并发的情况下，仍然可以保证单例。
优势？劣势？
　　在加载类的同时创建单例对象，如果这个对象不是立刻需要使用的，会额外增加内存的消耗。

2.2 懒汉模式

思想：
　　相比于饿汉模式，懒汉模式实际中的应用更多，因为在系统中，“被用到时再初始化”是更佳的解决方案。
　　设计思想与饿汉模式类似，同样是持有一个自身的引用，只是将 new 的动作延迟到 getinstance() 方法中执行。

class LazySingleton {
    private static LazySingleton instance;
    
    private LazySingleton() {
        if(instance != null) {
            throw new IllegalStateException();
        }
    }
    
    public static synchronized LazySingleton getInstance() {
        if(instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

反射能否打破单例？
对于 LazySingleton，这是个很有趣的问题，虽然我们在私有构造器中增加了 instance==null 的判断，但是由于延迟加载的原因，使得它无法完美地规避反射的入侵。这涉及到了反射入侵和 getInstance() 方法调用顺序的问题。如果在调用 getInstance() 方法之前进行反射入侵，那么就会打破单例，反之，可以保证单例。
同步方法带来的性能问题？
可以使用 synchronized 代码块 + Double-check Locking + volatile 关键字
优势？劣势？
优势：延迟加载。
劣势：不能完全屏蔽反射入侵，而且代码较为繁琐。

2.3 静态内部类模式

class StaticInnerSingleton {
    private static class Holder {
        private static StaticInnerSingleton instatnce = new StaticInnerSingleton();
    }
    
    private StaticInnerSingleton () {
        if(Holder.instatnce != null) {
            throw new IllegalStateException();
        }
    }
    
    public static StaticInnerSingleton getInstance() {
        return Holder.instatnce;
    }
}

反射能否打破单例？
首先，对外部类的私有构造器中加入 instance==null 的判断，防止反射入侵外部类。
其次，静态内部类保证了从外部很难获取 SingletonHolder 的 Class 对象，从而保证了内部类不会被反射。
多线程能否打破单例？
Holder 模式借用了饿汉模式的优势，就是在加载类（内部类）的同时对 instance 对象进行初始化。
由于自始至终类只会加载一次，所以即使在多线程的情况下，也能够保持单例的性质。
优势？劣势？
优势：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（不会被反射入侵）。
劣势：需要多加载一个类；相比于懒汉模式，Holder 创建的单例，只能通过 JVM 去控制器生命周期，不能手动 destroy。

3 总结

实现方法	优势	劣势	阻止反射入侵	阻止多线程入侵
饿汉模式		额外增加内存的消耗	√	√
懒汉模式	延迟加载	不能完全屏蔽反射入侵	×	√
静态内部类模式	延迟加载	只能通过 JVM 去控制器生命周期，不能手动 destroy	√	√

单例模式总结