单例模式的终极实现方案

时间 2019-11-08

标签模式终极实现方案繁體版

原文原文链接

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

控制实例数目设计模式

以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()方法时均需进行判断，所以该方式也是效率较低的code

利用双重检查加锁机制

双重检查加锁机制分为以下两重检查对象

在程序每次调用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()方法时才会去初始化类实例，所以也实现了延迟加载这一功能。如此即可使得这一实现方式可以同时具有线程安全、延迟加载以及节省大量同步判断资源等优点，能够说是单例模式的最佳实现了