WaitHandle Sınıf

Tanım

public ref class WaitHandle abstract : IDisposable

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable

public abstract class WaitHandle : IDisposable

public abstract class WaitHandle : MarshalByRefObject, IDisposable

[System.Runtime.InteropServices.ComVisible(true)]
public abstract class WaitHandle : MarshalByRefObject, IDisposable

type WaitHandle = class
    interface IDisposable

type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable

[<System.Runtime.InteropServices.ComVisible(true)>]
type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable

Public MustInherit Class WaitHandle
Implements IDisposable

Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable

Devralma

Object

WaitHandle

Devralma

Object

MarshalByRefObject

WaitHandle

Türetilmiş

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Öznitelikler

ComVisibleAttribute

Uygulamalar

IDisposable

Örnekler

Aşağıdaki kod örneği, Main iş parçacığı sınıfın statik WaitAny ve WaitAll yöntemlerini WaitHandle kullanarak görevlerin tamamlanmasını beklerken iki iş parçacığının arka plan görevlerini nasıl gerçekleştirebileceğini gösterir.

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).

Açıklamalar

WaitHandle sınıfı yerel bir işletim sistemi eşitleme tutamacını kapsüller ve çalışma zamanındaki birden çok bekleme işlemine izin veren tüm eşitleme nesnelerini temsil etmek için kullanılır. Bekleme tutamaçlarının diğer eşitleme nesneleriyle karşılaştırması için bkz. Eşitleme Temel Bilgilerine Genel Bakış.

Sınıfın WaitHandle kendisi soyut. 'den WaitHandle türetilen sınıflar, paylaşılan bir kaynağa erişimi almayı veya serbest bırakmayı belirten bir sinyal mekanizması tanımlar, ancak paylaşılan kaynaklara erişimi beklerken engellemek için devralınan WaitHandle yöntemleri kullanırlar. Türetilen WaitHandle sınıflar şunlardır:

• Sınıf Mutex . Bkz. Mutexes.

• EventWaitHandle sınıfı ve türetilmiş sınıfları AutoResetEvent ve ManualResetEvent.

• Sınıf Semaphore . Bkz. Semaphore ve SemaphoreSlim.

İş parçacıkları, 'den türetilen sınıflar tarafından devralınan örnek yöntemini WaitOneçağırarak tek bir bekleme tutamacını WaitHandleengelleyebilir.

türetilmiş sınıfları WaitHandle , iş parçacığı benzitesinde farklılık gösterir. Olay bekleme tanıtıcıları (EventWaitHandle, AutoResetEvent, ve ManualResetEvent) ve semaforlar iş parçacığı benzini içermez; herhangi bir iş parçacığı bir olay bekleme tutamacını veya semaforu işaret edebilir. Öte yandan, mutex'ler iş parçacığı benzitesine sahiptir; bir mutex'in sahibi olan iş parçacığı bunu serbest bırakmalıdır ve bir iş parçacığı sahip olmadığı bir mutex üzerinde yöntemini çağırırsa ReleaseMutex bir özel durum oluşturulur.

WaitHandle sınıfı öğesinden MarshalByRefObjecttüretildiği için, bu sınıflar uygulama etki alanı sınırları genelinde iş parçacıklarının etkinliklerini eşitlemek için kullanılabilir.

Türetilmiş sınıflarına ek olarak, WaitHandle sınıfı bir veya daha fazla eşitleme nesnesi sinyal alıncaya kadar bir iş parçacığını engelleyen bir dizi statik yönteme sahiptir. Bu modüller şunlardır:

• SignalAndWait, bir iş parçacığının bir bekleme tutamacını işaret etmesini ve hemen diğerini beklemesini sağlar.

• WaitAll, bir dizideki tüm bekleme tutamaçları sinyal alıncaya kadar bir iş parçacığının beklemesine olanak tanır.

• WaitAny, bir iş parçacığının belirtilen bekleme tutamaçlarından herhangi biri sinyal alınana kadar beklemesine olanak tanır.

Bu yöntemlerin aşırı yüklemeleri, beklemeyi bırakmak için zaman aşımı aralıkları ve beklemeye girmeden önce eşitleme bağlamından çıkma fırsatı sağlayarak diğer iş parçacıklarının eşitleme bağlamını kullanmasına olanak sağlar.

WaitHandle desenini Dispose uygular. Bkz . Dispose yöntemi uygulama. 'den WaitHandletüretdiğinizde, yerel işletim sistemi tanıtıcınızı depolamak için özelliğini kullanın SafeWaitHandle . Yönetilmeyen ek kaynaklar kullanmadığınız sürece korumalı Dispose yöntemi geçersiz kılmanız gerekmez.

Oluşturucular

Alanlar

Özellikler

Yöntemler

Belirtik Arabirim Kullanımları

Uzantı Metotları

Şunlara uygulanır

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

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

Ayrıca bkz.

• İş Parçacığı Oluşturma
• İş Parçacığı Oluşturma Nesneleri ve Özellikleri
• Zaman Uyumu Sağlayıcılar
• EventWaitHandle, AutoResetEvent ve ManualResetEvent
• Semafor