Question

std :: atomic类型允许对变量进行原子访问，但有时我会这样做像非原子访问一样，例如当访问受互斥锁保护时。考虑一个允许两个多线程访问的位域类（通过插入）和单线程矢量化访问（通过operator | =）：

class Bitfield
{
    const size_t size_, word_count_;
    std::atomic<size_t> * words_;
    std::mutex mutex_;

public:

    Bitfield (size_t size) :
        size_(size),
        word_count_((size + 8 * sizeof(size_t) - 1) / (8 * sizeof(size_t)))
    {
        // make sure words are 32-byte aligned
        posix_memalign(&words_, 32, word_count_ * sizeof(size_t));
        for (int i = 0; i < word_count_; ++i) {
            new(words_ + i) std::atomic<size_t>(0);
        }
    }
    ~Bitfield () { free(words_); }

private:
    void insert_one (size_t pos)
    {
        size_t mask = size_t(1) << (pos % (8 * sizeof(size_t)));
        std::atomic<size_t> * word = words_ + pos / (8 * sizeof(size_t));
        word->fetch_or(mask, std::memory_order_relaxed);
    }
public:
    void insert (const std::set<size_t> & items)
    {
        std::lock_guard<std::mutex> lock(mutex_);
        // do some sort of muti-threaded insert, with TBB or #pragma omp
        parallel_foreach(items.begin(), items.end(), insert_one);
    }

    void operator |= (const Bitfield & other)
    {
        assert(other.size_ == size_);
        std::unique_lock<std::mutex> lock1(mutex_, defer_lock);
        std::unique_lock<std::mutex> lock2(other.mutex_, defer_lock);
        std::lock(lock1, lock2); // edited to lock other_.mutex_ as well
        // allow gcc to autovectorize (256 bits at once with AVX)
        static_assert(sizeof(size_t) == sizeof(std::atomic<size_t>), "fail");
        size_t * __restrict__ words = reinterpret_cast<size_t *>(words_);
        const size_t * __restrict__ other_words
            = reinterpret_cast<const size_t *>(other.words_);
        for (size_t i = 0, end = word_count_; i < end; ++i) {
            words[i] |= other_words[i];
        }
    }
};

注意operator | =非常接近我实际代码中的内容，但insert（std :: set）是只是想捕捉一个人可以

的想法

acquire lock;
make many atomic accesses in parallel;
release lock;

我的问题是：混合这种原子和非原子的最佳方法是什么访问？下面[1,2]的答案表明铸造错误（我同意）。但是，标准肯定允许这种明显安全的访问吗？

更一般地说，是否可以使用读写器锁并允许“读者”以原子方式读写，以及独特的“作者”非原子地读写？

参考

Answer 1

C ++ 11之前的标准C ++没有多线程内存模型。我认为标准中没有任何更改会定义非原子访问的内存模型，因此这些更改得到了与C ++ 11之前的环境类似的保证。

实际上理论上甚至比使用memory_order_relaxed更糟糕，因为非原子访问的交叉线程行为完全未定义，而不是多个可能的执行顺序，其中一个必须最终发生。

因此，要在混合原子访问和非原子访问时实现此类模式，您仍然必须依赖于特定于平台的非标准构造（例如，_ReadBarrier）和/或对特定硬件的深入了解。

更好的选择是熟悉memory_order枚举，并希望通过给定的代码和编译器实现最佳的汇编输出。最终结果可能是正确的，可移植的，并且不包含不需要的内存栅栏，但是如果你像我一样，你应该首先拆卸和分析几个错误的版本;并且仍然无法保证在所有代码路径上使用原子访问不会在不同的体系结构或不同的编译器上产生一些多余的围栏。

所以最好的实际答案是简单性。设计您的跨线程交互尽可能简单，而不会完全破坏可扩展性，响应性或任何其他神圣的牛;几乎没有共享的可变数据结构;并尽可能少地访问它们，总是原子地。

Answer 2

如果你能做到这一点，你就有（可能）一个线程使用原子访问读/写数据对象，另一个线程读/写同一个数据对象而不使用原子访问。这是一场数据竞赛，行为将是未定义的。

Answer 3

在C ++ 20中，有std::atomic_ref，它允许对非原子数据进行原子操作。

因此，您应该能够将words_声明为非原子size_t*，并在需要时使用std::atomic_ref<size_t>进行原子操作。但是请注意要求：

尽管存在任何引用对象的atomic_ref实例，但对象必须通过这些atomic_ref进行独占访问实例。没有一个由atomic_ref引用的对象的子对象该对象可以被任何其他atomic_ref对象同时引用。

upd：在这种特殊情况下，您可能还需要std::shared_mutex才能将原子的“读者”修改与非原子的“作者”修改分开。

如何在C ++中混合原子操作和非原子操作？

参考

3 个答案: