EventWaitHandle Класс

Определение

Пространство имен:

System.Threading

Сборка:

System.Threading.dll

Исходный код:

EventWaitHandle.cs

Представляет событие синхронизации потока.

public ref class EventWaitHandle : System::Threading::WaitHandle

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Наследование

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Производный

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Примеры

В следующем примере кода используется перегрузка SignalAndWait(WaitHandle, WaitHandle) метода, чтобы позволить потоку main сигнализировать о заблокированном потоке, а затем подождать, пока поток завершит задачу.

Пример запускает пять потоков и позволяет им блокировать созданный с флагом EventWaitHandleEventResetMode.AutoReset , а затем освобождает один поток каждый раз, когда пользователь нажимает клавишу ВВОД . Затем в этом примере помещает в очередь еще пять потоков и освобождает их с помощью созданного EventWaitHandle с флагом EventResetMode.ManualReset .

using namespace System;
using namespace System::Threading;

public ref class Example
{
private:
   // The EventWaitHandle used to demonstrate the difference
   // between AutoReset and ManualReset synchronization events.
   //
   static EventWaitHandle^ ewh;

   // A counter to make sure all threads are started and
   // blocked before any are released. A Long is used to show
   // the use of the 64-bit Interlocked methods.
   //
   static __int64 threadCount = 0;

   // An AutoReset event that allows the main thread to block
   // until an exiting thread has decremented the count.
   //
   static EventWaitHandle^ clearCount =
      gcnew EventWaitHandle( false,EventResetMode::AutoReset );

public:
   [MTAThread]
   static void main()
   {
      // Create an AutoReset EventWaitHandle.
      //
      ewh = gcnew EventWaitHandle( false,EventResetMode::AutoReset );
      
      // Create and start five numbered threads. Use the
      // ParameterizedThreadStart delegate, so the thread
      // number can be passed as an argument to the Start
      // method.
      for ( int i = 0; i <= 4; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( ThreadProc ) );
         t->Start( i );
      }
      
      // Wait until all the threads have started and blocked.
      // When multiple threads use a 64-bit value on a 32-bit
      // system, you must access the value through the
      // Interlocked class to guarantee thread safety.
      //
      while ( Interlocked::Read( threadCount ) < 5 )
      {
         Thread::Sleep( 500 );
      }

      // Release one thread each time the user presses ENTER,
      // until all threads have been released.
      //
      while ( Interlocked::Read( threadCount ) > 0 )
      {
         Console::WriteLine( L"Press ENTER to release a waiting thread." );
         Console::ReadLine();
         
         // SignalAndWait signals the EventWaitHandle, which
         // releases exactly one thread before resetting,
         // because it was created with AutoReset mode.
         // SignalAndWait then blocks on clearCount, to
         // allow the signaled thread to decrement the count
         // before looping again.
         //
         WaitHandle::SignalAndWait( ewh, clearCount );
      }
      Console::WriteLine();
      
      // Create a ManualReset EventWaitHandle.
      //
      ewh = gcnew EventWaitHandle( false,EventResetMode::ManualReset );
      
      // Create and start five more numbered threads.
      //
      for ( int i = 0; i <= 4; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( ThreadProc ) );
         t->Start( i );
      }
      
      // Wait until all the threads have started and blocked.
      //
      while ( Interlocked::Read( threadCount ) < 5 )
      {
         Thread::Sleep( 500 );
      }

      // Because the EventWaitHandle was created with
      // ManualReset mode, signaling it releases all the
      // waiting threads.
      //
      Console::WriteLine( L"Press ENTER to release the waiting threads." );
      Console::ReadLine();
      ewh->Set();

   }

   static void ThreadProc( Object^ data )
   {
      int index = static_cast<Int32>(data);

      Console::WriteLine( L"Thread {0} blocks.", data );
      // Increment the count of blocked threads.
      Interlocked::Increment( threadCount );
      
      // Wait on the EventWaitHandle.
      ewh->WaitOne();

      Console::WriteLine( L"Thread {0} exits.", data );
      // Decrement the count of blocked threads.
      Interlocked::Decrement( threadCount );
      
      // After signaling ewh, the main thread blocks on
      // clearCount until the signaled thread has
      // decremented the count. Signal it now.
      //
      clearCount->Set();
   }
};

using System;
using System.Threading;

public class Example
{
    // The EventWaitHandle used to demonstrate the difference
    // between AutoReset and ManualReset synchronization events.
    //
    private static EventWaitHandle ewh;

    // A counter to make sure all threads are started and
    // blocked before any are released. A Long is used to show
    // the use of the 64-bit Interlocked methods.
    //
    private static long threadCount = 0;

    // An AutoReset event that allows the main thread to block
    // until an exiting thread has decremented the count.
    //
    private static EventWaitHandle clearCount = 
        new EventWaitHandle(false, EventResetMode.AutoReset);

    [MTAThread]
    public static void Main()
    {
        // Create an AutoReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

        // Create and start five numbered threads. Use the
        // ParameterizedThreadStart delegate, so the thread
        // number can be passed as an argument to the Start 
        // method.
        for (int i = 0; i <= 4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        // When multiple threads use a 64-bit value on a 32-bit
        // system, you must access the value through the
        // Interlocked class to guarantee thread safety.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Release one thread each time the user presses ENTER,
        // until all threads have been released.
        //
        while (Interlocked.Read(ref threadCount) > 0)
        {
            Console.WriteLine("Press ENTER to release a waiting thread.");
            Console.ReadLine();

            // SignalAndWait signals the EventWaitHandle, which
            // releases exactly one thread before resetting, 
            // because it was created with AutoReset mode. 
            // SignalAndWait then blocks on clearCount, to 
            // allow the signaled thread to decrement the count
            // before looping again.
            //
            WaitHandle.SignalAndWait(ewh, clearCount);
        }
        Console.WriteLine();

        // Create a ManualReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

        // Create and start five more numbered threads.
        //
        for(int i=0; i<=4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Because the EventWaitHandle was created with
        // ManualReset mode, signaling it releases all the
        // waiting threads.
        //
        Console.WriteLine("Press ENTER to release the waiting threads.");
        Console.ReadLine();
        ewh.Set();
    }

    public static void ThreadProc(object data)
    {
        int index = (int) data;

        Console.WriteLine("Thread {0} blocks.", data);
        // Increment the count of blocked threads.
        Interlocked.Increment(ref threadCount);

        // Wait on the EventWaitHandle.
        ewh.WaitOne();

        Console.WriteLine("Thread {0} exits.", data);
        // Decrement the count of blocked threads.
        Interlocked.Decrement(ref threadCount);

        // After signaling ewh, the main thread blocks on
        // clearCount until the signaled thread has 
        // decremented the count. Signal it now.
        //
        clearCount.Set();
    }
}

Imports System.Threading

Public Class Example

    ' The EventWaitHandle used to demonstrate the difference
    ' between AutoReset and ManualReset synchronization events.
    '
    Private Shared ewh As EventWaitHandle

    ' A counter to make sure all threads are started and
    ' blocked before any are released. A Long is used to show
    ' the use of the 64-bit Interlocked methods.
    '
    Private Shared threadCount As Long = 0

    ' An AutoReset event that allows the main thread to block
    ' until an exiting thread has decremented the count.
    '
    Private Shared clearCount As New EventWaitHandle(False, _
        EventResetMode.AutoReset)

    <MTAThread> _
    Public Shared Sub Main()

        ' Create an AutoReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.AutoReset)

        ' Create and start five numbered threads. Use the
        ' ParameterizedThreadStart delegate, so the thread
        ' number can be passed as an argument to the Start 
        ' method.
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        ' When multiple threads use a 64-bit value on a 32-bit
        ' system, you must access the value through the
        ' Interlocked class to guarantee thread safety.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Release one thread each time the user presses ENTER,
        ' until all threads have been released.
        '
        While Interlocked.Read(threadCount) > 0
            Console.WriteLine("Press ENTER to release a waiting thread.")
            Console.ReadLine()

            ' SignalAndWait signals the EventWaitHandle, which
            ' releases exactly one thread before resetting, 
            ' because it was created with AutoReset mode. 
            ' SignalAndWait then blocks on clearCount, to 
            ' allow the signaled thread to decrement the count
            ' before looping again.
            '
            WaitHandle.SignalAndWait(ewh, clearCount)
        End While
        Console.WriteLine()

        ' Create a ManualReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.ManualReset)

        ' Create and start five more numbered threads.
        '
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Because the EventWaitHandle was created with
        ' ManualReset mode, signaling it releases all the
        ' waiting threads.
        '
        Console.WriteLine("Press ENTER to release the waiting threads.")
        Console.ReadLine()
        ewh.Set()
        
    End Sub

    Public Shared Sub ThreadProc(ByVal data As Object)
        Dim index As Integer = CInt(data)

        Console.WriteLine("Thread {0} blocks.", data)
        ' Increment the count of blocked threads.
        Interlocked.Increment(threadCount)

        ' Wait on the EventWaitHandle.
        ewh.WaitOne()

        Console.WriteLine("Thread {0} exits.", data)
        ' Decrement the count of blocked threads.
        Interlocked.Decrement(threadCount)

        ' After signaling ewh, the main thread blocks on
        ' clearCount until the signaled thread has 
        ' decremented the count. Signal it now.
        '
        clearCount.Set()
    End Sub
End Class

Комментарии

Класс EventWaitHandle позволяет потокам взаимодействовать друг с другом посредством сигнализации. Как правило, один или несколько потоков блокируются в , EventWaitHandle пока неблокированный поток не вызовет Set метод , освобождая один или несколько заблокированных потоков. Поток может сигнализироватьEventWaitHandle, а затем блокировать его, вызывая static метод (Shared в Visual Basic). WaitHandle.SignalAndWait

Примечание

Класс EventWaitHandle предоставляет доступ к именованным событиям синхронизации системы.

Поведение объекта , EventWaitHandle для которого было показано, зависит от режима сброса. Объект , EventWaitHandle созданный с флагом EventResetMode.AutoReset , сбрасывается автоматически при получении сигнала после освобождения одного ожидающего потока. EventWaitHandle, созданный с помощью флага EventResetMode.ManualReset, находится в сигнальном состоянии, пока не будет вызван его метод Reset.

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

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

EventWaitHandle Объекты можно использовать с методами static(Shared в Visual Basic) WaitHandle.WaitAll и WaitHandle.WaitAny .

Дополнительные сведения см. в разделе Взаимодействие с потоками или сигнализация статьи Обзор примитивов синхронизации .

Внимание!

По умолчанию именованное событие не ограничивается пользователем, который его создал. Другие пользователи могут открывать и использовать событие, в том числе вмешиваться в событие, устанавливая или сбрасывая его ненадлежащим образом. Чтобы ограничить доступ для определенных пользователей, можно использовать перегрузку конструктора или EventWaitHandleAcl и передать при создании именованного EventWaitHandleSecurity события. Избегайте использования именованных событий без ограничений доступа в системах, в которых могут выполняться ненадежные пользователи, выполняющие код.

Конструкторы

EventWaitHandle(Boolean, EventResetMode)	Выполняет инициализацию нового экземпляра класса EventWaitHandle, определяя, получает ли сигнал, ожидающий дескриптор, и производится ли сброс автоматически или вручную.
EventWaitHandle(Boolean, EventResetMode, String)	Выполняет инициализацию нового экземпляра класса EventWaitHandle, определяющего получает ли сигнал дескриптор ожидания, если он был создан в результате данного вызова, сбрасывается ли он автоматически или вручную, а также имя системного события синхронизации.
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Инициализирует новый экземпляр класса EventWaitHandle и указывает следующие сведения: передавать ли сигнал в дескриптор ожидания при первичном запуске в результате этого вызова; выполнять ли сброс автоматически или вручную; имя системного события синхронизации; логическая переменная для сохранения информации о том, было ли создано именованное системное событие.

Поля

WaitTimeout

Указывает, что время ожидания операции WaitAny(WaitHandle[], Int32, Boolean) истекло до получения сигнала каким-либо из дескрипторов ожидания. Это поле является константой. (Унаследовано от WaitHandle)

Свойства

Handle	Устаревшие.. Возвращает или задает собственный дескриптор операционной системы. (Унаследовано от WaitHandle)
SafeWaitHandle	Возвращает или задает собственный дескриптор операционной системы. (Унаследовано от WaitHandle)

Методы

Close()	Освобождает все ресурсы, удерживаемые текущим объектом WaitHandle. (Унаследовано от WaitHandle)
CreateObjRef(Type)	Создает объект, который содержит всю необходимую информацию для создания прокси-сервера, используемого для взаимодействия с удаленным объектом. (Унаследовано от MarshalByRefObject)
Dispose()	Освобождает все ресурсы, используемые текущим экземпляром класса WaitHandle. (Унаследовано от WaitHandle)
Dispose(Boolean)	При переопределении в производном классе освобождает неуправляемые ресурсы, используемые объектом WaitHandle, и при необходимости освобождает управляемые ресурсы. (Унаследовано от WaitHandle)
Equals(Object)	Определяет, равен ли указанный объект текущему объекту. (Унаследовано от Object)
GetHashCode()	Служит хэш-функцией по умолчанию. (Унаследовано от Object)
GetLifetimeService()	Устаревшие.. Извлекает объект обслуживания во время существования, который управляет политикой времени существования данного экземпляра. (Унаследовано от MarshalByRefObject)
GetType()	Возвращает объект Type для текущего экземпляра. (Унаследовано от Object)
InitializeLifetimeService()	Устаревшие.. Получает объект службы времени существования для управления политикой времени существования для этого экземпляра. (Унаследовано от MarshalByRefObject)
MemberwiseClone()	Создает неполную копию текущего объекта Object. (Унаследовано от Object)
MemberwiseClone(Boolean)	Создает неполную копию текущего объекта MarshalByRefObject. (Унаследовано от MarshalByRefObject)
OpenExisting(String)	Открывает указанное именованное событие синхронизации, если оно уже существует.
Reset()	Задает несигнальное состояние события, вызывая блокирование потоков.
Set()	Задает сигнальное состояние события, позволяя одному или нескольким ожидающим потокам продолжить.
ToString()	Возвращает строку, представляющую текущий объект. (Унаследовано от Object)
TryOpenExisting(String, EventWaitHandle)	Открывает указанное именованное событие синхронизации, если оно уже существует, и возвращает значение, указывающее, успешно ли выполнена операция.
WaitOne()	Блокирует текущий поток до получения сигнала объектом WaitHandle. (Унаследовано от WaitHandle)
WaitOne(Int32)	Блокирует текущий поток до получения текущим дескриптором WaitHandle сигнала, используя 32-разрядное целое число со знаком для указания интервала времени в миллисекундах. (Унаследовано от WaitHandle)
WaitOne(Int32, Boolean)	Блокирует текущий поток до получения сигнала текущим объектом WaitHandle, используя 32-разрядное целое число со знаком для задания периода времени и указывая, следует ли выйти из домена синхронизации до начала ожидания. (Унаследовано от WaitHandle)
WaitOne(TimeSpan)	Блокирует текущий поток до получения сигнала текущим экземпляром, используя значение типа TimeSpan для указания интервала времени. (Унаследовано от WaitHandle)
WaitOne(TimeSpan, Boolean)	Блокирует текущий поток до получения сигнала текущим экземпляром, используя значение типа TimeSpan для задания интервала времени и указывая, следует ли выйти из домена синхронизации до начала ожидания. (Унаследовано от WaitHandle)

Методы расширения

GetSafeWaitHandle(WaitHandle)	Возвращает безопасный дескриптор для собственного дескриптора ожидания операционной системы.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Задает безопасный дескриптор для собственного дескриптора ожидания операционной системы.

Потокобезопасность

Данный тип потокобезопасен.

См. также раздел

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Управляемая поточность
• Обзор примитивов синхронизации