枚举实现单例模式分析理解

写法：

enum EnumSingleton{
    INSTANCE;
    public void doSomeThing(){
    }
}

Java中的枚举和其它语言不同，它是一个对象。早期的 Java 是没有枚举类型的大家都用类似于单例的方式来实现枚举，简单的说就是让构造  private  化，在  static  块中产生多个  final  的对象实例，通过比较引用（或  equals ）来进行比较

早期用类的方式实现的枚举

public class MyEnum {
    public static MyEnum NumberZero;
    public static MyEnum NumberOne;
    public static MyEnum NumberTwo;
    public static MyEnum NumberThree;

    static {
        NumberZero = new MyEnum(0);
        NumberOne = new MyEnum(1);
        NumberTwo = new MyEnum(2);
        NumberThree = new MyEnum(3);
    }

    private final int value;

    private MyEnum(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

Java5 的枚举

从 Java 5 开始有枚举类型之后，类似的实现可以这样

类似类方式实现的枚举实现

public enum MyEnum {
    NumberZero(0),
    NumberOne(1),
    NumberTwo(2),
    NumberThree(3);

    private final int value;

    MyEnum(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

其实仔细比较会发现，就是简化了定义过程，构造方法简不能使用 public 或 protected 修饰符，如果省略也不是package，而是 private；另外 final static 属性定义简化了，static 块也简化掉了。

当然，像这种值从 0 开始的，可以更简单的实现，getValue() 直接返回其顺序号就行。

更简单的实现方式（题外话）

public enum MyEnum {
    NumberZero,
    NumberOne,
    NumberTwo,
    NumberThree;

    public int getValue() {
        return ordinal();
    }
}

回头说说枚举变单例

上面说了，早期就是通过类似单例模式的方式来实现的枚举。而后的枚举实例也和类方式实现极为相似，那么，如果枚举值只有 1 个的时候，其实例也就只有 1 个，就完全符合了单例模式的限定。由于 Java 的 enum 可以跟类一样任意定义方法和属性，所以就完全可以用枚举来实现单例。这是其它语言如 C++、C# 做不到的。

第一个枚举单例，你要先理解enum， 在你的代码中INSTANCE本身就是一个EnumSingleton类型的引用, 与普通的饿汉式单例相似。

双重校验锁的方式

class LockSingleton{
    private volatile static LockSingleton singleton;
    private LockSingleton(){}
     
    //详见：http://www.ibm.com/developerworks/cn/java/j-dcl.html
    public static LockSingleton getInstance(){
        if(singleton==null){
            synchronized(LockSingleton.class){
                if(singleton==null){
                    singleton=new LockSingleton();
                }
            }
        }
        return singleton;
    }
}

双层校验, 第一次校验不是线程安全的，也就是说可能有多个线程同时得到singleton为null的结果，接下来的同步代码块保证了同一时间只有一个线程进入，而第一个进入的线程会创建对象，等其他线程再进入时对象已创建就不会继续创建。这是一个很巧妙的方式，如果对整个方法同步，所有获取单例的线程都要排队，但实际上只需要对创建过程同步来保证"单例"，多个线程不管是否已经有单例可以同时去请求。