DCLP不是线程安全的？

DCLP不是线程安全的？

hanlray@gmail.com

Revision: 1.0 Date: 2005/09/29

---

DCLP(Double-Checked Loking Pattern)应该是一种优化模式，用于解决在多线程环境下，为了实现共享资源的lazy initialization，采用通常的锁机制带来的效率问题。其最常见的应用就是用来实现Singleton设计模式，ACE中的Singleton就是这么实现的。它怎么可能不是线程安全的呢？读了Scott Meyers 和 Andrei Alexandrescu的"C++ and the Perils of Double-Checked Locking"，恐怕你就再也不敢使用DCLP了。本文是对该文的阐述。

用DCLP实现Singleton的代码一般类似于：

        1  // from the header file
        2  class Singleton {
        3  public:
        4      static Singleton* instance();
        5  ...
        6  private:
        7      static Singleton* pInstance;
        8  };
        9
        10 // from the implementation file
        11 Singleton* Singleton::pInstance = 0;
        12
        13 Singleton* Singleton::instance() {
        14     if (pInstance == 0) {
        15         pInstance = new Singleton;
        16     }
        17     return pInstance;
        18 }

这里pInstance = new Singleton;语句会引发三件事情:

Step 1: 分配内存来容纳一个Singleton对象

Step 2: 在分配好的内存中构造一个Singleton对象

Step 3: 使pInstance指向分配好的内存

如果编译器为该语句产生成的代码是是按照这个顺序，则不会出任何问题；但是编译器可能会颠倒第二步和第三步，生成类似下面的代码：

        Singleton* Singleton::instance() {
            if (pInstance == 0) {
                Lock lock;
                if (pInstance == 0) {
                    pInstance = // Step 3
                    operator new(sizeof(Singleton)); // Step 1
                    new (pInstance) Singleton; // Step 2
                }
            }
            return pInstance;
        }

这样的代码在多线程下就会有问题：假如线程A执行完Step 1和step 3后由于线程调度而被挂起，线程B就会得到一个未初始化过的Singleton对象，这显然是错误的。那么为什么编译器可能会生成这种“错误的”代码呢？编译器的理由：第一，这种代码的行为是一种标准定义的抽象机的observable behavior，亦即这种代码被抽象机认为是正确的。第二，这种代码可能具有更高的效率。 然而问题就出在第一点上：C++的抽象机是单线程的！它根本不知道会有多线程执行的情况！这样的代码在单线程的情况下显然没有问题，因而被抽象机认为是正确的；但这样的代码却不是线程安全的。对C++/C的这种基础问题我们当然无能为力，但如果我们能够对指令的顺序进行约束，DCLP仍然可以是正确的，可是C++/C语言并没有给我们这样的办法；这也是为什么线程包（如Posix Threads）会有部分是用汇编这种移植性不好的语言写的，它们需要用汇编语言来保证一些操作的顺序性，从而使它们在多线程环境下能够正常工作。对此，Peter A. Buhr甚至提出了Are Safe Concurrency Libraries Possible?，针对采用库来为C++加入多线程支持提出了质疑。关于使线程成为C++语言的一部分的提议，看这里。

也许最终C++会把线程会引入到语言中，就像Java和.Net CLI所做的那样；但是现在呢？DCLP当然是不能用了，而不用DCLP实现的Singleton，会大大增加锁的开销，因为每次instance函数调用的时候都会带来锁的操作。不过我们可以通过缓存Singleton对象指针来降低这个开销，不写：

            Singleton::instance()->transmogrify(); 
            Singleton::instance()->metamorphose();
            Singleton::instance()->transmute();            
        

而写：

            Singleton* const instance = Singleton::instance(); // cache instance pointer
            instance->transmogrify(); 
            instance->metamorphose();
            instance->transmute();            
        

甚至可以把instace指针存储到线程局部存储中，这样每个线程只会带来一次锁的开销。细想一下，DCLP的这个问题应该是由lazy initialization带来的，lazy initialization真的那么有用吗？eager initialization如何？即在程序开始运行时就初始化好资源。由于程序一开始都是单线程的，所以根本不用考虑同步问题，运行效率当然也最高。