单例模式 解析

本文基于 Android 源码设计模式解析与实战 这本书，也算是一个简单的记录.

定义

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例.

使用场景

确保某个类有且只有一个对象的场景，避免产生多个对象而产生更多的消耗.

实现单例模式注意点

1. 构造方法是不对外公开的，一般设置为private
2. 通过一个静态方法或者枚举返回单例对象模型
3. 确保单例类的对象有且只有一个，并且在多线程的情况下依旧如此
4. 确保单例类的对象在反序列化时不会生成新的对象

当类的构造方法设置private时，可以保证系统无法通过new 方法构造出一个对象，另外在多线程情况下我们也需要考虑对象的唯一性，在涉及序列化的时候，需要考虑到第4点.

实现方式

一般情况下，有以下的五种方式实现以上的单例模式

1. 饿汉模式

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton(){}

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

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

由于上述的问题，则出现了下面的第二种方式

2. 懒汉模式

public class Singleton {
    private static Singleton instance = null;

    private Singleton(){}

    public static synchronized Singleton getInstance(){
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

上面的synchronized关键字就是实现单例线程安全的保证，系统只有在调用getInstace()方法的时候才会初始化，这属于lazy loading的效果，但是由于该方法在每一次调用的时候，均会进行同步，即使单例已经存在，这样会造成不必要的同步开销，所以一般不建议使用，需要了解这种情况即可。

分析完上面的情况，我们就有一种避免对象已经生成同时每次都要同步的实现方式，由此推出了下面的第三种的实现
方式

3.Double Check Lock (DCL)实现单例

public class Singleton {
    private volatile static Singleton instance = null;

    private Singleton(){}

    public static Singleton getInstance(){

        if(instance == null) {
            synchronized (Singleton.class){
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

有上述的实现方式，可以发现主要的亮点在getInstance()方法里面，第一层的判断主要是避免不必要的同步，但是第二个判断是干什么的呢？我们也注意到了上面的内容中还出现了一个新的关键字volatitle,这个就需要慢慢道来：
首先由编译原理的知识可知，当线程执行到instace = new Singleton();这句话的时候，
它并不是一个原子操作，会编译成以下的三句话：
1. 给 Singleton的实例分配内存
2. 调用Singleton()的构造方法，初始化字段
3. 就將instance对象指向分配的内存空间（此时instance 就不等于 null）

这里首先这里需要区分以下JDK的版本，由于java编译器允许处理器乱序执行，在Jdk1.5之前java内存模型中cache，寄存器到主内存回写顺序的规定，上述的第2条和第3条的顺序是无法保证的，如果出现
1-3-2 这样的执行顺序，当执行完1-3，之后切换到另一个线程，此时的instance不为空，就会出现单例失效的问题，也即DCL失效，（注意前面的这种解释是代码中不存在volatitle关键字）所以在Jdk1.5
之后，官方调整了JVM，具体了volatitle关键字，所以在Jdk1.5之后加上该关键字即可，可以保证instance对象都是从内存中读取，就可以使用DCL方法完成单例模式。所以一般情况下，在Jdk6以下的版本后使用，这种是可以满足的。

以上的三种实现方式是比较常见的，但是在《Java 并发编程实践》里面对上面的DCL方法进行了
改进，使之不存在DCL失效的问题，由此得到了第四种实现方式：

4.静态内部类的实现方式

public class Singleton {
    private Singleton(){};

    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }

    private static class SingletonHolder{
        private static final Singleton instance = new Singleton();
    }
}

上述的方法，但第一次加载Singleton的时候，并不会初始化instance，只有在第一次调用getInstance()方法的时候，才会初始化，这样符合lazy loading，第一次调用getInstance()方法会导致JVM加载SingletonHolder类，这种方法不仅可以保证线程安全，也可以保证单例对象的唯一性，所以这是推荐使用的方法。

回想一下最开始的我们的注意点，我们发现只实现了前三点，对于序列化我们还没有提到，既然写了，必然是有用的，在上面的几个实例中，会出现一个重新创建对象的过程，那就是反序列化。

通过反序列化将一个单例对象的实例对象写道磁盘，然后在回读回来，从而得到一个实例。但是即使构造方法是是私有的，但是在反序列化的过程中依旧会创建一个新的实例，这时候就无法保证是单例了，如何避免这种情况呢？ 在反序列化的过程中，存在一个钩子方法，类拥有一个私有的，实例化的方法readResolve（），这个可以控制对象的反序列化，例如在上面的实现中为了避免反序列化重新生成新的对象，必须加入以下的方法：

private Object readResolver() throws ObjectStreamException{
    return instance;
}

也就是将单例对象返回，而不是默认生一个新的对象。

那么有没有不需要重写上述方法的单例模式，当然有，那就是下面介绍的

5. 枚举

public enum SingletonEnum{
    instance;
    public void doSomething(){
    }
}

默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个实例。即使反序列化也不存在该问题（ 但是一般不怎么使用，知道即可 ）

在使用的过程中根据实际情况进行选择不同的实现方法。

注意如果在加载的时候使用了不同的类加载器，也会引起单例失效，具体见下面的参考文献

参考文献：
1. Android 源码设计模式解析与实战
2. http://cantellow.iteye.com/blog/838473