单例模式的挑战：反射和序列化

参考1： 你写的单例模式，能防止反序列化和反射吗？

参考2：枚举实现单例

常见单例模式

// 饿汉，在类加载的时候就被实例化
/**
 * 恶汉式单例，线程安全
 * @author sicimike
 * @create 2020-02-23 20:15
 */
public class Singleton1 {

    private static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1() {}

    public static Singleton1 getInstance() {
        return INSTANCE;
    }
}

/**
 * 饿汉式单例，静态代码块，线程安全
 * @author sicimike
 * @create 2020-02-23 20:19
 */
public class Singleton2 {

    private static Singleton2 INSTANCE = null;

    static {
        INSTANCE = new Singleton2();
    }

    private Singleton2() {}

    public static Singleton2 getInstance() {
        return INSTANCE;
    }
}

// 懒汉式单例
/**
 * 懒汉式单例，线程安全
 * 双重校验锁
 * @author sicimike
 * @create 2020-02-23 20:34
 */
public class Singleton6 {

    private static volatile Singleton6 INSTANCE = null;

    private Singleton6() {}

    public static Singleton6 getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton6.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton6();
                }
            }
        }
        return INSTANCE;
    }
}

不加volatile关键字 线程不安全，根本原因就是INSTANCE = new Singleton5()不是原子操作。而是分为三步完成
1、分配内存给这个对象
2、初始化这个对象
3、把INSTANCE变量指向初始化的对象
正常情况下按照1 -> 2 -> 3的顺序执行，但是2和3可能会发生重排序，执行顺序变成1 -> 3 -> 2。如果是1 -> 3 -> 2的顺序执行。线程A执行完3，此时对象尚未初始化，但是INSTANCE变量已经不为null，线程B执行到synchronized关键字外部的if判断时，就直接返回了。此时线程B拿到的是一个尚未初始化完成的对象，可能会造成安全隐患。所以这种实现方式是线程不安全的。

volatile关键字的在这里的作用有两个：
解决了重排序的问题
保证了INSTANCE的修改，能够及时的被其他线程所知

静态内部类方式
既满足懒加载，又满足线程安全，代码量还少，相对来说是一种比较优雅的实现方式

/**
 * 懒汉式单例，线程安全
 * 静态内部类
 * @author sicimike
 * @create 2020-02-23 20:36
 */
public class Singleton7 {

    private Singleton7() {}

    public static Singleton7 getInstance() {
        return InnerClass.INSTANCE;
    }

    private static class InnerClass {
        private static Singleton7 INSTANCE = new Singleton7();
    }

}

枚举方式

public enum  DataSourceEnum {
    DATASOURCE;
    private DBConnection connection = null;
    private DataSourceEnum(){
        connection = new DBConnection();
    }
    public DBConnection getConnection(){
        return connection;
    }
}

public class DBConnection {
}

// 测试 返回 true 
public class Test {
    public static void main(String[] args) {
        DBConnection conn1 = DataSourceEnum.DATASOURCE.getConnection();
        DBConnection conn2 = DataSourceEnum.DATASOURCE.getConnection();
        System.out.println(conn1 == conn2);
    }
}

反射

反射会破坏单例

public void reflectSingleton1(){
    try {

        Object compare1 = Singleton1.getInstance();
        Class<?> tClass = Singleton1.class;
        Constructor constructor = tClass.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        Object instance = constructor.newInstance();
        System.out.println(instance);
        System.out.println(compare1);
        System.out.println(instance == compare1);
    } catch (Exception e){
        e.printStackTrace();
    }
}

// 输出
singleton.Singleton1@27f674d
singleton.Singleton1@1d251891
false

// 添加如下报错内容处理，防止通过反射初始化单例对象，但是不够优雅
private Singleton1() {
    if(INSTANCE != null){
        throw new RuntimeException("do not xia gao");
    }
}    

序列化

序列化也会破坏单例，不再举例。
可在Singleton1内添加如下方法

private Object readResolve(){
    return this.INSTANCE;
}

经过源码查看，若目标类有readResolve方法，那就通过反射的方式调用要被反序列化的类中的readResolve方法，返回一个对象，然后把这个新的对象复制给最终返回的对象。
因此，新建readResolve方法，返回单例类，即保证还是原来创建的类，没有创建新类，是一个对象。

最优解：就是用枚举

// 可以看一下DataSourceEnum类的反编译代码
public final class DataSourceEnum extends Enum
{
    public static DataSourceEnum[] values(){
        return (DataSourceEnum[])$VALUES.clone();
    }
	//toString的逆方法，返回指定名字，给定类的枚举常量
    public static DataSourceEnum valueOf(String name){
        return (DataSourceEnum)Enum.valueOf(creational/singleton/dbconn/DataSourceEnum, name);
    }
	//私有构造函数，参数有 此枚举常量的名称，枚举常量的序号
    private DataSourceEnum(String s, int i){
        super(s, i);
        //单例对象的属性
        connection = null;
        connection = new DBConnection();
    }

    public DBConnection getConnection(){
        return connection;
    }
	//单例对象
    public static final DataSourceEnum DATASOURCE;
    //单例对象的属性
    private DBConnection connection;
    private static final DataSourceEnum $VALUES[];
    static 
    {
    	//与饿汉式相似，类初始化时创建单例对象
        DATASOURCE = new DataSourceEnum("DATASOURCE", 0);
        $VALUES = (new DataSourceEnum[] {
            DATASOURCE
        });
    }
}

Java规范字规定，每个枚举类型及其定义的枚举变量在JVM中都是唯一的，因此在枚举类型的序列化和反序列化上，Java做了特殊的规定。在序列化的时候Java仅仅是将枚举对象的name属性输到结果中，反序列化的时候则是通过java.lang.Enum的valueOf()方法来根据名字查找枚举对象。也就是说，序列化的时候只将DATASOURCE这个名称输出，反序列化的时候再通过这个名称，查找对应的枚举类型，因此反序列化后的实例也会和之前被序列化的对象实例相同。