[转载] C++ DCLP 单例模式

转载于:https://my.oschina.net/shou1156226/blog/1143066
https://blog.csdn.net/weixin_33757911/article/details/91544531

1. 什么是双重检查锁定？

假设你有一个类，它实现了著名的单例模式，现在你想让它变得线程安全。显然的一个方法就是通过增加一个锁来保证互斥共享。这样的话，如果有两个线程同时调用了Singleton::getInstance，将只有其中之一会创建这个单例。

Singleton* Singleton::getInstance() { 

    Lock lock; 

    // scope-based lock, released automatically when the function returns 

    if (m_instance == NULL) {

        m_instance = new Singleton;

    } return m_instance;

}

这是完全合法的方法，但是一旦单例被创建，实际上就不再需要锁了。锁不一定慢，但是在高并发的条件下，不具有很好的伸缩性。

Singleton* Singleton::getInstance() {

    Singleton* tmp = m_instance; ... // insert memory barrier 

    if (tmp == NULL) {

        Lock lock;

        tmp = m_instance; 

        if (tmp == NULL) {

            tmp = new Singleton; ... // insert memory barrier 

            m_instance = tmp;

        }

    } return tmp;

}

双重检查锁定模式是由此得名：在单例指针m_instance为NULL的时候，我们仅仅使用了一个锁，这个锁使偶然访问到该单例的第一组线程继续下去。而在锁的内部，m_instance被再次检查，这样就只有第一个线程可以创建这个单例了。

这与可运行的实现非常相近。只是在突出显示的几行漏掉了某种内存屏障。在作者写这篇论文的时候，还没有填补此项空白的轻便的C/C++函数。现在，C++11已经有了。

2. 用 C++11 获得与释放屏障

你可以用获得与释放屏障 安全的完成上述实现，在我以前的文章中我已经详细的解释过这个主题。不过，为了让代码真正的具有可移植性，你还必须要将m_instance包装成原子类型，并且用放松的原子操作（译注：即非原子操作）来操作它。这里给出的是结果代码，获取与释放屏障部分高亮了。

std::atomic Singleton::m_instance;

std::mutex Singleton::m_mutex;

 

Singleton* Singleton::getInstance() {

    Singleton* tmp = m_instance.load(std::memory_order_relaxed); 

    std::atomic_thread_fence(std::memory_order_acquire); 

    if (tmp == nullptr) {

        std::lock_guard lock(m_mutex);

        tmp = m_instance.load(std::memory_order_relaxed); 

        if (tmp == nullptr) {

            tmp = new Singleton; 

            std::atomic_thread_fence(std::memory_order_release); 

            m_instance.store(tmp, std::memory_order_relaxed);

        }

    } 

    return tmp;

}

即使是在多核系统上，它也可以令人信赖的工作，因为内存屏障在创建单例的线程与其后任何跳过这个锁的线程之间，创建了一种同步的关系。Singleton::m_instance充当警卫变量，而单例本身的内容充当有效载荷。

image.png

所有那些有缺陷的DCLP实现都忽视了这一点：如果没有同步的关系，将无法保证第一个线程的所有写操作——特别是，那些在单例构造器中执行的写操作——可以对第二个线程可见，虽然m_instance指针本身是可见的！第一个线程具有的锁也对此无能为力，因为第二个线程不必获得任何锁，因此它能并发的运行。

3. 使用c++ 11低级排序约束

C++11的获取与释放屏障可以正确的实现DCLP，而且应该能够针对当今大多数的多核设备，生成优化的机器代码，但是它们似乎不是很时兴。在C++11中获得同等效果的首选方法，应该是使用基于低级排序约束的原子操作。正如我先前所说，一条写释放(write-release)可以同步于一条读获取(read-acquire)。

std::atomic Singleton::m_instance;

std::mutex Singleton::m_mutex;

 

Singleton* Singleton::getInstance() { 

    Singleton* tmp = m_instance.load(std::memory_order_acquire); 

    if (tmp == nullptr) {

        std::lock_guard lock(m_mutex);

        tmp = m_instance.load(std::memory_order_relaxed); 

        if (tmp == nullptr) {

            tmp = new Singleton; 

            m_instance.store(tmp, std::memory_order_release); 

        }

    } 

    return tmp;

}

从技术上说，这种无锁的同步形式，并不像独立屏障的形式那么严格；上面的操作只是意味着阻止它们自己周围的内存重新排序，这与独立的屏障不同，后者意味着阻止所有相邻的操作的特定类型的内存重排序。尽管如此，在x86/64, ARMv6/v7,以及 PowerPC架构上，对于这两种形式,可能的最好代码都是相同的。

4. 使用 C++11的顺序一致原子

C++11提供了一种完全不同的方法来写无锁代码。如果在所有原子库函数上，你忽略了可选的std::memory_order参数，那么默认值std::memory_order_seq_cst就会将所有的原子变量转变为顺序一致的(sequentially consistent)(SC)原子。通过SC原子，只要不存在数据竞争，整个算法就可以保证是顺序一致的。SC原子Java 5+中的volatile变量非常相似。这里是使用SC原子的一个DCLP实现。如之前所有例子一样，一旦单例被创建，第二行高亮将与第一行同步。

std::atomic Singleton::m_instance;

std::mutex Singleton::m_mutex;

 

Singleton* Singleton::getInstance() { 

    Singleton* tmp = m_instance.load(); 

    if (tmp == nullptr) {

        std::lock_guard lock(m_mutex);

        tmp = m_instance.load(); 

        if (tmp == nullptr) {

            tmp = new Singleton; 

            m_instance.store(tmp); 

        }

    } 

    return tmp;

}

SC原子被认为可以使程序员更容易思考。其代价是生成的机器代码似乎比之前的例子效率要低。

5. 使用C++11中的静态初始化器

如果你想得到一个线程安全的实例，C++11不允许你跳过以上的所有步骤。你可以简单使用一个静态初始化器。

Singleton& Singleton::getInstance() { 

    static Singleton instance; 

    return instance;

}

就个人而言，我常常想，如果是需要初始化一个单例，最好是在程序启动的时候做这个事情。但是显然DCLP可以拯救你于泥潭。而且在实际的使用中，你还可以用DCLP来将任意数值类型存储到一个无锁的哈希表。