在双重检查锁定模式中获取障碍

Question

在C++ and the Perils of Double-Checked Locking中，作者给出了一个如何正确实现模式的例子。

Singleton* Singleton::instance () {
   Singleton* tmp = pInstance;
   ... // insert memory barrier (1)
   if (tmp == 0) {
      Lock lock;
      tmp = pInstance;
      if (tmp == 0) {
         tmp = new Singleton;
         ... // insert memory barrier (2)
         pInstance = tmp;
      }
   }
   return tmp;
}

但是，我无法弄清楚，如果第一个记忆障碍必须在Singleton* tmp = pInstance;之后？ （编辑：要清楚，我明白需要屏障。我不明白的是，如果必须在分配tmp之后出现）如果是这样，为什么？以下是无效的吗？

Singleton* Singleton::instance () {
   ... // insert memory barrier (1)
   if (pInstance == 0) {
      Lock lock;
      if (pInstance == 0) {
         Singleton* tmp = new Singleton;
         ... // insert memory barrier (2)
         pInstance = tmp;
      }
   }
   return pInstance;
}

Answer 1

这是必不可少的。否则，在复制之前CPU可能会预取if之后发生的读取，这将是一场灾难。在pInstance不为NULL并且我们没有获取任何锁的情况下，您必须保证在读取代码中的pInstance之后发生的读取不会重新排序到阅读pInstance。

考虑：

Singleton* tmp = pInstance;
if (tmp == 0) { ... }
return tmp->foo;

如果CPU在tmp->foo之前读取tmp会怎样？例如，CPU可以将其优化为：

bool loaded = false;
int return_value = 0;

if (pInstance != NULL)
{ // do the fetch early
     return_value = pInstance->foo;
     loaded = true;
}

Singleton* tmp = pInstance;
if (tmp == 0) { ... }

return loaded ? return_value : tmp->foo;

注意这是做什么的？如果指针是非NULL，则tmp->foo的读取现在已移至检查之前。这是CPU可能执行的完全合法的内存预取优化（推测读取）。但它对双重检查锁定的逻辑绝对是灾难性的。

在我们看到if (tmp == 0)为非NULL之前，pInstance之后的代码不能预取任何内容，这一点至关重要。因此，您需要一些东西来阻止CPU重新组织代码的内存操作，如上所述。记忆障碍就是这样做的。

Answer 2

为什么你还在谈论2004年的论文？ C ++ 11保证静态变量只初始化一次。这是你的全面工作，100％正确的单身人士（当然，这是一个反模式的单身人士）：

static TheTon& TheTon::instance() {
    static TheTon ton;
    return ton;
}