Effective Java(第2版)：Item 3 —— Enforce the singleton property with a private constructor or an enum type

Java singleton constructor

单例的定义

singleton就是一个仅仅实例化一次的类（在任何时期，内存中都应该仅存在一个实例），称做：单例。单例通常代表了一个在本质上数量保持唯一的系统组件，如：窗口管理器、文件系统。

单例的实现

演进部分引自：http://wuchong.me/blog/2014/08/28/how-to-correctly-write-singleton-pattern/

演进过程

先不去看《Effective Java》中介绍的单例模式，先看一下单例模式的演进过程。

1. lazily initialize(unsafe)

//DON'T DO THIS
public class Singleton{
    private Singleton(){}
    private static Singleton INSTANCE;
    public static Singleton getInstance(){
        if(INSTANCE==null)
            INSTANCE = new Singleton();
        return INSTANCE;
    }
}

• 本例显然是直觉下的首选，但是仔细研究就会发现，在多线程访问的情况下很容易就会产生多个实例，破坏单例模式。

2. lazily initialize(safe)

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

• 修改上个例子，将其整个方法用synchronized修饰，互斥地访问方法，就可以保证线程安全。
• 首次创建单例时，互斥地访问getInstance方法，确保单例，非常不错。但是，创建完毕之后呢，互斥地去取得一个不变类的实例的引用，十分影响性能，而且没有必要。

3. double-check(only safe when field is decorated with volatile after Java 5)

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

• 为了弥补上例的性能缺陷，本例使用了double-check，在创建单例后不再互斥地访问。唯一要注意的一点是，volatile关键字不能少，而且使用Java 5及以上版本。这个关键字在本例中的作用是：确保INSTANCE==null时，INSTANCE没有正在创建实例。这句话可能有点儿绕，为什么二者不是等价的呢？
• 这是JVM的机制决定的，一个类创建实例的过程大致分为下面三步（以INSTANCE为例）：
  
  1. 在栈区为其分配合适大小的内存
  2. 在刚刚开辟的内存初始化各个字段的值
  3. 将储存在堆区的INSTANCE这个引用赋值为刚刚开辟的内存的首地址
• 看起来很完美，引用为null就意味着它没有在创建实例。但是，JVM会优化重调上面的三个过程，将第三步放在第二步之前，导致没有volatile修饰的double-check方法无法确保单例。
• 按理来说，用volatile修饰之后，就应该万事大吉了。可惜，事实并非如此。在Java 5之前的几个版本中，JVM的内存模型是存在缺陷的，使用了volatile关键字也不能肯定地禁止优化调序的发生。

4. static factory(not-full lazily initialize)

public class Singleton{
    private Singleton(){}
    private static final Singleton INSTANCE=new Singleton();
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

public class Singleton{
    private Singleton(){}
    private static final Singleton INSTANCE;
    static{
        INSTANCE = new Singleton();
    }
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

• 本例的单例特性通过类的静态字段来保证其唯一性。在类被使用时（包括：新建实例、静态方法被调用、静态字段被使用），静态字段就会被互斥地初始化，确保该字段的唯一。
• 在本例中两个类的区别（是否在静态构造方法中初始化静态字段），并不会影响一旦类被使用(任意方法或字段被调用)就会使静态字段实例化的事实。为什么提到静态构造方法的使用与否呢？
  因为在C#中，二者是有区别的，区别就在于编译后产生的中间代码是被beforefieldinit修饰还是被pricise修饰。被前者修饰，即使类的某个方法被调用了，但是如果没有使用到INSTANCE字段，那么它就不会被初始化，实现了full lazy instantiation。而后者的方式则与Java类似。(拓展阅读：C# in depth)
• Java与C#还是有一定的区别，想要实现full lazy instantiation，还得依靠静态内部类（见下面的例子）。

Effective Java(1st version)推崇的模式

5.static nealed class(full lazily initialize)

public class Singleton{
    private static class SingletonHolder{
        private static Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
    private Singleton(){}
}

之前第一版中作者最推崇的模式就是本例中的静态内部类，实现了完全的lazy instantiation。

Effective Java(2nd version)推崇的模式

• 本书先比较了Java 5之前的两种模式：直接暴露单例字段；通过静态方法暴露单例字段。
• 最后，作者在这一版本中推荐了枚举类型的单例模式。

(例4的前身)public static final field

//Singleton with public final field
public class Elvis{
    public static final Elvis INSTACE = new Elvis();
    private Elvis(){ ... }
    public void leaveTheBuilding(){ ... }
}

(同例4)static factory

//Sigleton with static factory
public class Elvis{
    private static final Elvis INSTACE = new Elvis();
    private Elvis(){ ... }
    public static getInstace(){return INSTANCE;}
    public void leaveTheBuilding(){ ... }
}

• 上面两例享有许多相同的优点，比如说：线程安全、部分的延迟初始化等，而且二者在现代的JVM上运行不会存在巨大的性能差异，有着几乎等同的性能。
• 但是，后者有着一个明显的优势，就是有利于后续的维护升级。例如，如果你想更改你的设计模式，为每个线程单独提供一个实例，那么后者的静态方法就可以随意改动而不影响已经使用了这个API的代码。
• 此外，二者都存在潜在的安全性问题。因为一个权限足够高的用户可以使用反射AccessibleObject.setAccessible修改单例的访问属性，从而生成新的实例。为了解决这个问题，可以设置私有构造方法被二次调用时抛出一个异常。

6. Enum

public enum Elvis{
    INSTANCE;
    public void leaveTheBuilding(){ ... }
}

• 从表面看不到任何的优越性，为什么作者在Java 5之后改为推崇枚举类型作为单例的首选了呢？
• 本例之前所有的例子，在实现Serializable接口时，都必须用transient关键字修饰所有单例类的字段。并且重写readResovle方法。来确保进行了序列化之后，再进行反序列化之后不会产生新的实例(即使构造方法是私有的，如果没有进行任何操作，反序列化仍可以生成新的实例)。
• 下面以例子来演示上述操作

public class Elvis implement Serializable{
    public static final Elvis INSTACE = new Elvis();
    private transient int ID;
    private Elvis(){ ... }
    public void leaveTheBuilding(){ ... }
    @Override
    public Object readResolve(){
        return INSTANCE;
    }
}

• Ps：静态字段无论是否被transient修饰，都不会被当作序列化的一部分，在反序列化时只去获取该静态字段的当前值。
• 就是由于枚举类型的自动化使其脱颖而出，如果你使用了枚举类型，那么上述的操作都可以被省略。
• Ps：枚举类型虽然使用方便，但是在安卓系统中还是被官方劝阻。因为枚举类型的方便是以内存使用与性能消耗的增加为代价的，所以还是使用静态内部类比较合适。毕竟，在安卓平台连Serializable接口都被嫌弃引起频繁的GC操作，安卓官方还推出了Parcelable这个代替的序列化接口。