单例模式是简单的设计模式之一，属于创建型模式，它提供了一种创建对象的方式，确保只有单个对象被创建。这个设计模式主要目的是想在整个系统中只能出现类的实例，即一个类只有一个对象。单列模式的解决的痛点就是节约资源，节省时间从两个方面看：
1. 由于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级的对象而言，是很重要的。
2. 因为不需要频创建对象，我们的GC压力也减轻了，而在GC中会有STW(stop the world), 从这一方面也节约了GC的时间，单例模式的缺点：简单的单例模式设计开发都比较简单，但是复杂的单例模式需要考虑线程安全等并发问题。
单例类什么时候被初始化呢？ 类加载的时候就会被初始化，java虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化，遇到new、getStatic、putStatic、invokeStatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这四条指令最常见的java代码场景：
1> 使用new关键字实例化对象
2> 读取一个类的静态字段(被final修饰、已在编译期把结果放在常量池的静态字段除外)
3> 设置一个类的静态字段(被final修饰、已在编译期把结果放在常量池的静态字段除外)
4> 调用一个类的静态方法
现在我们已知道类初始化的四种情况了。
那么我们来列举：八种单例实现方式，再分析其特点。
1. 饿汉式静态块单例：
public class HungryStaticSingleton{
private static final HungryStaticSingleton instance;
static {
instance = new HungryStaticSingleton();
}
private HungryStaticSingleton(){}
public static HungryStaticSingleton getInstance(){return instance;}
2. 懒汉式双重检查单例：
public class LazyDoubleCheckSingleton{
private static volatile static LazyDoubleCheckSingleton lazy = null;
private LazyDoubleCheckSingleton(){}
public static LazyDoubleCheckSingleton getInstance() {
if (null == lazy) {
synchronized(LazyDoubleCheckSingleton.class) {
if (null == lazy) {
lazy = new LazyDoubleCheckSingleton();
}
}
}
return lazy;
}
/**
加synchronized不必多说了，保证线程同步，原子性。
那为什么在静态常量中加volatile呢？
1. volatile 是在内存中可见性的。
2. 防止指令重排序：也就是说在new LazyDoubleCheckSingleton时指令重排序导致其他线程获取到未初始化完的对象。
instance = new LazyDoubleCheckSingleton()这句，这并非是一个原子操作。事实上在JVM中这句话大概做了下面三件 事。
1> lazy分配内存，
2> 调用LazyDoubleCheckSingleton构造函数来初始化成员变量
3> 将lazy对象指向分配的内存空间(执行完之后就不再为null了)，但是在JVM的即时编译期中存在指令排序的优化。
也就是说2> 和3> 的顺序是不能保证的，最终的执行顺序可能是1>2>3也有可能是1>3>2，如果是1>3>2的话， 则在3> 执行完毕、2> 未执行之前，被线程二抢占了，这时lazy已经是非null了(但却没有初始化)，所以线程二会 直接返回lazy,但是无法使用。
3. 内存屏障参考： https://zhuanlan.zhihu.com/p/43526907
*/
3. 懒汉式静态内部类方式实现单列
// 性能优于双重检查的懒汉模式
// 使用内部类可以避免多线程环境下不安全的问题，
// JVM对一个类的初始化会做限制，
// 同一个时间只会允许一个线程去初始化一个类，
// 这样从JVM层面避免了大部分单例实现的问题
public class LazyInnerClassSingleton{
// 默认使用LazyInnerClassSingleton，先初始化内部类
// 如果没使用的话，内部类是不加载的
// 为什么在私有的构造函数中加判空判断呢，是为了防止通过反射方式来创建实例
// 强制用指定的静态方法来实例化实例
private LazyInnerClassSingleton(){
if (LazyHolder.LAZY != null) {
throw new RuntimeException("不允许创建多个实例！")
}
}
// 每一个关键字都不是多余的
// static是为了使单例的空间共享
// 保证这个方法不会被重写，重载
public static LazyInnerClassSingleton getInstance() {
// 在返回结果之前，一定会先加载内部类。
return LazyHolder.LAZY;
}
// 默认不加载
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
/**
静态内部类实现单例，静态内部类不被调用时，默认是不会加载的。LazyInnerClassSingleton加载时，并不需要立即加载LazyHolder，内部类不被加载则不会去初始化，故不占用内存。只有当LazyInnerClassSingleton第一次被加载时， 且调用getInstance()方法时，调用了内部类，此时内部类去加载，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。无论多少个线程去创建，都只会返回一个实例，返回的地址都是同一个。
*/
4. 枚举单例
public enum EnumSingleton{
INSTANCE;
private Object data;
public Object getData() {return data;}
public static EnumSingleton getInstance(){return INSTANCE;}
}
《Effective Java》Josh Bloch推荐使用此方法实例单例，线程安全，并发好，抵御反射攻击，序列化和反序列化安全。
5. 容器式单例
// Spring中bean的获取也是通过这种方式
public class ContainerSingleton{
private ContainerSingleton(){}
private static Map<String, Object> ioc = new ConcurrentHashMap<>();
public static Object getInstance(String className){
synchronized(ioc) {
if (!ioc.containsKey(className)) {
Object obj = null;
try{
obj = Class.forName(className).newInstance();
ioc.put(className, obj);
}catch(Exception e) {
e.printStackTrance();
}
}
return ioc.get(className);
}
}
6. 序列化单例
public class SeriableSingleton implements Seria{
private static final SeriableSingleton INATANCE = new SeriableSingleton();
private SeriableSingleton(){}
public static SeriableSingleton getInstance(){
return INATANCE;
}
private Object readResolve(){return INATANCE;}
}
/**
序列化就是把内存中的状态通过转成字节码的形式，从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
内存中状态给永久保存下来了。
反序列化就是将已经持久化的字节码内容、转换为IO流，通过IO流的读取，进而将读取的内容转换为Java对象
在转换过程中会重新创建对象new。
为什么要加readResolve()这个方法呢？ 参考：https://blog.csdn.net/u014653197/article/details/78114041
*/
7. ThreadLocalSingleton单例
public class ThreadLocalSingleton{
private static final ThradLocal<ThreadLocalSingleton> threadLocalInstance = new ThreadLocal<ThreadLocalSingleton>(){
@Override
protected ThreadLocalSingleton initialValue() {
return new ThreadLocalSingleton();
}
}
public static ThreadLocalSingleton getInstance() {return threadLocalInstance.get()}
}
// 此种单例常用于数据库连接池中，线程之间是隔离。
总结：单例模式的特点：
1. 私有化构造器
为什么要私有化呢，如果构造器是public修饰，那完全可以通过new来实例化该类的对象。这样其他处的代码就无法通 过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。
2. 保证线程安全
在多线程情况下，保证原子性。像饿汉式，枚举单例，双重检查，内部类式单例等都是线程安全的。
3. 延迟加载
保证没有被使用之前是不会加载内存中的，
4. 防止序列化和反序列化破坏单列
5. 防御反射攻击单列
那么class的生命周期一般来说会经历加载、连接、初始化、使用、和卸载五个阶段：参考： https://www.jianshu.com/p/9f369a17d1fb
单例设计模式是23种设计模式常见的模式，也是我们熟知的模式。
此文章也参考了：
https://juejin.im/post/5b50b0dd6fb9a04f932ff53f
https://cloud.tencent.com/developer/article/1177048
https://www.jianshu.com/p/9f369a17d1fb
文章中还有几处知识点还没有具体整理出来。
