WaitHandle Klas

Definitie

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

Overname

Object

WaitHandle

Overname

Object

MarshalByRefObject

WaitHandle

Afgeleid

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Kenmerken

ComVisibleAttribute

Implementeringen

IDisposable

Voorbeelden

In het volgende codevoorbeeld ziet u hoe twee threads achtergrondtaken kunnen uitvoeren terwijl de hoofdthread wacht totdat de taken zijn voltooid met behulp van de statische WaitAny methoden WaitAll van de WaitHandle klasse.

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

Opmerkingen

De WaitHandle klasse bevat een systeemeigen greep voor besturingssysteemsynchronisatie en wordt gebruikt om alle synchronisatieobjecten in de runtime weer te geven die meerdere wachtbewerkingen toestaan. Zie Overzicht van synchronisatieprimitief voor een vergelijking van wachtgrepen met andere synchronisatieobjecten.

De WaitHandle klasse zelf is abstract. Klassen die zijn afgeleid van het definiëren van WaitHandle een signaleringsmechanisme om de toegang tot een gedeelde resource aan te geven of vrij te geven, maar ze gebruiken de overgenomen WaitHandle methoden om te blokkeren terwijl wordt gewacht op toegang tot gedeelde resources. De klassen die zijn afgeleid van WaitHandle :

• De Mutex klas. Zie Mutexes.

• De EventWaitHandle klasse en de afgeleide klassen, AutoResetEvent en ManualResetEvent.

• De Semaphore klas. Zie Semaphore en SemaphoreSlim.

Threads kunnen blokkeren voor een afzonderlijke wachtgreep door de instantiemethode WaitOneaan te roepen, die wordt overgenomen door klassen die zijn afgeleid van WaitHandle.

De afgeleide klassen verschillen WaitHandle in hun threadaffiniteit. Gebeurteniswachtingangen (EventWaitHandle, AutoResetEventen ) en ManualResetEventsemaforen hebben geen threadaffiniteit. Elke thread kan een wachtgreep of semafore van een gebeurtenis signaleren. Mutexes hebben daarentegen wel threadaffiniteit; de thread die eigenaar is van een mutex, moet deze vrijgeven en er wordt een uitzondering gegenereerd als een thread de ReleaseMutex methode aanroept op een mutex die deze niet bezit.

Omdat de WaitHandle klasse is afgeleid van MarshalByRefObject, kunnen deze klassen worden gebruikt om de activiteiten van threads over de grenzen van het toepassingsdomein te synchroniseren.

Naast de afgeleide klassen heeft de WaitHandle klasse een aantal statische methoden die een thread blokkeren totdat een of meer synchronisatieobjecten een signaal ontvangen. Deze omvatten:

• SignalAndWait, waarmee een thread één wachtgreep kan signaleren en onmiddellijk op een andere wachtgreep kan wachten.

• WaitAll, waarmee een thread kan wachten totdat alle wachtgrepen in een matrix een signaal ontvangen.

• WaitAny, waarmee een thread kan wachten tot een van een van een opgegeven set wachtgrepen is gesignaleerd.

De overbelasting van deze methoden biedt time-outintervallen voor het afbreken van de wachttijd en de mogelijkheid om een synchronisatiecontext af te sluiten voordat u de wacht invoert, zodat andere threads de synchronisatiecontext kunnen gebruiken.

WaitHandle implementeert het Dispose patroon. Zie De implementatie van een verwijderingsmethode. Wanneer u afgeleid bent van WaitHandle, gebruikt u de eigenschap om de SafeWaitHandle systeemeigen ingang van het besturingssysteem op te slaan. U hoeft de beveiligde Dispose methode niet te overschrijven, tenzij u aanvullende onbeheerde resources gebruikt.

Veiligheid thread

Dit type is thread veilig.

Zie ook

• draadtechniek
• Threading-objecten en -kenmerken
• Mutexes-
• EventWaitHandle, AutoResetEvent en ManualResetEvent
• Semaforen