单例模式的Java实现与思考

Published: Creative Commons Licence

一、摘要

本文对单例模式在 Java 里的不同实现方式进行了分析,对比了不同方案的优缺点并给出使用结论。

二、单例模式的实现

单例模式的要义是控制某一个类只有一个唯一的实例,并提供一个统一的访问点。它主要用在某些不希望有多个实例的场景,比如线程池。

1.基础实现

首先来看一个单例模式的基础实现:

public class Singleton {

    private static final Singleton instance = new Singleton();

    private Singleton() {
        System.out.println("Singleton()");
    }

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

这个实现声明了一个静态变量 instance,利用了 Java 类初始化的规则(详见下方参考资料里的 JSL 12.4.1):

  • 一个类只有在被实例化,调用静态方法和访问静态变量之前才会被初始化。
  • 类的初始化会执行静态初始化块和静态变量的初始化语句。
  • 类的初始化过程会加锁,可以保证只会执行一次。

因此这种方式保证了 instance 只会在类初始化的时候被创建一次,之后每次通过 getInstance 获取到的都是同一个实例。

2.懒加载实现

有时不想要实例过早初始化,而是在真正使用到的时候才初始化,这种策略被称为懒加载。

2.1 简单实现(存在问题)

public class LazySingletonNaive {

    private static LazySingletonNaive instance;

    private LazySingletonNaive() {
        System.out.println("LazySingletonNaive()");
    }

    public static LazySingletonNaive getInstance() {
        if (instance == null) {
            instance = new LazySingletonNaive();
        }
        return instance;
    }
}

问题:

  1. 这里的 getInstance 方法存在竞态条件,有可能两个线程分别检查到 instance == null,然后各自执行了一次实例化操作。
  2. 由于指令重排的原因,还有可能造成部分初始化问题,这一点在后面 DCL 时会说到。

2.2 线程安全的懒加载

  • 方法1:直接对 getInstance 方法加 synchronized
...
    public static synchronized LazySingletonNaive getInstance() {
...

这种方式最直接,但会带来很高的同步性能开销,一般不会使用。

  • 方法2:Double Check Lock
public class LazySingletonDCL {

    private static volatile LazySingletonDCL instance; // 这里必须使用 volatile 关键字,是为了避免部分初始化问题,下文详述。

    private LazySingletonDCL() {
        System.out.println("LazySingletonDCL()");
    }

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

}

getInstance 方法的逻辑是:

  1. 首先判断 instance 是否为空,如果不为空,则说明已经初始化过了,可以直接使用,这种情况下可以不用进入同步块,避免了绝大多数情况下的性能开销;
  2. 如果为空,则说明需要进行初始化,进入同步块,拿到锁之后需要再检查一次 instance 是否为空(Double Check 名称的来源),如果 instance 为空,则执行初始化,否则说明其他线程已经初始化过了,直接返回即可。

instance 实例必须要使用 volatile 修饰,是为了避免部分初始化问题。详细原因可以参见这篇文章:深入理解 Java 内存模型

  • 方法3:Holder 方式
public class LazySingletonHolder {

    private static class Holder {
        static final LazySingletonHolder instance = new LazySingletonHolder();
    }

    private LazySingletonHolder() {
        System.out.println("LazySingletonHolder()");
    }

    public static LazySingletonHolder getInstance() {
        return Holder.instance;
    }

}

这里新创建了一个静态私有内部类 Holder,它的唯一目的就是存储一个静态的 instance 实例。然后这个类只有在 getInstance 方法调用时才会初始化,从而把 instance 实例初始化,实现了懒加载。

这种方式也比较简单,同时避免了同步的性能开销,推荐使用。

问:同样是利用类的静态变量,为什么说 SingletonLazySingletonHolder 一个没有懒加载,一个实现了懒加载呢?

答:如果按照上面贴出来的代码,Singleton 类的初始化时机只有一个,那就是 getInstance 方法调用时,那它其实就是懒加载。但是实际中,这个类里可能不止 getInstance 一个公开方法,如果还暴露了其他的公开方法或者变量,在访问那些方法或变量时,也会触发类的初始化,就会造成还没调用 getInstance 就初始化了实例的情况,所以说它没有实现懒加载。 而 LazySingletonHolder 类里的 Holder 由于被限制为了私有,且静态变量的唯一访问时机就是 getInstance 方法,因此可以实现懒加载。 所以这两个类的核心区别在于 instance 的初始化时机,Singleton 没有做严格管控,有可能会由于别的不相关的操作而提前初始化,LazySingletonHolder 做了严格管控,从而实现了懒加载。

三、几种方式的对比与总结

结论:

  1. 基础实现方式足够简单,易于理解,也没有并发问题,如果没有特殊的需求,建议90%的场景直接使用。
  2. 如果应用场景确实需要懒加载,建议使用 Holder 方式。
  3. DCL 方式有点 tricky,可读性不够好,而且相比 Hold 方式没有优势,因此不建议使用。

那是不是 DCL 方式就没有用处了呢?也不是,如果想要对一个实例变量做懒加载,基于静态变量的 Holder 方式就行不通了,此时就必须使用 DCL 才行了。

四、参考资料