Java 实现一个单例模式_单例模式的 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 才行了。
本作品采用《CC 协议》，转载必须注明作者和本文链接