根据比较结果自动交换值

Question

我有一个非常简单的操作，需要以原子方式完成：

if (a > b)
  b = a

其中 a 和 b 是整数

编辑：，a 是本地的。

在 C# 中是否有快速的方法来做到这一点？如果可能的话，我想避免手动锁定。我查看了 Interlocked.CompareExchange，但据我了解，这仅测试相等性。

谢谢！

Answer 1

规范的方法是在循环中使用互锁比较交换：（

int oldvalue, newvalue ;
do {
  oldvalue = b ; // you'll want to force this to be a volatile read somehow
  if( a > oldvalue )
    newvalue = a ;
  else
    break ;
} while( interlocked replace oldvalue with newvalue in b does NOT succeed );

伪代码，因为我懒得查找在 C# 中进行互锁交换的正确方法）。

正如您所看到的，除非您有最重要的效率问题，否则使用普通的旧互斥体要简单得多且更具可读性。

编辑：这假设a是一个局部变量或者至少不受异步写入的影响。如果a和b都可以在你背后修改，那么就没有无锁的方式来原子地执行此更新。 （感谢 silev 指出这一点）。

Answer 2

亨宁是正确的。我将提供与 C# 相关的详细信息。该模式可以通过以下函数进行推广。

public static T InterlockedOperation<T>(ref T location, T operand)
{
  T initial, computed;
  do
  {
    initial = location;
    computed = op(initial, operand); // where op is replaced with a specific implementation
  } 
  while (Interlocked.CompareExchange(ref location, computed, initial) != initial);
  return computed;
}

根据您的具体情况，我们可以定义一个像这样的 InterlockedGreaterThanExchange 函数。

public static int InterlockedGreaterThanExchange(ref int location, int value)
{
  int initial, computed;
  do
  {
    initial = location;
    computed = value > initial ? value : initial;
  } 
  while (Interlocked.CompareExchange(ref location, computed, initial) != initial);
  return computed;
}

Answer 3

不存在这样的原子操作来以真正的原子方式执行比较和赋值。在 C# 中，真正的原子操作可以是Interlocked 操作，例如 CompareExhenge() 和 Exchange() 来交换两个整数值（32 位架构为 32 位，64 位架构为 64 位）。 -bit 用于 64 位处理器架构）。

显然，简单的赋值a = b是两个操作 - 读和写。因此，不可能在一个原子步骤中进行比较+赋值...在任何其他语言/架构中是否可能，我的意思是真正的原子？ ;)

编辑：原始问题并不表明“a”是局部变量... uhhhggg 这样一个小修正...无论如何我都会保留我的答案，因为我相信真正的原子操作的本质，并且不是某种有野心成为原子的“技巧”

所以总结一下：

• 我们不能将此类操作作为单个原子操作进行，
• 只有一种方法是使用锁定机制来同步它（假设原始问题没有说明） a 是本地，因此 a 和 b 都可能被其他线程访问

object lockObject = new object();
int a = 10;
int b = 5;

lock (lockObject)
{
   if (a > b)
   {
      b = a
   }
}

Answer 4

这些是我在阅读其他答案后想到的一些优化的“食谱”。与问题没有直接关系，但在此处添加，因为这是相关搜索的着陆点。试图将其保留为 a > b 或 a >= b 以匹配原始问题。并保持它们的一般性，以免描述偏离其他相关问题。两者都可以包装到方法中。

优化 - 单调 b

如果这是对 b 执行的唯一操作，否则 b 为 >单调递增，您可以优化联锁分配和重试，其中a > > b == false：

int initial;
do 
{
  initial = b;
}
while ((a > initial) && Interlocked.CompareExchange(ref b, a, initial) != initial);

如果a>； b == false 任何重试后都不会是 true （b 只会变得更大），并且可以跳过交换，因为 b< /code> 不会受到影响。

相关问题优化：松散限制

动作signal()每次局部变量a（例如，系统时间样本）时只应调用一次自上次调用 signal() 以来，已经增加了某个常数 threshold >= 1。这里，b 是与 a 相比的阈值占位符，如果 a >= b 则设置为 a + Threshold 。只有“获胜”线程才应该调用 signal()。

var initial = b;
if ((a > initial) && Interlocked.CompareExchange(ref b, a + threshold, initial) == initial)
{
  signal();
}

在这里，b 再次是单调的，但现在我们可以完全优化重试循环，因为我们只想知道本地线程是否在尊重阈值的同时与其他线程“赢得了比赛”代码>.此方法将有效地“阻止”任何其他线程在定义的阈值内发出信号。

节流注意事项

如果您需要“严格”节流（即“最小”a，其中 a >= b），则此选项将不起作用 - 因此“标题中的“宽松”。如果您只需要报告一系列紧密分组的 a 中的最后一个，这也不起作用 - 可能称为 “去抖动”，相关但不同的问题。