WaitHandle Klasa

Definicja

Hermetyzuje obiekty specyficzne dla systemu operacyjnego, które oczekują na wyłączny dostęp do udostępnionych zasobów.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
Dziedziczenie
Pochodne
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu pokazuje, jak dwa wątki mogą wykonywać zadania w tle, podczas gdy główny wątek czeka na ukończenie zadań przy użyciu statycznych WaitAny i WaitAll metod klasy 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).

Uwagi

Klasa WaitHandle hermetyzuje natywny uchwyt synchronizacji systemu operacyjnego i służy do reprezentowania wszystkich obiektów synchronizacji w środowisku uruchomieniowym, które zezwalają na wiele operacji oczekiwania.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. Porównanie dojścia oczekiwania z innymi obiektami synchronizacji zawiera temat Omówienie elementów pierwotnych synchronizacji.For a comparison of wait handles with other synchronization objects, see Overview of Synchronization Primitives.

Sama klasa WaitHandle jest abstrakcyjna.The WaitHandle class itself is abstract. Klasy pochodne WaitHandle definiują mechanizm sygnalizujący, aby wskazać pobieranie lub zwalnianie dostępu do zasobu udostępnionego, ale korzystają z dziedziczonych metod WaitHandle do blokowania podczas oczekiwania na dostęp do udostępnionych zasobów.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. Klasy pochodne WaitHandle obejmują:The classes derived from WaitHandle include:

Wątki mogą blokować pojedynczym dojściem oczekiwania przez wywołanie metody instancji WaitOne, która jest dziedziczona przez klasy pochodne od WaitHandle.Threads can block on an individual wait handle by calling the instance method WaitOne, which is inherited by classes derived from WaitHandle.

Klasy pochodne WaitHandle różnią się w zależności od ich wątku.The derived classes of WaitHandle differ in their thread affinity. Uchwyty oczekiwania zdarzeń (EventWaitHandle, AutoResetEvent i ManualResetEvent) i semafory nie mają koligacji wątku; dowolny wątek może sygnalizować uchwyt oczekiwania lub semafor zdarzenia.Event wait handles (EventWaitHandle, AutoResetEvent, and ManualResetEvent) and semaphores do not have thread affinity; any thread can signal an event wait handle or semaphore. Muteksy, z drugiej strony, mają koligację wątku; wątek, który jest właścicielem obiektu mutex, musi go zwolnić i wyjątek jest zgłaszany, jeśli wątek wywołuje metodę ReleaseMutex w elemencie mutex, który nie jest właścicielem.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.

Ponieważ Klasa WaitHandle pochodzi od MarshalByRefObject, te klasy mogą służyć do synchronizowania działań wątków między granicami domeny aplikacji.Because the WaitHandle class derives from MarshalByRefObject, these classes can be used to synchronize the activities of threads across application domain boundaries.

Oprócz klas pochodnych Klasa WaitHandle ma wiele metod statycznych, które blokują wątek do momentu, gdy jeden lub więcej obiektów synchronizacji odbierze sygnał.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. Należą do nich następujące elementy:These include:

  • SignalAndWait, która umożliwia wątek sygnalizujący jedno dojście oczekiwania i od razu czeka na inne.SignalAndWait, which allows a thread to signal one wait handle and immediately wait on another.

  • WaitAll, dzięki czemu wątek czeka, aż wszystkie uchwyty oczekiwania w tablicy otrzymają sygnał.WaitAll, which allows a thread to wait until all the wait handles in an array receive a signal.

  • WaitAny, dzięki czemu wątek czeka na zasygnalizowanie dowolnego jednego z określonych dojść oczekiwania.WaitAny, which allows a thread to wait until any one of a specified set of wait handles has been signaled.

Przeciążenia tych metod zapewniają przedziały czasu, w których porzucane są oczekiwania, oraz możliwość wyjścia kontekstu synchronizacji przed wprowadzeniem oczekiwania, zezwalając innym wątkom na korzystanie z kontekstu synchronizacji.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.

Ważne

Ten typ implementuje interfejs IDisposable.This type implements the IDisposable interface. Po zakończeniu korzystania z typu lub typu pochodnego należy usunąć jego wartość bezpośrednio lub pośrednio.When you have finished using the type or a type derived from it, you should dispose of it either directly or indirectly. Aby usunąć typ bezpośrednio, wywołaj metodę Close w bloku try / catch.To dispose of the type directly, call its Close method in a try/catch block. Aby usunąć go pośrednio, użyj konstrukcji językowej, takiej jak using (in C#) lub Using (w Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Używanie obiektu implementującego interfejs IDisposable" w temacie interfejsu IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

WaitHandle implementuje wzorzec Dispose.WaitHandle implements the Dispose pattern. Zobacz [implementowanie metody Dispose] (~/docs/Standard/garbage-collection/Implementing-Dispose. MD).See [Implementing a Dispose method](~/docs/standard/garbage-collection/implementing-dispose .md). Podczas wyprowadzania z WaitHandle Użyj właściwości SafeWaitHandle do przechowywania natywnego uchwytu systemu operacyjnego.When you derive from WaitHandle, use the SafeWaitHandle property to store your native operating system handle. Nie musisz przesłonić chronionej metody Dispose, chyba że używasz dodatkowych zasobów niezarządzanych.You do not need to override the protected Dispose method unless you use additional unmanaged resources.

Konstruktory

WaitHandle()

Inicjuje nowe wystąpienie klasy WaitHandle.Initializes a new instance of the WaitHandle class.

Pola

InvalidHandle

Reprezentuje nieprawidłowe natywne dojście systemu operacyjnego.Represents an invalid native operating system handle. To pole jest tylko do odczytu.This field is read-only.

WaitTimeout

Wskazuje, że upłynął limit czasu operacji WaitAny(WaitHandle[], Int32, Boolean) przed zasygnalizowaniem dowolnych dojść oczekiwania.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. To pole jest stałe.This field is constant.

Właściwości

Handle

Pobiera lub ustawia natywne dojście systemu operacyjnego.Gets or sets the native operating system handle.

SafeWaitHandle

Pobiera lub ustawia natywne dojście systemu operacyjnego.Gets or sets the native operating system handle.

Metody

Close()

Zwalnia wszystkie zasoby przechowywane przez bieżącą WaitHandle.Releases all resources held by the current WaitHandle.

CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

Dispose(Boolean)

Gdy jest zastępowany w klasie pochodnej, zwalnia niezarządzane zasoby używane przez WaitHandle i opcjonalnie zwalnia zarządzane zasoby.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
Finalize()

Zwalnia zasoby blokowane przez bieżące wystąpienie.Releases the resources held by the current instance.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle)

Sygnalizuje jeden WaitHandle i czeka na inny.Signals one WaitHandle and waits on another.

SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

Sygnalizuje jeden WaitHandle i czeka na inne określenie interwału limitu czasu jako 32-bitową liczbę całkowitą ze znakiem i określając, czy zamknąć domenę synchronizacji kontekstu przed wprowadzeniem oczekiwania.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)

Sygnalizuje jeden WaitHandle i czeka na inne określenie interwału limitu czasu jako TimeSpan i określenie, czy należy zamknąć domenę synchronizacji kontekstu przed wprowadzeniem oczekiwania.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()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
WaitAll(WaitHandle[])

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał.Waits for all the elements in the specified array to receive a signal.

WaitAll(WaitHandle[], Int32)

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał przy użyciu wartości Int32 w celu określenia interwału czasu.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)

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał, przy użyciu wartości Int32, aby określić przedział czasu i określać, czy zamknąć domenę synchronizacji przed oczekiwaniem.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)

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał przy użyciu wartości TimeSpan w celu określenia interwału czasu.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)

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał przy użyciu wartości TimeSpan w celu określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji przed oczekiwaniem.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[])

Czeka na dowolny element w określonej tablicy, aby otrzymać sygnał.Waits for any of the elements in the specified array to receive a signal.

WaitAny(WaitHandle[], Int32)

Czeka na dowolny element w określonej tablicy, aby otrzymać sygnał, przy użyciu 32-bitowej ze znakiem liczby całkowitej, aby określić interwał czasu.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)

Czeka, aż którykolwiek z elementów w określonej tablicy otrzyma sygnał przy użyciu 32-bitowej ze znakiem liczby całkowitej, aby określić przedział czasu, i określić, czy zamknąć domenę synchronizacji przed oczekiwaniem.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)

Czeka na dowolny element w określonej tablicy, aby otrzymać sygnał, przy użyciu TimeSpan w celu określenia interwału czasu.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)

Czeka na dowolny element w określonej tablicy, aby otrzymać sygnał, przy użyciu TimeSpan do określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji przed oczekiwaniem.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()

Blokuje bieżący wątek do momentu odebrania sygnału przez bieżącą WaitHandle.Blocks the current thread until the current WaitHandle receives a signal.

WaitOne(Int32)

Blokuje bieżący wątek, dopóki bieżąca WaitHandle otrzyma sygnał, używając 32-bitowej ze znakiem liczby całkowitej, aby określić interwał czasu (w milisekundach).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)

Blokuje bieżący wątek, dopóki bieżąca WaitHandle otrzyma sygnał, używając 32-bitowej podpisanej liczby całkowitej w celu określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji przed oczekiwaniem.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)

Blokuje bieżący wątek do momentu otrzymania przez bieżące wystąpienie sygnału przy użyciu TimeSpan do określenia interwału czasu.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

WaitOne(TimeSpan, Boolean)

Blokuje bieżący wątek do momentu otrzymania przez bieżące wystąpienie sygnału przy użyciu TimeSpan do określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji przed oczekiwaniem.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.

Jawne implementacje interfejsu

IDisposable.Dispose()

Zwalnia wszystkie zasoby używane przez WaitHandle.Releases all resources used by the WaitHandle.

Metody rozszerzania

GetSafeWaitHandle(WaitHandle)

Pobiera Bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Ustawia Bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.Sets a safe handle for a native operating system wait handle.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.This type is thread safe.

Zobacz też