将 Interlocked.CompareExchange 与类一起使用

Question

System.Threading.Interlocked.CompareExchange 运算符提供 Compare-And-Swap 操作的原子（因此线程安全）C# 实现。

例如 int i = 5; Interlocked.CompareExchange(ref i, 10, 5); 执行此命令后，int i 的值 = 10。并且比较和交换以原子方式发生（单个操作）。

当我尝试将其与类实例一起使用时，比较失败并且不交换值。

   public class X
   {
       public int y;
       public X(int val) { y = val; }
   }

现在，当我执行

    X a = new X(1);
    X b = new X(1);
    X c = new X(2);
    Interlocked.CompareExchange<X>(ref a, c, b);

比较和交换操作时，会失败。因此，我重写了类 X 的 Equals 和 == 运算符

    public override bool Equals(object obj) { return y == ((X) obj).y; }

，现在我得到 Interlocked.Equals(a,b) 作为 true，但是 CompareExchange 操作仍然失败。

有什么方法可以做到这一点吗？我想比较两个类实例，并根据比较结果为其中一个实例分配一个值。

Answer 1

Interlocked.CompareExchange 的正常使用是这样的模式：

SomeType oldValue, newValue;
do
{
  oldValue = someField;
  newValue = [Computation based on oldValue]
} while (CompareExchange(ref someField, newValue, oldValue) != oldValue);

基本思想是，如果该字段在读入 oldValue 的时间和读取该字段的时间之间没有发生更改， CompareExchange 得到处理，然后 newValue 将保存应存储到字段中的值。如果在计算过程中发生其他变化，则计算结果将被放弃，并且将使用新值重复计算。假设计算速度很快，最终的效果本质上是允许任意计算的行为就像它是原子的一样。

如果您想使用 Equals() 相等性执行 Compare-Exchange 式操作，您可能应该执行以下操作：

SomeType newValue = desired new value;
SomeType compareValue = desired comparand;
SomeType oldValue;
do
{
  oldValue = someField;
  if (!oldValue.Equals(compareValue) return oldValue;
} while (CompareExchange(ref someField, newValue, oldValue) != oldValue);
return oldValue;

请注意，如果 someField 持有对某个对象的引用，该对象将比较等于 compareValue，并且在比较期间将其更改为保存对不同对象的引用，将根据 compareValue 检查新值。将重复该过程，直到比较报告从字段字段读取的值不等于比较数，或者直到字段中的值对于 Equals() 和CompareExchange方法来完成。

Answer 2

不，这是不可能的。

Interlocked.CompareExchange 基本上直接映射到能够自动比较和交换内存地址内容的汇编指令。我相信在 32 位模式下，可以使用 64 位版本的指令（以及 32 位和 16 位版本），而在 64 位模式下，我认为可以使用 128 位版本。但仅此而已。 CPU 没有“基于其特定 Equals 函数交换 .NET 类”指令。

如果您想使用任意相等函数交换任意对象，您必须自己使用锁或其他同步机制来完成。

Interlocked.CompareExchange重载 > 函数适用于对象引用，但由于上述原因它使用引用相等性。它只是比较引用，然后交换它们。

根据您的评论，使用结构无法解决问题。同样，CPU 只能原子地比较和交换某些固定大小的值，并且它没有抽象数据类型的概念。可以使用引用类型，因为引用本身具有有效的大小，并且可以由 CPU 与另一个引用进行比较。但 CPU 对引用指向的对象一无所知。

Answer 3

我觉得整个页面存在一些弥漫性的混乱。首先，评论员认为该问题包含一个危险的假设是正确的：

int i = 5; 
Interlocked.CompareExchange(ref i, 10, 5);

执行此命令后，int i 的值将 = 10。

否，仅当 i 的值在此期间未更改为 5 以外的值时才有效。尽管这在此处显示的代码中似乎不太可能，但使用 CompareExchange 的全部意义在于它应该是可能的，因此这是这里的关键技术问题。我担心OP可能不理解Interlocked.CompareExchange的目的，特别是因为他没有检查返回值（见下文）。

现在原始问题的文本是：

“有什么方法可以做到这一点吗？我想比较两个类实例，并根据比较结果为其中一个实例分配一个值。”

由于“this”这个词没有可行的先行词，我们也许应该将后面的句子视为问题，释义为：

“有没有办法比较两个类实例并为其中一个实例分配一个值基于比较？”

不幸的是，这个问题仍然不清楚，或者可能与原子操作关系不大。首先，你不能“为[类实例]分配一个值”。这根本没有意义。对类实例的引用是一个值，但无法将任何内容“分配”给类实例本身。这是与值类型的一个主要区别，值类型可以相互分配。您可以使用 new 运算符创建一个实例，但您仍然只能获得对其的引用。同样，这些可能看起来像是技术细节，但如果问题确实涉及无锁并发，那么它们就是关键点。

接下来，Interlocked.CompareExchange 函数不会根据值来确定存储位置，而是有条件地将值存储到（给定的）位置 strong>，意味着它要么存储值（成功），要么保持存储位置不变（失败），同时可靠地指示发生了哪一种情况。

这意味着短语“基于比较”对于替代行动应该是什么是不完整的。看看OP问题的前一部分，一个最好的猜测可能是问题正在寻求有条件地操纵实例引用，而原子性是一个转移注意力的东西。这很难知道，因为如上所述，CompareExchange（用于陈述问题）不会在内存中“交换​​”两个值，它只可能“存储”一个值。

X a = new X(1);
X b = new X(1);
X c = new X(2);

if (a.y == b.y)
    a = c;
else
    // ???

通过 Equals 重载，这可以被简化：

if (a == b)
    a = c;
else
    // ???

OP 关注内部字段 y 的相等性似乎增加了对问题的这种解释走上正确轨道的可能性。但显然，这些答案与 Interlocked.CompareExchange 无关。我们需要更多信息来了解为什么 OP 认为赋值必须是原子的。

因此，我们应该注意到，也可以原子地交换现有实例中的 y 值：

var Hmmmm = Interlocked.CompareExchange(ref a.y, c.y, b.y);

或者交换实例引用，现在应该很明显了引用相等仅根据“引用相等”来定义：

var Hmmmm = Interlocked.CompareExchange(ref a, c, b);

从这里开始，问题需要更加清晰。例如，要重述本页其他地方的评论，但更强烈的是，不检查 Interlocked.CompareExchange 的返回值是一个错误。

这就是我在上面的示例中存储返回值的原因，以及我认为它的名称合适的原因。不对返回值进行分支就是不理解无锁（“乐观”）并发的基本原理，对此的讨论超出了本问题的范围。有关精彩的介绍，请参阅 Joe Duffy 撰写的 Windows 上的并发编程。

最后，我认为 OP 不太可能真正需要基于任意考虑以原子方式存储类引用，因为这是一个极其专业的操作，通常只在全面的无锁系统设计的关键时刻才需要。但是（与另一个答案相反）按照@supercat所描述的方式当然是可能的。

因此，请不要认为您无法在 .NET 中编写无锁代码，或者类引用对于 Interlocked 操作来说是任何类型的问题；事实上，情况恰恰相反：如果您实际上需要执行一个原子操作，在两个不同的存储位置之间进行选择或以其他方式影响多个内存位置，那么使用一种设计很简单，其中纠缠的位置被包装在一个简单的包含class 然后为您提供一个可以以无锁方式原子交换的引用。无锁编码在 .NET 中轻而易举，因为在乐观路径失败的罕见情况下，内存管理重试对象的麻烦更少。

可以这么说，根据我的经验，无锁并发的任何重要方面都是我无法在 C#/.NET/CLR 中实现的，即使有时有点粗糙围绕边缘，正如您可以从 https://stackoverflow.com/a/5589515/147511。