单例模式的创建方式

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

1.构造函数不能对外开放，一般为private

2.通过一个静态方法或者枚举返回单例类对象

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

4.确保单例类对象在反序列化时不会重新构造对象

单例模式的实现方式

1.饿汉单例模式

public class Test {
	private static final Test sTest = new Test();

	private Test() {

	}

	public static Test getInstance() {
		return sTest;
	}
}

饿汉模式即使没有使用单例，在内存中也会一直有对象，浪费的资源。

2.懒汉模式

public class Test {
	private static Test sTest;

	private Test() {

	}

	public static synchronized Test getInstance() {
		if (sTest == null) {
			sTest = new Test();
		}
		return mTest;
	}
}

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

3.DCL（Double Check Lock）模式

public class Test {
	private static Test sTest = null;

	private Test() {

	}

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

DCL方式实现单例模式的优点是既能够在需要时才初始化单例模式，又能够保证线程安全，且单例对象初始化后调用getInstance方法不进行同步锁，资源利用率高。缺点是第一次加载时反应稍慢，由于Java内存模型的原因偶尔会失败。这是为什么呢？

假设线程A执行到sTest = new Test()语句，这里看起来是一段代码，但实际上它并不是原子操作，这句代码会被编程成多条汇编语句，它大致做了3件事

1.给Test的实例分配内存

2.调用Test（）的构造函数，初始化成员字段

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

但是，由于Java编译器允许处理器乱序执行，以及JDK1.5之前JMM（Java Memory Model，即Java内存模型）中Cache，寄存器到主内存回写顺序的规定，上面的第二和第三步的顺序是无法保证的。也就是说执行顺序可能是1-2-3,，或者是1-3-2，如果是后者，在3执行完，2未执行的时候切换到线程B，sTest已经不为空了，线程B直接取走了sTest，再使用时就会出错，这就是DCL失效的问题。所以在高并发下有缺陷，虽然概率很小。

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

4.静态内部类模式

public class Test {

	private Test() {

	}

	public static Test getInstance() {
		return TestHolder.sTest;
	}

	public static class TestHolder {
		private static final Test sTest = new Test();
	}
}

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

5.枚举单例

public enum  Test {
	TEST;
	public void doSomething() {
		// 操作
	}
}

写法简单是枚举单例最大的优点，枚举在Java中与普通类一样，不仅能够有字段，还能够有自己的方法。最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。

上面的几种单例实现方式中，在一个情况下它们会出现重新创建对象的情况，那就是反序列化。

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

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

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

不管以哪种形式实现单例，核心原理都是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全，防止反序列化导致重新生成新的实例对象等问题。

对于客户端来说，通常没有高并发的情况，所以选择哪种方式并不会有太大的影响。出于效率考虑，推荐使用3,4的形式。单例模式有一个缺点需要注意，如果单例模式持有Context，那么很容易引发内存泄露，此时需要注意传递给单例对象的Context最好是Application Context