Java设计模式之——单例模式

单例模式基本介绍

单例模式是所有工程师最熟悉的设计模式之一，也是在开发中用的最多的。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的行为。比如我们在上篇博客中自定义的 ImageLoader，它就应该只有一个 ImageLoader 实例，因为这个 ImageLoader 中含有线程池、缓存系统、网络请求等，很消耗资源，因此没有必要让它构造多个实例。这种不能自由构造对象的情况，就应该采用单例来实现。

单例模式定义

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

单例模式的使用场景

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

单例模式 UML 类图

角色介绍：

• （1）Client —— 高层客户端；
• （2）Singleton —— 单例类

实现单例模式主要有如下几个关键点：

• （1）构造函数不对外开放，一般为 Private；
• （2）通过一个静态方法或枚举返回单例类对象；
• （3）确保单例类的对象有且只有一个，尤其是在多线程环境下；
• （4）确保单例类对象在反序列化时不会重新构建对象。

通过将单例类的构造方法私有化，使得客户端代码不能通过 new 的形式手动构造单例类的对象。单例类会暴露一个共有的静态方法，客户端需要调用这个静态方法获取到单例类的唯一对象，在获取这个单例对象的过程中需要保证线程安全，即在多线程环境下构造单例类的对象也是有且只有一个，这也是单例模式实现中比较困难的地方。

单例模式的实现方式

饿汉式

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

    private Singleton() {
    }

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

饿汉式是最简单的实现方式，在声明静态对象时就已经初始化，只需要在调用 getInstance 方法中返回初始化的对象就行。

饿汉式的优点：优点是加载时不需要实例化，在一定程度上节约时间。
饿汉式的缺点：优点既是缺点，虽然说饿汉式在加载时不需要实例化，节省了时间，但是却有点浪费资源。因为他是在声明静态对象时就已经初始化了，如果我们在后续开发中不使用这个对象，这个对象也是在内存中存在了，浪费了内存资源。

懒汉式

懒汉模式是声明一个静态对象，并且在用户第一次调用 getInstance 时进行初始化。懒汉单例模式实现如下：

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

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

大家可能已经发现了，getInstance() 方法中添加了 synchronized 关键字，也就是 getInstance 是一个同步方法，这就是上面所说的在多线程情况下保证单例对象唯一性的手段。细想一下，大家可能会发现一个问题，即使 instance 已经被初始化（第一次调用 getInstance 方法时就会初始化 instance），每次调用 getInstance 方法还是会进行同步，这样会消耗不必要的资源，这也是懒汉单例模式存在的最大问题。

最后总结一下，懒汉单例模式的优点是单例只有在使用时才会被实例化，在一定程度上节约了资源；缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用 getInstance 都进行同步，造成不必要的同步开销。这种模式一般不建议使用。

Double Check Lock（DCL）实现单例

DCL 方式实现单例模式的优点既能够在需要时才初始化单例，又能够保证线程安全，且单例对象初始化后调用 getInstance 不进行同步锁。代码如下所示：

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

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

可以发现我们在懒汉式的基础上仅仅是在方法上去除了 synchronized 关键字，将 synchronized 关键字放到了 getInstance 内部，仅此而已。

本程序的亮点自然都在 getInstance 方法上，可以看到 getInstance 方法中对 instance 进行了两次判空：第一层判断主要是为了避免不必要的同步，第二层的判断则是为了在 null 的情况下创建实例。这是什么意思呢？是不是有点摸不着头脑，下面我们就来分析一下：
假如我们没有第二层判断，我们来考虑这么一种情况：假设线程 A 执行到第一层判断、未进入 synchronized 中的语句，这时候被切换到了 线程 B 上，线程 B 执行完了 getInstance 方法，这个时候 线程A 又抢到执行权 ，因为 线程A 已经执行了第一层判断，那么当 线程A 进入 synchronized 代码段的时候如果我们没有第二层的判断，那么还是会实例化 Singleton 对象，这就造成了 Singleton 对象被多次实例化。所以从这方面的考虑，第二层判断的作用也就体现出来了，就是为了多线程中重复创建 单例实例 用的。

DCL的优点：资源利用率高，第一次执行 getInstance 时单例对象才会被实例化，
DCL的缺点：第一次加载时反应稍慢，也由于 Java 内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷，虽然发生概率很小。

DCL 模式是使用最多的单例实现方式，它能够在需要时才实例化单例对象，并且能够在绝大多数场景下保证单例对象的唯一性，除非你的代码在并发场景比较复杂或者低于 JDK6 版本下使用，否则，这种方式一般能够满足需求。

静态内部类单例模式

DCL 虽然在一定程度上解决了资源消耗、多余的同步、线程安全等问题，但是，它还是在某些情况下出现失效的问题。这个问题被称为双重检查锁定（DCL）失效，一般建议使用如下代码替代：

public class Singleton {
    private Singleton() {
    }

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

    //静态内部类
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }
}

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

枚举单例

前面讲解了一些单例模式实现方式，但是，这些实现方式不是稍显麻烦就是会在某些情况下出现问题。还有没有更简单的实现方式呢？我们看看下面的实现：

public enum  SinfletonEnum {
    INSTANCE
}

什么？枚举！没错，就是枚举！
写法简单是枚举单例最大的优点，枚举在 Java 中与普通的类是一样的，不仅能够有字段，还能够有自己的方法。最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。
为什么这么说呢？在上述的几种单例模式实现中，在一个情况下它们会出现重新创建对象的情况，那就是反序列化。

通过反序列化可以将一个单例的实例对象写到磁盘，然后在读回来，从而有效地获得一个实例。即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个新的实例，相当于调用该类的构造函数。反序列化操作提供了一个很特别的钩子函数，类中具有一个私有的、被实例化的方法 readResolve()，这个方法可以让开发人员控制对象的反序列化。例如，上述几个示例中如果要杜绝单例对象在被反序列化时重新生成对象，那么必须加入如下方法：

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

这样当JVM从内存中反序列化地”组装”一个新对象时,就会自动调用这个 readResolve方法来返回我们指定好的对象了, 单例规则也就得到了保证.
也就是在 readResolve() 方法中将 instance 对象返回，而不是默认的重新生成一个新的对象。而对于枚举，并不存在这个问题，因为即使反序列化它也不会重新生成新的实例。