WaitHandle Klasa

Definicja

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

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
Dziedziczenie
WaitHandle
Dziedziczenie
Pochodne
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu pokazuje, jak dwa wątki mogą wykonywać zadania w tle, podczas gdy wątek Main czeka na ukończenie zadań przy użyciu metod statycznych WaitAny WaitAll i klasy WaitHandle .

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 hermetyzuje dojście do natywnej synchronizacji systemu operacyjnego i jest używana do reprezentowania wszystkich obiektów synchronizacji w środowisku uruchomieniowym, które WaitHandle umożliwiają wiele operacji oczekiwania. Aby porównać dojścia oczekiwania z innymi obiektami synchronizacji, zobacz Overview of Synchronization Primitives (Omówienie elementów pierwotnych synchronizacji).

Sama WaitHandle klasa jest abstrakcyjna. Klasy pochodzące z klasy definiują mechanizm sygnalizujący podejmowanie lub zwalnianie dostępu do udostępnionego zasobu, ale używają dziedziczonych metod do blokowania podczas oczekiwania na dostęp do udostępnionych WaitHandle WaitHandle zasobów. Klasy pochodzące z klasy WaitHandle obejmują:

Wątki mogą blokować pojedyncze dojście oczekiwania, wywołując metodę wystąpienia , która jest dziedziczona przez WaitOne klasy pochodzące z klasy WaitHandle .

Klasy pochodne klasy różnią WaitHandle się koligacją wątku. Dojścia oczekiwania zdarzeń ( , i ) i semafory nie mają koligacji wątku; każdy wątek może sygnalizować dojście oczekiwania zdarzenia lub EventWaitHandle AutoResetEvent ManualResetEvent semafor. Z drugiej strony mutexes mają koligacji wątku; Wątek, który jest właścicielem mutex, musi go zwolnić, a wyjątek jest zgłaszany, jeśli wątek wywołuje metodę na ReleaseMutex mutex, który nie jest właścicielem.

Ponieważ klasa pochodzi od klasy , te klasy mogą służyć do synchronizowania działań wątków WaitHandle MarshalByRefObject poza granicami domeny aplikacji.

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

  • SignalAndWait, co umożliwia wątkowi sygnalizowanie jednego dojścia oczekiwania i natychmiastowe oczekiwanie na inne.

  • WaitAll, co umożliwia wątekowi oczekiwanie na otrzymanie sygnału przez wszystkie dojścia oczekiwania w tablicy.

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

Przeciążenia tych metod zapewniają interwały limitu czasu porzucania oczekiwania i możliwość wyjścia z kontekstu synchronizacji przed wprowadzeniem oczekiwania, dzięki czemu inne wątki mogą używać kontekstu synchronizacji.

Ważne

Ten typ implementuje IDisposable interfejs. Po zakończeniu korzystania z typu lub typu pochodnego należy usunąć go bezpośrednio lub pośrednio. Aby bezpośrednio usunąć typ, wywołaj jego Close metodę w try / catch bloku. Aby usunąć go pośrednio, użyj 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, który implementuje interfejs IDisposable" w IDisposable temacie interfejsu.

WaitHandle implementuje Dispose wzorzec. Zobacz Implementowanie metody Dispose. W przypadku wyprowadzenia WaitHandle z właściwości użyj właściwości do przechowywania SafeWaitHandle dojścia natywnego systemu operacyjnego. Nie ma potrzeby zastępowania metody chronionej, chyba że są potrzebne dodatkowe zasoby Dispose niezamówione.

Konstruktory

WaitHandle()

Inicjuje nowe wystąpienie klasy WaitHandle.

Pola

InvalidHandle

Reprezentuje nieprawidłowe dojście natywnego systemu operacyjnego. To pole jest tylko do odczytu.

WaitTimeout

Wskazuje, że WaitAny(WaitHandle[], Int32, Boolean) uchybnił czas operacji, zanim zasygnalizowane zostały jakiekolwiek dojścia oczekiwania. To pole jest stałe.

Właściwości

Handle
Nieaktualne.
Nieaktualne.

Pobiera lub ustawia dojście natywnego systemu operacyjnego.

SafeWaitHandle

Pobiera lub ustawia dojście natywnego systemu operacyjnego.

Metody

Close()

Zwalnia wszystkie zasoby przechowywane przez bieżący program WaitHandle .

CreateObjRef(Type)

Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy WaitHandle.

Dispose(Boolean)

W przypadku przesłonięć w klasie pochodnej program zwalnia nieza zarządzanie zasobami używanymi przez klasę i opcjonalnie zwalnia WaitHandle zarządzane zasoby.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
Finalize()

Zwalnia zasoby blokowane przez bieżące wystąpienie.

GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
InitializeLifetimeService()
Nieaktualne.

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

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu.

(Odziedziczone po MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle)

WaitHandleSygnalizuje jedną z nich i czeka na drugą.

SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

Sygnalizuje jedną z nich i czeka na inną, określając interwał przechyłania czasu jako 32-bitową liczbę całkowitą ze podpisem i określając, czy zamknąć domenę synchronizacji dla kontekstu przed wprowadzeniem WaitHandle oczekiwania.

SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

Sygnalizuje jedną z nich i czeka na inną, określając interwał czasu jako i określając, czy zamknąć domenę synchronizacji dla kontekstu przed wprowadzeniem WaitHandle TimeSpan oczekiwania.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)
WaitAll(WaitHandle[])

Czeka na odbieranie sygnału przez wszystkie elementy w określonej tablicy.

WaitAll(WaitHandle[], Int32)

Czeka, aż wszystkie elementy w określonej tablicy odbierzą sygnał, używając Int32 wartości do określenia przedziału czasu.

WaitAll(WaitHandle[], Int32, Boolean)

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając wartości do określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji Int32 przed oczekiwaniem.

WaitAll(WaitHandle[], TimeSpan)

Czeka, aż wszystkie elementy w określonej tablicy odbierzą sygnał, używając TimeSpan wartości do określenia przedziału czasu.

WaitAll(WaitHandle[], TimeSpan, Boolean)

Czeka na wszystkie elementy w określonej tablicy do odbierania sygnału, używając wartości do określenia interwału czasu i określając, czy zamknąć domenę synchronizacji przed TimeSpan oczekiwanie.

WaitAny(WaitHandle[])

Czeka, aż dowolny z elementów w określonej tablicy odbierze sygnał.

WaitAny(WaitHandle[], Int32)

Czeka, aż dowolny z elementów w określonej tablicy odbierze sygnał, używając 32-bitowej liczby całkowitej ze podpisem, aby określić przedział czasu.

WaitAny(WaitHandle[], Int32, Boolean)

Czeka na którykolwiek z elementów w określonej tablicy do odbierania sygnału, używając 32-bitowej liczby całkowitej ze podpisem w celu określenia przedziału czasu i określania, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.

WaitAny(WaitHandle[], TimeSpan)

Czeka, aż którykolwiek z elementów w określonej tablicy odbierze sygnał, używając do TimeSpan określenia przedziału czasu.

WaitAny(WaitHandle[], TimeSpan, Boolean)

Czeka na którykolwiek z elementów w określonej tablicy do odbierania sygnału, używając do określenia przedziału czasu i określania, czy zamknąć domenę synchronizacji TimeSpan przed oczekiwanie.

WaitOne()

Blokuje bieżący wątek, dopóki bieżący WaitHandle nie odbierze sygnału.

WaitOne(Int32)

Blokuje bieżący wątek, dopóki bieżący nie odbierze sygnału, używając 32-bitowej liczby całkowitej ze podpisem, aby określić interwał czasu WaitHandle w milisekundach.

WaitOne(Int32, Boolean)

Blokuje bieżący wątek, dopóki bieżący nie odbierze sygnału, używając 32-bitowej liczby całkowitej ze podpisem, aby określić interwał czasu i określić, czy należy zamknąć domenę synchronizacji przed WaitHandle oczekiwaniem.

WaitOne(TimeSpan)

Blokuje bieżący wątek, dopóki bieżące wystąpienie nie odbierze sygnału, używając do TimeSpan określenia przedziału czasu.

WaitOne(TimeSpan, Boolean)

Blokuje bieżący wątek, dopóki bieżące wystąpienie nie odbierze sygnału, używając do określenia przedziału czasu i określenia, czy należy zamknąć domenę synchronizacji TimeSpan przed oczekiwanie.

Jawne implementacje interfejsu

IDisposable.Dispose()

Ten interfejs API obsługuje infrastrukturę produktu i nie jest przeznaczony do użycia bezpośrednio z poziomu kodu.

Zwalnia wszelkie zasoby używane przez element WaitHandle.

Metody rozszerzania

GetSafeWaitHandle(WaitHandle)

Pobiera bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Ustawia bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.

Zobacz też