C ++中高效的线程安全单例

单例课程的通常模式如下

static Foo &getInst()
{
  static Foo *inst = NULL;
  if(inst == NULL)
    inst = new Foo(...);
  return *inst;    
}

但是，据我了解，此解决方案不是线程安全的，因为1）Foo的构造函数可能被多次调用（可能无关紧要），并且2）inst在返回到另一个线程之前可能未完全构建。

一种解决方案是在整个方法周围包裹一个互斥体，但是在我真正需要同步后很长一段时间内，我就要为同步开销付出代价。另一种方法是

static Foo &getInst()
{
  static Foo *inst = NULL;
  if(inst == NULL)
  {
    pthread_mutex_lock(&mutex);
    if(inst == NULL)
      inst = new Foo(...);
    pthread_mutex_unlock(&mutex);
  }
  return *inst;    
}

这是正确的方法，还是我应该注意的陷阱？例如，是否可能发生任何静态初始化顺序问题，即inst总是在首次调用getInst时始终保证为NULL？

您的解决方案称为“双重检查锁定”，并且您编写的方法也不是线程安全的。

这迈尔斯/ Alexandrescu的论文解释了为什么-但该文件也被广泛误解。它开始了“双重检查锁定在C ++中是不安全的”模因-但它的实际结论是，可以安全地实现C ++中的双重检查锁定，只需要在不明显的地方使用内存屏障。

本文包含伪代码，该伪代码演示了如何使用内存屏障安全地实现DLCP，因此对您的实现进行纠正应该不难。

如果您使用的是C ++ 11，这是执行此操作的正确方法：

Foo& getInst()
{
    static Foo inst(...);
    return inst;
}

根据新标准，不再需要关心这个问题。对象初始化将仅由一个线程进行，其他线程将等待其完成。或者，您可以使用std :: call_once。（更多信息在这里）

Herb Sutter讨论了CppCon 2014中的双重检查锁定。

以下是基于此我在C ++ 11中实现的代码：

class Foo {
public:
    static Foo* Instance();
private:
    Foo() {}
    static atomic<Foo*> pinstance;
    static mutex m_;
};

atomic<Foo*> Foo::pinstance { nullptr };
std::mutex Foo::m_;

Foo* Foo::Instance() {
  if(pinstance == nullptr) {
    lock_guard<mutex> lock(m_);
    if(pinstance == nullptr) {
        pinstance = new Foo();
    }
  }
  return pinstance;
}

您还可以在此处检查完整的程序：http : //ideone.com/olvK13

采用 pthread_once，可以确保初始化函数自动运行一次。

（在Mac OS X上，它使用自旋锁。不知道其他平台的实现。）

TTBOMK，唯一无需执行锁定即可保证线程安全的方法是在启动线程之前初始化所有单例。

您的替代方法称为“双重检查锁定”。

可能存在可以在其中运行的多线程内存模型，但是POSIX不能保证一种

ACE单例实现使用双重检查锁定模式来确保线程安全，您可以根据需要引用它。

您可以在此处找到源代码。

TLS在这里工作吗？https://zh.wikipedia.org/wiki/Thread-local_storage#C_and_C++

例如，

static _thread Foo *inst = NULL;
static Foo &getInst()
{
  if(inst == NULL)
    inst = new Foo(...);
  return *inst;    
 }

但是我们还需要一种明确删除它的方法，例如

static void deleteInst() {
   if (!inst) {
     return;
   }
   delete inst;
   inst = NULL;
}

该解决方案不是线程安全的，因为该语句

inst = new Foo();

可以由编译器分解为两个语句：

声明1：inst = malloc（sizeof（Foo））;
声明2：inst-> Foo（）;

假设在由一个线程执行语句1之后发生上下文切换。并且第二线程也执行该getInstance()方法。然后，第二个线程将发现“ inst”指针不为空。因此，第二线程将返回指向未初始化对象的指针，因为第一线程尚未调用构造函数。