双重检查锁定与延迟初始化

  |   0 评论   |   0 浏览

在 Java 多线程中,有时候需要采用延迟初始化来降低类和创建对象的开销双重检查锁定是常见的延迟初始化技术。

双重检查锁定的由来

在 Java 程序中,有时候可能需要推迟一些高开销的对象初始化操作,并且只有在使用这些对象的时候才进行初始化。

但要正确实现线程安全的延迟初始化需要一些技巧,否则很容易出现问题。

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

在 UnsafeLazyInitialization 类中,假设 A 线程执行代码 1 的同时,B 线程执行代码 2.
此时线程 A 可能会看到 instance 引用的对象还没有完全初始化。

对于 UnsafeLazyInitialization 类,我们可以对 getInstance() 方法做同步处理来实现线程安全的延迟初始化。

public class SafeLazyInitialization{
    private static Instance instance;

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

由于对 getInstance() 方法做了同步处理,synchronized 将导致性能开销。如果 getInstance() 方法被多个线程频繁调用,将会导致程序执行性能的下降。

在早期的 JVM 中, synchronized (甚至是无竞争的 synchronized)存在巨大的性能开销。因此人们想出了一个 "聪明"的技巧: 双重检查锁定(Double-Checked Locking). 人们想通过双重检查锁定来降低同步的开销。

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
}

如上面代码所示,如果第一次检查 instance 不为 null,那么就不需要执行下面的加锁和初始化操作。因此,可以大幅降低 synchronized 带来的性能开销。上面代码表面上看起来,似乎两全其美。

  • 多个线程试图在同一时间创建对象时,会通过加锁来保证只有一个线程能创建对象。
  • 在对象创建好之后,执行 getInstance() 方法将不需要获取锁,直接返回已创建好的对象。

但是,在线程执行到第 4 行,代码读取到 instance 不为 null 时,instance 引用的对象有可能还没有完全初始化。

问题根源

前面的双重检查锁定示例代码的 第 7 行(instance = new Singleton();)创建了一个对象。这行代码可以分解为如下 3 行代码

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

上面 3 行伪代码中的 2 和 3 之间,可能会被重排序(在一些 JIT 编译器上,这种重排序是真实发生的,详细参考文献 1 的 "Out-of-order writes" 部分)。 2 和 3 之间重排序之后的执行时序如下。

memory = allocate();     //1:分配对象的内存空间
instance = memory;       //3: 设置instance 指向刚分配的内存地址
                                    // 注意,此时对象还没有被初始化!
ctorInstance(memory);   //2:初始化对象

DoubleCheckedLocking 示例代码的第 7 行(instance = new Singleton();)如果发生重排序,另一个并发执行的线程 B 就有可能在第 4 行判断 instance 不为 null。线程 B 接下来讲访问 instance 所引用的对象,但此时这个对象可能还没有被 A 线程初始化。

在知晓了问题的根源之后,可以有两个办法来实现线程安全的延迟初始化。

  1. 不允许 2 和 3 重排序
  2. 允许 2 和 3 重排序,但不允许其他线程"看到"这个重排序

基于 volatile 的解决方案

对于前面的基于双重检查锁定来实现延迟初始化的方案(指 DoubleCheckedLocking 示例代码),只需要做一点改动,就可以实现线程安全的延迟初始化。

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;
     }
}

这个解决方案需要 JDK5 或更高版本(因为 JDK5 开始使用新的 JSR-133 内存模型规范,这个规范增强了 volatile 的语义).

当声明对象的引用为 volatile 后,创建对象的重排序在多线程环境中将被禁止。

基于类初始化的解决方案

JVM 在类的初始化阶段(即在 Class 被加载后,且被线程使用之前),会执行类的初始化。在执行类的初始化期间,JVM 会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化

基于这个特性,可以实现另一种线程安全的延迟初始化方案

public class InstanceFactory{
    
   private static class InstanceHolder{
      public static Instance instance = new Instance();
   }	

   public static Instance getInstance(){
      return InstanceeHolder.instance;   // 这里将导致 InstanceHolder 类被初始化。
  }
}

这个方案的实质是:允许对象创建的重排序,但不允许非构造线程“看到”这个重排序。

初始化一个类,包括执行这个类的静态初始化和初始化在这个类中声明的静态字段。根据 Java 语言规范,在首次发生下列任意一种情况时,一个类或接口类型 T 将被立即初始化。

  • 1) T 是一个类,而且一个 T 类型的实例被创建
  • 2) T 是一个类,且 T 中声明的一个静态方法被调用。
  • 3) T 中声明的一个静态字段被赋值
  • 4) T 中声明的一个静态字段被使用,而且这个字段不是一个常量字段
  • 5) T 是一个顶级类,而且一个断言语句嵌套在 T 内部被执行。

在 InstanceFactory 实例代码中,首次执行 getInstance() 方法的线程将导致 InstanceHandler 类被初始化


标题:双重检查锁定与延迟初始化
作者:zh847707713
地址:http://lovehao.cn/articles/2020/03/31/1585646854425.html