WaitHandle Klasa

Definicja

Przestrzeń nazw:

System.Threading

Zestawy:

netstandard.dll, System.Runtime.dll

Źródło:

WaitHandle.cs

Hermetyzuje obiekty specyficzne dla systemu operacyjnego, które oczekują na wyłączny dostęp do udostępnionych zasobów.

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

Dziedziczenie

Object

MarshalByRefObject

WaitHandle

Pochodne

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

Implementuje

IDisposable

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 WaitAnyWaitHandle i WaitAll metod klasy.

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

Uwagi

Klasa WaitHandle hermetyzuje natywną obsługę synchronizacji systemu operacyjnego i służy do reprezentowania wszystkich obiektów synchronizacji w środowisku uruchomieniowym, które zezwalają na wiele operacji oczekiwania. Porównanie dojść oczekiwania z innymi obiektami synchronizacji można znaleźć w temacie Overview of Synchronization Primitives (Omówienie elementów pierwotnych synchronizacji).

Sama klasa jest abstrakcyjna WaitHandle . Klasy pochodzące z WaitHandle definiowania mechanizmu sygnalizacyjnego wskazującego pobieranie lub zwalnianie dostępu do udostępnionego zasobu, ale używają dziedziczonej WaitHandle metody do blokowania podczas oczekiwania na dostęp do zasobów udostępnionych. Klasy pochodzące z WaitHandle następujących elementów:

• Klasa Mutex. Zobacz Mutexes( Mutexes).

• Klasa EventWaitHandle i jej klasy AutoResetEvent pochodne oraz ManualResetEvent.

• Klasa Semaphore. Zobacz Semaphore i SemaphoreSlim.

Wątki mogą blokować pojedynczy uchwyt oczekiwania, wywołując metodę WaitOnewystąpienia , która jest dziedziczona przez klasy pochodzące z WaitHandleklasy .

Pochodne klasy WaitHandle różnią się koligacją wątków. Obsługa oczekiwania zdarzeń (EventWaitHandle, AutoResetEvent, i ) i ManualResetEventsemafory nie mają koligacji wątku; każdy wątek może sygnalizować uchwyt oczekiwania zdarzeń lub semafor. Z drugiej strony mutexes mają koligację wątków; wątek, który jest właścicielem mutex musi go zwolnić, a wyjątek jest zgłaszany, jeśli wątek wywołuje ReleaseMutex metodę na mutex, którego nie jest właścicielem.

WaitHandle Ponieważ klasa pochodzi z MarshalByRefObjectklasy , te klasy mogą służyć do synchronizowania działań wątków między granicami domeny aplikacji.

Oprócz klas pochodnych WaitHandle klasa ma wiele metod statycznych, które blokują wątek, dopóki co najmniej jeden obiekt synchronizacji nie otrzyma sygnału. Są to:

• SignalAndWait, dzięki czemu wątek może sygnalizować jeden uchwyt oczekiwania i natychmiast czekać na inny.

• WaitAll, dzięki czemu wątek może czekać, aż wszystkie uchwyty oczekiwania w tablicy odbierają sygnał.

• WaitAny, dzięki czemu wątek może czekać, aż zostanie zasygnalizowany jeden z określonego zestawu uchwytów oczekiwania.

Przeciążenia tych metod zapewniają interwały limitu czasu dla porzucenia oczekiwania, a także możliwość zakończenia kontekstu synchronizacji przed wprowadzeniem oczekiwania, umożliwiając innym wątkom korzystanie z kontekstu synchronizacji.

Ważna

Ten typ implementuje interfejs IDisposable. Po zakończeniu używania typu lub typu uzyskanego z niego należy usunąć go bezpośrednio lub pośrednio. Aby usunąć typ bezpośrednio, wywołaj metodę Close w bloku try/catch. Aby usunąć go pośrednio, należy użyć konstrukcji języka, takiej jak using (w języku C#) lub Using (w Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Używanie obiektu implementującego IDisposable" (Using an Object that Implements IDisposable) w temacie interfejsu IDisposable.

WaitHandle implementuje Dispose wzorzec. Zobacz Implementowanie metody Dispose. Gdy pochodzisz z WaitHandleklasy , użyj SafeWaitHandle właściwości do przechowywania natywnego dojścia systemu operacyjnego. Nie trzeba zastępować chronionej Dispose metody, chyba że używasz dodatkowych zasobów niezarządzanych.

Konstruktory

Nazwa	Opis
WaitHandle()	Inicjuje nowe wystąpienie klasy WaitHandle.

Pola

Nazwa	Opis
InvalidHandle	Reprezentuje nieprawidłowy natywny uchwyt systemu operacyjnego. To pole jest tylko do odczytu.
WaitTimeout	Wskazuje, że WaitAny(WaitHandle[], Int32, Boolean) upłynął limit czasu operacji, zanim zostanie zasygnalizowana którakolwiek z dojść oczekiwania. To pole jest stałe.

Właściwości

Nazwa	Opis
Handle	Przestarzałe. Pobiera lub ustawia natywny uchwyt systemu operacyjnego.
SafeWaitHandle	Pobiera lub ustawia natywny uchwyt systemu operacyjnego.

Metody

Nazwa	Opis
Close()	Zwalnia wszystkie zasoby przechowywane przez bieżący WaitHandleelement .
Dispose()	Zwalnia wszystkie zasoby używane przez bieżące wystąpienie WaitHandle klasy.
Dispose(Boolean)	Po zastąpieniu w klasie pochodnej zwalnia niezarządzane zasoby używane przez WaitHandleprogram i opcjonalnie zwalnia zarządzane zasoby.
Equals(Object)	Określa, czy określony obiekt jest równy bieżącemu obiektowi. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLifetimeService()	Przestarzałe. Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
InitializeLifetimeService()	Przestarzałe. Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu. (Odziedziczone po MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	Sygnalizuje jeden WaitHandle i czeka na inny, określając interwał limitu czasu jako 32-bitową liczbę całkowitą ze znakiem i określając, czy zamknąć domenę synchronizacji dla kontekstu przed wprowadzeniem oczekiwania.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	Sygnalizuje jeden WaitHandle i czeka na inny, określając interwał limitu czasu jako i TimeSpan określając, czy należy zamknąć domenę synchronizacji dla kontekstu przed wprowadzeniem oczekiwania.
SignalAndWait(WaitHandle, WaitHandle)	Sygnalizuje jeden WaitHandle i czeka na inny.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
WaitAll(WaitHandle[], Int32, Boolean)	Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając Int32 wartości w celu określenia interwału czasu i określenia, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.
WaitAll(WaitHandle[], Int32)	Oczekuje, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając Int32 wartości w celu określenia interwału czasu.
WaitAll(WaitHandle[], TimeSpan, Boolean)	Czeka na wszystkie elementy w określonej tablicy, aby odebrać sygnał, używając TimeSpan wartości w celu określenia interwału czasu i określenia, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.
WaitAll(WaitHandle[], TimeSpan)	Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając TimeSpan wartości w celu określenia interwału czasu.
WaitAll(WaitHandle[])	Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał.
WaitAny(WaitHandle[], Int32, Boolean)	Czeka na dowolny z elementów w określonej tablicy, aby odebrać sygnał, używając 32-bitowej liczby całkowitej ze znakiem w celu określenia interwału czasu i określenia, czy zakończyć domenę synchronizacji przed oczekiwaniem.
WaitAny(WaitHandle[], Int32)	Oczekuje, aż dowolny z elementów w określonej tablicy otrzyma sygnał, używając 32-bitowej liczby całkowitej ze znakiem, aby określić interwał czasu.
WaitAny(WaitHandle[], TimeSpan, Boolean)	Czeka na dowolny z elementów w określonej tablicy, aby odebrać sygnał, przy użyciu parametru , TimeSpan aby określić interwał czasu i określić, czy zakończyć domenę synchronizacji przed oczekiwaniem.
WaitAny(WaitHandle[], TimeSpan)	Czeka na dowolny z elementów w określonej tablicy, aby odebrać sygnał, przy użyciu parametru , TimeSpan aby określić interwał czasu.
WaitAny(WaitHandle[])	Czeka na dowolny z elementów w określonej tablicy, aby odebrać sygnał.
WaitOne()	Blokuje bieżący wątek, dopóki bieżący nie WaitHandle otrzyma sygnału.
WaitOne(Int32, Boolean)	Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej liczby całkowitej ze znakiem, aby określić interwał czasu i określić, czy zakończyć domenę synchronizacji przed oczekiwaniem.
WaitOne(Int32)	Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej liczby całkowitej ze znakiem w celu określenia interwału czasu w milisekundach.
WaitOne(TimeSpan, Boolean)	Blokuje bieżący wątek, dopóki bieżące wystąpienie nie odbierze sygnału, używając parametru , TimeSpan aby określić interwał czasu i określić, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.
WaitOne(TimeSpan)	Blokuje bieżący wątek do momentu odebrania sygnału przez bieżące wystąpienie przy użyciu parametru , TimeSpan aby określić interwał czasu.

Metody rozszerzania

Nazwa	Opis
GetSafeWaitHandle(WaitHandle)	Pobiera bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Ustawia bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkiem.

Zobacz też

• Wątkowanie
• Obiekty wątkowe i funkcje
• Mutex
• EventWaitHandle, AutoResetEvent i ManualResetEvent
• Semafory