WaitHandle Класс

Определение

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

Наследование

Object

WaitHandle

Наследование

Object

MarshalByRefObject

WaitHandle

Производный

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Атрибуты

ComVisibleAttribute

Реализации

IDisposable

Примеры

В следующем примере кода показано, как два потока могут выполнять фоновые задачи, пока основной поток ожидает завершения задач с помощью статических WaitAnyWaitHandle методов и WaitAll класса .

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

Комментарии

Класс WaitHandle инкапсулирует собственный дескриптор синхронизации операционной системы и используется для представления всех объектов синхронизации в среде выполнения, допускающих несколько операций ожидания. Сравнение дескрипторов ожидания с другими объектами синхронизации см. в статье Общие сведения о примитивах синхронизации.

Сам WaitHandle класс является абстрактным. Классы, производные от WaitHandle , определяют механизм сигнализации, указывающий на получение или освобождение доступа к общему ресурсу, но они используют унаследованные WaitHandle методы для блокировки во время ожидания доступа к общим ресурсам. Классы, производные от :WaitHandle

• Класс Mutex. См. раздел Мьютексы.

• Класс EventWaitHandle и его производные классы и ManualResetEventAutoResetEvent .

• Класс Semaphore. См . раздел Семафор и СемафорSlim.

Потоки могут блокировать отдельный дескриптор ожидания, вызывая метод WaitOneэкземпляра , который наследуется классами, производными от WaitHandle.

Производные классы WaitHandle отличаются сходством потоков. Дескриптор ожидания событий (EventWaitHandle, AutoResetEventи ManualResetEvent) и семафоры не имеют сходства потоков; любой поток может сообщить об дескрипторе ожидания события или семафоре. Мьютексы, с другой стороны, имеют сходство потоков; Поток, владеющий мьютексом, должен освободить его, и если поток вызывает ReleaseMutex метод для мьютекса, которым он не владеет.

WaitHandle Так как класс является производным от MarshalByRefObject, эти классы можно использовать для синхронизации действий потоков через границы домена приложения.

В дополнение к производным классам WaitHandle класс имеет ряд статических методов, которые блокируют поток до тех пор, пока один или несколько объектов синхронизации не получат сигнал. Сюда входит следующее.

• SignalAndWait, который позволяет потоку сигнализировать один дескриптор ожидания и немедленно ожидать другого.

• WaitAll, который позволяет потоку ждать, пока все дескрипторы ожидания в массиве не получат сигнал.

• WaitAny, который позволяет потоку ждать, пока не будет показано любое из указанного набора дескрипторов ожидания.

Перегрузки этих методов предоставляют интервалы времени ожидания для отказа от ожидания и возможность выйти из контекста синхронизации перед вводом ожидания, позволяя другим потокам использовать контекст синхронизации.

WaitHandle Dispose реализует шаблон . См. раздел Реализация метода Dispose. При наследоваве от WaitHandle, используйте свойство для хранения собственного дескриптора SafeWaitHandle операционной системы. Не нужно переопределять защищенный Dispose метод, если не используются дополнительные неуправляемые ресурсы.

Конструкторы

Поля

Свойства

Методы

Явные реализации интерфейса

Методы расширения

Применяется к

Потокобезопасность

Данный тип потокобезопасен.

См. также раздел

• Работа с потоками
• Объекты и функциональные возможности работы с потоками
• Мьютексы
• EventWaitHandle, AutoResetEvent и ManualResetEvent
• Семафоры