WaitHandle Kelas

Definisi

Ruang nama:

System.Threading

Rakitan:

System.Runtime.dll

Sumber:

WaitHandle.cs

Merangkum objek khusus sistem operasi yang menunggu akses eksklusif ke sumber daya bersama.

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable

public abstract class WaitHandle : MarshalByRefObject, IDisposable

type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable

Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable

Warisan

Object

MarshalByRefObject

WaitHandle

Turunan

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

Penerapan

IDisposable

Contoh

Contoh kode berikut menunjukkan bagaimana dua utas dapat melakukan tugas latar belakang sementara utas Utama menunggu tugas selesai menggunakan metode WaitHandle statis WaitAny dan WaitAll kelas.

using namespace System;
using namespace System::Threading;

public ref class WaitHandleExample
{
    // Define a random number generator for testing.
private:
    static Random^ random = gcnew Random();
public:
    static void DoTask(Object^ state)
    {
        AutoResetEvent^ autoReset = (AutoResetEvent^) state;
        int time = 1000 * random->Next(2, 10);
        Console::WriteLine("Performing a task for {0} milliseconds.", time);
        Thread::Sleep(time);
        autoReset->Set();
    }
};

int main()
{
    // Define an array with two AutoResetEvent WaitHandles.
    array<WaitHandle^>^ handles = gcnew array<WaitHandle^> {
        gcnew AutoResetEvent(false), gcnew AutoResetEvent(false)};

    // Queue up two tasks on two different threads;
    // wait until all tasks are completed.
    DateTime timeInstance = DateTime::Now;
    Console::WriteLine("Main thread is waiting for BOTH tasks to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    WaitHandle::WaitAll(handles);
    // The time shown below should match the longest task.
    Console::WriteLine("Both tasks are completed (time waited={0})",
        (DateTime::Now - timeInstance).TotalMilliseconds);

    // Queue up two tasks on two different threads;
    // wait until any tasks are completed.
    timeInstance = DateTime::Now;
    Console::WriteLine();
    Console::WriteLine("The main thread is waiting for either task to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    int index = WaitHandle::WaitAny(handles);
    // The time shown below should match the shortest task.
    Console::WriteLine("Task {0} finished first (time waited={1}).",
        index + 1, (DateTime::Now - timeInstance).TotalMilliseconds);
}

// This code produces the following sample output.
//
// Main thread is waiting for BOTH tasks to complete.
// Performing a task for 7000 milliseconds.
// Performing a task for 4000 milliseconds.
// Both tasks are completed (time waited=7064.8052)

// The main thread is waiting for either task to complete.
// Performing a task for 2000 milliseconds.
// Performing a task for 2000 milliseconds.
// Task 1 finished first (time waited=2000.6528).

using System;
using System.Threading;

public sealed class App
{
    // Define an array with two AutoResetEvent WaitHandles.
    static WaitHandle[] waitHandles = new WaitHandle[]
    {
        new AutoResetEvent(false),
        new AutoResetEvent(false)
    };

    // Define a random number generator for testing.
    static Random r = new Random();

    static void Main()
    {
        // Queue up two tasks on two different threads;
        // wait until all tasks are completed.
        DateTime dt = DateTime.Now;
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        WaitHandle.WaitAll(waitHandles);
        // The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})",
            (DateTime.Now - dt).TotalMilliseconds);

        // Queue up two tasks on two different threads;
        // wait until any task is completed.
        dt = DateTime.Now;
        Console.WriteLine();
        Console.WriteLine("The main thread is waiting for either task to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        int index = WaitHandle.WaitAny(waitHandles);
        // The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).",
            index + 1, (DateTime.Now - dt).TotalMilliseconds);
    }

    static void DoTask(Object state)
    {
        AutoResetEvent are = (AutoResetEvent) state;
        int time = 1000 * r.Next(2, 10);
        Console.WriteLine("Performing a task for {0} milliseconds.", time);
        Thread.Sleep(time);
        are.Set();
    }
}

// This code produces output similar to the following:
//
//  Main thread is waiting for BOTH tasks to complete.
//  Performing a task for 7000 milliseconds.
//  Performing a task for 4000 milliseconds.
//  Both tasks are completed (time waited=7064.8052)
//
//  The main thread is waiting for either task to complete.
//  Performing a task for 2000 milliseconds.
//  Performing a task for 2000 milliseconds.
//  Task 1 finished first (time waited=2000.6528).

Imports System.Threading

NotInheritable Public Class App
    ' Define an array with two AutoResetEvent WaitHandles.
    Private Shared waitHandles() As WaitHandle = _
        {New AutoResetEvent(False), New AutoResetEvent(False)}
    
    ' Define a random number generator for testing.
    Private Shared r As New Random()
    
    <MTAThreadAttribute> _
    Public Shared Sub Main() 
        ' Queue two tasks on two different threads; 
        ' wait until all tasks are completed.
        Dim dt As DateTime = DateTime.Now
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        WaitHandle.WaitAll(waitHandles)
        ' The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})", _
            (DateTime.Now - dt).TotalMilliseconds)
        
        ' Queue up two tasks on two different threads; 
        ' wait until any tasks are completed.
        dt = DateTime.Now
        Console.WriteLine()
        Console.WriteLine("The main thread is waiting for either task to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        Dim index As Integer = WaitHandle.WaitAny(waitHandles)
        ' The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).", _
            index + 1,(DateTime.Now - dt).TotalMilliseconds)
    
    End Sub
    
    Shared Sub DoTask(ByVal state As [Object]) 
        Dim are As AutoResetEvent = CType(state, AutoResetEvent)
        Dim time As Integer = 1000 * r.Next(2, 10)
        Console.WriteLine("Performing a task for {0} milliseconds.", time)
        Thread.Sleep(time)
        are.Set()
    
    End Sub
End Class

' This code produces output similar to the following:
'
'  Main thread is waiting for BOTH tasks to complete.
'  Performing a task for 7000 milliseconds.
'  Performing a task for 4000 milliseconds.
'  Both tasks are completed (time waited=7064.8052)
' 
'  The main thread is waiting for either task to complete.
'  Performing a task for 2000 milliseconds.
'  Performing a task for 2000 milliseconds.
'  Task 1 finished first (time waited=2000.6528).

Keterangan

Kelas WaitHandle merangkum handel sinkronisasi sistem operasi asli dan digunakan untuk mewakili semua objek sinkronisasi dalam runtime yang memungkinkan beberapa operasi tunggu. Untuk perbandingan handel tunggu dengan objek sinkronisasi lainnya, lihat Gambaran Umum Primitif Sinkronisasi.

Kelas itu WaitHandle sendiri abstrak. Kelas yang berasal dari WaitHandle menentukan mekanisme sinyal untuk menunjukkan mengambil atau melepaskan akses ke sumber daya bersama, tetapi mereka menggunakan metode yang diwariskan WaitHandle untuk memblokir sambil menunggu akses ke sumber daya bersama. Kelas yang berasal dari WaitHandle meliputi:

• Kelas Mutex. Lihat Mutexes.

• Kelas EventWaitHandle dan kelas turunannya, AutoResetEvent dan ManualResetEvent.

• Kelas Semaphore. Lihat Semaphore dan SemaphoreSlim.

Utas dapat memblokir pada handel tunggu individu dengan memanggil metode WaitOneinstans , yang diwarisi oleh kelas yang berasal dari WaitHandle.

Kelas turunan WaitHandle berbeda dalam afinitas utas mereka. Handel tunggu peristiwa (EventWaitHandle, AutoResetEvent, dan ManualResetEvent) dan semaphore tidak memiliki afinitas utas; utas apa pun dapat menandakan handel tunggu peristiwa atau semaphore. Mutex, di sisi lain, memang memiliki afinitas utas; utas yang memiliki mutex harus melepaskannya, dan pengecualian dilemparkan jika utas ReleaseMutex memanggil metode pada mutex yang tidak dimilikinya.

WaitHandle Karena kelas berasal dari MarshalByRefObject, kelas-kelas ini dapat digunakan untuk menyinkronkan aktivitas utas di seluruh batas domain aplikasi.

Selain kelas turunannya, WaitHandle kelas memiliki sejumlah metode statis yang memblokir utas sampai satu atau beberapa objek sinkronisasi menerima sinyal. Ini termasuk:

• SignalAndWait, yang memungkinkan utas untuk memberi sinyal satu handel tunggu dan segera menunggu di yang lain.

• WaitAll, yang memungkinkan utas menunggu hingga semua handel tunggu dalam array menerima sinyal.

• WaitAny, yang memungkinkan utas untuk menunggu sampai salah satu dari sekumpulan handel tunggu tertentu telah diberi sinyal.

Kelebihan beban metode ini memberikan interval batas waktu untuk meninggalkan tunggu, dan kesempatan untuk keluar dari konteks sinkronisasi sebelum memasuki tunggu, memungkinkan utas lain menggunakan konteks sinkronisasi.

Penting

Jenis ini mengimplementasikan IDisposable antarmuka. Ketika Anda telah selesai menggunakan jenis atau jenis yang berasal darinya, Anda harus membuangnya baik secara langsung atau tidak langsung. Untuk membuang jenis secara langsung, panggil metodenya Close dalam try/catch blok. Untuk membuangnya secara tidak langsung, gunakan konstruksi bahasa seperti using (dalam C#) atau Using (di Visual Basic). Untuk informasi selengkapnya, lihat bagian "Menggunakan Objek yang Mengimplementasikan IDisposable" dalam IDisposable topik antarmuka.

WaitHandleDispose mengimplementasikan pola. Lihat Menerapkan metode Buang. Ketika Anda berasal dari WaitHandle, gunakan SafeWaitHandle properti untuk menyimpan handel sistem operasi asli Anda. Anda tidak perlu mengambil alih metode yang dilindungi Dispose kecuali Anda menggunakan sumber daya tambahan yang tidak dikelola.

Konstruktor

WaitHandle()

Menginisialisasi instans baru kelas WaitHandle.

Bidang

InvalidHandle	Mewakili handel sistem operasi asli yang tidak valid. Bidang ini hanya-baca.
WaitTimeout	Menunjukkan bahwa WaitAny(WaitHandle[], Int32, Boolean) waktu operasi habis sebelum salah satu handel tunggu diberi sinyal. Bidang ini konstan.

Properti

Handle	Kedaluwarsa. Mendapatkan atau mengatur handel sistem operasi asli.
SafeWaitHandle	Mendapatkan atau mengatur handel sistem operasi asli.

Metode

Close()	Merilis semua sumber daya yang dipegang oleh saat ini 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.
Dispose(Boolean)	Ketika ditimpa di kelas turunan, merilis sumber daya tidak terkelola yang digunakan oleh WaitHandle, dan secara opsional merilis sumber daya terkelola.
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)
SignalAndWait(WaitHandle, WaitHandle)	Sinyal satu WaitHandle dan menunggu di yang lain.
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	Memberi sinyal satu WaitHandle dan menunggu di yang lain, menentukan interval waktu habis sebagai bilangan bulat bertanda 32-bit dan menentukan apakah akan keluar dari domain sinkronisasi untuk konteks sebelum memasukkan tunggu.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	Memberi sinyal satu WaitHandle dan menunggu di yang lain, menentukan interval waktu habis sebagai TimeSpan dan menentukan apakah akan keluar dari domain sinkronisasi untuk konteks sebelum memasukkan tunggu.
ToString()	Mengembalikan string yang mewakili objek saat ini. (Diperoleh dari Object)
WaitAll(WaitHandle[])	Menunggu semua elemen dalam array yang ditentukan untuk menerima sinyal.
WaitAll(WaitHandle[], Int32)	Menunggu semua elemen dalam array yang ditentukan untuk menerima sinyal, menggunakan Int32 nilai untuk menentukan interval waktu.
WaitAll(WaitHandle[], Int32, Boolean)	Menunggu semua elemen dalam array yang ditentukan menerima sinyal, menggunakan Int32 nilai untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu.
WaitAll(WaitHandle[], TimeSpan)	Menunggu semua elemen dalam array yang ditentukan untuk menerima sinyal, menggunakan TimeSpan nilai untuk menentukan interval waktu.
WaitAll(WaitHandle[], TimeSpan, Boolean)	Menunggu semua elemen dalam array yang ditentukan menerima sinyal, menggunakan TimeSpan nilai untuk menentukan interval waktu, dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu.
WaitAny(WaitHandle[])	Menunggu salah satu elemen dalam array yang ditentukan untuk menerima sinyal.
WaitAny(WaitHandle[], Int32)	Menunggu salah satu elemen dalam array yang ditentukan menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu.
WaitAny(WaitHandle[], Int32, Boolean)	Menunggu salah satu elemen dalam array yang ditentukan untuk menerima sinyal, menggunakan bilangan bulat bertanda 32-bit untuk menentukan interval waktu, dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu.
WaitAny(WaitHandle[], TimeSpan)	Menunggu salah satu elemen dalam array yang ditentukan untuk menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu.
WaitAny(WaitHandle[], TimeSpan, Boolean)	Menunggu salah satu elemen dalam array yang ditentukan untuk menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu.
WaitOne()	Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal.
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.
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.
WaitOne(TimeSpan)	Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu.
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.

Metode Ekstensi

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

• Pengaluran
• Objek dan Fitur Perangkaian
• Mutex
• EventWaitHandle, AutoResetEvent, dan ManualResetEvent
• Semaphores