Android设计模式——单例的七种写法

本文为《Android设计模式解析与实战》读书笔记，供个人备忘、复习用

同时，本文也摘录了刘望舒大神的博文：设计模式（二）单例模式的七种写法

一、定义

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

二、单例模式UML类图：



角色介绍：

（1）、Client—————–高层客户端；

（2）、Singleton————–单例类。

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

（1）、构造函数不对外开放，一般为Private；

（2）、通过一个静态方法或枚举返回单例类对象；

（3）、确保单例类的对象有且只有一个，尤其是在多线程环境下；

（4）、确保单例类对象在反序列化时不会重新构建对象。

三、单例模式的多种写法

单例模式有多种写法各有利弊，现在我们来看看各种模式写法。

1、饿汉模式：

/**
* Created by lanbots on 2017/9/27.
* Email : lanbots@lanbots.cn
*/

public class Singleton {

private static Singleton instance = new Singleton();

private Singleton() {
}

public static Singleton getInstance() {
return instance;
}

}

这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。 这种方式基于类加载机制避免了多线程的同步
4000
问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。

2、懒汉模式（线程不安全）

/**
* Created by lanbots on 2017/9/27.
* Email : lanbots@lanbots.cn
*/

public class Singleton {

private static Singleton instance;

private Singleton() {
}

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

懒汉模式申明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，反映稍慢一些，而且在多线程不能正常工作。

3、懒汉模式（线程安全）

/**
* Created by lanbots on 2017/9/27.
* Email : lanbots@lanbots.cn
*/

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()

是一个同步方法。这种写法能够在多线程中很好的工作，但是每次调用

getInstance()

方法时都会进行同步，造成不必要的同步开销，而且大部分时候我们是用不到同步的，所以不建议用这种模式。

4、双重检查模式 （Double Check Lock)

/**
* Created by lanbots on 2017/9/27.
* Email : lanbots@lanbots.cn
*/

public class Singleton {

private static Singleton instance;

private Singleton() {
}

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

这种写法在

getSingleton()

方法中对

singleton

进行了两次判空，第一次是为了不必要的同步，第二次是在

singleton

等于

null

的情况下才创建实例。在这里用到了

volatile

关键字，不了解

volatile

关键字的可以查看Java多线程（三）volatile域这篇文章，在这篇文章我也提到了双重检查模式是正确使用

volatile

关键字的场景之一。

在这里使用

volatile

会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。

DCL

优点是资源利用率高，第一次执行

getInstance

时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。

DCL

虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是它还是在某些情况会出现失效的问题，也就是

DCL

失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代

DCL

。

5、静态内部类单例模式

/**
* Created by lanbots on 2017/9/27.
* Email : lanbots@lanbots.cn
*/

public class Singleton {

private Singleton() {
}

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

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

第一次加载

Singleton

类时并不会初始化

sInstance

，只有第一次调用

getInstance

方法时虚拟机加载

SingletonHolder

并初始化

sInstance

，这样不仅能确保线程安全也能保证

Singleton

类的唯一性，同时也延迟了单例的实例化，所以推荐使用静态内部类单例模式。

6、 枚举单例

/**
* Created by lanbots on 2017/9/27.
* * Email : lanbots@lanbots.cn.
*/

public enum Singletom {

INSTANCE;

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

}

枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。

7、 使用容器实现单例模式

/**
* Created by lanbots on 2017/9/27.
* Email : lanbots@lanbots.cn.
*/

public class SingletonManager {

private static Map<String, Objects> objMap = new HashMap<String, Objects>();

private SingletonManager() {

}

public static void registerService(String key, Objects instance) {
if (!objMap.containsKey(key)) {
objMap.put(key, instance);
}
}

public static Objects getService(String key) {
return objMap.get(key);
}
}

用

SingletonManager

将多种的单例类统一管理，在使用时根据

key

获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

三、总结

不管以哪种形式实现单例模式，它们的核心原理都是将构造函数私有化，并且静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题。选择哪种实现方法取决于项目本身，如是否复杂的并发环境，JDK版本是否过低、单例对象资源的消耗等。