WaitHandle Třída

Definice

Zapouzdřuje objekty specifické pro operační systém, které čekají na výhradní přístup ke sdíleným prostředkům.Encapsulates operating system-specific objects that wait for exclusive access to shared resources.

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class WaitHandle : MarshalByRefObject, IDisposable
type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable
Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable
Dědičnost
Odvozené
Atributy
Implementuje

Příklady

Následující příklad kódu ukazuje, jak mohou dvě vlákna provádět úlohy na pozadí, zatímco hlavní vlákno čeká na dokončení úkolů pomocí statického WaitAny a WaitAll metod třídy WaitHandle.The following code example shows how two threads can do background tasks while the Main thread waits for the tasks to complete using the static WaitAny and WaitAll methods of the WaitHandle class.

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 tasks are 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 objektů synchronizace v modulu runtime, které umožňují více operací čekání.The WaitHandle class encapsulates a native operating system synchronization handle and is used to represent all synchronization objects in the runtime that allow multiple wait operations. Porovnání obslužných rutin čekání s jinými synchronizačními objekty najdete v tématu Přehled základních synchronizací.For a comparison of wait handles with other synchronization objects, see Overview of Synchronization Primitives.

Třída WaitHandle sama o sobě je abstraktní.The WaitHandle class itself is abstract. Třídy odvozené od WaitHandle definují mechanismus signalizace k tomu, aby označovaly zaznamenání 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.Classes derived from WaitHandle define a signaling mechanism to indicate taking or releasing access to a shared resource, but they use the inherited WaitHandle methods to block while waiting for access to shared resources. Třídy odvozené z WaitHandle zahrnují:The classes derived from WaitHandle include:

Vlákna mohou zablokovat jednotlivé obslužné rutiny čekání voláním metody instance WaitOne, která je zděděna třídami odvozenými od WaitHandle.Threads can block on an individual wait handle by calling the instance method WaitOne, which is inherited by classes derived from WaitHandle.

Odvozené třídy WaitHandle se v spřažení vlákna liší.The derived classes of WaitHandle differ in their thread affinity. Obslužné rutiny čekání na události (EventWaitHandle, AutoResetEventa ManualResetEvent) a Semafory nemají spřažení vlákna; jakékoli vlákno může signalizovat zpracování nebo semafor události.Event wait handles (EventWaitHandle, AutoResetEvent, and ManualResetEvent) and semaphores do not have thread affinity; any thread can signal an event wait handle or semaphore. Mutexy mají na druhé straně spřažení vláken; vlákno, které vlastní mutex, musí uvolnit a výjimka je vyvolána, pokud vlákno volá metodu ReleaseMutex u objektu mutex, který nevlastní.Mutexes, on the other hand, do have thread affinity; the thread that owns a mutex must release it, and an exception is thrown if a thread calls the ReleaseMutex method on a mutex that it does not own.

Vzhledem k tomu, že třída WaitHandle je odvozena z MarshalByRefObject, lze tyto třídy použít k synchronizaci aktivit vláken napříč hranicemi aplikační domény.Because the WaitHandle class derives from MarshalByRefObject, these classes can be used to synchronize the activities of threads across application domain boundaries.

Kromě jeho odvozených tříd má třída WaitHandle několik statických metod, které blokují vlákno, dokud jeden nebo více synchronizačních objektů neobdrží signál.In addition to its derived classes, the WaitHandle class has a number of static methods that block a thread until one or more synchronization objects receive a signal. Zde jsou některé z nich:These include:

  • SignalAndWait, což umožňuje vláknu signalizovat jeden popisovač čekání a okamžitě počkat na další.SignalAndWait, which allows a thread to signal one wait handle and immediately wait on another.

  • WaitAll, která může vlákno počkat, dokud všechny obslužné rutiny čekání v poli obdrží signál.WaitAll, which allows a thread to wait until all the wait handles in an array receive a signal.

  • WaitAny, což umožňuje, aby vlákno čekalo, dokud se nesignalizuje některá ze zadaných sad Wait Handles.WaitAny, which allows a thread to wait until any one of a specified set of wait handles has been signaled.

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 vstupem do čekání, což ostatním vláknům umožňuje, aby používaly kontext synchronizace.The overloads of these methods provide timeout intervals for abandoning the wait, and the opportunity to exit a synchronization context before entering the wait, allowing other threads to use the synchronization context.

Důležité

Tento typ implementuje rozhraní IDisposable.This type implements the IDisposable interface. Po dokončení použití typu nebo typu odvozeného z něj byste jej měli přímo nebo nepřímo odstranit.When you have finished using the type or a type derived from it, you should dispose of it either directly or indirectly. Chcete-li přímo uvolnit typ, zavolejte jeho metodu Close v try/catch bloku.To dispose of the type directly, call its Close method in a try/catch block. Chcete-li ji nakládat nepřímo, použijte konstrukci jazyka, například using ( C#in) nebo Using (v Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Další informace naleznete v části "použití objektu, který implementuje IDisposable" v tématu IDisposable rozhraní.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

WaitHandle implementuje Dispose vzor.WaitHandle implements the Dispose pattern. Viz [implementace metody Dispose] (~/docs/Standard/Garbage-Collection/Implementing-Dispose. MD).See [Implementing a Dispose method](~/docs/standard/garbage-collection/implementing-dispose .md). Při odvozování z WaitHandlepoužijte vlastnost SafeWaitHandle k uložení vašeho nativního popisovače operačního systému.When you derive from WaitHandle, use the SafeWaitHandle property to store your native operating system handle. Nemusíte přepsat metodu Protected Dispose, pokud nepoužíváte další nespravované prostředky.You do not need to override the protected Dispose method unless you use additional unmanaged resources.

Konstruktory

WaitHandle()

Inicializuje novou instanci třídy WaitHandle třídy.Initializes a new instance of the WaitHandle class.

Pole

InvalidHandle

Představuje neplatný popisovač nativního operačního systému.Represents an invalid native operating system handle. Toto pole je jen pro čtení.This field is read-only.

WaitTimeout

Indikuje, že vypršel časový limit operace WaitAny(WaitHandle[], Int32, Boolean) předtím, než se nahlásily některé z obslužných rutin čekání.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Toto pole je konstantní.This field is constant.

Vlastnosti

Handle

Získá nebo nastaví popisovač nativního operačního systému.Gets or sets the native operating system handle.

SafeWaitHandle

Získá nebo nastaví popisovač nativního operačního systému.Gets or sets the native operating system handle.

Metody

Close()

Uvolní všechny prostředky držené aktuální WaitHandle.Releases all resources held by the current WaitHandle.

CreateObjRef(Type)

Vytvoří objekt, který obsahuje všechny relevantní informace požadované pro vygenerování proxy serveru, který se používá ke komunikaci se vzdáleným objektem.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Zděděno od MarshalByRefObject)
Dispose()

Uvolní všechny prostředky používané aktuální instancí třídy WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

Dispose(Boolean)

Při přepsání v odvozené třídě uvolní nespravované prostředky používané WaitHandlea volitelně uvolní spravované prostředky.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
Finalize()

Uvolní prostředky držené aktuální instancí.Releases the resources held by the current instance.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetLifetimeService()

Načte aktuální objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Zděděno od Object)
InitializeLifetimeService()

Získá objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Obtains a lifetime service object to control the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
MemberwiseClone(Boolean)

Vytvoří kopii aktuálního objektu MarshalByRefObject bez podstruktury.Creates a shallow copy of the current MarshalByRefObject object.

(Zděděno od MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle)

Signalizuje jeden WaitHandle a počká na jiné.Signals one WaitHandle and waits on another.

SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

Signalizuje jeden WaitHandle a počká na jiném, přičemž určí interval časového limitu jako 32é celé číslo se znaménkem a určí, jestli se má před zadáním čekání opustit synchronizační doména pro daný kontext.Signals one WaitHandle and waits on another, specifying a time-out interval as a 32-bit signed integer and specifying whether to exit the synchronization domain for the context before entering the wait.

SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

Signalizuje jednu WaitHandle a čeká na jinou hodnotu, zadejte časový limit jako TimeSpan a určete, jestli se má před přechodem do čekání ukončit synchronizující doména pro daný kontext.Signals one WaitHandle and waits on another, specifying the time-out interval as a TimeSpan and specifying whether to exit the synchronization domain for the context before entering the wait.

ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)
WaitAll(WaitHandle[])

Počká, až všechny prvky v zadaném poli dostanou signál.Waits for all the elements in the specified array to receive a signal.

WaitAll(WaitHandle[], Int32)

Počká, až všechny prvky v zadaném poli dostanou signál, a to pomocí Int32 hodnoty pro určení časového intervalu.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval.

WaitAll(WaitHandle[], Int32, Boolean)

Počká, až všechny prvky v zadaném poli dostanou signál, pomocí Int32 hodnoty zadejte časový interval a určete, jestli se má před čekáním ukončit synchronizovaná doména.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitAll(WaitHandle[], TimeSpan)

Počká, až všechny prvky v zadaném poli dostanou signál, a to pomocí TimeSpan hodnoty pro určení časového intervalu.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.

WaitAll(WaitHandle[], TimeSpan, Boolean)

Počká, až všechny prvky v zadaném poli dostanou signál, pomocí TimeSpan hodnoty pro určení časového intervalu a určení, jestli se má před čekáním ukončit synchronizovaná doména.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[])

Počká, až prvky v zadaném poli dostanou signál.Waits for any of the elements in the specified array to receive a signal.

WaitAny(WaitHandle[], Int32)

Počká, až prvky v zadaném poli dostanou signál, s použitím čísla se znaménkem 32, které určuje časový interval.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval.

WaitAny(WaitHandle[], Int32, Boolean)

Počká, až prvky v zadaném poli dostanou signál, pomocí čísla se znaménkem 32, které určuje časový interval, a určí, jestli se má před čekáním ukončit synchronizovaná doména.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[], TimeSpan)

Počká, až prvky v zadaném poli dostanou signál, pomocí TimeSpan k určení časového intervalu.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval.

WaitAny(WaitHandle[], TimeSpan, Boolean)

Počká, až prvky v zadaném poli dostanou signál, pomocí TimeSpan k určení časového intervalu a určení, zda se má před čekáním ukončit synchronizující doména.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne()

Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál.Blocks the current thread until the current WaitHandle receives a signal.

WaitOne(Int32)

Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí čísla se znaménkem 32, které určuje časový interval v milisekundách.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

WaitOne(Int32, Boolean)

Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, s použitím 32ého celého čísla se znaménkem k určení časového intervalu a určení, zda se má před čekáním ukončit synchronizující doména.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne(TimeSpan)

Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí TimeSpan k určení časového intervalu.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

WaitOne(TimeSpan, Boolean)

Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí TimeSpan k určení časového intervalu a určení, zda se má před čekáním ukončit synchronizující doména.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

Explicitní implementace rozhraní

IDisposable.Dispose()

Uvolní všechny prostředky, které WaitHandlepoužívá.Releases all resources used by the WaitHandle.

Metody rozšíření

GetSafeWaitHandle(WaitHandle)

Získá bezpečný popisovač pro zpracování nativního čekání operačního systému.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Nastaví bezpečný popisovač pro operační systém nativního čekání.Sets a safe handle for a native operating system wait handle.

Platí pro

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

Tento typ je bezpečný pro přístup z více vláken.This type is thread safe.

Viz také