다음을 통해 공유

WaitHandle 클래스

  • 참조

정의

네임스페이스:
System.Threading
어셈블리:
System.Runtime.dll
어셈블리:
mscorlib.dll
어셈블리:
netstandard.dll
Source:
WaitHandle.cs
Source:
WaitHandle.cs
Source:
WaitHandle.cs

공유 리소스에 대한 단독 액세스를 기다리는 운영 체제 관련 개체를 캡슐화합니다.

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
파생
특성
ComVisibleAttribute
구현
IDisposable

예제

다음 코드 예제에서는 주 스레드가 클래스의 WaitHandle 정적 WaitAny 및 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 파생된 클래스는 다음과 같습니다.

스레드는 에서 파생된 클래스에서 상속되는 instance 메서드WaitOne를 호출하여 개별 대기 핸들에서 WaitHandle차단할 수 있습니다.

의 파생 클래스는 WaitHandle 스레드 선호도에서 다릅니다. 이벤트 대기 핸들(EventWaitHandle, AutoResetEvent및 ManualResetEvent) 및 세마포에는 스레드 선호도가 없습니다. 스레드는 이벤트 대기 핸들 또는 세마포를 신호로 표시할 수 있습니다. 반면 뮤텍스에는 스레드 선호도가 있습니다. 뮤텍스를 소유하는 스레드는 뮤텍스를 해제해야 하며, 스레드가 소유하지 않은 뮤텍스에서 메서드를 호출 ReleaseMutex 하면 예외가 throw됩니다.

때문에 합니다 WaitHandle 클래스에서 파생 되며 MarshalByRefObject, 이러한 클래스를 사용 하 여 애플리케이션 도메인 경계를 넘어 스레드의 활동을 동기화 할 수 있습니다.

파생 클래스 WaitHandle 외에도 클래스에는 하나 이상의 동기화 개체가 신호를 받을 때까지 스레드를 차단하는 여러 정적 메서드가 있습니다. 여기에는 다음이 포함됩니다.

  • SignalAndWait- 스레드가 하나의 대기 핸들에 신호를 표시하고 다른 대기 핸들을 즉시 대기할 수 있도록 합니다.

  • WaitAll- 배열의 모든 대기 핸들이 신호를 받을 때까지 스레드가 대기할 수 있도록 합니다.

  • WaitAny- 지정된 대기 핸들 집합 중 하나가 신호를 수신할 때까지 스레드가 대기할 수 있도록 합니다.

이러한 메서드의 오버로드는 대기를 중단하기 위한 시간 제한 간격과 대기를 입력하기 전에 동기화 컨텍스트를 종료할 수 있는 기회를 제공하여 다른 스레드가 동기화 컨텍스트를 사용할 수 있도록 합니다.

중요

이 형식이 구현 하는 IDisposable 인터페이스입니다. 형식 또는 형식에서 파생된 형식 사용을 완료한 경우 직접 또는 간접적으로 삭제해야 합니다. 직접 형식의 dispose 호출 해당 Close 의 메서드를 try/catch 블록입니다. 삭제 하지 직접, 언어 구문 같은 사용 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)
Finalize()

현재 인스턴스에서 보유한 리소스를 해제합니다.
GetHashCode()

기본 해시 함수로 작동합니다.

(다음에서 상속됨 Object)
GetLifetimeService()
사용되지 않음.

이 인스턴스의 수명 정책을 제어하는 현재의 수명 서비스 개체를 검색합니다.

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

현재 인스턴스의 Type을 가져옵니다.

(다음에서 상속됨 Object)
InitializeLifetimeService()
사용되지 않음.

이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다.

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

현재 Object의 단순 복사본을 만듭니다.

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

현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다.

(다음에서 상속됨 MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle)

WaitHandle에 신호하고 다른 신호를 기다립니다.
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

제한 시간 간격을 부호 있는 32비트 정수로 지정하고 대기 상태로 들어가기 전에 컨텍스트에 대한 동기화 도메인을 종료할지 여부를 지정하여, WaitHandle 중 하나에게 알리고 다음을 기다립니다.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

제한 시간 간격을 TimeSpan으로 지정하고 대기 상태로 들어가기 전에 컨텍스트에 대한 동기화 도메인을 종료할지 여부를 지정하여, WaitHandle 중 하나에게 알리고 다음을 기다립니다.
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)

부호 있는 32비트 정수로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.
WaitOne(TimeSpan)

TimeSpan로 시간 간격을 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.
WaitOne(TimeSpan, Boolean)

TimeSpan로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.

명시적 인터페이스 구현

IDisposable.Dispose()

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

WaitHandle에서 사용하는 모든 리소스를 해제합니다.

확장 메서드

GetSafeWaitHandle(WaitHandle)

네이티브 운영 체제 대기 핸들에 대한 안전한 핸들을 가져옵니다.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

네이티브 운영 체제 대기 핸들에 대한 안전한 핸들을 설정합니다.

적용 대상

스레드 보안

이 형식은 스레드로부터 안전합니다.

추가 정보