eventwaithandle - waitone c#




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

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

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


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

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

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

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

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


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

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

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

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


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


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


Хорошо, обычно не рекомендуется добавлять 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);
        }
    }

}


Я создал простые примеры, чтобы прояснить понимание 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 поддерживает логическую переменную в памяти. Если логическая переменная имеет значение 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 и выходит из цикла и печатает «сигнал, полученный по каналу».

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

Метод 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();

Метод сброса

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

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

manualResetEvent.Reset();

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





manualresetevent