Interlocked.CompareExchange 也应该是一个可变变量吗？

问题描述

以下示例来自 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 关键字可能会节省一个不必要的循环吗？

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

解决方法

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

如果你从 CPU 缓存中得到一个脏值

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

如果您的意思是陈旧，那么不，那是不可能的，像 MESI 这样的缓存一致性协议可以防止这种情况发生。这就是为什么如果缓存线已经由这个核心拥有（MESI 修改或独占状态），像 CAS 这样的互锁事物不会非常慢。请参阅 Myths Programmers Believe about CPU Caches，其中讨论了一些 Java volatiles，我认为它类似于 C# volatile。

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

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

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

无锁原子的大多数良好用例都是在争用较少的情况下，因此通常事情可以成功，而硬件不必等待很长时间才能访问/拥有缓存行。因此，您希望尽快处理无争议的案例。避免使用 volatile，即使在竞争激烈的情况下有任何好处，我认为无论如何都没有。

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

没关系，因为 Interlocked.CompareExchange 插入了内存屏障。

initialValue = totalValue;

此时 totalValue 可以是任何值。缓存中的陈旧值，刚刚被替换，谁知道。虽然 volatile 会阻止读取缓存的值，但该值可能会在读取后立即失效，因此 volatile 无法解决任何问题。

Interlocked.CompareExchange(ref totalValue,computedValue,initialValue)

此时我们有内存屏障来确保 totalValue 是最新的。如果它等于 initialValue，那么我们也知道当我们开始计算时，initialValue 不是过时的。如果它不相等，我们再试一次，因为我们已经发出了一个内存屏障，我们不会冒险在下一次迭代中获得相同的陈旧值。

编辑：我发现不太可能有任何性能差异。如果没有争用，值就没有理由过时。如果存在高争用，则时间将被需要循环支配。

您可以通过研究 source code 方法的 ImmutableInterlocked.Update 获得一些见解：

/// <summary>
/// Mutates a value in-place with optimistic locking transaction semantics
/// via a specified transformation function.
/// The transformation is retried as many times as necessary to win the
/// optimistic locking race.
/// </summary>
public static bool Update<T>(ref T location,Func<T,T> transformer)
    where T : class
{
    Requires.NotNull(transformer,"transformer");

    bool successful;
    T oldValue = Volatile.Read(ref location);
    do
    {
        T newValue = transformer(oldValue);
        if (ReferenceEquals(oldValue,newValue))
        {
            // No change was actually required.
            return false;
        }

        T interlockedResult = Interlocked.CompareExchange(ref location,newValue,oldValue);
        successful = ReferenceEquals(oldValue,interlockedResult);
        oldValue = interlockedResult; // we already have a volatile read
            // that we can reuse for the next loop
    }
    while (!successful);
    return true;
}

您可以看到该方法首先对 location 参数进行易失性读取。我认为有两个原因：

这个方法有一点点扭曲，它避免了 Interlocked.CompareExchange 操作，以防新值恰好与已经存储的值相同。
transformer 委托的计算复杂度未知，因此在潜在的陈旧值上调用它的成本可能比初始 Volatile.Read 的成本高得多。

c#c#compare-and-swap cpu-architecture lock-free volatile volatile

Interlocked.CompareExchange 也应该是一个可变变量吗？

问题描述

解决方法

相关问答