JAVA 枚举单例模式

damao
  • 423

关于单例模式的实现有很多种,网上也分析了如今实现单利模式最好用枚举,好处不外乎三点:1.线程安全 2.不会因为序列化而产生新实例 3.防止反射攻击

但是貌似没有一篇文章解释ENUM单例如何实现了上述三点,请高手解释一下这三点~

关于第二点序列化问题,有一篇文章说枚举类自己实现了readResolve()方法,所以抗序列化,这个方法是当前类自己实现的(解决

关于第一点线程安全,从反编译后的类源码中可以看出也是通过类加载机制保证的,应该是这样吧(解决

关于第三点反射攻击,我有自己试着反射攻击了以下,不过报错了...看了下方的反编译类源码,明白了,因为单例类的修饰是abstract的,所以没法实例化。(解决

以下是我写的一个枚举单例,以及其class文件反编译过后的类

枚举单例

public enum Singleton {
    INSTANCE {

        @Override
        protected void read() {
            System.out.println("read");
        }

        @Override
        protected void write() {
            System.out.println("write");
        }

    };
    protected abstract void read();
    protected abstract void write();
}

反编译过后还原的类

public abstract class Singleton extends Enum
{

    private Singleton(String s, int i)
    {
        super(s, i);
    }

    protected abstract void read();

    protected abstract void write();

    public static Singleton[] values()
    {
        Singleton asingleton[];
        int i;
        Singleton asingleton1[];
        System.arraycopy(asingleton = ENUM$VALUES, 0, asingleton1 = new Singleton[i = asingleton.length], 0, i);
        return asingleton1;
    }

    public static Singleton valueOf(String s)
    {
        return (Singleton)Enum.valueOf(singleton/Singleton, s);
    }

    Singleton(String s, int i, Singleton singleton)
    {
        this(s, i);
    }

    public static final Singleton INSTANCE;
    private static final Singleton ENUM$VALUES[];

    static 
    {
        INSTANCE = new Singleton("INSTANCE", 0) {

            protected void read()
            {
                System.out.println("read");
            }

            protected void write()
            {
                System.out.println("write");
            }

        };
        ENUM$VALUES = (new Singleton[] {
            INSTANCE
        });
    }
}

```

回复
阅读 22.2k
1 个回答

使用枚举来实现单例,因为写法简单.在jdk1.5之前,即便有DCL(double checked locking)也可能会创建多个实例.jdk1.5开始提供用volatile关键字来修饰变量.通过DCL实现同步,枚举简单多了.

声明枚举实例的通常做法:

/**
* Singleton pattern example using Java Enumj
*/
public enum EasySingleton{
    INSTANCE;
}

通过EasySingleton.INSTANCE来访问

DCL实现:

/**
* Singleton pattern example with Double checked Locking
*/
public class DoubleCheckedLockingSingleton{
     private volatile DoubleCheckedLockingSingleton INSTANCE;

     private DoubleCheckedLockingSingleton(){}

     public DoubleCheckedLockingSingleton getInstance(){
         if(INSTANCE == null){
            synchronized(DoubleCheckedLockingSingleton.class){
                //double checking Singleton instance
                if(INSTANCE == null){
                    INSTANCE = new DoubleCheckedLockingSingleton();
                }
            }
         }
         return INSTANCE;
     }
}

上面的实现中getInstance()要被检查两次.确定其实例INSTANCE是否为null或已经实例化,
(这也就是为啥叫double checked locking模式)
可以使用DoubleCheckedLockingSingleton.getInstance()来获取实例

只是相比代码行数.枚举实现简单多了.

默认枚举实例的创建是线程安全的.(创建枚举类的单例在JVM层面也是能保证线程安全的),
所以不需要担心线程安全的问题

关于序列化.
以往的单例实现了序列化接口,那么就再也不能保持单例的状态了.因为readObject()方法一直返回一个
新的对象.使用radResolve()来避免此情况发生.

//readResolve to prevent another instance of Singleton
    private Object readResolve(){
        return INSTANCE;
    }

枚举单例 对序列化有保证

第三点.采用反射来创建实例时.可通过AccessibleObject.setAccessible(),通过反射机制来调用私有
构造器.那么枚举可以防止这种创建第二个实例的情况发生.

宣传栏