Java Double-Checked Locking 已死，C++ 呢？

已经有众多文章讨论 double-checked locking 模式在 Java 下面无法正常工作，这里先简要的总结一下。

根本原因在于 Java 的 memory model 允许所谓的 out-of-order write ，对于下面的 Java 代码，out-of-order write 可能导致灾难性的结果

public static Singleton getInstance()
{
  if (instance == null)
  {
    synchronized(Singleton.class) {  //1
      if (instance == null)          //2
        instance = new Singleton();  //3
    }
  }
  return instance;
}

问题的起因在于语句 //3 ，JIT 所生成的汇编代码所作的事情并不是先生成一个 Singleton 对象，然后将其地址赋予 instance 。相反，它的做法是

1. 先申请一块空内存
2. 将其地址赋予 instance
3. 在 instance 所指的地址之上构建对象

下面的汇编代码提供了证明，说明这不只是一个脑筋急转弯，而是实际发生在 JIT 里面的。代码来自 Peter Haggar 的文章，我只是引用一下。

054D20B0   mov         eax,[049388C8]          ;load instance ref
054D20B5   test          eax,eax                         ;test for null
054D20B7   jne           054D20D7
054D20B9   mov         eax,14C0988h
054D20BE   call          503EF8F0                    ;allocate memory
054D20C3   mov         [049388C8],eax          ;store pointer in
                                                                              ;instance ref. instance 
                                                                              ;non-null and ctor
                                                                              ;has not run
054D20C8   mov         ecx,dword ptr [eax]
054D20CA   mov         dword ptr [ecx],1         ;inline ctor - inUse=true;
054D20D0   mov         dword ptr [ecx+4],5     ;inline ctor - val=5;
054D20D7   mov         ebx,dword ptr ds:[49388C8h]
054D20DD   jmp         054D20B0

其中地址为 054D20BE 的代码正在分配内存，而接下来的一行将其赋予 instance ，这个时候 Singleton 的构造函数根本就还没有被调用。

那么问题在哪里？如果线程调度发生在 instance 已经被赋予一个内存地址，而 Singleton 的构造函数还没有被调用的微妙时刻，那么另一个进入此函数的线程会发觉 instance 已经不为 null ，从而放心大胆的将 instance 返回并使用之。但是这个可怜的线程并不知道此时 instance 还没有被初始化呢！

症结在于：首先，构造一个对象不是原子操作，而是可以被打断的；第二，更重要的，Java 允许在初始化之前就把对象的地址写回，这就是所谓 out-of-order 。

那么，对于 C++ 呢？典型的 C++ double-checked locking 可能是这样的

    static Singleton* getInstDC()
    {
        if(inst_ == 0)
        {
            boost::mutex::scoped_lock l(guard_);
            if(inst_ == 0)
                inst_ = new Singleton();
        }
        return inst_;
    }

正如 Java 的行为取决于 JIT 的处理方式，C++ 程序的行为要由编译器来决定。如果某个编译器的处理与 JIT 类似，那么 C++ 程序员也只好对 double-checked locking 说再见。下面是 VC7.1 在 release 配置下生成的代码：

    static Singleton* getInstDC()
    {
00401110  mov         eax,dword ptr fs:[00000000h]
00401116  push        0FFFFFFFFh
00401118  push        offset __ehhandler$?getInstDC@Singleton@@SAPAV1@XZ (4095F8h)
0040111D  push        eax 
        if(inst_ == 0)
0040111E  mov         eax,dword ptr [Singleton::inst_ (40D000h)]
00401123  mov         dword ptr fs:[0],esp
0040112A  sub         esp,8
0040112D  test        eax,eax
0040112F  jne         Singleton::getInstDC+6Eh (40117Eh)
        {
            boost::mutex::scoped_lock l(guard_);
00401131  mov         ecx,offset Singleton::guard_ (40D004h)
00401136  mov         dword ptr [esp],offset Singleton::guard_ (40D004h)
0040113D  call        boost::mutex::do_lock (401340h)
00401142  mov         byte ptr [esp+4],1
            if(inst_ == 0)
00401147  mov         eax,dword ptr [Singleton::inst_ (40D000h)]
0040114C  test        eax,eax
0040114E  mov         dword ptr [esp+10h],0
00401156  jne         Singleton::getInstDC+57h (401167h)
                inst_ = new Singleton();
00401158  push        1   
0040115A  call        operator new (4011A2h)
0040115F  add         esp,4
00401162  mov         dword ptr [Singleton::inst_ (40D000h)],eax
        }
00401167  mov         ecx,offset Singleton::guard_ (40D004h)
0040116C  mov         dword ptr [esp+10h],0FFFFFFFFh
00401174  call        boost::mutex::do_unlock (401360h)
        return inst_;
00401179  mov         eax,dword ptr [Singleton::inst_ (40D000h)]
    }
0040117E  mov         ecx,dword ptr [esp+8]
00401182  mov         dword ptr fs:[0],ecx
00401189  add         esp,14h
0040118C  ret             

从标记为红色的那一句，我们看到了希望：对 inst_ 的赋值发生在 new 完成之后，这意味着至少在 VC7.1 中，我们尚且可以放心使用 double-checked locking ，尽管它未必具有可移植性。