WaitHandle Klasse

Definition

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

Vererbung

Object

WaitHandle

Vererbung

Object

MarshalByRefObject

WaitHandle

Abgeleitet

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Attribute

ComVisibleAttribute

Implementiert

IDisposable

Beispiele

Das folgende Codebeispiel zeigt, wie zwei Threads Hintergrundaufgaben ausführen können, während der Hauptthread wartet, bis die Aufgaben mithilfe der statischen WaitAny und WaitAll Methoden der WaitHandle Klasse abgeschlossen werden.

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

Hinweise

Die WaitHandle Klasse kapselt ein systemeigenes Synchronisierungshandle des Betriebssystems und wird verwendet, um alle Synchronisierungsobjekte in der Laufzeit darzustellen, die mehrere Wartevorgänge zulassen. Einen Vergleich von Wartehandles mit anderen Synchronisierungsobjekten finden Sie unter Übersicht über Synchronisierungsgrundtypen.

Die WaitHandle Klasse selbst ist abstrakt. Klassen, die von WaitHandle der Definition eines Signalmechanismus abgeleitet wurden, um anzugeben, dass sie zugriff auf eine freigegebene Ressource nehmen oder freigeben, aber sie verwenden die geerbten Methoden, um zu blockieren, während sie auf den Zugriff auf freigegebene WaitHandle Ressourcen warten. Die von WaitHandle folgenden Klassen abgeleiteten Klassen:

• Die Mutex Klasse. Siehe Mutexes.

• Die EventWaitHandle Klasse und die abgeleiteten Klassen AutoResetEvent und ManualResetEvent.

• Die Semaphore Klasse. Siehe Semaphor und SemaphorESlim.

Threads können für ein einzelnes Wait Handle blockieren, indem die Instanzmethode WaitOneaufgerufen wird, die von Klassen geerbt wird, die von WaitHandleabgeleiteten Klassen geerbt werden.

Die abgeleiteten Klassen unterscheiden WaitHandle sich in ihrer Threadaffinität. Ereigniswartehandles (EventWaitHandle, AutoResetEventund ) und ManualResetEventSemaphoren haben keine Threadaffinität. Jeder Thread kann ein Ereigniswartehandle oder Semaphor signalisieren. Mutexes hingegen haben Threadaffinität; der Thread, der ein Mutex besitzt, muss es freigeben, und eine Ausnahme wird ausgelöst, wenn ein Thread die ReleaseMutex Methode für einen Mutex aufruft, den er nicht besitzt.

Da die WaitHandle Klasse von MarshalByRefObjectdiesen Klassen abgeleitet ist, können diese Klassen verwendet werden, um die Aktivitäten von Threads über Anwendungsdomänengrenzen hinweg zu synchronisieren.

Zusätzlich zu den abgeleiteten Klassen verfügt die WaitHandle Klasse über eine Reihe statischer Methoden, die einen Thread blockieren, bis mindestens ein Synchronisierungsobjekt ein Signal empfängt. Dazu zählen:

• SignalAndWait, wodurch ein Thread einen Wartepunkt signalisiert und sofort auf einen anderen wartet.

• WaitAll, wodurch ein Thread warten kann, bis alle Warteziehpunkte in einem Array ein Signal empfangen.

• WaitAny, wodurch ein Thread warten kann, bis eine der angegebenen Warteziehpunkte signalisiert wurde.

Die Überladungen dieser Methoden bieten Zeitüberschreitungsintervalle für das Beenden der Wartezeit und die Möglichkeit, einen Synchronisierungskontext zu beenden, bevor Sie die Wartezeit eingeben, sodass andere Threads den Synchronisierungskontext verwenden können.

WaitHandle implementiert das Dispose Muster. Siehe Implementieren einer Dispose-Methode. Wenn Sie von WaitHandledieser abgeleitet werden, verwenden Sie die SafeWaitHandle Eigenschaft, um das systemeigene Betriebssystemhandle zu speichern. Sie müssen die geschützte Dispose Methode nicht außer Kraft setzen, es sei denn, Sie verwenden zusätzliche nicht verwaltete Ressourcen.

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• Threading
• Threading-Objekte und -Funktionen
• Mutexe
• EventWaitHandle, AutoResetEvent und ManualResetEvent
• Semaphoren