WaitHandle Třída

Definice

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

Dědičnost

Object

WaitHandle

Dědičnost

Object

MarshalByRefObject

WaitHandle

Odvozené

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Atributy

ComVisibleAttribute

Implementuje

IDisposable

Příklady

Následující příklad kódu ukazuje, jak dvě vlákna mohou provádět úlohy na pozadí, zatímco hlavní vlákno čeká na dokončení úkolů pomocí statické WaitAny a WaitAll metody WaitHandle třídy.

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

Poznámky

Třída WaitHandle zapouzdřuje nativní popisovač synchronizace operačního systému a slouží k reprezentaci všech synchronizačních objektů v modulu runtime, které umožňují více operací čekání. Porovnání popisovačů čekání s jinými synchronizačními objekty najdete v tématu Přehled primitiv synchronizace.

Samotná WaitHandle třída je abstraktní. Třídy odvozené z WaitHandle definice signalizačního mechanismu označující převzetí nebo uvolnění přístupu ke sdílenému prostředku, ale při čekání na přístup ke sdíleným prostředkům používají zděděné WaitHandle metody k blokování. Mezi třídy odvozené z WaitHandle patří:

• Třída Mutex . Viz Mutexes.

• Třída EventWaitHandle a její odvozené třídy AutoResetEvent a ManualResetEvent.

• Třída Semaphore . Viz Semafor a SemaforSlim.

Vlákna mohou blokovat na jednotlivém popisovači čekání voláním metody WaitOneinstance , která je zděděna třídami odvozenými z WaitHandle.

Odvozené třídy se WaitHandle liší v jejich spřažení vlákna. Obslužné rutiny čekání událostí (EventWaitHandle, AutoResetEventa ManualResetEvent) a semafory nemají spřažení vlákna. Jakékoli vlákno může signalizovat popisovač čekání na událost nebo semafor. Mutexy, na druhé straně, mají spřažení vláken; vlákno, které vlastní mutex, ho musí uvolnit a vyvolá výjimku, pokud vlákno volá metodu ReleaseMutex na mutexu, který nevlastní.

Vzhledem k tomu, že WaitHandle třída je odvozena z MarshalByRefObject, lze tyto třídy použít k synchronizaci aktivit vláken napříč hranicemi domény aplikace.

Kromě odvozených tříd WaitHandle má třída řadu statických metod, které blokují vlákno, dokud jeden nebo více synchronizačních objektů neobdrží signál. Tady jsou některé z nich:

• SignalAndWait, který umožňuje vláknu signalizovat jeden popisovač čekání a okamžitě čekat na jiný.

• WaitAll, což umožňuje vláknu počkat, dokud všechny obslužné rutiny čekání v poli neobdrží signál.

• WaitAny, což umožňuje vláknu počkat, dokud nebude signalizována některá ze zadaných sad obslužných rutin čekání.

Přetížení těchto metod poskytují intervaly časového limitu pro opuštění čekání a možnost ukončit kontext synchronizace před zadáním čekání, což umožňuje jiným vláknům používat kontext synchronizace.

WaitHandle implementuje Dispose vzor. Viz Implementace metody Dispose. Při odvození z WaitHandlepoužijte SafeWaitHandle vlastnost k uložení popisovače nativního operačního systému. Pokud nepoužíváte další nespravované prostředky, nemusíte přepsat chráněnou Dispose metodu.

Konstruktory

Pole

Vlastnosti

Metody

Explicitní implementace rozhraní

Metody rozšíření

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.

Viz také

• Dělení na vlákna
• Objekty a funkce vytváření vláken
• Mutex – třídy
• EventWaitHandle, AutoResetEvent a ManualResetEvent
• Semafory