effective java 第3条 枚举与单例模式

Enum类比于Class 很像的 见下图

像吧 然后看下面这段话：

实际上在使用关键字enum创建枚举类型并编译后，编译器会为我们生成一个相关的类，这个类继承了Java API中的java.lang.Enum类，也就是说通过关键字enum创建枚举类型在编译后事实上也是一个类型而且该类继承自java.lang.Enum类

枚举不能被继承，可以实现接口

values() 以数组形式返回[a,b]
valueof(“a”) 返回 a

单例模式中的枚举实现

饿汉模式：

public class SingletonHungry {

    private static SingletonHungry instance = new SingletonHungry();

    private SingletonHungry() {
    }

    public static SingletonHungry getInstance() {
        return instance;
    }
}

懒汉模式：

public class Singleton {
    //volatile 可见性 防止指令重排 可能先创建好了对象
    //singleton = new Singleton(); 不是一个原子指令
    // 分三步
    // 1.分配对象内存
    // 2.调用构造器方法，执行初始化
    // 3.将对象引用赋值给变量。
    // 如果没有volatile  指令将会发生重排 （2,3）
    // 如果线程1 执行完 1,3（2.还未初始化）释放锁，
    // 线程2进入 拿到锁 发现变量不为null了，
    // 直接return 但此时（2.还未初始化），报错
    // volatile 防止重排 即  将对象引用赋值给变量前已经全部完全初始化
    private static volatile Singleton singleton = null;

    private Singleton(){}

    public static Singleton getSingleton(){
        //这个可以过滤掉大部分情况，减少synchronized 的开销
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }    
}
//当A与B同时调用getSingleton时，判断第一个if都为空，这时A拿到锁，
// 进行第二层if判断，条件成立new了一个对象；
// B在外层等待，A创建完成，释放锁，B拿到锁，进行第二层if判断，
// 条件不成立，结束释放锁。C调用getSingleton时第一层判断不成立，
// 直接拿到singleton对象返回，避免进入锁，减少性能开销。

值得关注的是volatile的禁止指令重排序优化功能在Java 1.5后才得以实现，因此1.5前的版本仍然是不安全的，即使使用了volatile关键字

我们可以利用静态内部类来实现更安全的机制，静态内部类单例模式如下

/**
 * Created by wuzejian on 2017/5/9.
 * 静态内部类
 */
public class SingletonInner {
    private static class Holder {
        private static SingletonInner singleton = new SingletonInner();
    }

    private SingletonInner(){}

    public static SingletonInner getSingleton(){
        return Holder.singleton;
    }
}

类变量 即static修饰的变量 在类（加载，连接，初始化），连接阶段赋默认值，初始化阶段初始化，并且由于静态内部类只会被加载一次，线程安全。

反射和序列化 反序列化会破坏单例。

反射 ：当然可以在构造函数里作处理，第二次用构造函数创建实例时抛异常即可

序列化 反序列化：破坏的原因要看反序列化的源码了：

反序列化方法readObject()的readObject0()中如果是Object对象则调用readOrdinaryObject()，该方法首先会通过一个三目运算来创建序列化的对象。如果这个对象能实例化就创建一个新对象

obj = desc.isInstantiable() ? desc.newInstance() : null;

原因找到了，反序列化回来的对象是新创建的，不是单例的那个了。

解决的办法也在源码中，在通过三目运算创建了对象之后，还会去找这个对象里是否有readResolve()方法，如果有，则通过这方法返回对象。（effective java 中还说要保证所有实例域都是瞬时的 transient）

  public Object readResolve() {
        return getInstance();
    }

用枚举解决：单元素的枚举类型经常成为实现Singleton的最佳方法
具体原理 看枚举

/**
 * 枚举单例
 */
public enum  SingletonEnum {
    INSTANCE;
    public void leavethebuilding(){....}
}
// 调用
SingletonEnum.INSTANCE.leavethebuilding()