В чем разница между ManualResetEvent и AutoResetEvent в .NET?

Представьте себе, что AutoResetEvent выполняет WaitOne() и Reset() как одну атомную операцию.

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

Взято из С# 3.0 Краткая книга, по Джозеф Альбахари

Threading in С# - Бесплатная электронная книга

A ManualResetEvent - это вариант AutoResetEvent. Он отличается тем, что он автоматически не выполняет reset после того, как поток пропускается по вызову WaitOne и, таким образом, функционирует как ворота: вызов Set открывает ворота, позволяя любое количество потоков, которые WaitOne у ворот; вызов reset закрывает ворота, вызывая, потенциально, очередь официантов накапливаться до следующего его открытия.

Можно было бы имитировать эту функциональность с помощью логического поля "gateOpen" (объявленного с ключевым словом volatile) в сочетании с "спин-спящим" - многократно проверяя флаг, а затем спя себя на короткий период времени.

ManualResetEvents иногда используются для оповещения о завершении конкретной операции или завершении инициализации потока и готовности к выполнению работы.

Я создал простые примеры, чтобы прояснить понимание ManualResetEvent vs AutoResetEvent.

AutoResetEvent: позволяет предположить, что у вас есть 3 рабочих потока. Если какой-либо из этих потоков вызовет WaitOne(), все остальные 2 потока остановят выполнение и ждут сигнала. Я предполагаю, что они используют WaitOne(). Это похоже на; если я не работаю, никто не работает. В первом примере вы можете увидеть, что

            autoReset.Set();
            Thread.Sleep(1000);
            autoReset.Set();

Когда вы вызываете Set(); все потоки будут работать и ждать сигнала. Через 1 секунду я посылаю второй сигнал, и они выполняются и ждут (WaitOne();). Подумайте о том, что эти парни - игроки футбольной команды, и если один из игроков говорит, что я буду ждать, пока меня не назовет менеджер, а другие будут ждать, пока менеджер не предложит им продолжить (Set();)

public class AutoResetEventSample
    {
        private AutoResetEvent autoReset = new AutoResetEvent(false);

        public void RunAll()
        {
            new Thread(Worker1).Start();
            new Thread(Worker2).Start();
            new Thread(Worker3).Start();
            autoReset.Set();
            Thread.Sleep(1000);
            autoReset.Set();
            Console.WriteLine("Main thread reached to end.");
        }

        public void Worker1()
        {
            Console.WriteLine("Entered in worker 1");
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Worker1 is running {0}", i);
                Thread.Sleep(2000);
                autoReset.WaitOne();
            }
        }
        public void Worker2()
        {
            Console.WriteLine("Entered in worker 2");

            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Worker2 is running {0}", i);
                Thread.Sleep(2000);
                autoReset.WaitOne();
            }
        }
        public void Worker3()
        {
            Console.WriteLine("Entered in worker 3");

            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Worker3 is running {0}", i);
                Thread.Sleep(2000);
                autoReset.WaitOne();
            }
        }
    }

В этом примере вы можете четко видеть, что при первом нажатии Set(); он будет пропускать все потоки, а затем через 1 секунду он сигнализирует всем потокам ждать! Как только вы установите их снова, независимо от того, что они вызывают WaitOne() внутри, они будут продолжать работать, потому что вы должны вручную вызвать Reset(), чтобы остановить их все.

            manualReset.Set();
            Thread.Sleep(1000);
            manualReset.Reset();
            Console.WriteLine("Press to release all threads.");
            Console.ReadLine();
            manualReset.Set();

Больше о взаимоотношениях с рефери/игроками, независимо от того, кто из игроков травмирован, и ждать, пока играющие другие будут продолжать работать. Если рефери говорит wait (Reset();), то все игроки будут ждать следующего сигнала.

    public class ManualResetEventSample
    {
        private ManualResetEvent manualReset = new ManualResetEvent(false);

        public void RunAll()
        {
            new Thread(Worker1).Start();
            new Thread(Worker2).Start();
            new Thread(Worker3).Start();
            manualReset.Set();
            Thread.Sleep(1000);
            manualReset.Reset();
            Console.WriteLine("Press to release all threads.");
            Console.ReadLine();
            manualReset.Set();
            Console.WriteLine("Main thread reached to end.");
        }

        public void Worker1()
        {
            Console.WriteLine("Entered in worker 1");
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Worker1 is running {0}", i);
                Thread.Sleep(2000);
                manualReset.WaitOne();
            }
        }
        public void Worker2()
        {
            Console.WriteLine("Entered in worker 2");

            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Worker2 is running {0}", i);
                Thread.Sleep(2000);
                manualReset.WaitOne();
            }
        }
        public void Worker3()
        {
            Console.WriteLine("Entered in worker 3");

            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Worker3 is running {0}", i);
                Thread.Sleep(2000);
                manualReset.WaitOne();
            }
        }
    }

Хорошо, обычно не рекомендуется добавлять 2 ответа в один поток, но я не хотел редактировать/удалять свой предыдущий ответ, так как он может помочь по-другому.

Теперь я создал, гораздо более полный и понятный, нижеприведенный ниже фрагмент приложения для запуска.

Просто запустите примеры на двух разных консолях и наблюдайте за поведением. Вы получите гораздо более четкое представление о том, что происходит за кулисами.

Событие сброса вручную

using System;
using System.Threading;

namespace ConsoleApplicationDotNetBasics.ThreadingExamples
{
    public class ManualResetEventSample
    {
        private readonly ManualResetEvent _manualReset = new ManualResetEvent(false);

        public void RunAll()
        {
            new Thread(Worker1).Start();
            new Thread(Worker2).Start();
            new Thread(Worker3).Start();
            Console.WriteLine("All Threads Scheduled to RUN!. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine("Main Thread is waiting for 15 seconds, observe 3 thread behaviour. All threads run once and stopped. Why? Because they call WaitOne() internally. They will wait until signals arrive, down below.");
            Thread.Sleep(15000);
            Console.WriteLine("1- Main will call ManualResetEvent.Set() in 5 seconds, watch out!");
            Thread.Sleep(5000);
            _manualReset.Set();
            Thread.Sleep(2000);
            Console.WriteLine("2- Main will call ManualResetEvent.Set() in 5 seconds, watch out!");
            Thread.Sleep(5000);
            _manualReset.Set();
            Thread.Sleep(2000);
            Console.WriteLine("3- Main will call ManualResetEvent.Set() in 5 seconds, watch out!");
            Thread.Sleep(5000);
            _manualReset.Set();
            Thread.Sleep(2000);
            Console.WriteLine("4- Main will call ManualResetEvent.Reset() in 5 seconds, watch out!");
            Thread.Sleep(5000);
            _manualReset.Reset();
            Thread.Sleep(2000);
            Console.WriteLine("It ran one more time. Why? Even Reset Sets the state of the event to nonsignaled (false), causing threads to block, this will initial the state, and threads will run again until they WaitOne().");
            Thread.Sleep(10000);
            Console.WriteLine();
            Console.WriteLine("This will go so on. Everytime you call Set(), ManualResetEvent will let ALL threads to run. So if you want synchronization between them, consider using AutoReset event, or simply user TPL (Task Parallel Library).");
            Thread.Sleep(5000);
            Console.WriteLine("Main thread reached to end! ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);

        }

        public void Worker1()
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine("Worker1 is running {0}/10. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(5000);
                // this gets blocked until _autoReset gets signal
                _manualReset.WaitOne();
            }
            Console.WriteLine("Worker1 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
        }
        public void Worker2()
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine("Worker2 is running {0}/10. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(5000);
                // this gets blocked until _autoReset gets signal
                _manualReset.WaitOne();
            }
            Console.WriteLine("Worker2 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
        }
        public void Worker3()
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine("Worker3 is running {0}/10. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(5000);
                // this gets blocked until _autoReset gets signal
                _manualReset.WaitOne();
            }
            Console.WriteLine("Worker3 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
        }
    }

}

Событие автоматического сброса

using System;
using System.Threading;

namespace ConsoleApplicationDotNetBasics.ThreadingExamples
{
    public class AutoResetEventSample
    {
        private readonly AutoResetEvent _autoReset = new AutoResetEvent(false);

        public void RunAll()
        {
            new Thread(Worker1).Start();
            new Thread(Worker2).Start();
            new Thread(Worker3).Start();
            Console.WriteLine("All Threads Scheduled to RUN!. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine("Main Thread is waiting for 15 seconds, observe 3 thread behaviour. All threads run once and stopped. Why? Because they call WaitOne() internally. They will wait until signals arrive, down below.");
            Thread.Sleep(15000);
            Console.WriteLine("1- Main will call AutoResetEvent.Set() in 5 seconds, watch out!");
            Thread.Sleep(5000);
            _autoReset.Set();
            Thread.Sleep(2000);
            Console.WriteLine("2- Main will call AutoResetEvent.Set() in 5 seconds, watch out!");
            Thread.Sleep(5000);
            _autoReset.Set();
            Thread.Sleep(2000);
            Console.WriteLine("3- Main will call AutoResetEvent.Set() in 5 seconds, watch out!");
            Thread.Sleep(5000);
            _autoReset.Set();
            Thread.Sleep(2000);
            Console.WriteLine("4- Main will call AutoResetEvent.Reset() in 5 seconds, watch out!");
            Thread.Sleep(5000);
            _autoReset.Reset();
            Thread.Sleep(2000);
            Console.WriteLine("Nothing happened. Why? Becasuse Reset Sets the state of the event to nonsignaled, causing threads to block. Since they are already blocked, it will not affect anything.");
            Thread.Sleep(10000);
            Console.WriteLine("This will go so on. Everytime you call Set(), AutoResetEvent will let another thread to run. It will make it automatically, so you do not need to worry about thread running order, unless you want it manually!");
            Thread.Sleep(5000);
            Console.WriteLine("Main thread reached to end! ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);

        }

        public void Worker1()
        {
            for (int i = 1; i <= 5; i++)
            {
                Console.WriteLine("Worker1 is running {0}/5. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(500);
                // this gets blocked until _autoReset gets signal
                _autoReset.WaitOne();
            }
            Console.WriteLine("Worker1 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
        }
        public void Worker2()
        {
            for (int i = 1; i <= 5; i++)
            {
                Console.WriteLine("Worker2 is running {0}/5. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(500);
                // this gets blocked until _autoReset gets signal
                _autoReset.WaitOne();
            }
            Console.WriteLine("Worker2 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
        }
        public void Worker3()
        {
            for (int i = 1; i <= 5; i++)
            {
                Console.WriteLine("Worker3 is running {0}/5. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(500);
                // this gets blocked until _autoReset gets signal
                _autoReset.WaitOne();
            }
            Console.WriteLine("Worker3 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
        }
    }

}

autoResetEvent.WaitOne()

похож на

try
{
   manualResetEvent.WaitOne();
}
finally
{
   manualResetEvent.Reset();
}

как атомная операция

Да, это правильно.

Вы можете получить представление об использовании этих двух.

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

Если вам нужен взаимный эксклюзивный доступ к любому ресурсу, вы должны использовать AutoResetEvent.

AutoResetEvent поддерживает логическую переменную в памяти. Если логическая переменная имеет значение false, она блокирует поток и, если логическая переменная истинна, она блокирует поток.

Когда мы создаем экземпляр объекта AutoResetEvent, мы передаем значение по умолчанию для значения boolean в конструкторе. Ниже приведен синтаксис создания экземпляра объекта AutoResetEvent.

AutoResetEvent autoResetEvent = new AutoResetEvent(false);

Метод WaitOne

Этот метод блокирует текущий поток и ждет сигнала другим потоком. Метод WaitOne помещает текущий поток в состояние "Спящий поток". Метод WaitOne возвращает true, если он принимает сигнал else, возвращает false.

autoResetEvent.WaitOne();

Вторая перегрузка метода WaitOne ожидает указанного количества секунд. Если он не получает ни одной сигнальной нити, продолжается ее работа.

static void ThreadMethod()
{
    while(!autoResetEvent.WaitOne(TimeSpan.FromSeconds(2)))
    {
        Console.WriteLine("Continue");
        Thread.Sleep(TimeSpan.FromSeconds(1));
    }

    Console.WriteLine("Thread got signal");
}

Мы вызвали метод WaitOne, передав в качестве аргументов 2 секунды. В цикле while он ждет сигнала в течение 2 секунд, а затем продолжает работу. Когда поток получил сигнал WaitOne, возвращает значение true и выходит из цикла и печатает сигнал "Thread got".

Установить метод

Метод AutoResetEvent Set отправил сигнал в ожидающий поток, чтобы продолжить его работу. Ниже приведен синтаксис вызова метода Set.

autoResetEvent.Set();

ManualResetEvent поддерживает булевскую переменную в памяти. Когда логическая переменная имеет значение false, она блокирует все потоки и когда логическая переменная истинна, она блокирует все потоки.

Когда мы создаем экземпляр ManualResetEvent, мы инициализируем его с использованием логического значения по умолчанию.

ManualResetEvent manualResetEvent = new ManualResetEvent(false);

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

Если мы инициализируем ManualResetEvent с истинным значением, все потоки, вызывающие метод WaitOne, не будут блокироваться и освобождаться дальше.

Метод WaitOne

Этот метод блокирует текущий поток и ждет сигнала другим потоком. Он возвращает true, если он получает сигнал else, возвращает false.

Ниже приведен синтаксис вызова метода WaitOne.

manualResetEvent.WaitOne();

Во второй перегрузке метода WaitOne мы можем указать временной интервал до тех пор, пока текущий поток не будет ждать сигнала. Если во внутреннем времени он не получает сигнал, он возвращает false и переходит в следующую строку метода.

Ниже приведен синтаксис вызова метода WaitOne с временным интервалом.

bool isSignalled = manualResetEvent.WaitOne(TimeSpan.FromSeconds(5));

Мы указываем 5 секунд в методе WaitOne. Если объект manualResetEvent не получает сигнал между 5 секундами, он устанавливает переменную isSignalled в значение false.

Установить метод

Этот метод используется для отправки сигнала во все ожидающие потоки. Метод Set() устанавливает для булевой переменной объекта ManualResetEvent значение true. Все ожидающие потоки разблокируются и продолжаются дальше.

Ниже приведен синтаксис вызова метода Set().

manualResetEvent.Set();

Reset Метод

Как только мы вызываем метод Set() в объекте ManualResetEvent, его логическое значение остается верным. Для reset можно использовать метод Reset(). reset измените логическое значение на false.

Ниже приведен синтаксис вызова метода reset.

manualResetEvent.Reset();

Мы должны немедленно вызвать метод reset после вызова метода Set, если мы хотим отправить сигнал в потоки несколько раз.

Да. Это абсолютно правильно.

Вы можете увидеть ManualResetEvent как способ указать состояние. Что-то включено (Set) или выключено (Reset). Случай с некоторой продолжительностью. Любой поток, ожидающий этого состояния, может продолжить.

Функция AutoResetEvent более сравнима с сигналом. Один выстрел указывает на то, что что-то произошло. Случай без какой-либо продолжительности. Обычно, но не обязательно "что-то", что произошло, мало и должно обрабатываться одним потоком - следовательно, автоматический reset после того, как один поток поглотил событие.