В чем разница между Lock и Monitor?

Различие между Lock и Monitor в C#

Короткий ответ: lock в C# является синтаксическим сахаром (sugar syntax) для использования классов Monitor.Enter() и Monitor.Exit() в конструкции try/finally. По сути, lock - это упрощенная и безопасная обертка над низкоуровневыми методами Monitor.

Техническая сущность

Конструкция lock

private readonly object _lockObject = new object();

public void ProcessData()
{
    lock (_lockObject)
    {
        // Критическая секция
        // Потокобезопасный код
    }
}

Что делает компилятор на самом деле:

public void ProcessData()
{
    object lockObj = _lockObject;
    bool lockTaken = false;
    
    try
    {
        Monitor.Enter(lockObj, ref lockTaken);
        // Критическая секция
        // Потокобезопасный код
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(lockObj);
        }
    }
}

Ключевые различия

1. Уровень абстракции и безопасность

• lock: Высокоуровневая конструкция, которая гарантирует освобождение мьютекса даже при возникновении исключения
• Monitor: Низкоуровневый примитив синхронизации, требующий более аккуратного использования

2. Гибкость и дополнительные возможности

Monitor предоставляет дополнительные методы, недоступные через lock:

private readonly object _syncObject = new object();

// Пример использования расширенных возможностей Monitor
public bool TryProcessWithTimeout(int timeoutMilliseconds)
{
    bool lockTaken = false;
    
    try
    {
        // Попытка захвата блокировки с таймаутом
        Monitor.TryEnter(_syncObject, timeoutMilliseconds, ref lockTaken);
        
        if (lockTaken)
        {
            // Критическая секция
            return true;
        }
        
        return false; // Не удалось захватить блокировку вовремя
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(_syncObject);
        }
    }
}

// Координация между потоками
public void ProducerConsumerExample()
{
    lock (_syncObject)
    {
        // Ждем сигнала от другого потока
        while (!resourceAvailable)
        {
            Monitor.Wait(_syncObject); // Освобождает блокировку и ждет
        }
        
        // Получили сигнал, продолжаем работу
        
        // Уведомляем другие потоки
        Monitor.Pulse(_syncObject); // Будит один поток
        Monitor.PulseAll(_syncObject); // Будит все потоки
    }
}

3. Производительность и контроль

• lock: Автоматическая обработка, но без контроля времени ожидания
• Monitor: Позволяет использовать TryEnter() с таймаутами, что предотвращает взаимные блокировки (deadlocks)

Практические рекомендации по использованию

Когда использовать lock:

• Стандартные сценарии синхронизации доступа к общим ресурсам
• Когда нужна простая и безопасная реализация
• В большинстве типовых случаев многопоточного программирования

Когда использовать Monitor напрямую:

// Сценарий 1: Сложная координация потоков
public class ThreadCoordinator
{
    private readonly object _lockObj = new object();
    private bool _isReady = false;
    
    public void WaitForSignal()
    {
        lock (_lockObj)
        {
            while (!_isReady)
            {
                Monitor.Wait(_lockObj); // Вариант использования, недоступный через lock
            }
        }
    }
    
    public void SendSignal()
    {
        lock (_lockObj)
        {
            _isReady = true;
            Monitor.PulseAll(_lockObj);
        }
    }
}

// Сценарий 2: Предотвращение deadlock с таймаутами
public bool SafeResourceAccess()
{
    bool lockTaken = false;
    
    try
    {
        // Пытаемся захватить блокировку не более 100 мс
        Monitor.TryEnter(_lockObj, 100, ref lockTaken);
        
        if (lockTaken)
        {
            // Безопасная работа с ресурсом
            return true;
        }
        
        // Альтернативная логика при невозможности захвата
        return false;
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(_lockObj);
        }
    }
}

Важные особенности реализации

Повторный вход (reentrancy)

Оба механизма поддерживают повторный вход - поток, владеющий блокировкой, может повторно захватывать ее без блокировки самого себя:

public void ReentrantExample()
{
    lock (_lockObject)
    {
        // Первый захват
        NestedLock(); // Внутренний lock на том же объекте сработает без блокировки
    }
}

private void NestedLock()
{
    lock (_lockObject) // Не вызывает блокировку, так как поток уже владеет блокировкой
    {
        // Вложенная критическая секция
    }
}

Рекомендации по объектам блокировки

// ПРАВИЛЬНО:
private readonly object _lockObject = new object(); // Выделенный объект для блокировки
private static readonly object _staticLock = new object(); // Для статических методов

// НЕПРАВИЛЬНО:
private string _lockString = "lock"; // Строки интернируются - могут быть общими!
private Type _lockType = typeof(MyClass); // Type объекты также общие
public object PublicLock = new object(); // Публичный объект блокировки опасен

Производительность и best practices

1. Минимизируйте время удержания блокировки - выполняйте только необходимые операции в критической секции
2. Избегайте вложенных блокировок - это главный источник deadlock
3. Используйте Monitor для сложных сценариев координации потоков
4. Всегда освобождайте блокировки в finally при использовании Monitor напрямую
5. Рассмотрите альтернативы - для высокопроизводительных сценариев могут подойти SemaphoreSlim, ReaderWriterLockSlim или Concurrent коллекции

Заключение

Хотя lock и Monitor тесно связаны, они служат разным целям в арсенале разработчика. lock - это инструмент для повседневного использования, обеспечивающий безопасную и простую синхронизацию. Monitor - это мощный низкоуровневый механизм для реализации сложных сценариев межпоточной координации, предоставляющий контроль над таймаутами и возможность организации продвинутых шаблонов взаимодействия потоков. Выбор между ними зависит от конкретных требований к гибкости, производительности и сложности синхронизации в вашем приложении.