c# - Interlocked.CompareExchange 也应该是一个 volatile 变量吗？

Question

以下示例来自 MSDN .

public class ThreadSafe
{
    // Field totalValue contains a running total that can be updated
    // by multiple threads. It must be protected from unsynchronized 
    // access.
    private float totalValue = 0.0F;

    // The Total property returns the running total.
    public float Total { get { return totalValue; }}

    // AddToTotal safely adds a value to the running total.
    public float AddToTotal(float addend)
    {
        float initialValue, computedValue;
        do
        {
            // Save the current running total in a local variable.
            initialValue = totalValue;

            // Add the new value to the running total.
            computedValue = initialValue + addend;

            // CompareExchange compares totalValue to initialValue. If
            // they are not equal, then another thread has updated the
            // running total since this loop started. CompareExchange
            // does not update totalValue. CompareExchange returns the
            // contents of totalValue, which do not equal initialValue,
            // so the loop executes again.
        }
        while (initialValue != Interlocked.CompareExchange(ref totalValue, 
        computedValue, initialValue));
        // If no other thread updated the running total, then 
        // totalValue and initialValue are equal when CompareExchange
        // compares them, and computedValue is stored in totalValue.
        // CompareExchange returns the value that was in totalValue
        // before the update, which is equal to initialValue, so the 
        // loop ends.

        // The function returns computedValue, not totalValue, because
        // totalValue could be changed by another thread between
        // the time the loop ends and the function returns.
        return computedValue;
    }
}

不应该将 totalValue 声明为 volatile 以获得可能的最新值吗？我想如果您从 CPU 缓存中获取脏值，那么对 Interlocked.CompareExchange 的调用应该负责获取最新值并导致循环重试。 volatile 关键字可能会节省一个不必要的循环吗？

我猜想 volatile 关键字并不是 100% 必要的，因为该方法具有采用不支持 volatile 关键字的 long 等数据类型的重载。

Answer 1

不，volatile 根本没有帮助，当然也不是因为这个原因。它只会给第一次读取“获取”语义而不是有效地放松，但任何一种方式都会编译为运行加载指令的类似 asm。

if you get a dirty value from a CPU cache

CPU 缓存是连贯的，因此您从 CPU 缓存中读取的任何内容都是该行当前全局认可的值。 “脏”只是意味着它与 DRAM 内容不匹配，并且如果/当被驱逐时必须被写回。加载值也可以从存储缓冲区转发，对于该线程最近存储的尚未全局可见的值，但这很好，互锁方法是完全障碍，导致等待存储缓冲区耗尽。

如果您的意思是陈旧，那么不，这是不可能的，像 MESI 这样的缓存一致性协议(protocol)可以防止这种情况。这就是为什么如果高速缓存行已由该内核拥有(MESI 已修改或独占状态)，则 CAS 之类的互锁操作不会非常慢。见 Myths Programmers Believe about CPU Caches其中谈到了一些关于 Java volatile 的内容，我认为它类似于 C# volatile。

This C++11 answer还解释了一些关于缓存一致性和 asm 的内容。 (请注意，C++11 volatile 与 C# 显着不同，并且不暗示任何线程安全或排序，但仍然暗示 asm 必须执行加载或存储，而不是优化到一个寄存器。)

---

在非 x86 上，在您甚至 尝试 CAS 之前在初始读取之后运行额外的屏障指令(以赋予那些获取语义)只会减慢速度。 (在包括 x86-64 在内的 x86 上， volatile 读取编译为与普通读取相同的 asm，但它会阻止编译时重新排序)。

如果当前线程只是通过非互锁的 = 赋值写入内容，则无法将 volatile 读取优化为仅使用寄存器中的值。这也无济于事；如果我们只是存储了一些东西并在寄存器中记住了我们存储的内容，那么从存储缓冲区进行存储转发的加载在道德上等同于仅使用寄存器值。

大多数无锁原子的好用例是在争用较低的情况下，因此通常事情可以成功，而无需硬件等待很长时间来访问/拥有缓存行。因此，您希望尽可能快地制作无争议的案例。避免使用 volatile，即使在高度竞争的情况下可以从中受益，我认为无论如何都没有。

如果您曾经进行过任何普通存储(使用 = 进行赋值，而不是互锁 RMW)，volatile 也会对它们产生影响。如果 C# volatile 提供类似于 C++ memory_order_seq_cst 的语义，这可能意味着在此线程中的后续内存操作可以运行之前等待存储缓冲区耗尽。在 那种 的情况下，如果您不需要订购 wrt，那么您会大大减慢涉及商店的代码。其他负载/存储。如果您在此 CAS 代码之前进行了这样的存储，是的，您将等到该存储(以及所有以前的存储)在全局范围内可见才能尝试重新加载它。这将意味着 CPU 正在等待执行的重新加载 + CAS 很可能不必旋转，因为 CPU 将拥有该行的所有权，但我认为你会有效地从作为一部分的完整屏障中获得类似的行为一个联锁的 CAS。