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

Я прочитал документацию по этому, и я думаю, что я понимаю. An AutoResetEventсбрасывается , когда код проходит черезevent.WaitOne() , но ManualResetEventне делает.

Это правильно?

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

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

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

Взято из книги о скорлупе C # 3.0, Джозеф Албахари

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

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

Эту функцию можно смоделировать с помощью логического поля gateOpen (объявленного с ключевым словом volatile) в сочетании с «spin-sleep» - многократно проверяя флаг, а затем в течение короткого промежутка времени.

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

Я создал простые примеры, чтобы уточнить понимание ManualResetEventпротив 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();
        }
    }
}

autoResetEvent.WaitOne()

похоже на

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

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

Хорошо, обычно не рекомендуется добавлять 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 поддерживает логическую переменную в памяти. Если логическая переменная имеет значение false, то она блокирует поток, а если логическая переменная имеет значение true, разблокирует поток.

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

AutoResetEvent autoResetEvent = new AutoResetEvent(false);

Метод WaitOne

Этот метод блокирует текущий поток и ожидает сигнала от другого потока. Метод WaitOne переводит текущий поток в состояние потока Sleep. Метод WaitOne возвращает true, если он получает сигнал, иначе возвращает 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, выходит из цикла и выдает «Поток получил сигнал».

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

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

autoResetEvent.Set();

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

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

ManualResetEvent manualResetEvent = new ManualResetEvent(false);

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

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

Метод WaitOne

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

Ниже приведен синтаксис вызова метода 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();

Метод сброса

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

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

manualResetEvent.Reset();

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

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

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

AutoResetEvent более сопоставим с сигналом. Один выстрел показывает, что что-то произошло. Событие без какой-либо продолжительности. Как правило, но не обязательно, «что-то», которое произошло, является небольшим и должно обрабатываться одним потоком - следовательно, автоматический сброс после того, как один поток использовал событие.

Да все верно.

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

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

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

Если вы хотите понять AutoResetEvent и ManualResetEvent, вам нужно понимать не многопоточность, а прерывания!

.NET хочет вызвать низкоуровневое программирование как можно дальше.

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

Первое, что нужно сделать, когда происходит прерывание, это сбросить его состояние, потому что оборудование работает следующим образом:

1. контакт подключен к сигналу, и аппаратное обеспечение ожидает его изменения (сигнал может иметь только два состояния).
2. если сигнал изменяется, значит, что-то произошло, и аппаратное обеспечение поместило переменную памяти в состояние, которое произошло (и оно останется таким, даже если сигнал снова изменится).
3. программа замечает, что переменные изменяют состояния и перемещают выполнение в функцию обработки.
4. Здесь первое, что нужно сделать, чтобы снова прослушать это прерывание, - сбросить эту переменную памяти в состояние «не произошло».

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