如何在 C# 中以原子方式交换 2 个整数？

Question

x86 asm xchg 指令的 C# 等效项是什么（如果有）？

使用该命令，imo 是一个真正的交换（不像Interlocked.Exchange），我可以简单地原子交换两个整数，这是我真正想要做的。

更新：

基于我的建议的示例代码。变量后缀“_V”被修饰为 volatile：

// PART 3 - process links
// prepare the new Producer
address.ProducerNew.WorkMask_V = 0;
// copy the current LinkMask
address.ProducerNew.LinkMask_V = address.Producer.LinkMask_V;
// has another (any) thread indicated it dropped its message link from this thread?
if (this.routerEmptyMask[address.ID] != 0)
{
  // allow all other bits to remain on (i.e. turn off now defunct links)
  address.ProducerNew.LinkMask_V &= ~this.routerEmptyMask[address.ID];
  // reset
  this.routerEmptyMask[address.ID] = 0;
}
// PART 4 - swap
address.ProducerNew = Interlocked.Exchange<IPC.Producer>(ref address.Producer, address.ProducerNew);
// PART 5 - lazily include the new links, make a working copy
workMask = address.Producer.LinkMask_V |= address.ProducerNew.WorkMask_V;

注意惰性更新。

Answer 1

这是 CLR 中 Interlocked.Exchange() 的可能实现，从 SSCLI20 源复制：

请注意，函数名称中的 UP 表示 UniProcessor。这在 SMP / 多核系统上不是原子的。此实现仅由 CLR 在单核系统上使用。

FASTCALL_FUNC ExchangeUP,8
        _ASSERT_ALIGNED_4_X86 ecx
        mov     eax, [ecx]      ; attempted comparand
retry:
        cmpxchg [ecx], edx
        jne     retry1          ; predicted NOT taken
        retn
retry1:
        jmp     retry
FASTCALL_ENDFUNC ExchangeUP

它优于使用 XCHG，因为此代码无需总线锁即可工作。 xchg 有一个隐含的 lock 前缀，因此与 xadd 或 cmpxchg 不同，它根本不能省略，单核系统仍然在一条指令中执行操作以使其相对于中断具有原子性（和因此单处理器上的其他线程）。

奇怪的跳转代码是在分支预测数据不可用的情况下进行的优化。毋庸置疑，在芯片制造商的慷慨帮助下，试图做得比优秀的软件工程师多年来深思熟虑的工作做得更好是一项艰巨的任务。

Answer 2

这是一个奇怪的想法。我不知道您是如何设置数据结构的。但是，如果您可以将两个int 值存储在long 中，那么我认为您可以原子地交换它们。

例如，假设您以下列方式包装了两个值：

class SwappablePair
{
    long m_pair;

    public SwappablePair(int x, int y)
    {
        m_pair = ((long)x << 32) | (uint)y;
    }

    /// <summary>
    /// Reads the values of X and Y atomically.
    /// </summary>
    public void GetValues(out int x, out int y)
    {
        long current = Interlocked.Read(ref m_pair);

        x = (int)(current >> 32);
        y = (int)(current & 0xffffffff);
    }

    /// <summary>
    /// Sets the values of X and Y atomically.
    /// </summary>
    public void SetValues(int x, int y)
    {
        // If you wanted, you could also take the return value here
        // and set two out int parameters to indicate what the previous
        // values were.
        Interlocked.Exchange(ref m_pair, ((long)x << 32) | (uint)y);
    }
}

那么您似乎可以添加以下 Swap 方法以“原子地”产生一对交换对（实际上，我不知道是否真的可以说以下 is 原子; 它更像是产生与原子交换相同的结果）。

/// <summary>
/// Swaps the values of X and Y atomically.
/// </summary>
public void Swap()
{
    long orig, swapped;
    do
    {
        orig = Interlocked.Read(ref m_pair);
        swapped = orig << 32 | (uint)(orig >> 32);
    } while (Interlocked.CompareExchange(ref m_pair, swapped, orig) != orig);
}

当然，我很可能错误地实现了这一点。这个想法可能存在缺陷。这只是一个想法。

Answer 3

为什么Interlocked.Exchange 不适合你？

如果您需要交换确切的内存位置，那么您使用的是错误的语言和平台，因为 .NET 将内存管理抽象出来，因此您无需考虑它。

如果你必须在没有Interlocked.Exchange 的情况下做这样的事情，你可以编写一些标记为unsafe 的代码，并像在 C 或 C++ 中那样进行传统的基于指针的交换，但你需要将它包装在合适的同步上下文，使其成为原子操作。

更新
您无需求助于unsafe 代码即可原子地进行交换。您可以将代码包装在同步上下文中以使其具有原子性。

lock (myLockObject)
{
  var x = Interlocked.Exchange(a, b);
  Interlocked.Exchange(b, x);
}

更新 2
如果同步不是一个选项（如 cmets 所示），那么我相信你不走运。当你追求一些无法衡量的效率时，你可能想把注意力集中在其他地方。如果两个整数值的交换是一个巨大的性能消耗，你可能使用了错误的平台。

Answer 4

Interlocked.Exchange 真的是你唯一能做的：

  var x = Interlocked.Exchange(a, b);
  Interlocked.Exchange(b, x);

您是正确的，这不会是原子的，但是使用局部变量，只要两行都执行，就可以保证值是一致的。您的其他选项是不安全代码（用于使用指针）、使用 p/invoke 到本机库，或重新设计以使其不再需要。

Answer 5

根据MSDN，Interlocked.Exchange 是原子的。

如果它不适合您，您可以使用 C/C++ 在 unsafe 部分中实现 XCHG。

Answer 6

Interlocked.Exchange 是在 c# 中以线程安全的方式交换两个 int 值的最佳方式。

使用这个类，即使您拥有多处理器计算机，但您永远不知道您的线程将在哪个处理器中运行。

Answer 7

我想我刚刚找到了最好的解决方案。它是：

Interlocked.Exchange() 方法（参考 T，T）

所有“新”变量都可以在一个类（Of T）中设置并与当前变量交换。这使得原子快照能够发生，同时有效地交换任意数量的变量。

Answer 8

在 Interlocked.Exchange 之外，我假设 XCHG 命令可能是 XOR Swap 的实现，因此您可以自己编写。

C 语法：（来自维基百科链接）

 void xorSwap (int *x, int *y) {
     if (x != y) {
         *x ^= *y;
         *y ^= *x;
         *x ^= *y;
     }
 }

编辑这不是原子的，你必须自己同步它