Java 设计模式DesignPattern之单例模式Singleton

我的博客

单例模式是我们经常用到的设计模式。
优点：如果对象的数据量比较大，单例模式可以避免重复的创建对象，保证内存中只有一份实例
缺点：不易被销毁，只有程序退出才会被销毁

首先，看一下简单的步骤

public class Singleton {

    /**
     * 私有静态实例，防止被引用。此处赋值null是为了实现延迟加载
     */
    private static Singleton singleton = null;

    /**
     * 私有构造方法，防止被实例化
     */
    private Singleton() {

    }

    /**
     * 公共、静态的方法,创建实例
     *
     * @return Singleton
     */
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;

    }
}

如果考虑多线程的情况，就可能出现创建多个实例的问题了。例如现在又两个线程，线程A和线程B，如果线程A正在创建实例，线程B访问 if (singleton == null) 判断，就会再次进入new Singleton()这行代码，这就出现创建两次实例的情况。为了避免这种情况，我们可以使用同步锁synchronized关键字

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

    }

这样就保证不会出现多线程访问造成多实例的问题了。但是这里有性能问题：每次获取实例都需要获取锁，很耗费性能。其实我们只需要第一次实例化的时候用到锁。那好，我们改良一下代码。

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

这样我们就保证了只对第一次实例化的情况使用了锁。但是，这里还有一个问题：由于指针重排序，造成实例还没有初始化就开始使用实例的情况。
在这里，需要温习一下java的基础知识：、
singleton = new Singleton()
这行代码都进行了哪些操作

memory = allocate();   //1：分配对象的内存空间
ctorInstance(memory);  //2：初始化对象
instance = memory;     //3：设置instance指向刚分配的内存地址

上述伪代码中2和3可能重新排序，出现下面的情况

memory = allocate();   //1：分配对象的内存空间
instance = memory;     //3：设置instance指向刚分配的内存地址
                       //注意，此时对象还没有被初始化！
ctorInstance(memory);  //2：初始化对象

此时线程B就会访问一个没有初始化的对象，出现异常。为了解决上述情况，我们需要稍微修改一下代码即可：把instance 声明为volatile类型，就可以实现线程安全的延迟初始化。

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

关于volatile的作用，只需要知道使用volatile上述伪代码中的指针重新排序将被禁止就行.

上述代码已经是线程安全的单例模式了，基于volatile的双重检查锁定（DOUBLE_CHECK）的解决方案。但是代码过于复杂。接下来介绍一种最简单也是最安全的单例模式。

    /**
     * 获得单例
     *
     * @return
     */
    public static Singleton getInstance() {
        return InstanceHolder.INSTANCE;
    }

    /**
     * 单例持有器
     */
    private static final class InstanceHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 禁止构造
     */
    private Singleton() {
    }

这种是基于类初始化的一种解决方案。JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。基于这个特性，可以实现另一种线程安全的延迟初始化方案（这个方案被称之为Initialization On Demand Holder idiom）

总结:
延迟初始化降低了初始化类或创建实例的开销，但增加了访问被延迟初始化的字段的开销。在大多数时候，正常的初始化要优于延迟初始化。如果确实需要对实例字段使用线程安全的延迟初始化，请使用上面介绍的基于volatile的延迟初始化的方案；如果确实需要对静态字段使用线程安全的延迟初始化，请使用上面介绍的基于类初始化的方案。