ManualResetEvent Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Threading.dll

Kaynak:

ManualResetEvent.cs

İşaretlendiğinde el ile sıfırlanması gereken bir iş parçacığı eşitleme olayını temsil eder. Bu sınıf devralınamaz.

public ref class ManualResetEvent sealed : System::Threading::EventWaitHandle

public sealed class ManualResetEvent : System.Threading.EventWaitHandle

type ManualResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle

Devralma

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Örnekler

Aşağıdaki örnekte ManualResetEvent nasıl çalıştığı gösterilmektedir. Örnek, imzasız durumdaki bir ManualResetEvent ile başlar (yani, oluşturucuya false geçirilir). Örnek, her biri WaitOne yöntemini çağırarak ManualResetEvent üzerinde blok oluşturan üç iş parçacığı oluşturur. Kullanıcı Enter tuşuna bastığında, örnek üç iş parçacığını da serbest bırakan Set yöntemini çağırır. Bunu, iş parçacıklarını her sürümden sonra otomatik olarak sıfırlayan AutoResetEvent sınıfının davranışıyla karşıtlık sağlayın.

Enter tuşuna yeniden basılması, ManualResetEventReset yöntemi çağrılana kadar sinyalli durumda kaldığını gösterir: Örnek iki iş parçacığı daha başlatır. Bu iş parçacıkları WaitOne yöntemini çağırdığında engellemez, bunun yerine tamamlamaya çalışır.

Enter tuşuna yeniden basılması, örneğin Reset yöntemini çağırmasına ve WaitOneçağırdığında engelleyen bir iş parçacığı daha başlatmasına neden olur. Enter tuşuna son kez basıldığında, son iş parçacığını serbest bırakmak için Set çağrılır ve program sona erer.

using namespace System;
using namespace System::Threading;

ref class Example
{
private:
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    static ManualResetEvent^ mre = gcnew ManualResetEvent(false);

    static void ThreadProc()
    {
        String^ name = Thread::CurrentThread->Name;

        Console::WriteLine(name + " starts and calls mre->WaitOne()");

        mre->WaitOne();

        Console::WriteLine(name + " ends.");
    }

public:
    static void Demo()
    {
        Console::WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <=2 ; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }

        Thread::Sleep(500);
        Console::WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                           "\nto release all the threads.\n");
        Console::ReadLine();

        mre->Set();

        Thread::Sleep(500);
        Console::WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                           "\ndo not block. Press Enter to show this.\n");
        Console::ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }

        Thread::Sleep(500);
        Console::WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                           "\nwhen they call WaitOne().\n");
        Console::ReadLine();

        mre->Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread^ t5 = gcnew Thread(gcnew ThreadStart(ThreadProc));
        t5->Name = "Thread_5";
        t5->Start();

        Thread::Sleep(500);
        Console::WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console::ReadLine();

        mre->Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console::ReadLine();
    }
};

int main()
{
   Example::Demo();
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre->WaitOne()
Thread_1 starts and calls mre->WaitOne()
Thread_2 starts and calls mre->WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_1 ends.
Thread_0 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre->WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre->WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre->WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

using System;
using System.Threading;

public class Example
{
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    private static ManualResetEvent mre = new ManualResetEvent(false);

    static void Main()
    {
        Console.WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <= 2; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                          "\nto release all the threads.\n");
        Console.ReadLine();

        mre.Set();

        Thread.Sleep(500);
        Console.WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                          "\ndo not block. Press Enter to show this.\n");
        Console.ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                          "\nwhen they call WaitOne().\n");
        Console.ReadLine();

        mre.Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread t5 = new Thread(ThreadProc);
        t5.Name = "Thread_5";
        t5.Start();

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console.ReadLine();

        mre.Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console.ReadLine();
    }

    private static void ThreadProc()
    {
        string name = Thread.CurrentThread.Name;

        Console.WriteLine(name + " starts and calls mre.WaitOne()");

        mre.WaitOne();

        Console.WriteLine(name + " ends.");
    }
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre.WaitOne()
Thread_1 starts and calls mre.WaitOne()
Thread_2 starts and calls mre.WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_0 ends.
Thread_1 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre.WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre.WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre.WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

Imports System.Threading

Public Class Example

    ' mre is used to block and release threads manually. It is
    ' created in the unsignaled state.
    Private Shared mre As New ManualResetEvent(False)

    <MTAThreadAttribute> _
    Shared Sub Main()

        Console.WriteLine(vbLf & _
            "Start 3 named threads that block on a ManualResetEvent:" & vbLf)

        For i As Integer = 0 To 2
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When all three threads have started, press Enter to call Set()" & vbLf & _
            "to release all the threads." & vbLf)
        Console.ReadLine()

        mre.Set()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When a ManualResetEvent is signaled, threads that call WaitOne()" & vbLf & _
            "do not block. Press Enter to show this." & vbLf)
        Console.ReadLine()

        For i As Integer = 3 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "Press Enter to call Reset(), so that threads once again block" & vbLf & _
            "when they call WaitOne()." & vbLf)
        Console.ReadLine()

        mre.Reset()

        ' Start a thread that waits on the ManualResetEvent.
        Dim t5 As New Thread(AddressOf ThreadProc)
        t5.Name = "Thread_5"
        t5.Start()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & "Press Enter to call Set() and conclude the demo.")
        Console.ReadLine()

        mre.Set()

        ' If you run this example in Visual Studio, uncomment the following line:
        'Console.ReadLine()

    End Sub


    Private Shared Sub ThreadProc()

        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine(name & " starts and calls mre.WaitOne()")

        mre.WaitOne()

        Console.WriteLine(name & " ends.")

    End Sub

End Class

' This example produces output similar to the following:
'
'Start 3 named threads that block on a ManualResetEvent:
'
'Thread_0 starts and calls mre.WaitOne()
'Thread_1 starts and calls mre.WaitOne()
'Thread_2 starts and calls mre.WaitOne()
'
'When all three threads have started, press Enter to call Set()
'to release all the threads.
'
'
'Thread_2 ends.
'Thread_0 ends.
'Thread_1 ends.
'
'When a ManualResetEvent is signaled, threads that call WaitOne()
'do not block. Press Enter to show this.
'
'
'Thread_3 starts and calls mre.WaitOne()
'Thread_3 ends.
'Thread_4 starts and calls mre.WaitOne()
'Thread_4 ends.
'
'Press Enter to call Reset(), so that threads once again block
'when they call WaitOne().
'
'
'Thread_5 starts and calls mre.WaitOne()
'
'Press Enter to call Set() and conclude the demo.
'
'Thread_5 ends.

Açıklamalar

İş parçacığı etkileşimi (veya iş parçacığı sinyali) için ManualResetEvent, AutoResetEventve EventWaitHandle kullanırsınız. Daha fazla bilgi için eşitleme temel bilgilerine genel bakış makalesinin İş Parçacığı etkileşimi veya sinyal bölümüne bakın.

Bir iş parçacığı, diğer iş parçacıkları devam etmeden önce tamamlanması gereken bir etkinliğe başladığında, sinyalsiz duruma getirmek için ManualResetEvent.Reset çağırır. Bu iş parçacığı, ManualResetEventdenetimi olarak düşünülebilir. ManualResetEvent.WaitOne bloğunu çağıran ve sinyali bekleyen iş parçacıkları. Denetim iş parçacığı etkinliği tamamladığında, bekleyen iş parçacıklarının devam edebileceğini belirten ManualResetEvent.Set çağırır. Tüm bekleyen iş parçacıkları serbest bırakılır.

sinyal verildikten sonra ManualResetEvent, Reset() yöntemi çağrılarak el ile sıfırlanana kadar sinyalli kalır. Yani, WaitOne çağrıları hemen geri döner.

Oluşturucuya boole değeri geçirerek bir ManualResetEvent ilk durumunu denetleyebilirsiniz: ilk durum sinyalliyse true ve aksi takdirde false.

ManualResetEvent static WaitAll ve WaitAny yöntemleriyle de kullanılabilir.

.NET Framework sürüm 2.0'dan başlayarak ManualResetEventEventWaitHandle sınıfından türetilir. ManualResetEvent, EventResetMode.ManualResetile oluşturulan EventWaitHandle işlevsel olarak eşdeğerdir.

Not

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

.NET Framework 4.0 sürümünden başlayarak, System.Threading.ManualResetEventSlim sınıfı ManualResetEventiçin basit bir alternatiftir.

Oluşturucular

ManualResetEvent(Boolean)

İlk durumun işaretlendi olarak ayarlanıp ayarlanmayacağını belirten bir Boole değeriyle ManualResetEvent sınıfının yeni bir örneğini başlatır.

Alanlar

WaitTimeout

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

Özellikler

Handle	Geçersiz. Yerel işletim sistemi tutamacını alır veya ayarlar. (Devralındığı yer: WaitHandle)
SafeWaitHandle	Yerel işletim sistemi tutamacı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, WaitHandletarafından kullanı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)
GetAccessControl()	Geçerli EventWaitHandle nesnesi tarafından temsil edilen adlandırılmış sistem olayının erişim denetimi güvenliğini temsil eden bir EventWaitHandleSecurity nesnesi alır. (Devralındığı yer: EventWaitHandle)
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()	Geçerli örneğin Type 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 Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnesinin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
Reset()	Olayın durumunu işaretsiz olarak ayarlar ve iş parçacıklarının engellenmesine neden olur. (Devralındığı yer: EventWaitHandle)
Set()	Bir veya daha fazla bekleyen iş parçacığının devam etmelerine olanak tanıyarak olayın durumunu işaretlendi olarak ayarlar. (Devralındığı yer: EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Adlandırılmış bir sistem olayı için erişim denetimi güvenliğini ayarlar. (Devralındığı yer: EventWaitHandle)
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
WaitOne()	Geçerli WaitHandle sinyal alıncaya kadar geçerli iş parçacığını engeller. (Devralındığı yer: WaitHandle)
WaitOne(Int32)	Geçerli WaitHandle bir sinyal alana kadar geçerli iş parçacığını engeller ve zaman aralığını milisaniye cinsinden belirtmek için 32 bit imzalı bir tamsayı kullanılır. (Devralındığı yer: WaitHandle)
WaitOne(Int32, Boolean)	Geçerli WaitHandle sinyal alana kadar geçerli 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 alana 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 sinyal alana kadar geçerli iş parçacığını engeller; zaman aralığını belirtmek için bir TimeSpan kullanarak ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtir. (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 bir tanıtıcı ayarlar.

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

Bu sınıf iş parçacığı güvenlidir.

Ayrıca bkz.

• WaitHandle
• yönetilen iş parçacığı
• Eşitleme temel bilgilerine genel bakış