WaitHandle クラス

定義

名前空間:

System.Threading

アセンブリ:

System.Runtime.dll

共有リソースへの排他アクセスの待機に使用するオペレーティング システム固有のオブジェクトをカプセル化します。

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

継承

Object

MarshalByRefObject

WaitHandle

派生

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

実装

IDisposable

例

次のコード例は、Main スレッドが クラスの静的 WaitAny メソッドと メソッドを使用してタスクの完了を待機している間に、 WaitAll 2 つのスレッドがバックグラウンド タスクを実行する方法を 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 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クラスとその派生クラス、AutoResetEventおよび ManualResetEvent。

• Semaphore クラスです。 「Semaphore と SemaphoreSlim」を参照してください。

スレッドは、 からWaitHandle派生したクラスによって継承される インスタンス メソッド WaitOneを呼び出すことによって、個々の待機ハンドルをブロックできます。

の派生クラス WaitHandle は、スレッド アフィニティが異なります。 イベント待機ハンドル (EventWaitHandle、、 AutoResetEventおよび ) と ManualResetEventセマフォにはスレッド アフィニティがありません。どのスレッドでも、イベント待機ハンドルまたはセマフォを通知できます。 一方、ミューテックスにはスレッド アフィニティがあります。ミューテックスを所有するスレッドはそれを解放する必要があり、スレッドが所有していないミューテックスで メソッドを ReleaseMutex 呼び出すと例外がスローされます。

クラスは WaitHandle から MarshalByRefObject派生しているため、これらのクラスを使用して、アプリケーション ドメインの境界を越えてスレッドのアクティビティを同期できます。

クラスには、その派生クラスに加えて、 WaitHandle 1 つ以上の同期オブジェクトがシグナルを受信するまでスレッドをブロックする静的メソッドが多数用意されています。 次の設定があります。

• SignalAndWaitを使用すると、スレッドは 1 つの待機ハンドルを通知し、すぐに別の待機ハンドルを待機できます。

• WaitAllは、配列内のすべての待機ハンドルがシグナルを受信するまでスレッドが待機できるようにします。

• WaitAnyは、指定された待機ハンドルのセットのいずれかが通知されるまでスレッドが待機できるようにします。

これらのメソッドのオーバーロードは、待機を破棄するためのタイムアウト間隔と、待機に入る前に同期コンテキストを終了する機会を提供し、他のスレッドが同期コンテキストを使用できるようにします。

重要

この型は IDisposable インターフェイスを実装します。 型またはそこから派生した型の使用が完了したら、直接または間接的に破棄する必要があります。 直接的に型を破棄するには、try/catch ブロック内で Close メソッドを呼び出します。 間接的に型を破棄するには、using (C# の場合) または Using (Visual Basic 言語) などの言語構成要素を使用します。 詳細については、IDisposable インターフェイスに関するトピック内の「IDisposable を実装するオブジェクトの使用」セクションを参照してください。

WaitHandle は パターンを実装します Dispose 。 Dispose メソッドの実装に関するページを参照してください。 から WaitHandle派生する場合は、 プロパティを SafeWaitHandle 使用してネイティブ オペレーティング システム ハンドルを格納します。 追加のアンマネージド リソースを使用しない限り、保護された Dispose メソッドをオーバーライドする必要はありません。

コンストラクター

WaitHandle()

WaitHandle クラスの新しいインスタンスを初期化します。

フィールド

InvalidHandle	無効なネイティブ オペレーティング システム ハンドルを表します。 このフィールドは読み取り専用です。
WaitTimeout	待機ハンドルがシグナル状態になる前に WaitAny(WaitHandle[], Int32, Boolean) 操作がタイムアウトになったことを示します。 このフィールドは定数です。

プロパティ

Handle	古い. ネイティブ オペレーティング システム ハンドルを取得または設定します。
SafeWaitHandle	ネイティブ オペレーティング システム ハンドルを取得または設定します。

メソッド

Close()	現在の WaitHandle によって保持されているすべてのリソースを解放します。
CreateObjRef(Type)	リモート オブジェクトとの通信に使用するプロキシの生成に必要な情報をすべて格納しているオブジェクトを作成します。 (継承元 MarshalByRefObject)
Dispose()	WaitHandle クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。
Dispose(Boolean)	派生クラスでオーバーライドされると、WaitHandle によって使用されているアンマネージド リソースを解放し、オプションでマネージド リソースも解放します。
Equals(Object)	指定されたオブジェクトが現在のオブジェクトと等しいかどうかを判断します。 (継承元 Object)
GetHashCode()	既定のハッシュ関数として機能します。 (継承元 Object)
GetLifetimeService()	古い. 対象のインスタンスの有効期間ポリシーを制御する、現在の有効期間サービス オブジェクトを取得します。 (継承元 MarshalByRefObject)
GetType()	現在のインスタンスの Type を取得します。 (継承元 Object)
InitializeLifetimeService()	古い. このインスタンスの有効期間ポリシーを制御する有効期間サービス オブジェクトを取得します。 (継承元 MarshalByRefObject)
MemberwiseClone()	現在の Object の簡易コピーを作成します。 (継承元 Object)
MemberwiseClone(Boolean)	現在の MarshalByRefObject オブジェクトの簡易コピーを作成します。 (継承元 MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle)	1 つの WaitHandle を通知し、別のハンドルを待機します。
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	1 つの WaitHandle を通知し、別のハンドルを待機します。タイムアウト間隔として 32 ビット符号付き整数を指定し、待機に入る前にコンテキストの同期ドメインを終了するかどうかを指定します。
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	1 つの WaitHandle を通知し、別のハンドルを待機します。タイムアウト間隔として TimeSpan を指定し、待機に入る前にコンテキストの同期ドメインを終了するかどうかを指定します。
ToString()	現在のオブジェクトを表す文字列を返します。 (継承元 Object)
WaitAll(WaitHandle[])	指定した配列内のすべての要素がシグナルを受信するまで待機します。
WaitAll(WaitHandle[], Int32)	Int32 値を使用して時間間隔を指定し、指定した配列内のすべての要素がシグナルを受信するまで待機します。
WaitAll(WaitHandle[], Int32, Boolean)	指定した配列内のすべての要素がシグナルを受信するまで待機します。Int32 値を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。
WaitAll(WaitHandle[], TimeSpan)	TimeSpan 値を使用して時間間隔を指定し、指定した配列内のすべての要素がシグナルを受信するまで待機します。
WaitAll(WaitHandle[], TimeSpan, Boolean)	指定した配列内のすべての要素がシグナルを受信するまで待機します。TimeSpan 値を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。
WaitAny(WaitHandle[])	指定した配列内のいずれかの要素がシグナルを受信するまで待機します。
WaitAny(WaitHandle[], Int32)	32 ビット符号付き整数を使用して時間間隔を指定し、指定した配列内のいずれかの要素がシグナルを受信するまで待機します。
WaitAny(WaitHandle[], Int32, Boolean)	32 ビットの符号付き整数を使用して時間間隔を指定し、待機する前に同期ドメインを終了するかどうかを指定して、指定した配列内のいずれかの要素がシグナルを受信するまで待機します。
WaitAny(WaitHandle[], TimeSpan)	TimeSpan を使用して時間間隔を指定し、指定した配列内のいずれかの要素がシグナルを受信するまで待機します。
WaitAny(WaitHandle[], TimeSpan, Boolean)	指定した配列内のいずれかの要素がシグナルを受信するまで待機します。TimeSpan を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。
WaitOne()	現在の WaitHandle がシグナルを受け取るまで、現在のスレッドをブロックします。
WaitOne(Int32)	32 ビット符号付き整数を使用して時間間隔をミリ秒単位で指定し、現在の WaitHandle がシグナルを受信するまで、現在のスレッドをブロックします。
WaitOne(Int32, Boolean)	現在の WaitHandle がシグナルを受信するまで現在のスレッドをブロックします。時間間隔を指定するために 32 ビット符号付き整数を使用し、待機の前でも同期ドメインを終了するかどうかを指定します。
WaitOne(TimeSpan)	TimeSpan を使用して時間間隔を指定し、現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。
WaitOne(TimeSpan, Boolean)	現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。TimeSpan を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。

拡張メソッド

GetSafeWaitHandle(WaitHandle)	ネイティブ オペレーティング システムの待機ハンドルのためのセーフ ハンドルを取得します。
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	ネイティブ オペレーティング システムの待機ハンドルのためのセーフ ハンドルを設定します。

スレッド セーフ

この型はスレッド セーフです。

こちらもご覧ください

• スレッド化
• スレッド処理オブジェクトと機能
• ミューテックス
• EventWaitHandle、AutoResetEvent、および ManualResetEvent
• セマフォ