ManualResetEvent Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Threading.dll

Source:

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 nasıl ManualResetEvent çalıştığı gösterilmektedir. Örnek, imzalanmamış durumda bir ManualResetEvent ile başlar (yani oluşturucuya false geçirilir). Örnek, her biri yöntemini çağırarak WaitOne üzerinde ManualResetEvent blokları olan üç iş parçacığı oluşturur. Kullanıcı Enter tuşuna bastığında, örnek üç iş parçacığını Set da serbest bırakan yöntemini çağırır. Bunu, iş parçacıklarını birer birer serbest bırakan ve her yayından sonra otomatik olarak sıfırlayan sınıfının davranışıyla AutoResetEvent karşıtlık oluşturun.

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

Enter tuşuna yeniden basılması, örneğin yöntemini çağırmasına Reset ve çağırdığında WaitOneengelleyen bir iş parçacığı daha başlatmasına neden olur. Son kez Enter tuşuna basıldığında, son iş parçacığını serbest bırakmak için çağrı yapılır Set 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 , AutoResetEventve EventWaitHandle kullanırsınızManualResetEvent. 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.

Bir iş parçacığı, diğer iş parçacıkları devam etmeden önce tamamlanması gereken bir etkinliği başlatırsa, sinyalsiz duruma getirmek ManualResetEvent için ManualResetEvent.Reset'i çağırır. Bu iş parçacığı, öğesini denetlediği ManualResetEventdüşü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 edebildiğini haber vermek için ManualResetEvent.Set öğesini çağırır. Tüm bekleyen iş parçacıkları serbest bırakılır.

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

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

ManualResetEventve WaitAny yöntemleriyle staticWaitAll de kullanılabilir.

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

Not

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

.NET Framework sürüm 4.0'ı kullanmaya System.Threading.ManualResetEventSlim başlayarak sınıfı için basit bir alternatiftirManualResetEvent.

Oluşturucular

ManualResetEvent(Boolean)

sınıfının yeni bir örneğini ManualResetEvent , ilk durumun sinyalli olarak ayarlanıp ayarlanmayacağını belirten bir Boole değeriyle 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)
GetAccessControl()	EventWaitHandleSecurity Geçerli EventWaitHandle nesne tarafından temsil edilen adlandırılmış sistem olayı için erişim denetimi güvenliğini temsil eden bir 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()	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)
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 dizeyi döndürür. (Devralındığı yer: Object)
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ı

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 sınıf iş parçacığı güvenlidir.

Ayrıca bkz.

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