设计模式学习 -- 单例模式

一、定义

单例模式（Singleton Pattern），属于创建型模式。该模式确保一个类只有一个实例，并提供一个全局访问点。
使用单例模式的情况下，在内存中只有一个实例，减小了内存的开销。同时，对于频繁使用的重量级对象，省略了创建对象的时间。

Q: 类加载器呢？两个类加载器可能有机会各自创建自己的单例实例。
A: 是的。每个类加载器都定义了一个命名空间，如果有两个以上的类加载器，不同的类加载器可能会加载同一个类，从整个程序来看，同一个类会被加载多次。如果这样的事情发生在单例上，就会产生多个单例并存的怪异的现象。所以，如果你的程序有多个类加载器又同时使用了单例模式，请小心。
有一个解决办法：自行指定类加载器，并指定同一个类加载器。

---

二、实现

getInstance() 可以延迟实例化。

1. 饿汉模式

public class Singleton {
	private static Singleton instance = new Singleton();
	
	private Singleton() {
		// pass
	}

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

它基于 classloader 机制避免了多线程的同步问题，即此实现是线程安全的，但是 instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance() 方法，但是也不能确定有其他方式导致类装载，这时候初始化 instance 显然没有达到懒加载的效果。

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

public class Singleton {
	private static Singleton instance;

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

这种方式比较常见，符合懒加载，但是这种实现的最大缺点就是在多线程的情况下时不安全的。

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

public class Singleton {
	private static Singleton instance;

	private Singleton() {
		// pass
	}
	
	public static synchronized Singleton getInstance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}	
}

这种方式符合懒加载，也能在多线程环境下工作，但是效率很低。

4. 双重检查模式（DCL）

public class Singleton {
	private static volatile Singleton instance;

	private Singleton() {
		// pass
	}

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

DCL，即 double-checked loking。这种方式采用双锁机制，安全且在多线程情况下保持高性能。两个 if 判 null 是为了减小锁的粒度，保证线程安全，同时也提高了性能。因为只要对象一创建成功，第一层 if 就阻拦了进入同步语句块，提高了性能，同时如果没有创建对象，进入同步语句块，保证了线程安全。

volatile 关键字在这这里的作用很重要，防止了指令重排序（ volatile 可以实现可见性）。
因为 volatile 无法保证原子性，instance = new Singleton();不是一个原子操作，实际情况是，在 JVM 中，这一条语句做了三件事：

1. 给 instance 分配内存；
2. 调用 Singleton 的构造函数来初始化成员变量；
3. 将 instance 对象指向分配的内存空间。

在 JVM 的即时编译器中，会做指令的优化重排，所以这三件事的执行顺序并不能保证，有可能是1-2-3，也有可能是1-3-2。如果是后者，3执行完，但是2未执行，此时被另一个线程抢占了，这时 instance 已经是非 null 了（但却没有初始化），就会直接返回 instance，当然此时如果使用这个 instance 就会报错。

5. 静态内部类

public class Singleton {
	private static Singleton instance;

	private Singleton() {
		// pass
	}
	
	public static Singleton getInstance() {
		return SingletonHolder.INSTANCE;
	}

	private static class SingletonHolder {
		private static final Singleton INSTANCE = new Singleton();
	}
}

这种方式能达到和 DCL 一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是 DCL。这种方式只适用于静态域的情况，DCL 可在实例域需要延迟初始化时使用。

这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 1 种方式（即饿汉模式）不同的是：第 1 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到懒加载效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance() 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 1 种方式就显得很合理。

6. 枚举单例

public enum Singleton {
	INSTANCE
}

这是实现单例模式的最佳方法。默认枚举实例的创建是线程安全的，所以不需要担心线程安全的问题。它更简洁，自动支持序列化机制，绝对防止多次实例化。不能通过反射攻击（reflection attack）来调用私有构造方法。

---

三、参考

1. 菜鸟教程 - 单例模式
2. 掘金 - 面试官所认为的单例模式
3. Head First 设计模式(中文版)