Что такое AutoResetEvent и ManualResetEvent? В чём разница между ними?

AutoResetEvent и ManualResetEvent: примитивы синхронизации потоков

AutoResetEvent и ManualResetEvent — это два класса в пространстве имён System.Threading, реализующие механизм событий (events) для синхронизации потоков в .NET. Оба являются обёртками вокруг нативных объектов операционной системы Windows и наследуются от абстрактного класса EventWaitHandle.

Основная концепция

Оба класса работают по принципу сигнального состояния:

• Сигнальное состояние (signaled) — поток может продолжить выполнение.
• Несигнальное состояние (non-signaled) — поток блокируется при ожидании.

// Базовый пример использования
var resetEvent = new AutoResetEvent(false); // начальное состояние non-signaled

AutoResetEvent: автоматический сброс

AutoResetEvent автоматически сбрасывается в несигнальное состояние после того, как один поток был пропущен через WaitOne().

class AutoResetEventExample
{
    private static AutoResetEvent _autoEvent = new AutoResetEvent(false);
    
    static void Main()
    {
        // Поток 1: ждёт сигнала
        Thread thread1 = new Thread(WorkerThread);
        thread1.Start();
        
        Thread.Sleep(1000); // Имитация работы
        
        // Сигнализируем - поток1 продолжится, событие автоматически сбросится
        _autoEvent.Set();
        
        // Поток2: будет ждать, так как событие уже сброшено
        Thread thread2 = new Thread(WorkerThread);
        thread2.Start();
        
        Thread.Sleep(1000);
        _autoEvent.Set(); // Только теперь поток2 продолжит
    }
    
    static void WorkerThread()
    {
        Console.WriteLine($"Поток {Thread.CurrentThread.ManagedThreadId} ждёт...");
        _autoEvent.WaitOne();
        Console.WriteLine($"Поток {Thread.CurrentThread.ManagedThreadId} продолжил выполнение");
    }
}

Ключевые особенности AutoResetEvent:

• Автоматический переход в non-signaled после пробуждения одного потока
• Гарантирует, что только один ожидающий поток получит сигнал
• Похоже на турникет: один "проход" на каждый сигнал

ManualResetEvent: ручной сброс

ManualResetEvent требует явного сброса вручную через метод Reset(). После перехода в сигнальное состояние, все ожидающие потоки могут пройти, и оно останется в этом состоянии, пока явно не будет сброшено.

class ManualResetEventExample
{
    private static ManualResetEvent _manualEvent = new ManualResetEvent(false);
    
    static void Main()
    {
        // Запускаем несколько потоков
        for (int i = 0; i < 3; i++)
        {
            Thread thread = new Thread(WorkerThread);
            thread.Start();
        }
        
        Thread.Sleep(1000);
        
        // Все три потока одновременно получат сигнал к продолжению
        _manualEvent.Set();
        
        Thread.Sleep(500);
        
        // Новый поток не будет ждать - событие всё ещё в signaled
        Thread anotherThread = new Thread(WorkerThread);
        anotherThread.Start();
        anotherThread.Join();
        
        // Явно сбрасываем для будущих потоков
        _manualEvent.Reset();
    }
    
    static void WorkerThread()
    {
        Console.WriteLine($"Поток {Thread.CurrentThread.ManagedThreadId} начал ожидание");
        _manualEvent.WaitOne();
        Console.WriteLine($"Поток {Thread.CurrentThread.ManagedThreadId} завершил работу");
    }
}

Ключевые особенности ManualResetEvent:

• Требует явного вызова Reset() для возврата в non-signaled
• После Set() все ожидающие потоки могут продолжить выполнение
• Похоже на ворота: открыл — все проходят, закрыл — все ждут

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

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

Для AutoResetEvent:

• Реализация паттерна "Производитель-Потребитель" с одним потребителем
• Поочерёдный доступ к ресурсу
• Синхронизация двух потоков по принципу "ведущий-ведомый"

Для ManualResetEvent:

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

Современные альтернативы

В современных .NET приложениях часто используют более высокоуровневые примитивы:

• SemaphoreSlim для ограничения доступа к ресурсам
• CountdownEvent для ожидания завершения нескольких операций
• Barrier для синхронизации этапов в параллельных алгоритмах
• TaskCompletionSource в асинхронном программировании

// Современная альтернатива с async/await
var tcs = new TaskCompletionSource<bool>();

// Вместо ManualResetEvent.Set()
tcs.SetResult(true);

// Вместо WaitOne()
await tcs.Task;

Важные нюансы

1. Использование в using — оба класса реализуют IDisposable, важно освобождать ресурсы:

   using (var resetEvent = new AutoResetEvent(false))
   {
       // работа с событием
   }
   

2. Timeout в WaitOne() — всегда используйте таймауты для избежания deadlock:

   if (resetEvent.WaitOne(TimeSpan.FromSeconds(5)))
   {
       // успешное ожидание
   }
   

3. Cross-process — через конструктор EventWaitHandle можно создавать именованные события для межпроцессного взаимодействия.

Заключение

AutoResetEvent идеально подходит для сценариев, где нужно гарантировать поочерёдную обработку или строго одноразовое пробуждение на каждый сигнал. ManualResetEvent лучше использовать, когда необходимо уведомить множество потоков о наступлении какого-либо события (например, о готовности системы к работе).

Выбор между ними зависит от семантики синхронизации: если нужно пропускать потоки по одному — AutoResetEvent, если нужно открыть "шлюз" для всех ожидающих — ManualResetEvent. В современных приложениях рекомендуется рассматривать альтернативы из пространства имён System.Threading.Tasks и System.Threading.Channels для более безопасной и производительной синхронизации.