初识单例模式——Android设计模式

一、单列模式的定义

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

二、单例模式的使用场景

确保某一个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且只有一个。

三、单例模式的UML类图

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

（1）   构造函数不对外开发（private）；

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

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

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

四、单列模式的实现方式

（1）饿汉模式

在声明静态对象时就已经初始化

public class Singleton {
	private static final Singleton instance = new Singleton();
	// 私有构造方法（不对外提供构造方法）
	private Singleton() {}
	// 公有静态函数，外部可通过该接口获取单例对象
	public static Singleton getInstance() {
		return istance;
	}
}

（2）懒汉模式

声明的静态对象在用户第一次调用getInstance()方法时进行初始化

public class Singleton {
	private static Singleton instance = null;

	private Singleton() {}
	// 同步方法
	public static synchronized Singleton getInstance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

我们可以发现在getInstance()方法中添加了synchronize关键字将其定义为同步方法，保证在多线程情况下单例对象的唯一。从代码中我们可以知道，我们只有在第一次调用getInstance()方法时instance才会被实例化，在一定程度上节约了资源，但在我们每次调用getInstance()方法时都需要进行同步，从而这也造成不必要的同步开销，这也正是懒汉模式最大的缺陷。因此，这种模式往往并不推荐使用。

（3）双重检查锁定（Double Check Lock | DCL）模式

该方式能够保证在需要时才初始化单例，又能保证线程安全，且单例对象初始化后getInstance()方法不再进行同步锁。

public class Singleton {
	private volatile static Singleton instance = null;

	private Singleton() {}

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

什么？这里有两层判空？你没看错，这也正是该方式的亮点所在。第一层判断主要是为了避免不必要的同步，也正是因为如此，在单例对象初始化后也便不再进行同步。第二层判断是在未实例化单例对象时进行初始化。

不知你有没有注意到instance对象的定义还使用了volatile关键字修饰，这又是为何？

假设线程A执行到instance = new Singleton()语句，这里看来只是一句代码，但它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，大致做了如下三件事：

1.给Singleton实例分配内存；

2.调用Singleton（）构造函数初始化成员字段；

3.将instance对象指向分配的内存空间（此时instance就不是null了）。

但是，由于Java编译器允许处理器乱序执行，以及JDK1.5之前JMM（Java Memory Model，即Java内存模型）中Cache、寄存器到主内存回写顺序的规定，上面2和3的顺序是无法保证的，也就是说执行顺序可能是1->2->3也可能是1->3->2，如果是后者，并且在3执行完毕、2未执行之前，被切换到线程B上，这时候instance因为已经在线程A内执行过了3，instance已经是非空，线程B直接就取走instance去使用，这便会出错了，这便是DCL失效的问题，而且这种难以追踪难以重现的错误很可能会隐藏很久。

所幸在JDL1.5之后，调整了JVM，具体化了volatile关键字。我们在此使用此关键字就可以保证instance对象每次都是从主内存中取出，就可以使用DCL的写法来完成单例模式。当然，volatile或多或少也会影响到性能，但考虑到程序的正确性，这点牺牲还是值得的。

DAL的优点：资源利用率高，第一次执行getInstance()方法时单例对象才会被实例化，效率高。缺点：第一次加载时反应稍慢，也由于Java内存模型的原因偶尔会失败。在高并发坏境下也有一定的缺陷，虽然发生概率很小。DCL模式是使用最多的单例实现方式，它能够在需要是才实例化单例对象，并且能够在绝大多数场景下保证单例对象的唯一性，只要你的代码在并非场景比较复杂或低于JDK6版本下使用，否则，这种方式一般能够满足需求。

（4）静态内部类单例模式

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

public class Singleton {
	private Singleton() {}

	public static Singleton getInstance() {
		return SingletonHolder.instance;
	}
	
	public static class SingletonHolder {
		private static final Singleton instance = new Singleton();
	}
}

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

（5）枚举单例

public enum Singleton {
	INSTANCE;
	public void doSomething() {
		// 代码内容...
	}
}

枚举不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。

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

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

也就是在readResolve()方法中将instance对象返回，而不是默认的重新生成一个新的对象。而对于枚举，并不存在这个问题，因为即使反序列化它也不会重新生成新的实例。

（6）使用容器实现单例模式

public class SingletonManager {
	private static Map<String, Object> map = new HashMap<String, Object>();
		
	private SingletonManager() {}
	public static void registerService(String key, Object instance) {
		if (!map.containsKey(key)) {
			map.put(key, instance);
		}
	}
	public static Object getService(String key) {
		return map.get(key);
	}
}

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

五、总结

这是本人参考《Android源码设计模式解析与实战》所做的读书笔记，看完单例模式的相关章节也有了进一步了解，不管以哪种形式实现单例模式，其核心原理是将构造函数私有化，并通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题，选择哪种实现方式取决于项目本身，如是否是复杂的并非环境、JDK版本是否过低，单例对象资源消耗等。