懒汉模式(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并发编程的艺术》