单例模式——最常用的设计模式

本文是个人在学习《Android 源码设计模式》的读书笔记，仅供学习。

单例模式是应用最广的设计模式之一，就算是你没有听说过设计模式，但也一定听说过单例，这个模式也可能是很多初级程序员唯一会使用的涉及模式。在这个模式中，单例对象的类必须保证只有一个实例存在。即不能自由构造对象的情况，就是单例模式的使用场景。

设计模式的使用场景很常见，一般如果碰到如下情况时，就应该考虑使用单例：
确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象应该有且只有一个。例如，创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源，这时就应该考虑使用单例模式。

单例模式的实现不难，只要做到了如下几点，那么就是一个单例模式：
- 构造函数不对外开放，一般为private；
- 通过一个静态方法或者枚举返回单例类对象；
- 确保单例类的对象有且仅有一个，尤其是在多线程的环境下；
- 确保单例类对象在反序列化时不会重新构建对象；

单例模式有很多种写法，下面由浅入深列出常见的7种方式：

1. 饿汉模式：

public class Singleton {

    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }

}

饿汉式单例是最简单的单例了，但在声明静态变量时就已经初试化了。于是问题就来了，如果我没有使用到这个单例，那这个初始化岂不是浪费空间？于是就有了如下懒汉式的写法：

2. 懒汉式单例：

public class Singleton {

    private static Singleton instance ;

    private Singleton () {}

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

注意代码种的getInstance()函数使用了synchronized关键字，这个关键字确保了代码在多线程情况下单例对象的唯一性。

懒汉式单例的有点时单例只有在使用时菜会被初始化，在一定程度上节约了资源。其缺点是第一次加载时需要进行实例化，反应慢，最大的问题是每次调用getInstance()时都会进行同步，造成不必要的同步开销。所以这种模式不建议采用。

3. Double Check Lock 式单例

public class Singleton {

    private static Singleton instance ;

    private Singleton() {}

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

这种模式的资源利用率高，第一次执行getInstance()时单例对象才会被实例化，效率高。缺点是第一次加载反应慢，也由于Java内存模型的原因偶尔会失败，在高并发下也有一定的缺陷，虽然发生的概率较小。

关于这种写法，强烈建议看一下这篇文章：Java 单例真的写对了么?。这篇文章里分析了这种单例模式的问题所在，而且使用了volatile关键字给出了优化版本的双重检查机制，也是本文种第七个单例实现方案。

4. 静态内部类式单例，推荐

public class Singleton {

    private Singleton() {}

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

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

首先强烈推荐这种实现方式。当第一次加载Singleton类时并不会初始化instance，只有在第一次调用Singleton的getInstance方法时才会导致instance被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这时推荐使用的单例模式的实现方式。

5. 枚举单例

public enum Singleton {
    SINGLETON;

    public void doSomethingd() {
        System.out.print("do sth.");
    }
}

这种方案可能是单例的最简单写法了，枚举在Java中与普通的类是一样的，不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。例如反序列化情况，当从磁盘序列化到内存时，即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个信的实例，相当于调用该类的构造函数。反序列化操作提供了一个很特别的钩子函数，类中具有一个私有的、被实例化的方法readResolve()，这个方法可以让开发人员控制对象的反序列化。后面会说到。

也就是说，前面的几个单例并没有避免序列化时创建新的对象，而枚举则不存在这个问题

6. 容器单例模式

public class SingletonManager {

    private static Map<String, Object> objectMap = new HashMap<>();

    private SingletonManager() {}

    public static void registerService(String key, Object obj) {
        if(!objectMap.containsKey(key)) {
            objectMap.put(key, obj);
        }
    }

    public static Object getService(String key) {
        return objectMap.get(key);
    }
}

这种方式很另类，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对应的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。在Android中这种方式就类似与Context.getSystemService(String)。

7. 线程安全的饿汉式单例，推荐：

public class Singleton {

    private static volatile Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance () {
        Singleton inst = instance;  // <<< 在这里创建临时变量
        if (inst == null) {
            synchronized (Singleton.class) {
                inst = instance;
                if (inst == null) {
                    inst = new Singleton();
                    instance = inst;
                }
            }
        }
        return inst;  // <<< 注意这里返回的是临时变量
    }
}

本方法就是上文提到了对双重检查锁定的升级版本。具体信息请看参考文章。

序列化问题：

传统单例写法，如果实现了序列化接口，他们就不能再保持单例，因为readObject() 方法每次会返回新的对象，所以你需要重写这个方法：

private Object readResolve(){
    return INSTANCE;
}

参考：

1. 你真的会写单例模式吗——Java实现
2. 单例模式（从放弃到入门）
3. Java 单例真的写对了么?