单例模式的终极实现方案

单例模式（Singleton）是一种使用率非常高的设计模式，其主要目的在于保证某一类在运行期间仅被创建一个实例，并为该实例提供了一个全局访问方法，通常命名为getInstance()方法。单例模式的本质简言之即是：

控制实例数目

以Java为例，单例模式通常可分为饿汉式和懒汉式两种常规实现方式

饿汉式单例实现

饿汉式顾名思义，就是对类实例（食物？）的需求非常强烈，因此，在装载该单例类的时候就会创建类实例。如下

public class Singleton {
    /**
     * 装载时即创建类实例，并保存在类变量instance中
     * 加上static关键词使得该变量能在getInstance()静态方法中使用
     */
    private static Singleton instance = new Singleton();
 
    /**
     * 私有化构造方法，使外部无法通过构造方法构造除instance外的类实例
     * 从而达到单例模式控制类实例数目的目的
     */
    private Singleton() {
    }
 
    /**
     * 类实例的全局访问方法
     * 加上static关键词使得外部可以通过类名直接调用该方法获取类实例
     * @return 单例类实例
     */
    public static Singleton getInstance() {
        //  由于类实例在类装载时已被创建并保存在instance中，因此可直接返回
        return instance;
    }
}

事实上，在Android开发中，Android Studio提供了一个直接创建单例类的功能（File->new->Singleton），该功能自动生成的单例类正是采用了饿汉式的实现方式

懒汉式单例实现

说到懒，我们自然而然会想到拖延症这一恶习，这一点和懒汉式的单例实现方式相似，这一实现方式会一直等到真正需要使用对象实例的时候再去创建该实例。如下

public class Singleton {
    /**
     * 装载时不创建类实例，但需要利用一个类变量去保存后续创建的类实例
     * 添加static关键词使得该变量能在getInstance()静态方法中使用
     */
    private static Singleton instance = null;
 
    /**
     * 私有化构造方法，使外部无法通过构造方法构造除instance外的类实例
     * 从而达到单例模式控制类实例数目的目的
     */
    private Singleton() {
    }
 
    /**
     * 类实例的全局访问方法
     * 添加static关键词使得外部可以通过类名直接调用该方法获取类实例
     * @return 单例类实例
     */
    public static Singleton getInstance() {
        //  如果instance未被初始化，则初始化该类实例
        if (instance == null) {
            instance = new Singleton();
        }
 
        return instance;
    }
}

事实上，虽然我们前面拿拖延症来与懒汉式做类比，但懒汉式的拖延却是实际开发中的一种较为常见的节省资源的方式，即延迟加载思想。这一思想的核心在于直到需要使用某些资源或数据时再去加载该资源或获取该数据，这样可以尽可能地节省使用前的内存空间

线程安全的懒汉式单例实现

不难分析出，当外部多个线程同时想要获取单例类实例时，上述懒汉式实现方式便很容易导致并发问题。通常有如下几种改进方式

添加synchronized关键词

....
public static synchronized Singleton getInstance() {
....

这种改进方式是最简单的，但由于外部每次调用getInstance()方法时均需进行判断，因此该方式也是效率较低的

利用双重检查加锁机制

双重检查加锁机制分为如下两重检查

• 在程序每次调用getInstance()方法时先不进行同步，而是在进入该方法后再去检查类实例是否存在，若不存在则进入接下来的同步代码块
• 进入同步代码块后将再次检查类实例是否存在，若不存在则创建一个新的实例

这样一来，就只需要在类实例初始化时进行一次同步判断即可，而非每次调用getInstance()方法时都进行同步判断，大大节省了时间，具体实现如下

public class Singleton {
    /**
     * 装载时不创建类实例，但需要利用一个类变量去保存后续创建的类实例
     * 添加volatile关键词使其不会被本地线程缓存，保证线程能正确处理
     * 添加static关键词使得该变量能在getInstance()静态方法中使用
     */
    private volatile static Singleton instance = null;
 
    /**
     * 私有化构造方法，使外部无法通过构造方法构造除instance外的类实例
     * 从而达到单例模式控制类实例数目的目的
     */
    private Singleton() {
    }
 
    /**
     * 类实例的全局访问方法
     * 添加static关键词使得外部可以通过类名直接调用该方法获取类实例
     * @return 单例类实例
     */
    public static Singleton getInstance() {
        //  第一重检查：如果instance未被初始化，则进入同步代码块
        if (instance == null) {
            //  同步代码块，保证线程安全
            synchronized (Singleton.class) {
                //  第二重检查：如果instance未被初始化，则初始化该类实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
 
        return instance;
    }
}

利用Java缓存思想实现的单例实现

public class Singleton {
    //  类实例缓存KEY值
    private static final String KEY = "CACHE";
 
    //  类实例缓存容器
    private static Map<String, Singleton> map = new HashMap<>();
 
    /**
     * 私有化构造方法，使外部无法通过构造方法构造除instance外的类实例
     * 从而达到单例模式控制类实例数目的目的
     */
    private Singleton() {
    }
 
    /**
     * 类实例的全局访问方法
     * 添加static关键词使得外部可以通过类名直接调用该方法获取类实例
     * @return 单例类实例
     */
    public static Singleton getInstance() {
        //  尝试从缓存容器中获取类实例
        Singleton instance = map.get(KEY);
        //  未能获取类实例，则初始化该实例，并将其缓存至容器中
        if (instance == null) {
            instance = new Singleton();
            map.put(KEY, instance);
        }
 
        return instance;
    }
}

上述实现方式暂未考虑线程安全问题。事实上，利用缓存来实现的单例模式其最大的优点在于对单例模式进行扩展。我们自然而然地可以想到这么一种情况，既然在实际开发中经常需要保证某个类只能被创建一个实例，那么，会不会出现保证某个类只能被创建两个或多个实例这种需求呢？对于这项需求，我们首先可以想到，上述实现方式中所建立的缓存容器是可以存储多个类实例的，利用这一特点，只需考虑一个问题，即外部调用时到底需要为其返回哪一个实例，便可实现“双例模式”以及“多例模式”（原谅我为它们取了一些奇怪的名字）了，具体实现如下

public class Singleton {
    //  可创建的最大类实例数，这里以“双例模式”为例
    private static final int MAX = 2;
 
    //  类实例缓存KEY值
    private static final String KEY = "CACHE";
 
    //  当前正在使用的实例序号
    private static int index = 1;
 
    //  类实例缓存容器
    private static Map<String, Singleton> map = new HashMap<>();
 
    /**
     * 私有化构造方法，使外部无法通过构造方法构造除instance外的类实例
     * 从而达到单例模式控制类实例数目的目的
     */
    private Singleton() {
    }
 
    /**
     * 类实例的全局访问方法
     * 添加static关键词使得外部可以通过类名直接调用该方法获取类实例
     * @return 单例类实例
     */
    public static Singleton getInstance() {
        //  尝试从缓存容器中获取第index个类实例
        String key = KEY + index;
        Singleton instance = map.get(key);
        //  未能获取类实例，则初始化该实例，并将其缓存至容器相应index中
        if (instance == null) {
            instance = new Singleton();
            map.put(key, instance);
        }
 
        //  这里以最基本的顺序调用为例，其他复杂调度方式不加讨论，具体调用方式如下
        //  index++，以在下一次调用中获取下一个类实例，当达到类实例数上限时，重新获取第一个类实例
        if ((++index) > MAX) {
            index = 1;
        }
 
        return instance;
    }
}

单例模式的最佳实现

综合而言，上述实现方式都或多或少地存在诸如线程不安全、无法做到延迟加载等小缺陷。这里给出一个可以称得上完美的最佳解决方案

Lazy Initialization Holder Class 模式

这一方案的核心在于Java的类级内部类（即使用static关键词修饰的内部类，否则称之为对象级内部类）以及多线程缺省同步锁，先来看看具体实现

public class Singleton {
    /**
     * 类级内部类，用于缓存类实例
     * 该类将在被调用时才会被装载，从而实现了延迟加载
     * 同时由于instance采用静态初始化的方式，因此JVM能保证其线程安全性
     */
    private static class Instance {
        private static Singleton instance = new Singleton();
    }
 
    /**
     * 私有化构造方法，使外部无法通过构造方法构造除instance外的类实例
     * 从而达到单例模式控制类实例数目的目的
     */
    private Singleton() {
    }
 
    /**
     * 类实例的全局访问方法
     * 添加static关键词使得外部可以通过类名直接调用该方法获取类实例
     * @return 单例类实例
     */
    public static Singleton getInstance() {
        return Instance.instance;
    }
}

在前面提到的饿汉式实现方式中，我们利用Java的静态初始化、借由JVM实现了线程安全，因此这里同样采用了这种方式。而另一方面，为了避免饿汉式实现中无法进行延迟加载的缺陷，我们构造了一个类级内部类来缓存类实例，由于该类只会在通过getInstance()方法去调用时才会被系统装载，换言之，只有初次调用getInstance()方法时才会去初始化类实例，因此也实现了延迟加载这一功能。如此便可使得这一实现方式能够同时具备线程安全、延迟加载以及节省大量同步判断资源等优势，可以说是单例模式的最佳实现了