Java对象延迟初始化的实现

一、什么是延迟初始化？

在Java多线程程序中，有时候需要采用延迟初始化来降低初始化类和创建对象的开销。

延迟初始化实际上就是：当我们要进行一些高开销的对象初始化操作时，只有在使用这些对象时才进行初始化。最显著的意义在于，假如程序实际上不会用到这些类，那初始化它们的开销就会被完全避免。

二、延迟初始化的错误实现方式

1、线程不安全的延迟初始化

public class UnsafeLazyInitialization {
    private static Instance instance;
    public static Instance getInstance() {
        if (instance == null) //1：A线程执行
            instance = new Instance(); //2：B线程执行
        return instance;
    }
    static class Instance {
    }
}

在UnsafeLazyInitialization类中，假设线程A执行代码1的同时，B线程执行代码2。此时线程A很可能看到instance引用的对象还没有完成初始化。所以我们必须对1、2这两步操作进行同步处理。

2、直接使用synchronized进行同步-有巨大的性能开销

public class SafeLazyInitialization {
    private static Instance instance;
    public synchronized static Instance getInstance() {
        if (instance == null)
            instance = new Instance();
        return instance;
    }
    static class Instance {
    }
}

在早期的JVM中，使用synchronized存在巨大的性能开销，这在实际的应用中时几乎不可能被接受的。

3、双重检查锁定-看似聪明的解决方案

public class DoubleCheckedLocking { //1
    private static Instance instance; //2
    public static Instance getInstance() { //3
        if (instance == null) { //4:第一次检查
            synchronized (DoubleCheckedLocking.class) { //5:加锁
                if (instance == null) //6:第二次检查
                    instance = new Instance(); //7:问题的根源出在这里
            } //8
        } //9
        return instance; //10
    } //11
    static class Instance {
    }
}

为了克服同步带来的大量开销，人们想得到了双重检查锁定这一看似聪明的解决方案。目的是仅仅对一开始竞争状态的getInstance加锁，带来开销。

但由于代码可能的重排序，直接使用上述代码是一种错误的优化。原因如下：

示例代码第七行，即 instance = new Instance(); 可以分解为如下的三行伪代码

memory = allocate();//1:分配对象的内存空间
ctorInstance(memory);//2:初始化对象
instance = memory;//3:设置instance指向刚分配的内存地址

假如2、3之间发生重排序，可能顺序变成如下这样

memory = allocate();//1:分配对象的内存空间
instance = memory;//3:设置instance指向刚分配的内存地址
ctorInstance(memory);//2:初始化对象

也就是说，当instance已经指向分配的内存地址时，对象还没有被初始化。

我们再回到示例代码

public class DoubleCheckedLocking { //1
    private static Instance instance; //2
    public static Instance getInstance() { //3
        if (instance == null) { //4:第一次检查
            synchronized (DoubleCheckedLocking.class) { //5:加锁
                if (instance == null) //6:第二次检查
                    instance = new Instance(); //7:问题的根源出在这里
            } //8
        } //9
        return instance; //10
    } //11
    static class Instance {
    }
}

当线程A在进行代码的第7行，即new Instance时，内部发生了重排序，即 instance = memory 在 ctorInstance(memory) 后进行。假如进程A刚刚进行到这两步之间。而进程B恰巧在第四行（第一次检查）处进行判断。那么线程B判断instance不为null，很可能向下进行，进而访问instance所引用的对象。而这时进程A尚未初始化instance！从而程序发生错误。

三、延迟初始化的正确实现方式

在上面的说明中了解了问题的根源后，我们可以很容易想到两个方法来实现线程安全的延迟初始化。

(1)不允许伪代码中的2和3两行重排序

(2)允许2和3重排序，但不允许其他线程"看到"这个重排序

1、基于volatile的解决方案

我们只要对之前双重检查锁定的代码进行一些小小的修改，就可以实现我们期望中的延迟初始化。

public class SafeDoubleCheckedLocking {
    private volatile static Instance instance;
    public static Instance getInstance() {
        if (instance == null) {
            synchronized (SafeDoubleCheckedLocking.class) {
                if (instance == null)
                    instance = new Instance();//instance为volatile
            }
        }
        return instance;
    }
    static class Instance {
    }
}

当instance的引用被声明为volatile时，创建对象时的重排序就将在多线程环境中被禁止。从而实现了用双重检查锁定来实现延迟初始化。

注：这个方案需要JDK5以上版本，因为自JDK5开始使用新的JSR-133内存模型，这个规范增强了volatile的语义。

2、基于类初始化锁的解决方案

JVM在类的初始化阶段（即Class被加载后，被线程使用前），会执行类的初始化。在执行类的初始化期间，JVM会获取一个锁，这个锁可以同步多个线程对一个类初始化。基于这个特性，我们可以用以下的方式来实现延迟初始化。

注意这个锁是对于类的初始化，而非对象的！

public class InstanceFactory {
    private static class InstanceHolder {//利用这个类的初始化锁
        public static Instance instance = new Instance();
    }
    public static Instance getInstance() {
        return InstanceHolder.instance; //这里将InstanceHolder被初始化
    }
    static class Instance {
    }
}

当getInstance第一次被调用，发生竞争时，InstanceHolder将被初始化。其中的静态变量instance也在此时被初始化。而InstanceHolder这个类的初始化锁保证了instance的初始化是被同步的。即无论new instance时是否发生重排序，都不会被其他线程所看到。从而解决了同步问题。

类的初始化锁相关知识在此不赘述，可参考《The Art of Java Concurrency Programming》相关篇目。

四、两种解决方案的对比

我们很容易可以发现，基于类初始化锁的方案的实现代码要更加简洁。但基于volatile的双重检查锁定方案有一个额外的优势，它可以对实例字段实现延迟初始化。

当我们进行延迟初始化处理时，面对实例字段我们使用基于volatile的方案，面对静态字段我们使用集于类初始化锁的方案。

2021-1-16