懒汉模式(lazy init)
public class Singleton {
private Singleton singleton;
// 构造函数是private，防止外部实例化
private Singleton() {}
// 静态方法获取实例
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
return singleton;
}
}
}
上面的方法实现简单，在单线程环境下没有问题，但是在多线程环境下就会有并发安全问题。如果两个线程同时进入if (singleton == null)这里，就会同时去实例化，这样就达不到单例的目的。
加synchronized锁
加锁能够保证并发环境下的数据安全性。下面是并发版本的单例模式：
public class Singleton {
private Singleton singleton;
// 构造函数是private，防止外部实例化
private Singleton() {}
// 静态方法获取实例
public synchronized static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
return singleton;
}
}
}
加锁虽然保证了线程安全性，但是记住锁通常是低效的，如果锁竞争激烈，性能将会下降。
synchronized锁+DCL（Double Check Lock）
public class Singleton {
private Singleton singleton;
// 构造函数是private，防止外部实例化
private Singleton() {}
public static Singleton getInstance() {
if (singleton == null) { // 第一次检查
synchronized (Singleton.class) {
if (singleton == null) { // 第二次检查，"double check"的由来
singleton = new Singleton();
}
}
}
return singleton;
}
}
DCL方法中做了两次singleton == null的判断，那么这里为什么需要做两次检查呢？
首先我们看一下这个方法的过程：
- 检查singleton实例是否为空，如果不为空直接返回。
- 对Singleton的class加synchronized锁，锁住整个类。如果没有获取锁则阻塞等待。
- 判断singleton实例是否为空，如果为空则进行初始化。
设想一下，在最开始，如果N个线程同时并发来获取实例，除了获取锁的线程之外其他的线程都阻塞在第2步，等待第一个线程初始化实例完成后。后面的N - 1线程会穿行执行synchronized代码块，如果代码块中没有判断singleton是否为null，则还是会再"new" N - 1 个实例出来，无法达到单例的目的。
因此这里的DCL机制是必须的。
上面的方案看起来很完美，但是在更严苛的意义上还是有问题的，假设线程1获取锁之后在执行singleton = new Singleton();这一行，这里是new 一个Singleton实例，Java中新建一个对象分为三个步骤：
- 在内存中开辟一块地址
- 对象初始化
- 将指针指向这块内存地址
Java中如果我们在一个线程中观察代码，代码都是顺序穿行执行的，但是如果我们在一个线程中观察其他线程，其他线程中的执行都是乱序的。这句话说的是Java中的指令重排序现象。如果在新建Singleton对象的时候第2步和第3步发生了重排序，线程1将singleton指针指向了内存中的地址，但是此时我们的对象还没有初始化。这个时候线程2进来，看到singleton不是null，于是直接返回。这个时候错误就发生了：线程2拿到了一个没有经过初始化的对象。
解决这个问题的思路也很简单：防止指令重排序，Java中可以通过volatile关键字来防止指令重排序。
synchronized锁+DCL（Double Check Lock）+volatile
public class Singleton {
private volatile Singleton singleton;
// 构造函数是private，防止外部实例化
private Singleton() {}
public static Singleton getInstance() {
if (singleton == null) { // 第一次检查
synchronized (Singleton.class) {
if (singleton == null) { // 第二次检查，"double check"的由来
singleton = new Singleton();
}
}
}
return singleton;
}
}
我们将singleton改成了volatile类型的，volatile同时保证了可见性和有序性。
DCL和缓存雪崩
public abstract class DoubleCheckCache {
private Map<String, Object> localCache = new HashMap<>();
public Object get(String key) {
Object res = null;
if (localCache.get(key) == null) { // 第一次检查
synchronized (this) {
if (localCache.get(key) == null) { // 第二次检查，其他排队请求获取锁的线程走到这里时已经能够看到缓存中的值了，也就不用再发起远程调用了
res = loadExternal(key);
localCache.put(key, res);
}
}
}
return res;
}
// 从外部加载key对应的value，通常是从数据库加载或者是发起RPC调用来加载，此操作是耗时的
protected abstract Object loadExternal(String key);
}
DCL不仅在单例模式中有运用，在防止缓存雪崩中也有运用，上面代码中使用了DCL来防止多个线程多次调用loadExternal。其原理和上面的单例模式类似，这里就不再过多阐述。
终极方案-基于类初始化
该解决方案的根本就在于：利用classloder的机制来保证初始化instance时只有一个线程。JVM在类初始化阶段会获取一个锁，这个锁可以同步多个线程对同一个类的初始化。
public class Singleton {
private static class SingletonHolder {
public static Singleton singleton = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.singleton;
}
}
Java语言规定，对于每一个类或者接口C,都有一个唯一的初始化锁LC与之相对应。从C到LC的映射，由JVM的具体实现去自由实现。JVM在类初始化阶段期间会获取这个初始化锁，并且每一个线程至少获取一次锁来确保这个类已经被初始化过了。
参考资料
方腾飞：《Java并发编程的艺术》
