Как устроен lock?

Механизм работы lock в C#

lock в C# — это высокоуровневая языковая конструкция, обеспечивающая взаимное исключение (mutual exclusion) при доступе к общему ресурсу из нескольких потоков. Это базовый механизм синхронизации, предотвращающий состояние гонки (race condition).

Принцип работы на уровне компилятора и CLR

Конструкция lock является "синтаксическим сахаром" — компилятор C# преобразует её в вызов методов Monitor.Enter и Monitor.Exit в блоке try-finally:

Исходный код C#:

private readonly object _lockObject = new object();

public void ThreadSafeMethod()
{
    lock (_lockObject)
    {
        // Критическая секция
        // Доступ к общему ресурсу
    }
}

Эквивалент после компиляции:

public void ThreadSafeMethod()
{
    bool lockTaken = false;
    object lockObj = _lockObject;
    
    try
    {
        Monitor.Enter(lockObj, ref lockTaken);
        // Критическая секция
        // Доступ к общему ресурсу
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(lockObj);
        }
    }
}

Ключевые аспекты реализации

1. Объект синхронизации (sync object):

   • Должен быть ссылочным типом (нельзя использовать value types)
   • Рекомендуется использовать отдельный приватный объект, специально созданный для синхронизации
   • Никогда не использовать this, typeof(), строки или публичные объекты — это может привести к взаимным блокировкам (deadlocks)

2. Монитор (Monitor):

   • Каждый объект в CLR имеет связанный с ним заголовок синхронизации (sync block), который содержит:

     - Флаг блокировки
     - Счетчик рекурсивных захватов
     - Указатель на очередь ожидающих потоков

• Monitor.Enter атомарно проверяет и устанавливает флаг блокировки
• Если блокировка уже захвачена другим потоком, текущий поток переходит в состояние ожидания

1. Очередь ожидания:
   • CLR поддерживает две очереди для каждого объекта-монитора:

     - **Готовых к выполнению** — потоки, ожидающие своей очереди на захват
     - **Ожидания** — потоки, вызвавшие `Monitor.Wait()`

• Потоки в очереди готовых переходят в состояние WaitSleepJoin

Пример правильного использования

public class ThreadSafeCounter
{
    private readonly object _syncRoot = new object();
    private int _count = 0;
    
    public void Increment()
    {
        lock (_syncRoot)
        {
            _count++;
            // Другие операции с общим состоянием
        }
    }
    
    public int GetCount()
    {
        lock (_syncRoot)
        {
            return _count;
        }
    }
}

Важные особенности и рекомендации

• Рекурсивность: lock в C# рекурсивен — один поток может многократно захватывать один и тот же объект
• Время удержания: Держите блокировку максимально короткое время — только для операций с общим состоянием
• Избегайте блокировок внутри блокировок — это основная причина deadlocks
• Использование lockTaken: Современная практика использует перегрузку с ref bool lockTaken для безопасной обработки исключений

Альтернативы и связанные механизмы

// Использование ReaderWriterLockSlim для оптимизации чтения/записи
private readonly ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();

public void ReadOperation()
{
    _rwLock.EnterReadLock();
    try { /* множественное чтение */ }
    finally { _rwLock.ExitReadLock(); }
}

public void WriteOperation()
{
    _rwLock.EnterWriteLock();
    try { /* эксклюзивная запись */ }
    finally { _rwLock.ExitWriteLock(); }
}

Производительность и внутренняя реализация

На низком уровне Monitor использует:

• Spin-ожидание — короткие циклы проверки перед переходом в состояние ожидания
• Синхронизацию на уровне ОС через примитивы вроде событий Windows или мьютексов Linux
• Умную стратегию — адаптивное поведение в зависимости от характеристик системы

Важно: Начиная с .NET Core, реализация Monitor была значительно оптимизирована, особенно для сценариев с низкой конкуренцией.

Типичные ошибки

1. Захват нескольких блокировок в неправильном порядке
2. Выполнение долгих операций (IO, сетевые вызовы) внутри lock
3. Утечка блокировок при необработанных исключениях (решается конструкцией try-finally)
4. Синхронизация на разных объектах при доступе к одному ресурсу

lock остается фундаментальным механизмом синхронизации в C#, но для сложных сценариев рассмотрите Mutex, SemaphoreSlim, Concurrent коллекции или асинхронные примитивы вроде SemaphoreSlim.WaitAsync().