ManualResetEvent Kelas

Definisi

Ruang nama:

System.Threading

Rakitan:

System.Threading.dll

Sumber:

ManualResetEvent.cs

Mewakili peristiwa sinkronisasi utas yang, ketika disinyalir, harus diatur ulang secara manual. Kelas ini tidak dapat diwariskan.

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

Warisan

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Contoh

Contoh berikut menunjukkan cara kerja ManualResetEvent. Contoh dimulai dengan ManualResetEvent dalam status tidak bertanda tangan (yaitu, false diteruskan ke konstruktor). Contohnya membuat tiga utas, yang masing-masing memblokir pada ManualResetEvent dengan memanggil metode WaitOne. Saat pengguna menekan tombol Enter, contoh memanggil metode Set, yang merilis ketiga utas. Berbeda dengan perilaku kelas AutoResetEvent, yang merilis utas satu per satu, mengatur ulang secara otomatis setelah setiap rilis.

Menekan tombol Enter lagi menunjukkan bahwa ManualResetEvent tetap dalam status sinyal hingga metode Reset dipanggil: Contoh memulai dua utas lagi. Utas ini tidak memblokir ketika mereka memanggil metode WaitOne, tetapi sebaliknya berjalan hingga selesai.

Menekan tombol Enter lagi menyebabkan contoh memanggil metode Reset dan memulai satu utas lagi, yang memblokir saat memanggil WaitOne. Menekan tombol Enter satu kali terakhir memanggil Set untuk merilis utas terakhir, dan program berakhir.

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.

Keterangan

Anda menggunakan ManualResetEvent, AutoResetEvent, dan EventWaitHandle untuk interaksi utas (atau sinyal utas). Untuk informasi selengkapnya, lihat bagian interaksi Thread, atau sinyal dari artikel Gambaran Umum primitif sinkronisasi.

Ketika utas memulai aktivitas yang harus diselesaikan sebelum utas lain dilanjutkan, utas memanggil ManualResetEvent.Reset untuk menempatkan ManualResetEvent dalam status tidak diberi sinyal. Utas ini dapat dianggap sebagai mengendalikan ManualResetEvent. Utas yang memanggil blok ManualResetEvent.WaitOne, menunggu sinyal. Ketika utas pengontrol menyelesaikan aktivitas, alur memanggil ManualResetEvent.Set untuk memberi sinyal bahwa utas tunggu dapat dilanjutkan. Semua utas tunggu dirilis.

Setelah disinyalir, ManualResetEvent tetap diberi sinyal sampai diatur ulang secara manual dengan memanggil metode Reset(). Artinya, panggilan ke WaitOne segera kembali.

Anda dapat mengontrol status awal ManualResetEvent dengan meneruskan nilai Boolean ke konstruktor: true jika status awal diberi sinyal, dan false sebaliknya.

ManualResetEvent juga dapat digunakan dengan metode staticWaitAll dan WaitAny.

Dimulai dengan .NET Framework versi 2.0, ManualResetEvent berasal dari kelas EventWaitHandle. ManualResetEvent secara fungsional setara dengan EventWaitHandle yang dibuat dengan EventResetMode.ManualReset.

Nota

Tidak seperti kelas ManualResetEvent, kelas EventWaitHandle menyediakan akses ke peristiwa sinkronisasi sistem bernama.

Dimulai dengan .NET Framework versi 4.0, kelas System.Threading.ManualResetEventSlim adalah alternatif ringan untuk ManualResetEvent.

Konstruktor

ManualResetEvent(Boolean)

Menginisialisasi instans baru kelas ManualResetEvent dengan nilai Boolean yang menunjukkan apakah akan mengatur status awal ke sinyal.

Bidang

WaitTimeout

Menunjukkan bahwa operasi WaitAny(WaitHandle[], Int32, Boolean) kehabisan waktu 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 disimpan oleh WaitHandlesaat ini. (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 kelas WaitHandle saat ini. (Diperoleh dari WaitHandle)
Dispose(Boolean)	Saat ditimpa di kelas turunan, merilis sumber daya yang tidak dikelola 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)
GetAccessControl()	Mendapatkan objek EventWaitHandleSecurity yang mewakili keamanan kontrol akses untuk peristiwa sistem bernama yang diwakili oleh objek EventWaitHandle saat ini. (Diperoleh dari EventWaitHandle)
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 Type instans 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 Objectsaat ini. (Diperoleh dari Object)
MemberwiseClone(Boolean)	Membuat salinan dangkal objek MarshalByRefObject saat ini. (Diperoleh dari MarshalByRefObject)
Reset()	Mengatur status peristiwa ke nonsignaled, menyebabkan utas diblokir. (Diperoleh dari EventWaitHandle)
Set()	Mengatur status peristiwa menjadi sinyal, memungkinkan satu atau beberapa alur tunggu untuk melanjutkan. (Diperoleh dari EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Mengatur keamanan kontrol akses untuk peristiwa sistem bernama. (Diperoleh dari EventWaitHandle)
ToString()	Mengembalikan string yang mewakili objek saat ini. (Diperoleh dari Object)
WaitOne()	Memblokir utas saat ini hingga WaitHandle saat ini menerima sinyal. (Diperoleh dari WaitHandle)
WaitOne(Int32)	Memblokir utas saat ini hingga WaitHandle saat ini 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 WaitHandle saat ini 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 handleyang ditentukan.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Mengatur deskriptor keamanan untuk handel tunggu peristiwa yang ditentukan.
GetSafeWaitHandle(WaitHandle)	Mendapatkan handel yang aman untuk handel tunggu sistem operasi asli.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Mengatur handel yang aman untuk handel tunggu sistem operasi asli.

Keamanan Thread

Kelas ini aman untuk utas.

Lihat juga

• WaitHandle
• Managed Threading
• Ringkasan primitif sinkronisasi