单例模式和DCL

懒汉模式(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的判断，那么这里为什么需要做两次检查呢？
首先我们看一下这个方法的过程：

1. 检查singleton实例是否为空，如果不为空直接返回。
2. 对Singleton的class加synchronized锁，锁住整个类。如果没有获取锁则阻塞等待。
3. 判断singleton实例是否为空，如果为空则进行初始化。

设想一下，在最开始，如果N个线程同时并发来获取实例，除了获取锁的线程之外其他的线程都阻塞在第2步，等待第一个线程初始化实例完成后。后面的N - 1线程会穿行执行synchronized代码块，如果代码块中没有判断singleton是否为null，则还是会再"new" N - 1 个实例出来，无法达到单例的目的。
因此这里的DCL机制是必须的。

上面的方案看起来很完美，但是在更严苛的意义上还是有问题的，假设线程1获取锁之后在执行singleton = new Singleton();这一行，这里是new 一个Singleton实例，Java中新建一个对象分为三个步骤：

1. 在内存中开辟一块地址
2. 对象初始化
3. 将指针指向这块内存地址

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并发编程的艺术》