Канонический способ - использовать блокировку сравнения-обмена в цикле:

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

(Псевдокод, потому что я не утруждаю себя поиском правильного способа выполнения заблокированного обмена на С#).

Как видите, если у вас нет первостепенных проблем с эффективностью, использование простых старых мьютексов намного проще и читабельнее.

Изменить: предполагается, что a является локальной переменной или, по крайней мере, не подлежит асинхронной записи. И a, и b могут быть изменены за вашей спиной, тогда не существует безблокировочного способа выполнить это обновление атомарно. (Спасибо silev за указание на это).

Хеннинг прав. Я предоставлю подробности, поскольку они относятся к 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;
}

Не существует такой атомарной операции, которая выполняла бы как сравнение, так и присваивание по-настоящему атомарно. В C# настоящими атомарными операциями могут быть операции Interlocked, такие как CompareExchenge() и Exchange(), для обмена двумя целочисленными значениями (32-битные для 32-битной архитектуры и 64-битные для 64-битной архитектуры процессора).

Очевидно, что простое присваивание a = b представляет собой две операции — чтение и запись. Таким образом, нет возможности выполнить сравнение + присваивание за один атомарный шаг... Возможно ли это на любом другом языке/архитектуре, я имею в виду настоящий атомарный? ;)

РЕДАКТИРОВАТЬ: в исходном вопросе не указано, что 'a' является локальной переменной... э-э-э, такое небольшое исправление... в любом случае я оставлю свой ответ как есть, потому что я верю в природу истинных атомарных операций, а не в какие-то «трюки», которые претендуют на атомарность

Итак, подведем итог:

• мы не можем делать такие операции как одну атомарную операцию
• только один способ - синхронизировать его с помощью механизма блокировки (при условии, что в исходном вопросе не указано, что a является локальным, поэтому и a, и b потенциально могут быть доступны другому потоку

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

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

Это пара оптимизированных рецептов, которые я придумал после прочтения других ответов. Не имеет прямого отношения к вопросу, но добавляет сюда, так как именно здесь приземлились похожие поиски. Пытался сохранить это значение 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 это не повлияет.

Связанная с оптимизацией проблема: слабое регулирование

Действие signal() следует вызывать один раз каждый раз, когда локальная переменная a (например, отсчет системного времени) увеличивается на некоторую константу threshold >= 1 с момента последнего вызова signal(). Здесь b — это пороговый заполнитель по сравнению с a и устанавливается равным a + threshold, если a >= b. Только победившая нить должна вызывать signal().

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

Здесь b снова является монотонным, но теперь мы можем полностью отказаться от цикла повторных попыток, так как мы хотим только знать, выиграл ли локальный поток гонку с другими потоками, соблюдая threshold. Этот метод эффективно блокирует сигнализацию любого другого потока в пределах определенного порога.

Предостережения по регулированию

Этот не сработает, если вам нужен строгий дроссель, то есть наименьшее a, где a >= b, поэтому в заголовке свободная. Это также не сработает, если вам нужно сообщить только о последнем из серии тесно сгруппированных as — то, что можно назвать debouncing, родственная, но отдельная проблема.