Какие знаешь способы безопасно залочить что-либо при асинхронной операции?

Безопасная блокировка в асинхронных операциях

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

Ключевые подходы и библиотеки

1. SemaphoreSlim с асинхронными методами

SemaphoreSlim — наиболее рекомендуемый вариант, так как предоставляет асинхронные методы WaitAsync() для неблокирующего ожидания.

private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

public async Task ProcessDataAsync()
{
    await _semaphore.WaitAsync();
    try
    {
        // Критическая секция с асинхронными операциями
        await SomeAsyncOperation();
    }
    finally
    {
        _semaphore.Release();
    }
}

• Плюсы: Лёгковесный, поддерживает таймауты и отмену через CancellationToken.
• Минусы: Не рекурсивный (вызов WaitAsync в том же потоке вызовет deadlock).

2. AsyncLock (кастомная реализация)

Часто используется обёртка на основе SemaphoreSlim для удобства с using.

public class AsyncLock
{
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
    
    public async Task<IDisposable> LockAsync()
    {
        await _semaphore.WaitAsync();
        return new Releaser(_semaphore);
    }
    
    private struct Releaser : IDisposable
    {
        private readonly SemaphoreSlim _semaphore;
        public Releaser(SemaphoreSlim semaphore) => _semaphore = semaphore;
        public void Dispose() => _semaphore.Release();
    }
}

// Использование
private readonly AsyncLock _asyncLock = new AsyncLock();
public async Task SafeMethodAsync()
{
    using (await _asyncLock.LockAsync())
    {
        await Task.Delay(100);
    }
}

3. ReaderWriterLockSlim с асинхронными обёртками

Для сценариев "много читателей / один писатель" можно использовать ReaderWriterLockSlim с адаптацией через Task.Run (осторожно с контекстом синхронизации!).

private readonly ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();

public async Task ReadAsync()
{
    await Task.Run(() => 
    {
        _rwLock.EnterReadLock();
        try
        {
            // Чтение данных
        }
        finally
        {
            _rwLock.ExitReadLock();
        }
    });
}

• Плюсы: Оптимизация для чтения.
• Минусы: Не полностью асинхронный, может создавать потоки.

4. Каналы (System.Threading.Channels)

Для потокобезопасной асинхронной передачи данных между производителями и потребителями.

private readonly Channel<int> _channel = Channel.CreateUnbounded<int>();

public async Task ProduceAndConsumeAsync()
{
    // Писатель
    await _channel.Writer.WriteAsync(42);
    
    // Читатель
    while (await _channel.Reader.WaitToReadAsync())
    {
        if (_channel.Reader.TryRead(out var item))
        {
            // Обработка item
        }
    }
}

5. Immutable коллекции и lock-free подходы

Использование неизменяемых структур данных и атомарных операций для минимизации блокировок.

private ImmutableDictionary<string, int> _data = ImmutableDictionary<string, int>.Empty;

public void UpdateData(string key, int value)
{
    ImmutableInterlocked.Update(ref _data, dict => dict.SetItem(key, value));
}

Важные принципы и предупреждения

• Избегайте lock с await внутри: Блокировка захватывается потоком, но если этот поток освобождается во время await, другой поток может вызвать deadlock при попытке войти в ту же критическую секцию.
• Минимизируйте время удержания блокировки: В асинхронном коде особенно важно сокращать критическую секцию до минимума, чтобы не снижать параллелизм.
• Используйте CancellationToken: Всегда поддерживайте отмену в асинхронных блокировках, чтобы избежать вечного ожидания.
• Остерегайтесь рекурсивных вызовов: Некоторые примитивы (например, SemaphoreSlim) не поддерживают рекурсивный вход.
• Контекст синхронизации: Учитывайте контекст (например, UI) при использовании Task.Run для блокировок, чтобы не нарушить обновление UI.

Вывод

Основным инструментом для безопасной блокировки в асинхронных операциях является SemaphoreSlim с методом WaitAsync(). Для более сложных сценариев (например, конкурентное чтение-запись) рассматриваются асинхронные обёртки над ReaderWriterLockSlim или специализированные примитивы из библиотек (например, AsyncReaderWriterLock из Nito.AsyncEx). Всегда оценивайте необходимость блокировки — часто проблему можно решить через изменение архитектуры (очереди, неизменяемые данные, каналы).