EventWaitHandle Kelas

Definisi

Ruang nama:

System.Threading

Rakitan:

System.Threading.dll

Sumber:

EventWaitHandle.cs

Mewakili peristiwa sinkronisasi utas.

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

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Warisan

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Turunan

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Contoh

Contoh kode berikut menggunakan metode kelebihan beban untuk memungkinkan utas utama memberi sinyal utas SignalAndWait(WaitHandle, WaitHandle) yang diblokir lalu menunggu hingga utas menyelesaikan tugas.

Contohnya memulai lima utas dan memungkinkannya memblokir pada yang EventWaitHandle dibuat dengan EventResetMode.AutoReset bendera, lalu merilis satu utas setiap kali pengguna menekan tombol Enter . Contohnya kemudian mengantre lima utas lain dan merilis semuanya menggunakan yang EventWaitHandle dibuat dengan EventResetMode.ManualReset bendera .

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

Keterangan

Kelas ini EventWaitHandle memungkinkan utas untuk berkomunikasi satu sama lain dengan memberi sinyal. Biasanya, satu atau beberapa utas memblokir pada EventWaitHandle hingga utas yang tidak diblokir memanggil metode , merilis Set satu atau beberapa utas yang diblokir. Utas dapat memberi sinyal EventWaitHandle dan kemudian memblokirnya, dengan memanggil static metode (Shared dalam Visual Basic WaitHandle.SignalAndWait ).

Catatan

Kelas EventWaitHandle ini menyediakan akses ke peristiwa sinkronisasi sistem bernama.

Perilaku yang EventWaitHandle telah disinyalkan tergantung pada mode resetnya. Dibuat EventWaitHandle dengan EventResetMode.AutoReset bendera direset secara otomatis saat diberi sinyal, setelah merilis satu utas tunggu. EventWaitHandle yang dibuat dengan bendera EventResetMode.ManualReset tetap diberi sinyal sampai metode Reset dipanggil.

Peristiwa reset otomatis menyediakan akses eksklusif ke sumber daya. Jika aktivitas reset otomatis ditandai saat tidak ada rangkaian yang menunggu, itu tetap ditandai sampai rangkaian mencoba untuk menunggu. Aktivitas ini melepaskan rangkaian dan segera diatur ulang, memblokir rangkaian berikutnya.

Peristiwa reset manual seperti gerbang. Ketika peristiwa tidak diberi sinyal, utas yang menunggu di atasnya akan memblokir. Ketika peristiwa disinyalir, semua utas tunggu dirilis, dan peristiwa tetap diberi sinyal (yaitu, tunggu berikutnya tidak memblokir) sampai metodenya Reset dipanggil. Peristiwa reset manual berguna ketika satu utas harus menyelesaikan aktivitas sebelum utas lain dapat dilanjutkan.

EventWaitHandle objek dapat digunakan dengan static(Shared dalam Visual Basic) WaitHandle.WaitAll dan WaitHandle.WaitAny metode.

Untuk informasi selengkapnya, lihat bagian Interaksi utas, atau sinyal dari artikel Gambaran Umum primitif sinkronisasi .

Perhatian

Secara default, peristiwa bernama tidak dibatasi untuk pengguna yang membuatnya. Pengguna lain mungkin dapat membuka dan menggunakan peristiwa, termasuk mengganggu peristiwa dengan mengatur atau mengatur ulang secara tidak pantas. Untuk membatasi akses ke pengguna tertentu, Anda dapat menggunakan kelebihan beban konstruktor atau EventWaitHandleAcl dan meneruskan EventWaitHandleSecurity saat membuat peristiwa bernama. Hindari menggunakan peristiwa bernama tanpa pembatasan akses pada sistem yang mungkin memiliki pengguna yang tidak tepercaya yang menjalankan kode.

Konstruktor

EventWaitHandle(Boolean, EventResetMode)	Menginisialisasi instans EventWaitHandle baru kelas, menentukan apakah handel tunggu awalnya diberi sinyal, dan apakah itu direset secara otomatis atau manual.
EventWaitHandle(Boolean, EventResetMode, String)	Menginisialisasi instans EventWaitHandle baru kelas, menentukan apakah handel tunggu awalnya diberi sinyal jika dibuat sebagai akibat dari panggilan ini, baik direset secara otomatis atau manual, dan nama peristiwa sinkronisasi sistem.
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Menginisialisasi instans EventWaitHandle baru kelas, menentukan apakah handel tunggu awalnya diberi sinyal jika dibuat sebagai akibat dari panggilan ini, baik direset secara otomatis atau manual, nama peristiwa sinkronisasi sistem, dan variabel Boolean yang nilainya setelah panggilan menunjukkan apakah peristiwa sistem bernama dibuat.

Bidang

WaitTimeout

Menunjukkan bahwa WaitAny(WaitHandle[], Int32, Boolean) waktu operasi habis sebelum salah satu handel tunggu diberi sinyal. Bidang ini konstan. (Diperoleh dari WaitHandle)

Properti

Handle	Kedaluwarsa. Mendapatkan atau mengatur handel sistem operasi asli. (Diperoleh dari WaitHandle)
SafeWaitHandle	Mendapatkan atau mengatur handel sistem operasi asli. (Diperoleh dari WaitHandle)

Metode

Close()	Merilis semua sumber daya yang dipegang oleh saat ini WaitHandle. (Diperoleh dari WaitHandle)
CreateObjRef(Type)	Membuat objek yang berisi semua informasi relevan yang diperlukan untuk menghasilkan proksi yang digunakan untuk berkomunikasi dengan objek jarak jauh. (Diperoleh dari MarshalByRefObject)
Dispose()	Merilis semua sumber daya yang digunakan oleh instans WaitHandle kelas saat ini. (Diperoleh dari WaitHandle)
Dispose(Boolean)	Ketika ditimpa di kelas turunan, merilis sumber daya tidak terkelola yang digunakan oleh WaitHandle, dan secara opsional merilis sumber daya terkelola. (Diperoleh dari WaitHandle)
Equals(Object)	Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diperoleh dari Object)
GetHashCode()	Berfungsi sebagai fungsi hash default. (Diperoleh dari Object)
GetLifetimeService()	Kedaluwarsa. Mengambil objek layanan seumur hidup saat ini yang mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
GetType()	Mendapatkan instans Type saat ini. (Diperoleh dari Object)
InitializeLifetimeService()	Kedaluwarsa. Mendapatkan objek layanan seumur hidup untuk mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
MemberwiseClone()	Membuat salinan dangkal dari yang saat ini Object. (Diperoleh dari Object)
MemberwiseClone(Boolean)	Membuat salinan dangkal objek saat ini MarshalByRefObject . (Diperoleh dari MarshalByRefObject)
OpenExisting(String)	Membuka peristiwa sinkronisasi bernama yang ditentukan, jika sudah ada.
Reset()	Mengatur status peristiwa ke tidak ditandatangani, menyebabkan utas diblokir.
Set()	Mengatur status peristiwa yang akan disinyalir, memungkinkan satu atau beberapa utas tunggu untuk dilanjutkan.
ToString()	Mengembalikan string yang mewakili objek saat ini. (Diperoleh dari Object)
TryOpenExisting(String, EventWaitHandle)	Membuka peristiwa sinkronisasi bernama yang ditentukan, jika sudah ada, dan mengembalikan nilai yang menunjukkan apakah operasi berhasil.
WaitOne()	Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal. (Diperoleh dari WaitHandle)
WaitOne(Int32)	Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu dalam milidetik. (Diperoleh dari WaitHandle)
WaitOne(Int32, Boolean)	Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu. (Diperoleh dari WaitHandle)
WaitOne(TimeSpan)	Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu. (Diperoleh dari WaitHandle)
WaitOne(TimeSpan, Boolean)	Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu. (Diperoleh dari WaitHandle)

Metode Ekstensi

GetAccessControl(EventWaitHandle)	Mengembalikan deskriptor keamanan untuk yang ditentukan handle.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Mengatur deskriptor keamanan untuk penanganan tunggu peristiwa yang ditentukan.
GetSafeWaitHandle(WaitHandle)	Mendapatkan handel aman untuk handel tunggu sistem operasi asli.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Mengatur handel yang aman untuk handel tunggu sistem operasi asli.

Keamanan Thread

Jenis ini aman untuk utas.

Lihat juga

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Pengaluran Terkelola
• Ringkasan primitif sinkronisasi