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 mit den statischen WaitAny Methoden und WaitAll der -Klasse darauf wartet, dass die WaitHandle Aufgaben abgeschlossen sind.

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

Hinweise

Die WaitHandle -Klasse kapselt ein natives 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 abgeleitet werden, definieren einen Signalisierungsmechanismus, der angibt, dass zugriff auf eine freigegebene Ressource übernommen oder freigegeben wird, aber sie verwenden die geerbten WaitHandle Methoden, um zu blockieren, während sie auf den Zugriff auf freigegebene Ressourcen warten. Zu den von WaitHandle abgeleiteten Klassen gehören:

• Die Mutex-Klasse. Weitere Informationen finden Sie unter Mutexes.

• Die EventWaitHandle -Klasse und ihre abgeleiteten Klassen AutoResetEvent und ManualResetEvent.

• Die Semaphore-Klasse. Siehe Semaphor und SemaphorESlim.

Threads können für ein einzelnes Wartehandle blockieren, indem sie die instance -Methode WaitOneaufrufen, die von von abgeleiteten WaitHandleKlassen geerbt wird.

Die abgeleiteten Klassen von WaitHandle unterscheiden sich in ihrer Threadaffinität. Ereigniswartehandles (EventWaitHandle, AutoResetEventund ) und ManualResetEventSemaphore weisen keine Threadaffinität auf. Jeder Thread kann ein Ereigniswartehandle oder Semaphor signalisieren. Mutexe hingegen haben Threadaffinität; Der Thread, der einen Mutex besitzt, muss ihn 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 MarshalByRefObjectabgeleitet wird, 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 gehören:

• SignalAndWait, wodurch ein Thread ein Wartehandle signalisieren und sofort auf einen anderen warten kann.

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

• WaitAny, wodurch ein Thread warten kann, bis einer der angegebenen Wartehandles signalisiert wurde.

Die Überladungen dieser Methoden bieten Timeoutintervalle zum Verlassen der Wartezeit und die Möglichkeit, einen Synchronisierungskontext vor dem Eintritt in die Warte zu beenden, sodass andere Threads den Synchronisierungskontext verwenden können.

WaitHandle implementiert das Dispose Muster. Weitere Informationen finden Sie unter Implementieren einer Dispose-Methode. Wenn Sie von WaitHandleableiten, verwenden Sie die SafeWaitHandle -Eigenschaft, um ihr systemeigenes Betriebssystemhandle zu speichern. Sie müssen die geschützte Dispose Methode nur überschreiben, wenn Sie zusätzliche nicht verwaltete Ressourcen verwenden.

Konstruktoren

Felder

Eigenschaften

Methoden

Explizite Schnittstellenimplementierungen

Erweiterungsmethoden

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• Threading
• Threading Objects and Features (Threadingobjekte und -funktionen)
• Mutexe
• EventWaitHandle, AutoResetEvent und ManualResetEvent
• Semaphoren