基于枚举的单例模式及Enum原理

基本概述

项目中经常用到基于双检测的同步单例模式，但是这种模式存在被反射和序列化攻破的缺点。在effective java 中提到了使用基于枚举的单例模式，这种单例模式能有效规避上述缺点。基于个人学习理解进行如下总结。

双检测同步单例模式

public class DoubleCheckSingleBean {
    private String name;
    // volatile修饰 保证线程同步
    private static volatile DoubleCheckSingleBean instance;
    private DoubleCheckSingleBean(String name){
        this.name=name;
    }
    public static DoubleCheckSingleBean getInstance(){
        if(instance==null){
            synchronized (DoubleCheckSingleBean.class){// 在此处锁住
                if(instance==null){// 进入锁后还要判断
                    instance=new DoubleCheckSingleBean("single");
                }
            }
        }
        return instance;
    }
}

这种单例模式可以用反射设置构造函数的可侵入性进实例化，也可以用反序列化破坏单例。

基于枚举的单例模式

public class SingleEnumBean {
    private String name;
    private SingleEnumBean(String name){
        this.name=name;
    }
    static enum HolderEnum{
        INSTANCE;
        private SingleEnumBean bean;
        HolderEnum(){
            this.bean=new SingleEnumBean("single");
        }
        public SingleEnumBean getBean(){
            return bean;
        }
    }
    public static SingleEnumBean getSingleBean(){
        return HolderEnum.INSTANCE.getBean();
    }
}

看了一些资料，很多基于枚举的单例模式是这样实现的，但是貌似同样能通过反射拿到新的实例。根据个人理解，基于枚举的单例是不是就是把一定要按单例使用的对象定义为枚举。

枚举代替类实现单例模式

public enum  SingleEnum {
    INSTANCE;
    private String name;
    SingleEnum(){
        this.name="single";
    }
    public String getName(){
        return this.name;
    }
}

枚举本身是java中的一种语法糖，通过返编译拿到SingleEnum的具体实现。

public final class SingleEnum extends Enum
{

    public static SingleEnum[] values()
    {
        return (SingleEnum[])$VALUES.clone();
    }

    public static SingleEnum valueOf(String s)
    {
        return (SingleEnum)Enum.valueOf(com/example/demo/test/EnumSingletonTest/SingleEnum, s);
    }

    private SingleEnum(String s, int i)
    {
        super(s, i);
        name = "single";
    }

    public String getName()
    {
        return name;
    }

    public static final SingleEnum INSTANCE;
    private String name;
    private static final SingleEnum $VALUES[];

    static 
    {
        INSTANCE = new SingleEnum("INSTANCE", 0);
        $VALUES = (new SingleEnum[] {
            INSTANCE
        });
    }
}

从反编译的结果可以看出enum就是集成至Enum的class，其中存在一个static代码块，代码块初始化了定义的INSTANCE。因此枚举类本身就是单例的，其本身也被设定成是不能通过反射创建的。其实现了readObject方法在反序列化中也是不能创建新的实例的。

/**
* prevent default deserialization
*/
private void readObject(ObjectInputStream in) throws IOException,
   ClassNotFoundException {
   throw new InvalidObjectException("can't deserialize enum");
}

个人学习总结，仅供参考，欢迎交流。