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) 使用 方法多載，讓主線程發出封鎖的線程訊號，然後等候線程完成工作。

此範例會啟動五個線程，並允許他們在使用 旗標建立的 EventWaitHandleEventResetMode.AutoReset 上封鎖，然後在每次使用者按下 Enter 鍵時釋放一個線程。 此範例接著會排入另五個 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 方法為止，釋放一或多個封鎖的線程。 線程可以在 Visual Basic) 方法中呼叫 static (Shared，然後對它發出訊EventWaitHandle號並WaitHandle.SignalAndWait加以封鎖。

注意

類別 EventWaitHandle 提供具名系統同步處理事件的存取權。

已發出訊號的 EventWaitHandle 行為取決於其重設模式。 使用旗標建立的 EventResetMode.AutoReset ，EventWaitHandle會在發出訊號之後，在釋放單一等候線程之後自動重設。 搭配 EventResetMode.ManualReset 旗標建立的 EventWaitHandle 會維持已收到訊號的狀態，直到其 Reset 方法被呼叫為止。

自動重設事件提供資源的獨佔存取權。 如果自動重設事件在沒有任何執行緒處於等候狀態時收到訊號，它會維持收到訊號的狀態，直到有執行緒嘗試等候它為止。 此事件會釋出執行緒並立即重設，以阻斷後續的執行緒。

手動重設事件就像閘道。 當事件未收到訊號時，等候事件的線程將會封鎖。 當事件發出訊號時，會釋放所有等候的線程，而且事件會維持訊號 (也就是說，在呼叫其 Reset 方法之前，後續等候不會封鎖) 。 當一個線程必須完成活動，才能繼續其他線程之前，手動重設事件會很有用。

EventWaitHandle物件可以與 Visual Basic) WaitHandle.WaitAll 和 WaitHandle.WaitAny 方法中的 (Shared 搭配static使用。

如需詳細資訊，請參閱同步處理基本概觀一文的線程互動或訊號一節。

警告

根據預設，具名事件不會限制為建立它的使用者。 其他使用者可能能夠開啟和使用事件，包括藉由設定或不當重設事件來干擾事件。 若要限制特定使用者的存取權，您可以使用建構函式多載，或在 EventWaitHandleAcl 建立具名事件時傳入 EventWaitHandleSecurity 。 避免在可能有不受信任的使用者執行程式碼的系統上使用具名事件，而不受存取限制。

建構函式

EventWaitHandle(Boolean, EventResetMode)	初始化 EventWaitHandle 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號，以及是以自動還是手動方式來重設。
EventWaitHandle(Boolean, EventResetMode, String)	初始化 EventWaitHandle 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號 (如果它是因這個呼叫而建立)、是以自動還是手動方式進行重設，以及系統同步處理事件的名稱。
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	初始化 EventWaitHandle 類別的新執行個體，指定如果等候控制代碼是因此呼叫而建立，一開始是否會發出信號；它是否會自動或手動重設；系統同步處理事件的名稱；以及布林值變數，其值會在呼叫之後指出是否已建立具名系統事件。

欄位

WaitTimeout

表示 WaitAny(WaitHandle[], Int32, Boolean) 作業在發出任何等候控制代碼信號之前便已逾時。 這個欄位為常數。 (繼承來源 WaitHandle)

屬性

Handle	已淘汰. 取得或設定原生 (Native) 的作業系統控制代碼。 (繼承來源 WaitHandle)
SafeWaitHandle	取得或設定原生 (Native) 的作業系統控制代碼。 (繼承來源 WaitHandle)

方法

Close()	釋放目前 WaitHandle 所持有的全部資源。 (繼承來源 WaitHandle)
CreateObjRef(Type)	建立包含所有相關資訊的物件，這些資訊是產生用來與遠端物件通訊的所需 Proxy。 (繼承來源 MarshalByRefObject)
Dispose()	釋放 WaitHandle 類別目前的執行個體所使用的全部資源。 (繼承來源 WaitHandle)
Dispose(Boolean)	當在衍生類別中覆寫時，釋放 WaitHandle 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 (繼承來源 WaitHandle)
Equals(Object)	判斷指定的物件是否等於目前的物件。 (繼承來源 Object)
GetHashCode()	做為預設雜湊函式。 (繼承來源 Object)
GetLifetimeService()	已淘汰. 擷取控制這個執行個體存留期 (Lifetime) 原則的目前存留期服務物件。 (繼承來源 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)

擴充方法

GetAccessControl(EventWaitHandle)	傳回所指定 handle 的安全性描述元。
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	設定所指定事件等候控制代碼的安全性描述元。
GetSafeWaitHandle(WaitHandle)	取得原生作業系統等候控制代碼的安全控制代碼。
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	設定原生作業系統等候控制代碼的安全控制代碼。

執行緒安全性

此型別具備執行緒安全。

另請參閱

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Managed 執行緒處理
• 同步處理原始物件概觀