В чем разница между Monitor, Mutex и Semaphore?

Различия между Monitor, Mutex и Semaphore в C#

В C# и .NET Monitor, Mutex и Semaphore являются механизмами синхронизации потоков, но они имеют различные характеристики и сценарии применения.

1. Monitor (Монитор)

Monitor — это низкоуровневый механизм синхронизации, предоставляемый средой CLR, используемый для организации взаимоисключающего доступа к общим ресурсам в рамках одного процесса.

Основные особенности:

• Привязка к объекту: Каждый объект в .NET имеет связанный с ним монитор.
• Внутрипроцессный: Работает только в границах одного процесса.
• Рекурсивность: Поток, захвативший монитор, может повторно войти в критическую секцию.
• Методы: Используется через Monitor.Enter()/Monitor.Exit() или ключевое слово lock.

private readonly object _lockObject = new object();

public void ThreadSafeMethod()
{
    lock (_lockObject) // Использование lock (синтаксический сахар для Monitor)
    {
        // Критическая секция
    }
}

2. Mutex (Мьютекс)

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

Основные особенности:

• Межпроцессный: Может синхронизировать потоки разных процессов.
• Именованные мьютексы: Можно создать именованный мьютекс для системного уровня.
• Рекурсивность: Как и Monitor, поддерживает рекурсивные захваты.
• Более тяжеловесный: Из-за возможности межпроцессного использования работает медленнее Monitor.

// Локальный мьютекс (внутри процесса)
using var mutex = new Mutex();

// Именованный мьютекс (межпроцессный)
using var namedMutex = new Mutex(false, "Global\\MyAppMutex");

try
{
    namedMutex.WaitOne(); // Захват мьютекса
    // Работа с общим ресурсом
}
finally
{
    namedMutex.ReleaseMutex(); // Освобождение мьютекса
}

3. Semaphore (Семафор)

Semaphore — это механизм, позволяющий ограничить количество потоков, которые могут одновременно обращаться к ресурсу.

Основные особенности:

• Счетчик: Управляет доступом на основе счетчика.
• Межпроцессный: Как и Mutex, может работать между процессами.
• Не является рекурсивным: Не отслеживает владельца.
• Два типа: Semaphore (стандартный) и SemaphoreSlim (оптимизирован для внутрипроцессного использования).

// Semaphore с начальным счетчиком 3 и максимумом 3
using var semaphore = new Semaphore(3, 3, "Global\\MySemaphore");

// SemaphoreSlim (легковесный, только внутри процесса)
var semaphoreSlim = new SemaphoreSlim(3, 3);

// В потоке:
await semaphoreSlim.WaitAsync(); // Уменьшаем счетчик
try
{
    // Доступ к ресурсу (максимум 3 потока одновременно)
}
finally
{
    semaphoreSlim.Release(); // Увеличиваем счетчик
}

Сравнительная таблица

Рекомендации по использованию

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

• Синхронизация внутри одного процесса
• Высокопроизводительные сценарии (критические секции с минимальными накладными расходами)
• Простая взаимная блокировка одного потока на ресурс

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

• Синхронизация между процессами (например, доступ к общему файлу)
• Глобальные блокировки на уровне ОС
• Когда нужна рекурсивность в межпроцессном сценарии

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

• Ограничение одновременного доступа к ресурсу (пул соединений, лимит запросов)
• Сценарии "производитель-потребитель" с ограниченной емкостью
• Координация работы нескольких потоков с заданным параллелизмом

Пример выбора на практике

// 1. Monitor - для быстрой синхронизации внутри приложения
private readonly object _syncRoot = new object();
public void UpdateCache()
{
    lock (_syncRoot)
    {
        // Обновление кэша
    }
}

// 2. Mutex - для предотвращения запуска второго экземпляра приложения
using var mutex = new Mutex(true, "Global\\MyApplication", out bool createdNew);
if (!createdNew)
{
    Console.WriteLine("Приложение уже запущено!");
    return;
}

// 3. SemaphoreSlim - для ограничения параллельных HTTP-запросов
private readonly SemaphoreSlim _throttler = new SemaphoreSlim(5, 5);
public async Task MakeRequestAsync()
{
    await _throttler.WaitAsync();
    try
    {
        // Выполнение запроса (не более 5 одновременно)
    }
    finally
    {
        _throttler.Release();
    }
}

Заключение

Выбор между Monitor, Mutex и Semaphore зависит от конкретных требований синхронизации. Monitor оптимален для высокопроизводительных внутрипроцессных сценариев, Mutex необходим для межпроцессной синхронизации, а Semaphore предназначен для контроля количества одновременно работающих потоков. В современных приложениях также часто используют более высокоуровневые конструкции, такие как async/await с SemaphoreSlim для асинхронных операций.