WaitHandle WaitHandle WaitHandle WaitHandle Class

정의

공유 리소스에 대한 단독 액세스를 기다리는 운영 체제 관련 개체를 캡슐화합니다.Encapsulates operating system-specific objects that wait for exclusive access to shared resources.

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class WaitHandle : MarshalByRefObject, IDisposable
type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable
Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable
상속
파생
특성
구현

예제

다음 코드 예제에서는 두 개의 스레드 수는 어떻게 수행 주 하는 동안 백그라운드 작업 스레드 작업이 정적을 사용 하 여 완료 되기를 기다립니다 WaitAny 하 고 WaitAll 의 메서드는 WaitHandle 클래스.The following code example shows how two threads can do background tasks while the Main thread waits for the tasks to complete using the static WaitAny and WaitAll methods of the WaitHandle class.

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 tasks are 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 'App

' 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 클래스 네이티브 운영 체제 동기화 핸들을 캡슐화 하 고 런타임에서 여러 개의 대기 작업을 허용 하는 모든 동기화 개체를 나타내는 데 사용 됩니다.The WaitHandle class encapsulates a native operating system synchronization handle and is used to represent all synchronization objects in the runtime that allow multiple wait operations. 다른 동기화 개체를 사용 하 여 대기 핸들의 비교를 참조 하세요 동기화 기본 형식 개요합니다.For a comparison of wait handles with other synchronization objects, see Overview of Synchronization Primitives.

WaitHandle 클래스 자체는 추상 클래스입니다.The WaitHandle class itself is abstract. 파생 된 클래스 WaitHandle 신호 메커니즘을 수행 하거나 공유 리소스에 대 한 액세스를 해제 의미를 정의 하지만 상속 된 사용 WaitHandle 공유 리소스에 대 한 액세스를 기다리는 동안 차단 하는 방법입니다.Classes derived from WaitHandle define a signaling mechanism to indicate taking or releasing access to a shared resource, but they use the inherited WaitHandle methods to block while waiting for access to shared resources. 파생 된 클래스가 WaitHandle 포함:The classes derived from WaitHandle include:

인스턴스 메서드를 호출 하 여 개별 대기 핸들에서 스레드가 차단할 수 있습니다 WaitOne에서 파생 된 클래스에 상속 되는 WaitHandle합니다.Threads can block on an individual wait handle by calling the instance method WaitOne, which is inherited by classes derived from WaitHandle.

파생된 클래스 WaitHandle 스레드 선호도 다릅니다.The derived classes of WaitHandle differ in their thread affinity. 이벤트 대기 핸들 (EventWaitHandle, AutoResetEvent, 및 ManualResetEvent) 세마포에 스레드 선호도 없습니다 하 고 모든 스레드를 이벤트 대기 핸들 또는 세마포 신호를 보낼 수 있습니다.Event wait handles (EventWaitHandle, AutoResetEvent, and ManualResetEvent) and semaphores do not have thread affinity; any thread can signal an event wait handle or semaphore. 뮤텍스, 반면에 권한이 스레드 선호도 있습니다. 뮤텍스를 소유 하는 스레드를 해제 해야 하 고 스레드 호출 하는 경우 예외가 throw 되는 ReleaseMutex 소유 하지 않는 뮤텍스를 메서드.Mutexes, on the other hand, do have thread affinity; the thread that owns a mutex must release it, and an exception is thrown if a thread calls the ReleaseMutex method on a mutex that it does not own.

때문에 합니다 WaitHandle 클래스에서 파생 되며 MarshalByRefObject, 이러한 클래스를 사용 하 여 애플리케이션 도메인 경계를 넘어 스레드의 활동을 동기화 할 수 있습니다.Because the WaitHandle class derives from MarshalByRefObject, these classes can be used to synchronize the activities of threads across application domain boundaries.

파생된 클래스 외에도 WaitHandle 클래스 개수가 하나 될 때까지 스레드를 차단 하는 정적 메서드 또는 동기화 개체가 신호를 수신 합니다.In addition to its derived classes, the WaitHandle class has a number of static methods that block a thread until one or more synchronization objects receive a signal. 여기에는 다음이 포함됩니다.These include:

  • SignalAndWait에 하나의 대기 핸들이 신호를 보내고 다른 곧바로 대기 하기 위한 스레드 수 있습니다.SignalAndWait, which allows a thread to signal one wait handle and immediately wait on another.

  • WaitAll을 허용 하는 스레드가 모든 대기 핸들 배열에 신호를 받을 때까지 대기 해야 합니다.WaitAll, which allows a thread to wait until all the wait handles in an array receive a signal.

  • WaitAny-지정 된 대기 핸들 집합 중 하나가 신호를 받을 때까지 스레드가 대기 하도록 허용 합니다.WaitAny, which allows a thread to wait until any one of a specified set of wait handles has been signaled.

이러한 메서드의 오버 로드는 대기 및 동기화 컨텍스트를 사용 하 여 다른 스레드를 허용 하는 대기를 시작 하기 전에 동기화 컨텍스트를 종료 하는 기회를 중단 하는 것에 대 한 제한 시간 간격을 제공 합니다.The overloads of these methods provide timeout intervals for abandoning the wait, and the opportunity to exit a synchronization context before entering the wait, allowing other threads to use the synchronization context.

중요

이 형식이 구현 하는 IDisposable 인터페이스입니다.This type implements the IDisposable interface. 형식 또는 여기에서 파생 된 형식을 사용 하 여 마쳤으면 직접 또는 간접적으로으로 삭제 해야 있습니다.When you have finished using the type or a type derived from it, you should dispose of it either directly or indirectly. 직접 형식의 dispose 호출 해당 Close 의 메서드를 try / catch 블록입니다.To dispose of the type directly, call its Close 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.

WaitHandle 구현 된 Dispose 패턴입니다.WaitHandle implements the Dispose pattern. Dispose 메서드 구현을 참조 하세요.See [Implementing a Dispose method](~/docs/standard/garbage-collection/implementing-dispose .md). 파생 하는 경우 WaitHandle를 사용 하 여는 SafeWaitHandle 에 네이티브 운영 체제 핸들을 저장 하는 속성입니다.When you derive from WaitHandle, use the SafeWaitHandle property to store your native operating system handle. 보호 된 재정의할 필요가 없습니다 Dispose 메서드 사용 하지 않는 경우 관리 되지 않는 리소스를 추가 합니다.You do not need to override the protected Dispose method unless you use additional unmanaged resources.

생성자

WaitHandle() WaitHandle() WaitHandle() WaitHandle()

WaitHandle 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the WaitHandle class.

필드

InvalidHandle InvalidHandle InvalidHandle InvalidHandle

유효하지 않은 네이티브 운영 체제 핸들을 나타냅니다.Represents an invalid native operating system handle. 이 필드는 읽기 전용입니다.This field is read-only.

WaitTimeout WaitTimeout WaitTimeout 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.

속성

Handle Handle Handle Handle

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

SafeWaitHandle SafeWaitHandle SafeWaitHandle SafeWaitHandle

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

메서드

Close() Close() Close() Close()

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

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

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

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

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

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

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

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()

현재 인스턴스에서 보유한 리소스를 해제합니다.Releases the resources held by the current instance.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

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

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

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

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

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

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

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

(Inherited from MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle) SignalAndWait(WaitHandle, WaitHandle) SignalAndWait(WaitHandle, WaitHandle) SignalAndWait(WaitHandle, WaitHandle)

WaitHandle에 신호하고 다른 신호를 기다립니다.Signals one WaitHandle and waits on another.

SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean) SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean) SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean) SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

제한 시간 간격을 부호 있는 32비트 정수로 지정하고 대기 상태로 들어가기 전에 컨텍스트에 대한 동기화 도메인을 종료할지 여부를 지정하여, WaitHandle 중 하나에게 알리고 다음을 기다립니다.Signals one WaitHandle and waits on another, specifying a time-out interval as a 32-bit signed integer and specifying whether to exit the synchronization domain for the context before entering the wait.

SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean) SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean) SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean) SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

제한 시간 간격을 TimeSpan으로 지정하고 대기 상태로 들어가기 전에 컨텍스트에 대한 동기화 도메인을 종료할지 여부를 지정하여, WaitHandle 중 하나에게 알리고 다음을 기다립니다.Signals one WaitHandle and waits on another, specifying the time-out interval as a TimeSpan and specifying whether to exit the synchronization domain for the context before entering the wait.

ToString() ToString() ToString() ToString()

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

(Inherited from Object)
WaitAll(WaitHandle[]) WaitAll(WaitHandle[]) WaitAll(WaitHandle[]) WaitAll(WaitHandle[])

지정된 배열의 모든 요소가 신호를 받기를 기다립니다.Waits for all the elements in the specified array to receive a signal.

WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32)

시간 간격을 지정하는 Int32 값을 사용하여 지정된 배열의 모든 요소가 신호를 받기를 기다립니다.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval.

WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean)

Int32 값을 사용하여 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 지정된 배열의 모든 요소가 신호를 받기를 기다립니다.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan)

TimeSpan 값을 사용하여 시간 간격을 지정함으로써 지정된 배열의 모든 요소가 신호를 받기를 기다립니다.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.

WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean)

TimeSpan 값을 사용하여 시간 간격을 측정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 지정된 배열의 모든 요소가 신호를 받기를 기다립니다.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[]) WaitAny(WaitHandle[]) WaitAny(WaitHandle[]) WaitAny(WaitHandle[])

지정된 배열의 모든 요소가 신호를 받기를 기다립니다.Waits for any of the elements in the specified array to receive a signal.

WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32)

부호 있는 32비트 정수를 사용하여 시간 간격을 지정함으로써 지정된 배열의 임의 요소가 신호를 받기를 기다립니다.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval.

WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean)

부호 있는 32비트 정수를 사용하여 시간 간격을 지정하고 대기 전에 동기화 도메인을 종료할지를 지정하여 지정된 배열의 요소가 신호를 받기를 기다립니다.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan)

TimeSpan을 사용하여 시간 간격을 지정함으로써 지정된 배열의 임의 요소가 신호를 받기를 기다립니다.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval.

WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean)

TimeSpan 값으로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정한 다음 지정된 배열의 요소가 신호를 받기를 기다립니다.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne() WaitOne() WaitOne() WaitOne()

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

WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) 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.

WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) 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.

WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan)

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

WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) 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.

명시적 인터페이스 구현

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

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

확장 메서드

GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle)

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

SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

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

적용 대상

스레드 보안

이 형식은 스레드로부터 안전합니다.This type is thread safe.

추가 정보