阅读 3243

单例模式和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并发编程的艺术》

文章分类
阅读
文章标签