我怎么原子交换2个整数在C＃中？ [英] How do I atomically swap 2 ints in C#?

问题描述

什么（如果有的话）是C＃相当于ASM命令XCHG的。

What (if any) is the C# equivalent of the ASM command "XCHG".

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

With that command, which imo is a genuine exchange (unlike Interlocked.Exchange), I could simply atomically swap two ints, which is what I am really trying to do.

更新：

样品code根据我的建议。可变后缀_V被装饰成挥发性的：

Sample code based upon my suggestion. Variable suffixed "_V" are decorated as 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;

请注意在懒惰更新。

推荐答案

下面是一种怪异的想法。我不知道究竟你怎么会有你的数据结构设置。但是，如果可能的话，你可以的保存在你的两个 INT 值长 ，然后我认为的，你可以以原子交换他们。

Here's kind of a weird idea. I don't know exactly how you have your data structure set up. But if it's possible you could store your two int values in a long, then I think you could swap them atomically.

例如，假设您通过以下方式包裹你的两个值：

For example, let's say you wrapped your two values in the following manner:

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);
    }
}

然后好像你可以添加以下交换方法导致交换对原子（实际上，我不知道这是否是公平的，真正说，下面的是的原子;它更喜欢它的产生相同的结果作为一个原子交换的）

Then it seems you could add the following Swap method to result in a swapped pair "atomically" (actually, I don't know if it's fair to really say that the following is atomic; it's more like it produces the same result as an atomic swap).

/// <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);
}

这是极有可能我实现了，当然这不正确。而且有可能是这种想法的一个缺陷。这只是一个想法。

It is highly possible I've implemented this incorrectly, of course. And there could be a flaw in this idea. It's just an idea.

这篇关于我怎么原子交换2个整数在C＃中？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！