ManualResetEvent 클래스

정의

신호를 받을 때 수동으로 재설정되어야 하는 스레드 동기화 이벤트를 나타냅니다.Represents a thread synchronization event that, when signaled, must be reset manually. 이 클래스는 상속될 수 없습니다.This class cannot be inherited.

public ref class ManualResetEvent sealed : System::Threading::EventWaitHandle
public ref class ManualResetEvent sealed : System::Threading::WaitHandle
public sealed class ManualResetEvent : System.Threading.EventWaitHandle
public sealed class ManualResetEvent : System.Threading.WaitHandle
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ManualResetEvent : System.Threading.EventWaitHandle
type ManualResetEvent = class
    inherit EventWaitHandle
type ManualResetEvent = class
    inherit WaitHandle
[<System.Runtime.InteropServices.ComVisible(true)>]
type ManualResetEvent = class
    inherit EventWaitHandle
Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle
Public NotInheritable Class ManualResetEvent
Inherits WaitHandle
상속
ManualResetEvent
상속
상속
특성

예제

다음 예제에서는가 작동 하는 방법을 보여 줍니다 ManualResetEvent .The following example demonstrates how ManualResetEvent works. 이 예제는 ManualResetEvent unsignaled 상태의로 시작 false 합니다. 즉,가 생성자에 전달 됩니다.The example starts with a ManualResetEvent in the unsignaled state (that is, false is passed to the constructor). 이 예제에서는 각각의 메서드를 호출 하 여에 있는 세 개의 스레드를 만듭니다 ManualResetEvent WaitOne .The example creates three threads, each of which blocks on the ManualResetEvent by calling its WaitOne method. 사용자가 Enter 키를 누르면이 예제에서는 Set 세 개의 스레드를 모두 해제 하는 메서드를 호출 합니다.When the user presses the Enter key, the example calls the Set method, which releases all three threads. 이는 한 AutoResetEvent 번에 하나씩 스레드를 해제 하 여 각 릴리스 후 자동으로 다시 설정 하는 클래스의 동작과 대조 됩니다.Contrast this with the behavior of the AutoResetEvent class, which releases threads one at a time, resetting automatically after each release.

Enter 키를 다시 누르면 ManualResetEvent 메서드가 호출 될 때까지가 신호를 받은 상태로 유지 됩니다 Reset . 예제에서는 두 개의 스레드를 더 시작 합니다.Pressing the Enter key again demonstrates that the ManualResetEvent remains in the signaled state until its Reset method is called: The example starts two more threads. 이러한 스레드는 메서드를 호출 하는 경우를 차단 하지 않고 WaitOne 실행을 완료 합니다.These threads do not block when they call the WaitOne method, but instead run to completion.

Enter 키를 다시 누르면 예제가 메서드를 호출 하 고를 호출할 Reset 때 차단 되는 하나 이상의 스레드를 시작 합니다 WaitOne .Pressing the Enter key again causes the example to call the Reset method and to start one more thread, which blocks when it calls WaitOne. Enter 키를 눌러 Set 마지막 스레드를 해제 하 고 프로그램이 종료 됩니다.Pressing the Enter key one final time calls Set to release the last thread, and the program ends.

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 스레드 상호 작용 (또는 스레드 신호)에는, 및를 사용 합니다.You use ManualResetEvent, AutoResetEvent, and EventWaitHandle for thread interaction (or thread signaling). 자세한 내용은 동기화 기본 형식 개요 문서의 스레드 상호 작용 또는 신호 섹션을 참조 하세요.For more information, see the Thread interaction, or signaling section of the Overview of synchronization primitives article.

스레드가 다른 스레드를 계속 하기 전에 완료 해야 하는 작업을 시작 하는 경우 ManualResetEvent 를 호출 하 여 ManualResetEvent 신호를 받지 않는 상태로 전환 합니다.When a thread begins an activity that must complete before other threads proceed, it calls ManualResetEvent.Reset to put ManualResetEvent in the non-signaled state. 이 스레드는를 제어 한다고 생각할 수 있습니다 ManualResetEvent .This thread can be thought of as controlling the ManualResetEvent. ManualResetEvent system.threading.waithandle.waitone 블록을 호출 하 고 신호를 대기 하는 스레드입니다.Threads that call ManualResetEvent.WaitOne block, awaiting the signal. 제어 스레드가 작업을 완료 하면 ManualResetEvent를 호출 하 여 대기 중인 스레드가 진행 될 수 있음을 알립니다 .When the controlling thread completes the activity, it calls ManualResetEvent.Set to signal that the waiting threads can proceed. 대기 중인 모든 스레드가 해제 됩니다.All waiting threads are released.

신호를 받으면은 ManualResetEvent 메서드를 호출 하 여 수동으로 다시 설정할 때까지 신호를 받은 상태로 유지 됩니다 Reset() .Once it has been signaled, ManualResetEvent remains signaled until it is manually reset by calling the Reset() method. 즉,을 호출 하면가 WaitOne 즉시 반환 됩니다.That is, calls to WaitOne return immediately.

부울 값을 생성자에 전달 하 여의 초기 상태를 제어할 수 있습니다 ManualResetEvent . true 초기 상태가 신호를 받으면이 고, false 그렇지 않으면입니다.You can control the initial state of a ManualResetEvent by passing a Boolean value to the constructor: true if the initial state is signaled, and false otherwise.

ManualResetEvent 및 메서드와 함께 사용할 수도 있습니다 static WaitAll WaitAny .ManualResetEvent can also be used with the static WaitAll and WaitAny methods.

.NET Framework 버전 2.0부터은 ManualResetEvent 클래스에서 파생 EventWaitHandle 됩니다.Beginning with the .NET Framework version 2.0, ManualResetEvent derives from the EventWaitHandle class. 는를 ManualResetEvent EventWaitHandle 사용 하 여 만든와 기능적으로 동일 EventResetMode.ManualReset 합니다.A ManualResetEvent is functionally equivalent to an EventWaitHandle created with EventResetMode.ManualReset.

참고

클래스와 달리 ManualResetEvent 클래스는 EventWaitHandle 명명 된 시스템 동기화 이벤트에 대 한 액세스를 제공 합니다.Unlike the ManualResetEvent class, the EventWaitHandle class provides access to named system synchronization events.

.NET Framework 버전 4.0부터 System.Threading.ManualResetEventSlim 클래스는에 대 한 간단한 대안입니다 ManualResetEvent .Beginning with the .NET Framework version 4.0, the System.Threading.ManualResetEventSlim class is a lightweight alternative to ManualResetEvent.

생성자

ManualResetEvent(Boolean)

초기 상태를 신호 받음으로 설정할지 여부를 나타내는 부울 값을 사용하여 ManualResetEvent 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the ManualResetEvent class with a Boolean value indicating whether to set the initial state to signaled.

필드

WaitTimeout

대기 핸들이 신호를 받기 전에 WaitAny(WaitHandle[], Int32, Boolean) 작업이 제한 시간을 초과했음을 나타냅니다.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. 이 필드는 상수입니다.This field is constant.

(다음에서 상속됨 WaitHandle)

속성

Handle
사용되지 않습니다.

네이티브 운영 체제 핸들을 가져오거나 설정합니다.Gets or sets the native operating system handle.

(다음에서 상속됨 WaitHandle)
SafeWaitHandle

네이티브 운영 체제 핸들을 가져오거나 설정합니다.Gets or sets the native operating system handle.

(다음에서 상속됨 WaitHandle)

메서드

Close()

현재 WaitHandle에서 보유한 모든 리소스를 해제합니다.Releases all resources held by the current WaitHandle.

(다음에서 상속됨 WaitHandle)
CreateObjRef(Type)

원격 개체와 통신하는 데 사용되는 프록시 생성에 필요한 모든 관련 정보가 들어 있는 개체를 만듭니다.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(다음에서 상속됨 MarshalByRefObject)
Dispose()

WaitHandle 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the current instance of the WaitHandle class.

(다음에서 상속됨 WaitHandle)
Dispose(Boolean)

파생 클래스에서 재정의된 경우 WaitHandle에서 사용하는 관리되지 않는 리소스를 해제하고 필요에 따라 관리되는 리소스를 해제합니다.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(다음에서 상속됨 WaitHandle)
Equals(Object)

지정된 개체가 현재 개체와 같은지 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetAccessControl()

현재 EventWaitHandleSecurity 개체로 표시되는 명명된 시스템 이벤트에 대한 액세스 제어 보안을 나타내는 EventWaitHandle 개체를 가져옵니다.Gets an EventWaitHandleSecurity object that represents the access control security for the named system event represented by the current EventWaitHandle object.

(다음에서 상속됨 EventWaitHandle)
GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetLifetimeService()

이 인스턴스의 수명 정책을 제어하는 현재의 수명 서비스 개체를 검색합니다.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(다음에서 상속됨 MarshalByRefObject)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
InitializeLifetimeService()

이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다.Obtains a lifetime service object to control the lifetime policy for this instance.

(다음에서 상속됨 MarshalByRefObject)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
MemberwiseClone(Boolean)

현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다.Creates a shallow copy of the current MarshalByRefObject object.

(다음에서 상속됨 MarshalByRefObject)
Reset()

스레드가 차단되도록 이벤트 상태를 신호 없음으로 설정합니다.Sets the state of the event to nonsignaled, which causes threads to block.

Reset()

스레드가 차단되도록 이벤트 상태를 신호 없음으로 설정합니다.Sets the state of the event to nonsignaled, causing threads to block.

(다음에서 상속됨 EventWaitHandle)
Set()

하나 이상의 대기 중인 스레드가 계속 진행되도록 이벤트 상태를 신호 받음으로 설정합니다.Sets the state of the event to signaled, which allows one or more waiting threads to proceed.

Set()

하나 이상의 대기 중인 스레드가 계속 진행되도록 이벤트 상태를 신호 받음으로 설정합니다.Sets the state of the event to signaled, allowing one or more waiting threads to proceed.

(다음에서 상속됨 EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)

명명된 시스템 이벤트에 대한 액세스 제어 보안을 설정합니다.Sets the access control security for a named system event.

(다음에서 상속됨 EventWaitHandle)
ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)
WaitOne()

현재 WaitHandle이(가) 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current WaitHandle receives a signal.

(다음에서 상속됨 WaitHandle)
WaitOne(Int32)

부호 있는 32비트 정수로 시간 간격(밀리초)을 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(다음에서 상속됨 WaitHandle)
WaitOne(Int32, Boolean)

부호 있는 32비트 정수로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(다음에서 상속됨 WaitHandle)
WaitOne(TimeSpan)

TimeSpan로 시간 간격을 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(다음에서 상속됨 WaitHandle)
WaitOne(TimeSpan, Boolean)

TimeSpan로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(다음에서 상속됨 WaitHandle)

명시적 인터페이스 구현

IDisposable.Dispose()

이 API는 제품 인프라를 지원하며 코드에서 직접 사용되지 않습니다.

WaitHandle에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the WaitHandle.

(다음에서 상속됨 WaitHandle)

확장 메서드

GetAccessControl(EventWaitHandle)

지정된 handle에 대한 보안 설명자를 반환합니다.Returns the security descriptors for the specified handle.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

지정된 이벤트 대기 핸들에 대한 보안 설명자를 설정합니다.Sets the security descriptors for the specified event wait handle.

GetSafeWaitHandle(WaitHandle)

네이티브 운영 체제 대기 핸들에 대한 안전한 핸들을 가져옵니다.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

네이티브 운영 체제 대기 핸들에 대한 안전한 핸들을 설정합니다.Sets a safe handle for a native operating system wait handle.

적용 대상

스레드 보안

이 클래스는 스레드로부터 안전 합니다.This class is thread safe.

추가 정보