Является ли нулевой оператор объединения (??) в C # потокобезопасным?

public void DoCallback() {
    (Callback ?? new Action(() => { }))();
}

гарантированно эквивалентен:

public void DoCallback() {
    Action local = Callback;
    if (local == null)
       local = new Action(() => { });
    local();
}

Может ли это вызвать исключение NullReferenceException, зависит от модели памяти. Модель памяти платформы Microsoft .NET задокументирована так, чтобы никогда не вводить дополнительных операций чтения, поэтому значение, протестированное против null, является тем же значением, которое будет вызвано, и ваш код безопасен. Однако модель памяти CLI ECMA-335 менее строгая и позволяет среде выполнения исключать локальную переменную и дважды обращаться к полю Callback (я предполагаю, что это поле или свойство, которое обращается к простому полю).

Вы должны отметить Callback поле volatile, чтобы убедиться, что используется правильный барьер памяти - это делает код безопасным даже в слабой модели ECMA-335.

Если это не критический для производительности код, просто используйте блокировку (достаточно прочитать обратный вызов в локальную переменную внутри блокировки, вам не нужно удерживать блокировку при вызове делегата) - все остальное требует подробных знаний о моделях памяти, чтобы знать, действительно ли это безопасно, и точные детали могут измениться в будущих версиях .NET (в отличие от Java, Microsoft не полностью определила модель памяти .NET).

Обновлять

Если мы исключим проблему получения устаревшего значения, как поясняет ваше редактирование, то опция объединения с нулевым значением всегда будет работать надежно (даже если точное поведение не может быть определено). Альтернативная версия (если не null, то вызовите ее), однако, не будет и рискует NullReferenceException.

Оператор объединения с нулем приводит к тому, что Callback вычисляется только один раз. Делегаты неизменяемы:

Комбинирующие операции, такие как Combine и Remove, не изменяют существующих делегатов. Вместо этого такая операция возвращает новый делегат, содержащий результаты операции, неизмененный делегат или значение null. Операция объединения возвращает значение null, если результатом операции является делегат, который не ссылается хотя бы на один метод. Операция объединения возвращает неизмененный делегат, если запрошенная операция не действует.

Кроме того, делегаты являются ссылочными типами, поэтому простое чтение или запись гарантированно будет атомарным (спецификация языка C #, параграф 5.5):

Чтение и запись следующих типов данных являются атомарными: bool, char, byte, sbyte, short, ushort, uint, int, float и ссылочные типы.

Это подтверждает, что оператор объединения с нулем не может прочитать недопустимое значение, а также потому, что значение будет считано только тогда, когда нет возможности ошибки.

С другой стороны, условная версия считывает делегат один раз, а затем вызывает результат второго независимого чтения. Если первое чтение возвращает ненулевое значение, но делегат (атомарно, но это не помогает) перезаписан на null до того, как произойдет второе чтение, компилятор в конечном итоге вызовет Invoke для нулевой ссылки, поэтому будет сгенерировано исключение .

Все это отражено в IL для двух методов.

Оригинальный ответ

В отсутствие явной документации об обратном да, здесь есть состояние гонки, как и в более простом случае.

public int x = 1;

int y = x == 1 ? 1 : 0;

Принцип тот же: сначала оценивается условие, а затем создается результат выражения (и позже используется). Если случится что-то такое, что изменит состояние, будет уже слишком поздно.

Я не вижу в этом коде состояния гонки. Есть несколько потенциальных проблем:

• Callback += someMethod; не является атомарным. Простое задание есть.
• DoCallback может вызывать устаревшее значение, но оно будет согласованным.
• Проблему устаревшего значения можно избежать, только удерживая блокировку на протяжении всего обратного вызова. Но это очень опасный паттерн, создающий тупиковые ситуации.

Более ясным способом написания DoCallback было бы:

public void DoCallback()
{
   var callback = Callback;//Copying to local variable is necessary
   if(callback != null)
     callback();
}

Это также немного быстрее, чем ваш исходный код, поскольку он не создает и не вызывает бездействующий делегат, если Callback равно null.

И вы можете захотеть заменить свойство на событие, чтобы получить атомарные += и -=:

 public event Action Callback;

При вызове += для свойства происходит Callback = Callback + someMethod. Это не атомарно, поскольку Callback может быть изменено между чтением и записью.

При вызове += в поле, таком как событие, происходит вызов Subscribe метода события. Подписка на события гарантированно будет атомарной для событий, подобных полям. На практике для этого используются некоторые Interlocked техники.

Использование оператора слияния с нулевым значением ?? здесь не имеет особого значения, да и по своей сути он не является потокобезопасным. Важно то, что вы прочитали Callback только один раз. Есть и другие похожие шаблоны с ??, которые никоим образом не являются потокобезопасными.

Мы предполагаем, что это безопасно, потому что это одна строка? Обычно это не так. Вам действительно следует использовать оператор блокировки перед доступом к любой разделяемой памяти.