通过 std::unique_ptr 的 LazyArray 模板，这是双重检查习语的正确实现吗？

Question

此代码是否使用 C++11 atomic 安全地实现了双重检查习惯用法？ 我在“C++ 编程语言第 4 版”中看到。一个使用atomic<bool> 的示例，我尽力保持相同，但我不自信。另外，这个可以改进吗？

由于once_flag 的存储开销，我想避免使用call_once。

这个“LazyArray”是为了减少内存而编写的，目的是用对客户端代码的最小更改来替换数组（预计只有一小部分元素会被访问）。从多个线程访问数组是不争的事实，并且由于性能的原因，广泛的锁定会出现问题。

/**
 * Lazy creation of array elements.
 * They will only be created when they are referenced.
 *
 * This "array" does not support iteration because it can have holes
 *
 * Array bounds isn't checked to keep it fast.
 * Destruction of the array destroys all the T objects (via the unique_ptr d'tor)
 */

template<class T, size_t size>
class LazyArray
{
    typedef LazyArray<T, size> mytype;
public:
    // copying is not allowed (unlike regular arrays)
    LazyArray(const LazyArray&) = delete;
    LazyArray& operator=(const LazyArray&) = delete;

    LazyArray(){}

    T& operator[](size_t i)
    {
        return at(i);
    }

    const T& operator[](size_t i) const
    {
        return const_cast<mytype *>(this)->at(i);
    }
private:
    using guard = std::lock_guard<std::mutex>;

    // get T object at index i by reference
    T& at(size_t i) // only non-const variant is implemented, const version will use const_cast
    {
        auto &p = m_array[i];
        std::atomic<T*> ap(p.get());

        if(!ap) // object not created yet
        {
            guard g(mtx);
            ap = p.get();
            if(!ap)
                p.reset(new T);
        }
        return *p;
    }

    std::unique_ptr<T> m_array[size];
    std::mutex mtx;
};

Answer 1

理论上不会。

支票：

        std::atomic<T*> ap(p.get());
        if(!ap) // object not created yet

应该获取对应这个版本：

                p.reset(new T);

事实上并非如此。

它可能会如何失败：

1. 对象构造的某些部分 new T 在其他线程看到 p 分配了新值后可能对它可见
2. 分配 p.reset 可能会被破坏，因为它是非原子的

可能在某些平台上。

1. 如果存储可以在其他存储之后重新排序（在 x86 上不会发生），或者如果编译器决定自行交换这些存储（不太可能），则会发生这种情况
2. 指针大小的变量写入不会被破坏

---

使用std::atomic 解决这两个问题：

   std::atomic<T*> m_array[size];

当然，您必须手动删除 T*。 我建议基于std::atomic<T*> 创建atomic_unique_ptr 并在那里使用它