В C#: Volatile, Interlocked или lock — что выбрать для потокобезопасности простого флага?

Краткий ответ: для простого флага остановки потока — используйте volatile или Interlocked. lock — избыточен.

Вы правильно заметили проблему: без специальных маркеров компилятор, JIT и процессор могут кешировать поле _isRunning в регистре, и цикл while (_isRunning) никогда не увидит изменений из другого потока. Это приводит к "зависанию" потока.

Все три подхода (volatile, Interlocked, lock) решают эту проблему, но с разной степенью "тяжести" и гарантиями. Давайте разберём каждый.

1. volatile — лёгкий барьер памяти

Ключевое слово volatile говорит компилятору и JIT: "Не оптимизируй это поле! Всегда читай его из оперативной памяти, а не из кеша. И не переставляй операции чтения/записи через этот барьер".

Это самый лёгкий способ для простых флагов:

private volatile bool _isRunning = true;

public void Stop()
{
    _isRunning = false; // Запись сразу видна всем потокам
}

Минусы volatile:

• Работает только с типами, размер которых ≤ 4 байт (int, bool, ссылки) на 32-битных системах (и ≤ 8 байт на 64-битных).
• Не гарантирует атомарности! Если вы делаете _counter++, то volatile не спасёт — операция чтение-модификация-запись не атомарна.
• Может быть избыточным для сложной логики.

2. Interlocked — атомарные операции

Класс Interlocked предоставляет атомарные методы для чтения, записи и модификации. Он гарантирует как атомарность, так и барьер памяти.

Для вашего флага можно использовать Interlocked.Exchange и Interlocked.CompareExchange:

private int _isRunning = 1; // Используем int, так как Interlocked не работает с bool напрямую

public void Start()
{
    Task.Run(() =>
    {
        while (Interlocked.CompareExchange(ref _isRunning, 0, 0) == 1) // Атомарное чтение
        {
            Console.WriteLine("Working...");
            Thread.Sleep(100);
        }
    });
}

public void Stop()
{
    Interlocked.Exchange(ref _isRunning, 0); // Атомарная запись
}

Или проще, используя Interlocked.Read (только для 64-битных значений на 32-битных системах):

while (Interlocked.Read(ref _isRunning) == 1)

Плюсы Interlocked: атомарность + барьер памяти. Идеально для счётчиков, флагов, переключения состояний.

Минусы: чуть больше кода, чем volatile. Не работает с bool напрямую (нужен int).

3. lock — тяжелая артиллерия

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

private readonly object _lock = new object();
private bool _isRunning = true;

public void Start()
{
    Task.Run(() =>
    {
        bool shouldRun;
        lock (_lock) { shouldRun = _isRunning; }
        while (shouldRun)
        {
            Console.WriteLine("Working...");
            Thread.Sleep(100);
            lock (_lock) { shouldRun = _isRunning; }
        }
    });
}

public void Stop()
{
    lock (_lock) { _isRunning = false; }
}

Для простого флага это избыточно: вы платите за захват монитора (блокировка), хотя вам нужна только видимость изменений, а не взаимное исключение.

Итоговая рекомендация

• Для простого флага остановки потока: используйте volatile — это самый простой и производительный вариант.
• Для счётчиков или операций типа "прочитай-измени-запиши": используйте Interlocked (например, Interlocked.Increment).
• Для сложных структур данных или необходимости синхронизации нескольких потоков: используйте lock (или более современные ReaderWriterLockSlim, SemaphoreSlim).

В вашем примере с bool-флагом volatile — идеальное решение.

public class Worker
{
    private CancellationTokenSource _cts;

    public void Start()
    {
        _cts = new CancellationTokenSource();
        var token = _cts.Token;

        Task.Run(() =>
        {
            while (!token.IsCancellationRequested)
            {
                Console.WriteLine("Working...");
                Thread.Sleep(100);
            }
        }, token);
    }

    public void Stop()
    {
        _cts?.Cancel();
        _cts?.Dispose();
    }
}