这里需要 volatile

Question

我正在实现一个“序列锁”类，以允许对数据结构进行锁定写入和无锁读取。

将包含数据的结构包含序列值，在写入时序列值将增加两次。写开始前一次，写完后一次。作者在读者之外的其他线程上。

这是保存数据副本的结构，序列值如下所示：

template<typename T>
struct seq_data_t
{
    seq_data_t() : seq(0) {};
    int seq;                     <- should this be 'volatile int seq;'?
    T data;
};

整个序列锁类在一个循环缓冲区中保存了这个结构的 N 个副本。写入器线程总是覆盖循环缓冲区中最旧的数据副本，然后将其标记为当前副本。写入被互斥锁。

读取功能未锁定。它尝试读取数据的“当前”副本。它在读取之前存储“seq”值。然后它读取数据。然后它再次读取 seq 值，并将其与第一次读取的值进行比较。如果 seq 值没有变化，则认为 read 是好的。

由于写入线程可以在读取发生时更改“seq”的值，我认为应该将 seq 变量标记为 volatile，以便读取函数在读取数据后显式读取该值。

读取函数如下所示：它将在写入者以外的线程上，并且可能在多个线程上。

    void read(std::function<void(T*)>read_function)
    {
        for (;;)
        {
            seq_data_type<T>* d = _data.current; // get current copy
            int seq1 = d->seq;      // store starting seq no
            if (seq1 % 2)           // if odd, being modified...
                continue;           //     loop back

            read_function(&d->data);  // call the passed in read function
                                      // passing it our data.


//??????? could this read be optimized out if seq is not volatile?
            int seq2 = d->seq;      // <-- does this require that seq be volatile?
//???????

            if (seq1 == seq2)       // if still the same, good.
                return;             // if not the same, we will stay in this
                                    // loop until this condition is met.
        }
    }

问题：

1) seq 在这种情况下必须是 volatile 吗？

2) 在具有多个成员的结构的上下文中，是否只有 volatile 限定变量 volatile，而不是其他成员？也就是说，如果我只在结构中将其标记为 volatile，那么它是否只是 'seq' volatile？

Answer 1

不要使用volatile，使用std::atomic<>。 volatile 旨在用于与内存映射硬件进行交互，std::atomic<> 旨在用于线程同步。为工作使用正确的工具。

良好的std::atomic<> 实现的特点：

• 它们对于标准整数类型是无锁的（通常是 long long 之前的所有类型）。

• 它们适用于任何数据类型，但将对复杂数据类型使用透明互斥体。

• 如果std::atomic<> 是无锁的，它会插入正确的内存屏障/栅栏以实现正确的语义。

• std::atomic<> 的操作无法优化，毕竟它们是为线程间通信而设计的。

Answer 2

正如Is volatile required here 所说，您不应该使用volatile 进行线程间同步。这就是原因（来自 C++ 标准）：

[..] volatile 是对实现避免激进的提示 涉及对象的优化，因为对象的值 可能会通过实现无法检测到的方式进行更改。[...]

volatile不做是确保一个线程中的操作顺序（尤其是内存读取和写入）在其他线程中以相同的顺序可见（due to superscalar architecture of modern CPUs ) .为此，您需要 内存屏障 或 内存栅栏（同一事物的不同名称）。以下是一些您可能会觉得有用的阅读材料：

• What is a memory fence?
• 内存屏障的内存顺序 - http://en.cppreference.com/w/cpp/atomic/memory_order

Answer 3

1) seq 在这种情况下必须是 volatile 吗？

当然，来自seq 的读取很可能会使用-O3 进行优化。所以是的，您应该提示编译器 seq 可能会在其他地方（即在其他线程中）使用 volatile 关键字进行更改。

对于 x86 架构，这就足够了，因为 x86 内存模型（几乎）是顺序的，如 on Wikipedia 所述。

为了可移植性，您最好使用原子原语。

2) 在具有多个成员的结构的上下文中，是否只有 volatile 限定变量 volatile，而不是其他成员？也就是说，如果我只在结构中将其标记为 volatile，那么它是否只是 'seq' volatile？

不，data 也应该标记为 volatile（或者您也应该使用原子原语）。基本上，循环：

for (;;) {
    seq1 = d->seq;
    read_data(d->data);
    seq2 = d->seq;
    if (seq1 == seq2)
        return;
}

相当于：

read_data(d->data);
return;

因为代码中唯一可观察到的效果是read_data() 调用。

请注意，-O3 编译器很可能会非常广泛地重新排序您的代码。因此，即使对于 x86 架构，您也需要在第一个 seq 读取、data 读取和第二个 seq 读取之间设置一个编译器屏障，即：

for (;;)
    {
        seq_data_type<T>* d = _data.current;
        int seq1 = d->seq;
        COMPILER_BARRIER();
        if (seq1 % 2)
            continue;

        read_function(&d->data);
        COMPILER_BARRIER();
        int seq2 = d->seq;
        if (seq1 == seq2)
            return;
    }
}

最轻量级的编译器屏障是：

 #define COMPILER_BARRIER asm volatile("" ::: "memory")

对于 C++11，您可以改用 atomic_signal_fence()。

总的来说，使用std::atomic<> 更安全：它更便携，而且不像volatiles 和编译器障碍那么棘手......

还请查看 Herb Sutter 名为“原子武器”的演示文稿，其中解释了编译器和其他内存屏障以及原子：https://channel9.msdn.com/Shows/Going+Deep/Cpp-and-Beyond-2012-Herb-Sutter-atomic-Weapons-1-of-2

Answer 4

如果代码是可移植的，volatile 是不合适的，除非处理内存映射的硬件。我再说一遍，从不合适。 Microsoft Visual C++（x86 或 x86/64）使用默认编译器标志，添加了一些标准中没有的内存顺序保证。因此，使用该编译器并打开非标准行为，volatile 可能适用于某些多线程操作。

使用标准的多线程支持，例如std::atomic、std::mutex、std::condition_variable等

Answer 5

实际的问题是在写入时从某些内存（在这种情况下为data）读取被描述为数据竞争，因此程序的行为是未定义的。即使您将seq 设为原子，从data 读取仍会导致数据竞争。一种可能的正确方法是也锁定读取。

回答您关于volatile 是否解决了从seq 读取被优化的问题：编译器不会从seq 中删除两个读取，但这并不能解决任何问题，因为seq 仍然很容易发生到数据竞争，也会导致未定义的行为。 volatile 不是这个意思，所以不要滥用它。

Answer 6

答案是：视情况而定。您是否有理由怀疑您的编译器不知道从回调函数中执行的代码可以随时执行？在托管系统编译器（Windows/Linux 等）上通常不是这种情况，但在嵌入式系统中很可能是这种情况，尤其是裸机或 RTOS。

这个话题有点像死马，例如here：

volatile 的作用：

• 如果变量是从外部源（硬件寄存器、中断、不同线程、回调函数等）修改的，则保证变量中的值是最新的。
• 阻止对变量的读/写访问的所有优化。
• 当编译器没有意识到线程/中断/回调被程序调用时，防止可能发生在多个线程/中断/回调函数之间共享的变量上的危险优化错误。 （这在各种有问题的嵌入式系统编译器中尤为常见，当您遇到此错误时，很难追查到。）

volatile 没有：

• 它不保证原子访问或任何形式的线程安全。
• 它不能用来代替互斥体/信号量/保护/临界区。它不能用于线程同步。

volatile 可以做什么或不可以做什么：

• 编译器可能会也可能不会实现它以提供内存屏障，以防止在多核环境中出现指令缓存/指令管道/指令重新排序问题。你永远不应该假设 volatile 会为你做这件事，除非编译器文档明确声明它会这样做。