单例模式的Java如何去实现？

一、摘要

本文分析了单例模式在 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;
}

}
注意这里的 getInstance 方法存在竞态条件，有可能两个线程分别检查到 instance == null，然后各自执行了一次实例化操作。

而且由于指令重排的原因，还有可能造成部分初始化问题，这一点在后面 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 方法的逻辑是：

首先判断 instance 是否为空，如果不为空，则说明已经初始化过了，可以直接使用，这种情况下可以不用进入同步块，避免了绝大多数情况下的性能开销；
如果为空，则说明需要进行初始化，进入同步块，拿到锁之后需要再检查一次 instance 是否为空（Double Check 名称的来源)，如果 instance 为空，则执行初始化，否则说明其他线程已经初始化过了，直接返回即可。
instance 实例必须要使用 volatile 修饰，是为了避免部分初始化问题。

方法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 实例初始化，实现了懒加载。

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

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

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

结论：

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

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