WaitHandle Třída

Definice

Obor názvů:

System.Threading

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

WaitHandle.cs

Zapouzdřuje objekty specifické pro operační systém, které čekají na výhradní přístup ke sdíleným prostředkům.

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable

public abstract class WaitHandle : MarshalByRefObject, IDisposable

type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable

Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable

Dědičnost

Object

MarshalByRefObject

WaitHandle

Odvozené

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

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ých WaitAnyWaitHandle a WaitAll metod třídy.

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

WaitHandle Třída zapouzdřuje nativní popisovač synchronizace operačního systému a používá se 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 naleznete 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řijetí nebo uvolnění přístupu ke sdílenému prostředku, ale používají zděděné WaitHandle metody k blokování při čekání na přístup ke sdíleným prostředkům. Třídy odvozené z WaitHandle těchto tříd:

• Třída Mutex . Viz Mutexes.

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

• Třída Semaphore . Viz Semaphore a SemaphoreSlim.

Vlákna mohou blokovat na jednotlivé obslužné rutiny čekání voláním instance metoda WaitOne, která je zděděna třídami odvozenými z WaitHandle.

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

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

Kromě odvozených tříd má třída řadu statických metod, které blokují vlákno, WaitHandle 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 čekací úchyt a okamžitě čekat na jiný.

• WaitAll, který umožňuje vláknu čekat, až všechny obslužné rutiny čekání v poli obdrží signál.

• WaitAny, což umožňuje vláknu čekat, dokud nebude signalizována jakákoli ze zadaných sady obslužných rutin čekání.

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

Důležité

Tento typ implementuje rozhraní IDisposable. Až budete hotovi s použitím typu nebo typu odvozeného z něj, měli byste ho likvidovat buď přímo, nebo nepřímo. Chcete-li typ odstranit přímo, zavolejte jeho Close metodu v bloku try/catch. Pokud ho chcete zlikvidovat nepřímo, použijte konstruktor jazyka, jako je using (v jazyce C#) nebo Using (v jazyce Visual Basic). Další informace naleznete v části Použití objektu, který implementuje IDisposable v IDisposable tématu rozhraní.

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

Konstruktory

Name	Description
WaitHandle()	Inicializuje novou instanci WaitHandle třídy.

Pole

Name	Description
InvalidHandle	Představuje neplatný popisovač nativního operačního systému. Toto pole je jen pro čtení.
WaitTimeout	Označuje, že WaitAny(WaitHandle[], Int32, Boolean) operace vypršela před signálem jakéhokoli z popisovačů čekání. Toto pole je konstantní.

Vlastnosti

Name	Description
Handle	Zastaralé. Získá nebo nastaví nativní popisovač operačního systému.
SafeWaitHandle	Získá nebo nastaví nativní popisovač operačního systému.

Metody

Name	Description
Close()	Uvolní všechny prostředky uchovávané aktuálním WaitHandle.
Dispose()	Uvolní všechny prostředky používané aktuální instancí WaitHandle třídy.
Dispose(Boolean)	Při přepsání v odvozené třídě uvolní nespravované prostředky používané nástrojem WaitHandlea volitelně uvolní spravované prostředky.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	Signalizuje jedno a WaitHandle čeká na jiný, určuje interval časového limitu jako 32bitové celé číslo se znaménkem a určuje, jestli se má před zadáním čekání ukončit synchronizační doména pro kontext.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	Signalizuje jednu WaitHandle a čeká na jinou, určuje časový limit jako TimeSpan interval a určuje, jestli se má před zadáním čekání ukončit synchronizační doména pro kontext.
SignalAndWait(WaitHandle, WaitHandle)	Signalizuje jeden WaitHandle a čeká na druhý.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
WaitAll(WaitHandle[], Int32, Boolean)	Počká, až všechny prvky v zadaném poli obdrží signál, pomocí Int32 hodnoty určí časový interval a určí, zda se má před čekáním ukončit synchronizační doména.
WaitAll(WaitHandle[], Int32)	Čeká, až všechny prvky v zadaném poli obdrží signál pomocí Int32 hodnoty k určení časového intervalu.
WaitAll(WaitHandle[], TimeSpan, Boolean)	Počká, až všechny prvky v zadaném poli obdrží signál, pomocí TimeSpan hodnoty určí časový interval a určí, zda se má před čekáním ukončit synchronizační doména.
WaitAll(WaitHandle[], TimeSpan)	Čeká, až všechny prvky v zadaném poli obdrží signál pomocí TimeSpan hodnoty k určení časového intervalu.
WaitAll(WaitHandle[])	Čeká na příjem signálu u všech prvků v zadaném poli.
WaitAny(WaitHandle[], Int32, Boolean)	Počká, až některý z prvků v zadaném poli přijme signál pomocí 32bitového znaménka pro zadání časového intervalu a určí, jestli se má před čekáním ukončit synchronizační doména.
WaitAny(WaitHandle[], Int32)	Počká, až některý z prvků v zadaném poli přijme signál pomocí 32bitového znaménka integer k určení časového intervalu.
WaitAny(WaitHandle[], TimeSpan, Boolean)	Počká, až některý z prvků v zadaném poli obdrží signál pomocí parametru TimeSpan a určí časový interval a určí, zda se má před čekáním ukončit synchronizační doména.
WaitAny(WaitHandle[], TimeSpan)	Počká, až některý z prvků v zadaném poli přijme signál pomocí parametru k TimeSpan určení časového intervalu.
WaitAny(WaitHandle[])	Počká, až některý z prvků v zadaném poli přijme signál.
WaitOne()	Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál.
WaitOne(Int32, Boolean)	Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určí časový interval a určí, jestli se má před čekáním ukončit synchronizační doména.
WaitOne(Int32)	Blokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určuje časový interval v milisekundách.
WaitOne(TimeSpan, Boolean)	Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí parametru TimeSpan a určí, zda se má před čekáním ukončit synchronizační doména.
WaitOne(TimeSpan)	Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál pomocí TimeSpan k určení časového intervalu.

Metody rozšíření

Name	Description
GetSafeWaitHandle(WaitHandle)	Získá bezpečný popisovač pro nativní obslužný rutina čekání operačního systému.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Nastaví bezpečný popisovač pro nativní obslužný rutinu čekání operačního systému.

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

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

Viz také

• Závitování
• Objekty a funkce vláken
• Mutexy
• EventWaitHandle, AutoResetEvent a ManualResetEvent
• Semafory