ManualResetEvent クラス

定義

名前空間:

System.Threading

アセンブリ:

System.Threading.dll

ソース:

ManualResetEvent.cs

通知されたら手動でリセットする必要があるスレッド同期イベントを表します。 このクラスは継承できません。

public ref class ManualResetEvent sealed : System::Threading::EventWaitHandle

public sealed class ManualResetEvent : System.Threading.EventWaitHandle

type ManualResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle

継承

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

例

次の例では、ManualResetEvent のしくみを示します。 この例は、署名されていない状態の ManualResetEvent で始まります (つまり、false がコンストラクターに渡されます)。 この例では、WaitOne メソッドを呼び出して、各スレッドを ManualResetEvent にブロックする 3 つのスレッドを作成します。 ユーザーが Enter キーを押すと、Set メソッドが呼び出され、3 つのスレッドがすべて解放されます。 これは、スレッドを一度に 1 つずつ解放し、各リリース後に自動的にリセットする AutoResetEvent クラスの動作と対照的です。

Enter キーをもう一度押すと、Reset メソッドが呼び出されるまで、ManualResetEvent がシグナル状態のままになります。この例では、さらに 2 つのスレッドを開始します。 これらのスレッドは、WaitOne メソッドを呼び出すときはブロックされず、代わりに完了まで実行されます。

Enter キーをもう一度押すと、Reset メソッドが呼び出され、もう 1 つのスレッドが開始され、WaitOneが呼び出されたときにブロックされます。 Enter キー 押すと、最後のスレッドを解放するために最後の Set が呼び出され、プログラムが終了します。

using namespace System;
using namespace System::Threading;

ref class Example
{
private:
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    static ManualResetEvent^ mre = gcnew ManualResetEvent(false);

    static void ThreadProc()
    {
        String^ name = Thread::CurrentThread->Name;

        Console::WriteLine(name + " starts and calls mre->WaitOne()");

        mre->WaitOne();

        Console::WriteLine(name + " ends.");
    }

public:
    static void Demo()
    {
        Console::WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <=2 ; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }

        Thread::Sleep(500);
        Console::WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                           "\nto release all the threads.\n");
        Console::ReadLine();

        mre->Set();

        Thread::Sleep(500);
        Console::WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                           "\ndo not block. Press Enter to show this.\n");
        Console::ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }

        Thread::Sleep(500);
        Console::WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                           "\nwhen they call WaitOne().\n");
        Console::ReadLine();

        mre->Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread^ t5 = gcnew Thread(gcnew ThreadStart(ThreadProc));
        t5->Name = "Thread_5";
        t5->Start();

        Thread::Sleep(500);
        Console::WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console::ReadLine();

        mre->Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console::ReadLine();
    }
};

int main()
{
   Example::Demo();
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre->WaitOne()
Thread_1 starts and calls mre->WaitOne()
Thread_2 starts and calls mre->WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_1 ends.
Thread_0 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre->WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre->WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre->WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

using System;
using System.Threading;

public class Example
{
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    private static ManualResetEvent mre = new ManualResetEvent(false);

    static void Main()
    {
        Console.WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <= 2; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                          "\nto release all the threads.\n");
        Console.ReadLine();

        mre.Set();

        Thread.Sleep(500);
        Console.WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                          "\ndo not block. Press Enter to show this.\n");
        Console.ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                          "\nwhen they call WaitOne().\n");
        Console.ReadLine();

        mre.Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread t5 = new Thread(ThreadProc);
        t5.Name = "Thread_5";
        t5.Start();

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console.ReadLine();

        mre.Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console.ReadLine();
    }

    private static void ThreadProc()
    {
        string name = Thread.CurrentThread.Name;

        Console.WriteLine(name + " starts and calls mre.WaitOne()");

        mre.WaitOne();

        Console.WriteLine(name + " ends.");
    }
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre.WaitOne()
Thread_1 starts and calls mre.WaitOne()
Thread_2 starts and calls mre.WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_0 ends.
Thread_1 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre.WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre.WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre.WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

Imports System.Threading

Public Class Example

    ' mre is used to block and release threads manually. It is
    ' created in the unsignaled state.
    Private Shared mre As New ManualResetEvent(False)

    <MTAThreadAttribute> _
    Shared Sub Main()

        Console.WriteLine(vbLf & _
            "Start 3 named threads that block on a ManualResetEvent:" & vbLf)

        For i As Integer = 0 To 2
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When all three threads have started, press Enter to call Set()" & vbLf & _
            "to release all the threads." & vbLf)
        Console.ReadLine()

        mre.Set()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When a ManualResetEvent is signaled, threads that call WaitOne()" & vbLf & _
            "do not block. Press Enter to show this." & vbLf)
        Console.ReadLine()

        For i As Integer = 3 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "Press Enter to call Reset(), so that threads once again block" & vbLf & _
            "when they call WaitOne()." & vbLf)
        Console.ReadLine()

        mre.Reset()

        ' Start a thread that waits on the ManualResetEvent.
        Dim t5 As New Thread(AddressOf ThreadProc)
        t5.Name = "Thread_5"
        t5.Start()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & "Press Enter to call Set() and conclude the demo.")
        Console.ReadLine()

        mre.Set()

        ' If you run this example in Visual Studio, uncomment the following line:
        'Console.ReadLine()

    End Sub


    Private Shared Sub ThreadProc()

        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine(name & " starts and calls mre.WaitOne()")

        mre.WaitOne()

        Console.WriteLine(name & " ends.")

    End Sub

End Class

' This example produces output similar to the following:
'
'Start 3 named threads that block on a ManualResetEvent:
'
'Thread_0 starts and calls mre.WaitOne()
'Thread_1 starts and calls mre.WaitOne()
'Thread_2 starts and calls mre.WaitOne()
'
'When all three threads have started, press Enter to call Set()
'to release all the threads.
'
'
'Thread_2 ends.
'Thread_0 ends.
'Thread_1 ends.
'
'When a ManualResetEvent is signaled, threads that call WaitOne()
'do not block. Press Enter to show this.
'
'
'Thread_3 starts and calls mre.WaitOne()
'Thread_3 ends.
'Thread_4 starts and calls mre.WaitOne()
'Thread_4 ends.
'
'Press Enter to call Reset(), so that threads once again block
'when they call WaitOne().
'
'
'Thread_5 starts and calls mre.WaitOne()
'
'Press Enter to call Set() and conclude the demo.
'
'Thread_5 ends.

注釈

ManualResetEvent、AutoResetEvent、および EventWaitHandle をスレッド操作 (またはスレッド シグナル通知) に使用します。 詳細については、同期プリミティブの概要に関する記事の「スレッドの相互作用、またはシグナル通知の」セクション 参照してください。

スレッドは、他のスレッドが続行する前に完了する必要があるアクティビティを開始すると、ManualResetEvent.Reset 呼び出して、 を非シグナル状態にします。 このスレッドは、ManualResetEventを制御すると考えることができます。 シグナルを待機 ManualResetEvent.WaitOne ブロックを呼び出すスレッド。 制御スレッドがアクティビティを完了すると、ManualResetEvent.Set を呼び出して、待機中のスレッドが続行できることを通知します。 待機中のすべてのスレッドが解放されます。

シグナル通知が行われると、ManualResetEvent は、Reset() メソッドを呼び出して手動でリセットされるまでシグナル通知を受け取ります。 つまり、WaitOne 呼び出しはすぐに戻ります。

ManualResetEvent の初期状態を制御するには、コンストラクターにブール値を渡します。初期状態が通知される場合は true し、それ以外の場合は false。

ManualResetEvent は、staticWaitAll メソッドと WaitAny メソッドでも使用できます。

.NET Framework バージョン 2.0 以降では、ManualResetEvent は EventWaitHandle クラスから派生します。 ManualResetEvent は、EventResetMode.ManualResetで作成された EventWaitHandle と機能的に同等です。

手記

ManualResetEvent クラスとは異なり、EventWaitHandle クラスは、名前付きシステム同期イベントへのアクセスを提供します。

.NET Framework バージョン 4.0 以降では、System.Threading.ManualResetEventSlim クラスは、ManualResetEventの軽量な代替手段です。

コンストラクター

ManualResetEvent(Boolean)

初期状態を signaled に設定するかどうかを示すブール値を使用して、ManualResetEvent クラスの新しいインスタンスを初期化します。

フィールド

WaitTimeout

待機ハンドルのいずれかが通知される前に、WaitAny(WaitHandle[], Int32, Boolean) 操作がタイムアウトしたことを示します。 このフィールドは定数です。 (継承元 WaitHandle)

プロパティ

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

メソッド

Close()	現在の WaitHandleによって保持されているすべてのリソースを解放します。 (継承元 WaitHandle)
CreateObjRef(Type)	リモート オブジェクトとの通信に使用されるプロキシの生成に必要なすべての関連情報を含むオブジェクトを作成します。 (継承元 MarshalByRefObject)
Dispose()	WaitHandle クラスの現在のインスタンスで使用されているすべてのリソースを解放します。 (継承元 WaitHandle)
Dispose(Boolean)	派生クラスでオーバーライドされると、WaitHandleによって使用されるアンマネージ リソースを解放し、必要に応じてマネージド リソースを解放します。 (継承元 WaitHandle)
Equals(Object)	指定したオブジェクトが現在のオブジェクトと等しいかどうかを判断します。 (継承元 Object)
GetAccessControl()	現在の EventWaitHandle オブジェクトによって表される名前付きシステム イベントのアクセス制御セキュリティを表す EventWaitHandleSecurity オブジェクトを取得します。 (継承元 EventWaitHandle)
GetHashCode()	既定のハッシュ関数として機能します。 (継承元 Object)
GetLifetimeService()	古い. このインスタンスの有効期間ポリシーを制御する現在の有効期間サービス オブジェクトを取得します。 (継承元 MarshalByRefObject)
GetType()	現在のインスタンスの Type を取得します。 (継承元 Object)
InitializeLifetimeService()	古い. このインスタンスの有効期間ポリシーを制御する有効期間サービス オブジェクトを取得します。 (継承元 MarshalByRefObject)
MemberwiseClone()	現在の Objectの簡易コピーを作成します。 (継承元 Object)
MemberwiseClone(Boolean)	現在の MarshalByRefObject オブジェクトの簡易コピーを作成します。 (継承元 MarshalByRefObject)
Reset()	イベントの状態を非署名に設定し、スレッドをブロックします。 (継承元 EventWaitHandle)
Set()	イベントの状態を signaled に設定し、1 つ以上の待機中のスレッドを続行できるようにします。 (継承元 EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	名前付きシステム イベントのアクセス制御セキュリティを設定します。 (継承元 EventWaitHandle)
ToString()	現在のオブジェクトを表す文字列を返します。 (継承元 Object)
WaitOne()	現在の WaitHandle がシグナルを受信するまで、現在のスレッドをブロックします。 (継承元 WaitHandle)
WaitOne(Int32)	現在の WaitHandle がシグナルを受信するまで、32 ビット符号付き整数を使用してミリ秒単位で時間間隔を指定するまで、現在のスレッドをブロックします。 (継承元 WaitHandle)
WaitOne(Int32, Boolean)	現在の WaitHandle がシグナルを受信するまで、32 ビット符号付き整数を使用して時間間隔を指定し、待機前に同期ドメインを終了するかどうかを指定するまで、現在のスレッドをブロックします。 (継承元 WaitHandle)
WaitOne(TimeSpan)	TimeSpan を使用して時間間隔を指定して、現在のインスタンスがシグナルを受信するまで、現在のスレッドをブロックします。 (継承元 WaitHandle)
WaitOne(TimeSpan, Boolean)	TimeSpan を使用して時間間隔を指定し、待機前に同期ドメインを終了するかどうかを指定して、現在のインスタンスがシグナルを受信するまで、現在のスレッドをブロックします。 (継承元 WaitHandle)

拡張メソッド

GetAccessControl(EventWaitHandle)	指定した handleのセキュリティ記述子を返します。
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	指定したイベント待機ハンドルのセキュリティ記述子を設定します。
GetSafeWaitHandle(WaitHandle)	ネイティブ オペレーティング システムの待機ハンドルのセーフ ハンドルを取得します。
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	ネイティブ オペレーティング システムの待機ハンドルのセーフ ハンドルを設定します。

スレッド セーフ

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

こちらもご覧ください

• WaitHandle
• マネージド スレッド の
• 同期プリミティブ の概要