WaitHandle Klass

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

Arv

Object

WaitHandle

Arv

Object

MarshalByRefObject

WaitHandle

Härledda

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Attribut

ComVisibleAttribute

Implementeringar

IDisposable

Exempel

I följande kodexempel visas hur två trådar kan utföra bakgrundsaktiviteter medan huvudtråden väntar på att aktiviteterna ska slutföras med hjälp av WaitAny klassens statiska WaitAll metoder och WaitHandle metoder.

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

Kommentarer

Klassen WaitHandle kapslar in ett inbyggt operativsystemets synkroniseringshandtag och används för att representera alla synkroniseringsobjekt i körningen som tillåter flera vänteåtgärder. En jämförelse av väntereferenser med andra synkroniseringsobjekt finns i Översikt över synkroniseringsprimatorer.

Själva WaitHandle klassen är abstrakt. Klasser som härleds från WaitHandle definierar en signalmekanism för att ange att åtkomsten till en delad resurs ska öppnas eller frigöras, men de använder de ärvda WaitHandle metoderna för att blockera i väntan på åtkomst till delade resurser. Klasserna som härleds från WaitHandle inkluderar:

• Klassen Mutex . Se Mutexes.

• Klassen EventWaitHandle och dess härledda klasser, AutoResetEvent och ManualResetEvent.

• Klassen Semaphore . Se Semafor och SemaphoreSlim.

Trådar kan blockeras på en enskild väntereferens genom att anropa instansmetoden WaitOne, som ärvs av klasser som härletts från WaitHandle.

De härledda klasserna WaitHandle skiljer sig åt i sin trådtillhörighet. Händelseväntereferenser (EventWaitHandle, AutoResetEvent, och ManualResetEvent) och semaforer har inte trådtillhörighet. Alla trådar kan signalera ett händelseväntehandtag eller semafor. Mutexes, å andra sidan, har trådtillhörighet; tråden som äger en mutex måste släppa den och ett undantag utlöses om en tråd anropar ReleaseMutex metoden på en mutex som den inte äger.

WaitHandle Eftersom klassen härleds från MarshalByRefObjectkan dessa klasser användas för att synkronisera aktiviteter för trådar över programdomängränser.

Förutom sina härledda klasser WaitHandle har klassen ett antal statiska metoder som blockerar en tråd tills ett eller flera synkroniseringsobjekt får en signal. Dessa inkluderar:

• SignalAndWait, vilket gör att en tråd kan signalera ett väntehandtag och omedelbart vänta på en annan.

• WaitAll, vilket gör att en tråd kan vänta tills alla väntehandtag i en matris får en signal.

• WaitAny, vilket gör att en tråd kan vänta tills någon av en angiven uppsättning väntehandtag har signalerats.

Överlagringarna av dessa metoder ger tidsgränsintervall för att avbryta väntetiden och möjligheten att avsluta en synkroniseringskontext innan du går in i väntan, vilket gör att andra trådar kan använda synkroniseringskontexten.

WaitHandle implementerar Dispose mönstret. Se Implementera en Avyttringsmetod. När du härleder från WaitHandleanvänder du SafeWaitHandle egenskapen för att lagra ditt interna operativsystemhandtag. Du behöver inte åsidosätta den skyddade Dispose metoden om du inte använder ytterligare ohanterade resurser.

Trådsäkerhet

Den här typen är trådsäker.

Se även

• trådning
• Trådhanteringsobjekt och funktioner
• mutexes
• EventWaitHandle, AutoResetEvent och ManualResetEvent
• Semaforer