【设计模式】单例模式

本篇文章总结自 【狂神说Java单例模式】bilibili【狂神说Java】单例模式

单例模式可以由四种方式来实现

1. 饿汉式
2. 懒汉式
3. 内部类式
4. 枚举

• 饿汉式单例，在类加载的过程中对象直接被实例化，没有线程安全问题，但当类中属性很多时，会耗费大量的资源

public class Hunger {

    private Hunger() {}

    private static final Hunger hunger = new Hunger();

    public static Hunger getInstance() {
        return hunger;
    }

}

• 懒汉式单例，不会浪费资源，但会产生线程安全问题；所以使用了双重检测模式，但依旧有产生拿不到实例对象的问题，所以又引入关键字 volatile：

该知识点前提需了解 volatile 关键字
volatile是一个特征修饰符（type specifier）volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。
volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。
说白了，加上了volatile的变量，编译器在用到这个变量的时候要保证该变量是一个实际存在的变量。

public class LazySingle {

    private LazySingle() {}

    private static volatile LazySingle lazySingle;

    public static LazySingle getInstance() {
        if (lazySingle == null) {
            synchronized (LazySingle.class) {
                if (lazySingle == null) {
                    lazySingle = new LazySingle();
                    /**
                     * 这是 双重检测模式的 懒汉单例 DCL懒汉式
                     * 多线程下如果变量lazySingle不用volatile修饰 可能出现问题：
                     * 
                     * 1.计算机先给变量分配内存空间
                     * 2.创建出实例对象
                     * 3.将该实例对象指向内存
                     * 
                     * 一般来说是按照1，2，3的步骤
                     * 当发生指令重排，也可能出现1，3，2的情况
                     * 当A线程执行到 new LazySingle() 时，该对象已经被分配了空间但还实例化
                     * B线程判断 lazySingle不为null，但lazySingle此时还未被实例化，就会发生问题
                     *
                     * 所以给 lazySingle 加上关键字volatile，以保证计算机不会指令重排
                     */
                }
            }
        }
        return lazySingle;
    }
}

但如果使用反射技术去直接获取私有的无参构造，也能够破环单例

• 内部类单例，第一次调用getInstance()时才会导致虚拟机加载内部类，能够保证线程安全，但是反射技术依旧可以通过获取无参破坏单例：

public class Holder {

    private Holder() {}

    public static Holder getInstance() {
        return innerClass.HOLDER;
    }

    static class innerClass {
        private static final Holder HOLDER = new Holder();
    }
    
}

反射破环内部类单例：

public static void main(String[] args) throws Exception {
	Constructor<Holder> declaredConstructor = Holder.class.getDeclaredConstructor(null);
	declaredConstructor.setAccessible(true);
	Holder instance1 = declaredConstructor.newInstance();
	
	Holder instance2 = Holder.getInstance();
	
	System.out.println(instance1);
	System.out.println(instance2);
}

• 枚举单例模式，先下结论，枚举单例保证线程安全，且不会被反射破坏

public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance() {
        return INSTANCE;
    }

}

直接使用反射来测试枚举：

public static void main(String[] args) throws Exception {
    EnumSingle instance1 = EnumSingle.INSTANCE;
    
    Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
    declaredConstructor.setAccessible(true);
    EnumSingle instance2 = declaredConstructor.newInstance();
    System.out.println(instance1);
    System.out.println(instance2); 
}

结果直接抛异常：Exception in thread "main" java.lang.NoSuchMethodException: EnumSingle.<init>()
并没有相应方法；所有枚举都会继承父类Enum.java，去父类里看一下，父类只有一个有参构造：

protected Enum(String name, int ordinal) {
	this.name = name;
    this.ordinal = ordinal;
}

所以在反射中获取对应参数类型的构造：Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
但结果仍抛异常：

可以进入反射构造器的new实例方法中看一下，发现416行做了判断，如果反射的类是一个枚举则表示不能反射出一个枚举实例，所以枚举单例不能被反射破坏：

另一种探究方式：

/**
 * 探究枚举单例为什么不能被反射破坏
 *
 * 先假定枚举中源码有无参构造器，获取枚举的无参创建实例
 * 结果报错：java.lang.NoSuchMethodException: EnumSingle.<init>()，并没有相应的方法
 * 使用 javap -p 反编译.class文件，发现其中是有无参构造器的
 * 再使用jad程序反编译.calss，发现其中有一个参数为 (String, int) 的构造
 * 但依旧报错：java.lang.IllegalArgumentException: Cannot reflectively create enum objects
 * 无法使用反射创建枚举对象
 *
 */