EventWaitHandle Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Threading.dll

Kaynak:

EventWaitHandle.cs

İş parçacığı eşitleme olayını temsil eder.

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

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Devralma

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Türetilmiş

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Örnekler

Aşağıdaki kod örneği, ana iş parçacığının SignalAndWait(WaitHandle, WaitHandle) engellenen bir iş parçacığına sinyal göndermesini ve ardından iş parçacığının görevi bitirmesini beklemesini sağlamak için yöntem aşırı yüklemesini kullanır.

Örnek beş iş parçacığı başlatır ve bayrağıyla oluşturulan bir EventWaitHandle iş parçacığını EventResetMode.AutoReset engellemelerine olanak tanır, ardından kullanıcı Enter tuşuna her bastığında bir iş parçacığı serbest bırakır. Örnek daha sonra beş iş parçacığını daha kuyruğa alır ve bayrağıyla EventResetMode.ManualReset oluşturulan öğesini EventWaitHandle kullanarak hepsini serbest bırakır.

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

Açıklamalar

sınıfı, EventWaitHandle iş parçacıklarının sinyal göndererek birbirleriyle iletişim kurmasına olanak tanır. Genellikle, engeli kaldırılan bir iş parçacığı yöntemini çağırana Set kadar bir EventWaitHandle veya daha fazla iş parçacığı engellenen iş parçacıklarından birini veya daha fazlasını serbest bırakarak bir üzerinde engeller. bir iş parçacığı , (Shared Visual Basic'te) WaitHandle.SignalAndWait yöntemini çağırarak static bir EventWaitHandle sinyal verebilir ve ardından bunu engelleyebilir.

Not

sınıfı adlandırılmış EventWaitHandle sistem eşitleme olaylarına erişim sağlar.

Sinyal alınan bir EventWaitHandle öğesinin davranışı, sıfırlama moduna bağlıdır. EventWaitHandle bayrağıyla EventResetMode.AutoReset oluşturulan bir, tek bir bekleyen iş parçacığı serbest bırakıldıktan sonra sinyal gönderildiğinde otomatik olarak sıfırlanır. EventWaitHandle bayrağıyla oluşturulan yöntemi çağrılana EventResetMode.ManualReset kadar Reset sinyal olarak kalır.

Otomatik sıfırlama olayları bir kaynağa özel erişim sağlar. Hiçbir iş parçacığı beklemediğinde otomatik sıfırlama olayı sinyalle gösterilirse, bir iş parçacığı beklemeye çalışana kadar sinyalli olarak kalır. Olay, iş parçacığını serbest bırakır ve hemen sıfırlanır ve izleyen iş parçacıklarını engeller.

El ile sıfırlama olayları geçit gibidir. Olay sinyal verilmediğinde, üzerinde bekleyen iş parçacıkları engellenir. Olay sinyallendiğinde, bekleyen tüm iş parçacıkları serbest bırakılır ve yöntemi çağrılana kadar Reset olay sinyalli kalır (yani sonraki beklemeler engellenmez). El ile sıfırlama olayları, diğer iş parçacıklarının devam etmesi için bir iş parçacığının bir etkinliği tamamlaması gerektiğinde yararlıdır.

EventWaitHandlenesneleri (Shared Visual Basic'te) WaitHandle.WaitAll ve WaitHandle.WaitAny yöntemleriyle statickullanılabilir.

Daha fazla bilgi için Eşitleme temel bilgilerine genel bakış makalesinin İş parçacığı etkileşimi veya sinyal oluşturma bölümüne bakın.

Dikkat

Varsayılan olarak, adlandırılmış bir olay onu oluşturan kullanıcıyla sınırlı değildir. Diğer kullanıcılar, uygun olmayan bir şekilde ayarlayarak veya sıfırlayarak olaya müdahale etmek de dahil olmak üzere olayı açabilir ve kullanabilir. Belirli kullanıcılara erişimi kısıtlamak için bir oluşturucu aşırı yüklemesi kullanabilir veya EventWaitHandleAcl adlandırılmış olayı oluştururken bir EventWaitHandleSecurity geçirebilirsiniz. Kod çalıştıran güvenilmeyen kullanıcılara sahip olabilecek sistemlerde erişim kısıtlamaları olmadan adlandırılmış olayları kullanmaktan kaçının.

Oluşturucular

EventWaitHandle(Boolean, EventResetMode)	Bekleme tutamacının EventWaitHandle başlangıçta işaretlenip işaretlenmediğini ve otomatik olarak mı yoksa el ile mi sıfırlanıp sıfırlanmayacağını belirterek sınıfın yeni bir örneğini başlatır.
EventWaitHandle(Boolean, EventResetMode, String)	Sınıfının yeni bir örneğini başlatır ve bekleme tutamacının EventWaitHandle bu çağrının sonucu olarak oluşturulması durumunda ilk olarak sinyal verilip verilmeyeceğini, otomatik olarak mı yoksa el ile mi sıfırlanmasını ve sistem eşitleme olayının adını belirtir.
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Bu çağrının EventWaitHandle sonucu olarak oluşturulursa, otomatik olarak mı yoksa el ile mi sıfırlanır, bir sistem eşitleme olayının adı ve çağrıdan sonraki değeri adlandırılmış sistem olayının oluşturulup oluşturulmadığını belirten bir Boole değişkenini belirterek sınıfının yeni bir örneğini başlatır.

Alanlar

WaitTimeout

Bekleme tutamaçlarından herhangi biri sinyal almadan önce bir WaitAny(WaitHandle[], Int32, Boolean) işlemin zaman aşımına uğramasını gösterir. Bu alan sabittir. (Devralındığı yer: WaitHandle)

Özellikler

Handle	Geçersiz. Yerel işletim sistemi tanıtıcısını alır veya ayarlar. (Devralındığı yer: WaitHandle)
SafeWaitHandle	Yerel işletim sistemi tanıtıcısını alır veya ayarlar. (Devralındığı yer: WaitHandle)

Yöntemler

Close()	Geçerli WaitHandletarafından tutulan tüm kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
Dispose()	WaitHandle sınıfının geçerli örneği tarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
Dispose(Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, tarafından WaitHandlekullanılan yönetilmeyen kaynakları serbest bırakır ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
OpenExisting(String)	Belirtilen adlandırılmış eşitleme olayını (zaten varsa) açar.
Reset()	Olayın durumunu işaretsiz olarak ayarlar ve iş parçacıklarının engellenmesine neden olur.
Set()	Bir veya daha fazla bekleyen iş parçacığının devam etmelerine olanak tanıyarak olayın durumunu işaretlendi olarak ayarlar.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)
TryOpenExisting(String, EventWaitHandle)	Belirtilen adlandırılmış eşitleme olayını zaten varsa açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür.
WaitOne()	Geçerli bir sinyal alıncaya kadar geçerli WaitHandle iş parçacığını engeller. (Devralındığı yer: WaitHandle)
WaitOne(Int32)	Geçerli iş parçacığı, milisaniye cinsinden zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir sinyal alana kadar geçerli WaitHandle iş parçacığını engeller. (Devralındığı yer: WaitHandle)
WaitOne(Int32, Boolean)	Geçerli bir sinyal alana kadar geçerli WaitHandle iş parçacığını engeller; zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanın ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtin. (Devralındığı yer: WaitHandle)
WaitOne(TimeSpan)	Geçerli örnek bir sinyal alıncaya kadar geçerli iş parçacığını engeller ve zaman aralığını belirtmek için bir TimeSpan kullanılır. (Devralındığı yer: WaitHandle)
WaitOne(TimeSpan, Boolean)	Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller; zaman aralığını belirtmek için bir TimeSpan kullanın ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtin. (Devralındığı yer: WaitHandle)

Uzantı Metotları

GetAccessControl(EventWaitHandle)	Belirtilen handleiçin güvenlik tanımlayıcılarını döndürür.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Belirtilen olay bekleme tanıtıcısı için güvenlik tanımlayıcılarını ayarlar.
GetSafeWaitHandle(WaitHandle)	Yerel işletim sistemi bekleme tutamacını güvenli tutamacını alır.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Yerel işletim sistemi bekleme tutamacı için güvenli tanıtıcı ayarlar.

İş Parçacığı Güvenliği

Bu güvenli iş parçacığı türüdür.

Ayrıca bkz.

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Yönetilen İş Parçacığı Oluşturma
• Eşitleme temellerine genel bakış