关于c++:C单例模式双重锁漏洞内存读写的乱序执行编译器问题

阐明

首先解释为什么会呈现这个问题：在懒汉模式下存在多线程不平安的问题（饿汉模式是线程平安的），为了解决这个问题，首先采纳的是利用C++中lock_guard类，这个类实现原理采纳RAII，不必手动治理unlock。

class singleton {
private:
    singleton() {}
    static singleton *p;
    static mutex lock_;
public:
    static singleton *instance();
};

singleton *singleton::p = nullptr;

singleton* singleton::instance() {
    lock_guard<mutex> guard(lock_);
    if (p == nullptr)
        p = new singleton();
    return p;
}

解决了懒汉模式的这个问题，又呈现了性能问题：每次执行都会有加锁开释锁， 而这个步骤只有在第一次new Singleton()才是有必要的.

因而引出DCL

双重查看锁模式

class singleton {
private:
    singleton() {}

    static singleton *p;
    static mutex lock_;
public:
    singleton *instance();

    // 实现一个内嵌垃圾回收类
    class CGarbo
    {
    public:
        ~CGarbo()
        {
            if(singleton::p)
                delete singleton::p;
        }
    };
    // 2022-4-21
    // 所谓的垃圾回收，就是定义一个动态的类，类外面只有一个办法，这个办法查看singleton::p是否是空，不是空，执行delete
    // 因为是动态的办法，程序会主动的开释该对象，从而达到主动回收的机制。
    static CGarbo Garbo; // 定义一个动态成员变量，程序完结时，零碎会主动调用它的析构函数从而开释单例对象
};

singleton *singleton::p = nullptr;
singleton::CGarbo Garbo;

singleton* singleton::instance() {
    if (p == nullptr) {
        lock_guard<mutex> guard(lock_);
        if (p == nullptr)
            p = new singleton();
    }
    return p;
}

留神咱们的题目是单例模式双重锁破绽。

DCLP的关键在于，大多数对instance的调用会看到p是非空的，因而甚至不必尝试去初始化它。因而，DCLP在尝试获取锁之前查看p是否为空。只有当查看胜利（也就是p还没有被初始化）时才会去取得锁，而后再次查看p是否依然为空（因而命名为双重查看锁）。第二次查看是必要，因为就像咱们刚刚看到的，很有可能另一个线程偶尔在第一次查看之后，取得锁胜利之前初始化p。

看起来上述代码十分美妙，可是过了相当一段时间后，才发现这个破绽，起因是：内存读写的乱序执行(编译器问题)。

再次思考初始化p的那一行：

p = new singleton;
这条语句会导致三个事件的产生：

调配可能存储singleton对象的内存；
在被调配的内存中结构一个singleton对象；
让p指向这块被调配的内存。
可能会认为这三个步骤是按程序执行的，但实际上只能确定步骤1是最先执行的，步骤2，3却不肯定。问题就呈现在这。

线程A调用instance，执行第一次p的测试，取得锁，依照1,3,执行，而后被挂起。此时p是非空的，然而p指向的内存中还没有Singleton对象被结构。
线程B调用instance，断定p非空， 将其返回给instance的调用者。调用者对指针解援用以取得singleton，噢，一个还没有被结构出的对象。bug就呈现了。
DCLP可能良好的工作仅当步骤一和二在步骤三之前被执行，然而并没有办法在C或C++中表白这种限度。这就像是插在DCLP心脏上的一把匕首：咱们须要在绝对指令程序上定义限度，然而咱们的语言没有给出表白这种限度的办法。

第一种解决办法：memory barrier指令

第一种实现：

基于operator new+placement new，遵循1,2,3执行程序顺次编写代码。

// method 1 operator new + placement new
singleton *instance() {
    if (p == nullptr) {
        lock_guard<mutex> guard(lock_);
        if (p == nullptr) {
            singleton *tmp = static_cast<singleton *>(operator new(sizeof(singleton)));
            new(tmp)singleton();
            p = tmp;
        }
    }
    return p;
}

第二种实现：

基于间接嵌入ASM汇编指令mfence，uninx的barrier宏也是通过该指令实现的。

#define barrier() __asm__ volatile ("lwsync")
singleton *singleton::instance() {
    if (p == nullptr) {
        lock_guard<mutex> guard(lock_);
        barrier();
        if (p == nullptr) {
            p = new singleton();
        }
    }
    return p;
}