笔记：SpringBoot 单例模式

单例模式：确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。属于创建型模式。

/**
 * @author: denk
 * desc: 饿汉式 缺点：用不用都初始化，浪费内存空间
 * date: 2019/7/24
 */
public class HungrySingleton {
    private static final HungrySingleton hugrySingleton = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return hugrySingleton;
    }
}

/**
 * @author: denk
 * desc: 懒汉式，线程不安全，加锁解决
 * date: 2019/7/24
 */
public class LazySingleton {
    private static LazySingleton lazySingleton = null;

    private LazySingleton() {
    }

    private synchronized static LazySingleton getInstance() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

/**
 * @author: denk
 * desc: 方法上加锁检查浪费效率，衍生出双重检查锁
 * date: 2019/7/24
 */
public class DoubleCheckSingleton {
    private static DoubleCheckSingleton doubleCheckSingleton = null;

    private DoubleCheckSingleton() {
    }

    private static DoubleCheckSingleton getIntance() {
        if (doubleCheckSingleton == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (doubleCheckSingleton == null) {
                    doubleCheckSingleton = new DoubleCheckSingleton();
                }
            }
        }
        return doubleCheckSingleton;
    }
}

/**
 * @author: denk
 * desc: 静态内部类实现的单例模式，构造方法加判断防止反射，readResolve方法防止反序列化
 * <p>
 * date: 2019/7/24
 */
public class InnerClassSingleton {
    private InnerClassSingleton() {
        if (SingletonHolder.innerClassSingleton != null) {//防止使用反射
            throw new RuntimeException("ERROR");
        }
    }


    private static final InnerClassSingleton getIntance() {
        return SingletonHolder.innerClassSingleton;
    }

    private static class SingletonHolder {
        private static final InnerClassSingleton innerClassSingleton = new InnerClassSingleton();
    }

    private Object readResolve() {
        return SingletonHolder.innerClassSingleton;//防止反序列化破坏单例，通过反射调用该函数 还是创建了两个对象，但是使用该函数里面的对象覆盖，而反序列化出来的对象会被GC回收
    }
}

/**
 * @author: denk
 * desc: 注册式单例，从JDK层面，保证枚举不能被序列化和反射
 * date: 2019/7/31
 */
public enum EnumSingleton {
    INSTANCE;

    //扩展，实际的单例对象
    private Object intance;

    public Object getIntance() {
        return intance;
    }

    EnumSingleton() {
        intance = new Object();
    }
}

https://www.runoob.com/design-pattern/singleton-pattern.html

经验之谈：一般情况下，不建议使用懒汉方式，建议使用饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用静态内部类登记方式。如果涉及到反序列化创建对象时，可以尝试使用枚举方式。如果有其他特殊的需求，可以考虑使用双检锁方式。