AutoResetEvent 클래스

정의

단일 대기 스레드를 해제한 후에 신호를 받으면 자동으로 재설정되는 스레드 동기화 이벤트를 나타냅니다.Represents a thread synchronization event that, when signaled, resets automatically after releasing a single waiting thread. 이 클래스는 상속될 수 없습니다.This class cannot be inherited.

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

예제

다음 예제에서는를 사용 하 여 AutoResetEvent Set 사용자가 Enter 키를 누를 때마다 기본 클래스에서 메서드를 호출 하 여 한 번에 하나의 스레드를 해제 하는 방법을 보여 줍니다.The following example shows how to use AutoResetEvent to release one thread at a time, by calling the Set method (on the base class) each time the user presses the Enter key. 이 예제에서는 AutoResetEvent 신호를 받은 상태로 만든를 대기 하는 세 개의 스레드를 시작 합니다.The example starts three threads, which wait on an AutoResetEvent that was created in the signaled state. 가 이미 신호를 받은 상태 이기 때문에 첫 번째 스레드는 즉시 해제 됩니다 AutoResetEvent .The first thread is released immediately, because the AutoResetEvent is already in the signaled state. 이렇게 하면를 AutoResetEvent 신호를 받지 않은 상태로 다시 설정 하므로 후속 스레드가 차단 됩니다.This resets the AutoResetEvent to the non-signaled state, so that subsequent threads block. 사용자가 Enter 키를 눌러 한 번에 하나씩 해제할 때까지 차단 된 스레드는 해제 되지 않습니다.The blocked threads are not released until the user releases them one at a time by pressing the Enter key.

첫 번째 스레드에서 스레드를 해제 한 후에는 AutoResetEvent AutoResetEvent 신호를 받지 않은 상태에서 만든 다른 스레드에서 스레드를 대기 합니다.After the threads are released from the first AutoResetEvent, they wait on another AutoResetEvent that was created in the non-signaled state. 세 스레드를 모두 차단 하므로 Set 메서드를 모두 해제 하려면 세 번 호출 해야 합니다.All three threads block, so the Set method must be called three times to release them all.

using namespace System;
using namespace System::Threading;

ref class Example
{
private:
    static AutoResetEvent^ event_1 = gcnew AutoResetEvent(true);
    static AutoResetEvent^ event_2 = gcnew AutoResetEvent(false);

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

        Console::WriteLine("{0} waits on AutoResetEvent #1.", name);
        event_1->WaitOne();
        Console::WriteLine("{0} is released from AutoResetEvent #1.", name);

        Console::WriteLine("{0} waits on AutoResetEvent #2.", name);
        event_2->WaitOne();
        Console::WriteLine("{0} is released from AutoResetEvent #2.", name);

        Console::WriteLine("{0} ends.", name);
    }

public:
    static void Demo()
    {
        Console::WriteLine("Press Enter to create three threads and start them.\r\n" +
                           "The threads wait on AutoResetEvent #1, which was created\r\n" +
                           "in the signaled state, so the first thread is released.\r\n" +
                           "This puts AutoResetEvent #1 into the unsignaled state.");
        Console::ReadLine();
            
        for (int i = 1; i < 4; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(&ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }
        Thread::Sleep(250);

        for (int i = 0; i < 2; i++)
        {
            Console::WriteLine("Press Enter to release another thread.");
            Console::ReadLine();
            event_1->Set();
            Thread::Sleep(250);
        }

        Console::WriteLine("\r\nAll threads are now waiting on AutoResetEvent #2.");
        for (int i = 0; i < 3; i++)
        {
            Console::WriteLine("Press Enter to release a thread.");
            Console::ReadLine();
            event_2->Set();
            Thread::Sleep(250);
        }

        // Visual Studio: Uncomment the following line.
        //Console::Readline();
    }
};

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

/* This example produces output similar to the following:

Press Enter to create three threads and start them.
The threads wait on AutoResetEvent #1, which was created
in the signaled state, so the first thread is released.
This puts AutoResetEvent #1 into the unsignaled state.

Thread_1 waits on AutoResetEvent #1.
Thread_1 is released from AutoResetEvent #1.
Thread_1 waits on AutoResetEvent #2.
Thread_3 waits on AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #1.
Press Enter to release another thread.

Thread_3 is released from AutoResetEvent #1.
Thread_3 waits on AutoResetEvent #2.
Press Enter to release another thread.

Thread_2 is released from AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #2.

All threads are now waiting on AutoResetEvent #2.
Press Enter to release a thread.

Thread_2 is released from AutoResetEvent #2.
Thread_2 ends.
Press Enter to release a thread.

Thread_1 is released from AutoResetEvent #2.
Thread_1 ends.
Press Enter to release a thread.

Thread_3 is released from AutoResetEvent #2.
Thread_3 ends.
 */
using System;
using System.Threading;

// Visual Studio: Replace the default class in a Console project with 
//                the following class.
class Example
{
    private static AutoResetEvent event_1 = new AutoResetEvent(true);
    private static AutoResetEvent event_2 = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Press Enter to create three threads and start them.\r\n" +
                          "The threads wait on AutoResetEvent #1, which was created\r\n" +
                          "in the signaled state, so the first thread is released.\r\n" +
                          "This puts AutoResetEvent #1 into the unsignaled state.");
        Console.ReadLine();
            
        for (int i = 1; i < 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }
        Thread.Sleep(250);

        for (int i = 0; i < 2; i++)
        {
            Console.WriteLine("Press Enter to release another thread.");
            Console.ReadLine();
            event_1.Set();
            Thread.Sleep(250);
        }

        Console.WriteLine("\r\nAll threads are now waiting on AutoResetEvent #2.");
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Press Enter to release a thread.");
            Console.ReadLine();
            event_2.Set();
            Thread.Sleep(250);
        }

        // Visual Studio: Uncomment the following line.
        //Console.Readline();
    }

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

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name);
        event_1.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name);

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name);
        event_2.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name);

        Console.WriteLine("{0} ends.", name);
    }
}

/* This example produces output similar to the following:

Press Enter to create three threads and start them.
The threads wait on AutoResetEvent #1, which was created
in the signaled state, so the first thread is released.
This puts AutoResetEvent #1 into the unsignaled state.

Thread_1 waits on AutoResetEvent #1.
Thread_1 is released from AutoResetEvent #1.
Thread_1 waits on AutoResetEvent #2.
Thread_3 waits on AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #1.
Press Enter to release another thread.

Thread_3 is released from AutoResetEvent #1.
Thread_3 waits on AutoResetEvent #2.
Press Enter to release another thread.

Thread_2 is released from AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #2.

All threads are now waiting on AutoResetEvent #2.
Press Enter to release a thread.

Thread_2 is released from AutoResetEvent #2.
Thread_2 ends.
Press Enter to release a thread.

Thread_1 is released from AutoResetEvent #2.
Thread_1 ends.
Press Enter to release a thread.

Thread_3 is released from AutoResetEvent #2.
Thread_3 ends.
 */
Imports System.Threading

' Visual Studio: Replace the default class in a Console project with 
'                the following class.
Class Example

    Private Shared event_1 As New AutoResetEvent(True)
    Private Shared event_2 As New AutoResetEvent(False)

    <MTAThread()> _
    Shared Sub Main()
    
        Console.WriteLine("Press Enter to create three threads and start them." & vbCrLf & _
                          "The threads wait on AutoResetEvent #1, which was created" & vbCrLf & _
                          "in the signaled state, so the first thread is released." & vbCrLf & _
                          "This puts AutoResetEvent #1 into the unsignaled state.")
        Console.ReadLine()
            
        For i As Integer = 1 To 3
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next
        Thread.Sleep(250)

        For i As Integer = 1 To 2
            Console.WriteLine("Press Enter to release another thread.")
            Console.ReadLine()

            event_1.Set()
            Thread.Sleep(250)
        Next

        Console.WriteLine(vbCrLf & "All threads are now waiting on AutoResetEvent #2.")
        For i As Integer = 1 To 3
            Console.WriteLine("Press Enter to release a thread.")
            Console.ReadLine()

            event_2.Set()
            Thread.Sleep(250)
        Next

        ' Visual Studio: Uncomment the following line.
        'Console.Readline()
    End Sub

    Shared Sub ThreadProc()
    
        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name)
        event_1.WaitOne()
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name)

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name)
        event_2.WaitOne()
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name)

        Console.WriteLine("{0} ends.", name)
    End Sub
End Class

' This example produces output similar to the following:
'
'Press Enter to create three threads and start them.
'The threads wait on AutoResetEvent #1, which was created
'in the signaled state, so the first thread is released.
'This puts AutoResetEvent #1 into the unsignaled state.
'
'Thread_1 waits on AutoResetEvent #1.
'Thread_1 is released from AutoResetEvent #1.
'Thread_1 waits on AutoResetEvent #2.
'Thread_3 waits on AutoResetEvent #1.
'Thread_2 waits on AutoResetEvent #1.
'Press Enter to release another thread.
'
'Thread_3 is released from AutoResetEvent #1.
'Thread_3 waits on AutoResetEvent #2.
'Press Enter to release another thread.
'
'Thread_2 is released from AutoResetEvent #1.
'Thread_2 waits on AutoResetEvent #2.
'
'All threads are now waiting on AutoResetEvent #2.
'Press Enter to release a thread.
'
'Thread_2 is released from AutoResetEvent #2.
'Thread_2 ends.
'Press Enter to release a thread.
'
'Thread_1 is released from AutoResetEvent #2.
'Thread_1 ends.
'Press Enter to release a thread.
'
'Thread_3 is released from AutoResetEvent #2.
'Thread_3 ends.

설명

AutoResetEvent ManualResetEvent EventWaitHandle 스레드 상호 작용 (또는 스레드 신호)에는, 및를 사용 합니다.You use AutoResetEvent, ManualResetEvent, 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.

중요

이 형식이 구현 하는 IDisposable 인터페이스입니다.This type implements the IDisposable interface. 형식을 사용 하 여 마쳤으면 직접 또는 간접적으로의 삭제 해야 있습니다.When you have finished using the type, you should dispose of it either directly or indirectly. 직접 형식의 dispose 호출 해당 Dispose 의 메서드를 try/catch 블록입니다.To dispose of the type directly, call its Dispose method in a try/catch block. 삭제 하지 직접, 언어 구문 같은 사용 using (C#에서) 또는 Using (Visual Basic에서는).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). 자세한 내용은 "를 사용 하는 개체는 구현 IDisposable" 섹션을 참조 하세요.를 IDisposable 인터페이스 항목입니다.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

스레드는 AutoResetEvent. system.threading.waithandle.waitone를 호출 하 여 신호를 대기 합니다.A thread waits for a signal by calling AutoResetEvent.WaitOne. AutoResetEvent가 신호를 받지 않은 상태에 있는 경우 AutoResetEvent 가 호출 될 때까지 스레드가 차단 됩니다.If the AutoResetEvent is in the non-signaled state, the thread blocks until AutoResetEvent.Set is called.

Set신호 AutoResetEvent 를 호출 하 여 대기 스레드를 해제 합니다.Calling Set signals AutoResetEvent to release a waiting thread. AutoResetEvent 는 대기 중인 단일 스레드를 해제할 때까지 신호를 받은 상태로 유지 한 다음 자동으로 신호를 받지 않는 상태로 돌아갑니다.AutoResetEvent remains signaled until a single waiting thread is released, and then automatically returns to the non-signaled state. 대기 중인 스레드가 없는 경우 상태는 무기한 신호 받음 상태로 유지 됩니다.If no threads are waiting, the state remains signaled indefinitely.

가 신호를 받은 상태에서 스레드가를 호출 하는 경우 WaitOne AutoResetEvent 스레드는 차단 되지 않습니다.If a thread calls WaitOne while the AutoResetEvent is in the signaled state, the thread does not block. AutoResetEvent 스레드를 즉시 해제 하 고 신호를 받지 않는 상태로 되돌립니다.The AutoResetEvent releases the thread immediately and returns to the non-signaled state.

중요

모든 메서드에 대 한 호출에서 스레드를 릴리스할 수 있는 것은 아닙니다 Set .There is no guarantee that every call to the Set method will release a thread. 두 호출이 너무 가까이 있어 두 번째 호출이 스레드를 해제 하기 전에 발생 하도록 하려면 하나의 스레드만 해제 됩니다.If two calls are too close together, so that the second call occurs before a thread has been released, only one thread is released. 두 번째 호출이 발생 하지 않은 것 처럼입니다.It's as if the second call did not happen. 또한를 Set 대기 중인 스레드가 없고가 이미 신호를 받은 상태에서가 호출 되 면 AutoResetEvent 호출은 효과가 없습니다.Also, if Set is called when there are no threads waiting and the AutoResetEvent is already signaled, the call has no effect.

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

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

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

참고

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

생성자

AutoResetEvent(Boolean)

초기 상태를 신호 받음으로 설정할지 여부를 나타내는 부울 값을 사용하여 AutoResetEvent 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the AutoResetEvent 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 at most one waiting thread 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.

추가 정보