ManualResetEventSlim ManualResetEventSlim ManualResetEventSlim ManualResetEventSlim Class

정의

신호를 받을 때 수동으로 재설정되어야 하는 스레드 동기화 이벤트를 나타냅니다.Represents a thread synchronization event that, when signaled, must be reset manually. 이 클래스는 ManualResetEvent의 간단한 대체 항목입니다.This class is a lightweight alternative to ManualResetEvent.

public ref class ManualResetEventSlim : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class ManualResetEventSlim : IDisposable
type ManualResetEventSlim = class
    interface IDisposable
Public Class ManualResetEventSlim
Implements IDisposable
상속
ManualResetEventSlimManualResetEventSlimManualResetEventSlimManualResetEventSlim
특성
구현

예제

다음 예제에서는 사용 하는 방법을 보여 줍니다는 ManualResetEventSlim합니다.The following example shows how to use a ManualResetEventSlim.

using System;
using System.Threading;
using System.Threading.Tasks;
class MRESDemo
{

    static void Main()
    {
        MRES_SetWaitReset();
        MRES_SpinCountWaitHandle();
    }
    // Demonstrates:
    //      ManualResetEventSlim construction
    //      ManualResetEventSlim.Wait()
    //      ManualResetEventSlim.Set()
    //      ManualResetEventSlim.Reset()
    //      ManualResetEventSlim.IsSet
    static void MRES_SetWaitReset()
    {
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres3 = new ManualResetEventSlim(true);  // initialize as signaled

        // Start an asynchronous Task that manipulates mres3 and mres2
        var observer = Task.Factory.StartNew(() =>
        {
            mres1.Wait();
            Console.WriteLine("observer sees signaled mres1!");
            Console.WriteLine("observer resetting mres3...");
            mres3.Reset(); // should switch to unsignaled
            Console.WriteLine("observer signalling mres2");
            mres2.Set();
        });

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet);
        Console.WriteLine("main thread signalling mres1");
        mres1.Set(); // This will "kick off" the observer Task
        mres2.Wait(); // This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!");
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet);

        // It's good form to Dispose() a ManualResetEventSlim when you're done with it
        observer.Wait(); // make sure that this has fully completed
        mres1.Dispose();
        mres2.Dispose();
        mres3.Dispose();
    }

    // Demonstrates:
    //      ManualResetEventSlim construction w/ SpinCount
    //      ManualResetEventSlim.WaitHandle
    static void MRES_SpinCountWaitHandle()
    {
        // Construct a ManualResetEventSlim with a SpinCount of 1000
        // Higher spincount => longer time the MRES will spin-wait before taking lock
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false, 1000);
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false, 1000);

        Task bgTask = Task.Factory.StartNew(() =>
        {
            // Just wait a little
            Thread.Sleep(100);

            // Now signal both MRESes
            Console.WriteLine("Task signalling both MRESes");
            mres1.Set();
            mres2.Set();
        });

        // A common use of MRES.WaitHandle is to use MRES as a participant in 
        // WaitHandle.WaitAll/WaitAny.  Note that accessing MRES.WaitHandle will
        // result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(new WaitHandle[] { mres1.WaitHandle, mres2.WaitHandle });
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.");

        // Clean up
        bgTask.Wait();
        mres1.Dispose();
        mres2.Dispose();
    }
}
Imports System.Threading
Imports System.Threading.Tasks

Module MRESDemo

    Sub Main()

    End Sub
    ' Demonstrates:
    ' ManualResetEventSlim construction
    ' ManualResetEventSlim.Wait()
    ' ManualResetEventSlim.Set()
    ' ManualResetEventSlim.Reset()
    ' ManualResetEventSlim.IsSet
    Private Sub MRES_SetWaitReset()
        ' initialize as unsignaled
        Dim mres1 As New ManualResetEventSlim(False)
        ' initialize as unsignaled
        Dim mres2 As New ManualResetEventSlim(False)
        ' initialize as signaled
        Dim mres3 As New ManualResetEventSlim(True)

        ' Start an asynchronous Task that manipulates mres3 and mres2
        Dim observer = Task.Factory.StartNew(
            Sub()
                mres1.Wait()
                Console.WriteLine("observer sees signaled mres1!")
                Console.WriteLine("observer resetting mres3...")
                mres3.Reset()
                ' should switch to unsignaled
                Console.WriteLine("observer signalling mres2")
                mres2.[Set]()
            End Sub)

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet)
        Console.WriteLine("main thread signalling mres1")
        mres1.[Set]()
        ' This will "kick off" the observer Task
        mres2.Wait()
        ' This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!")
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet)

        ' make sure that observer has fully completed
        observer.Wait()
        ' It's good form to Dispose() a ManualResetEventSlim when you're done with it
        mres1.Dispose()
        mres2.Dispose()
        mres3.Dispose()
    End Sub

    ' Demonstrates:
    ' ManualResetEventSlim construction w/ SpinCount
    ' ManualResetEventSlim.WaitHandle
    Private Sub MRES_SpinCountWaitHandle()
        ' Construct a ManualResetEventSlim with a SpinCount of 1000
        ' Higher spincount => longer time the MRES will spin-wait before taking lock
        Dim mres1 As New ManualResetEventSlim(False, 1000)
        Dim mres2 As New ManualResetEventSlim(False, 1000)

        Dim bgTask As Task = Task.Factory.StartNew(
            Sub()
                ' Just wait a little
                Thread.Sleep(100)

                ' Now signal both MRESes
                Console.WriteLine("Task signalling both MRESes")
                mres1.[Set]()
                mres2.[Set]()
            End Sub)

        ' A common use of MRES.WaitHandle is to use MRES as a participant in 
        ' WaitHandle.WaitAll/WaitAny. Note that accessing MRES.WaitHandle will
        ' result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(New WaitHandle() {mres1.WaitHandle, mres2.WaitHandle})
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.")

        ' Wait for bgTask to complete and clean up
        bgTask.Wait()
        mres1.Dispose()
        mres2.Dispose()
    End Sub
End Module

설명

이 클래스를 사용 하 여 보다 성능 향상을 위해 ManualResetEvent 대기 시간이 매우 짧은 것으로 예상 되 고 이벤트가 프로세스 경계를 넘어서지 않는 경우.You can use this class for better performance than ManualResetEvent when wait times are expected to be very short, and when the event does not cross a process boundary. ManualResetEventSlim에서는 이벤트에 신호가 전달되기를 기다리는 짧은 시간 동안 고속 회전을 사용합니다.ManualResetEventSlim uses busy spinning for a short time while it waits for the event to become signaled. 대기 시간이 짧은 경우 대기 핸들을 사용하여 기다리는 것보다 회전하는 것이 비용이 적게 들 수 있습니다.When wait times are short, spinning can be much less expensive than waiting by using wait handles. 그러나 이벤트가 특정 기간 내에 신호를 받지 않는 경우 일반적인 이벤트 핸들 대기에 ManualResetEventSlim을 사용합니다.However, if the event does not become signaled within a certain period of time, ManualResetEventSlim resorts to a regular event handle wait.

생성자

ManualResetEventSlim() ManualResetEventSlim() ManualResetEventSlim() ManualResetEventSlim()

신호 없음을 초기 상태로 사용하여 ManualResetEventSlim 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the ManualResetEventSlim class with an initial state of nonsignaled.

ManualResetEventSlim(Boolean) ManualResetEventSlim(Boolean) ManualResetEventSlim(Boolean) ManualResetEventSlim(Boolean)

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

ManualResetEventSlim(Boolean, Int32) ManualResetEventSlim(Boolean, Int32) ManualResetEventSlim(Boolean, Int32) ManualResetEventSlim(Boolean, Int32)

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

속성

IsSet IsSet IsSet IsSet

이벤트가 설정되었는지를 가져옵니다.Gets whether the event is set.

SpinCount SpinCount SpinCount SpinCount

커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수를 가져옵니다.Gets the number of spin waits that will occur before falling back to a kernel-based wait operation.

WaitHandle WaitHandle WaitHandle WaitHandle

WaitHandle의 내부 ManualResetEventSlim 개체를 가져옵니다.Gets the underlying WaitHandle object for this ManualResetEventSlim.

메서드

Dispose() Dispose() Dispose() Dispose()

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

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

ManualResetEventSlim에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다.Releases the unmanaged resources used by the ManualResetEventSlim, 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)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetType() GetType() GetType() GetType()

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

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

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

(Inherited from Object)
Reset() Reset() Reset() Reset()

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

Set() Set() Set() Set()

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

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

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

(Inherited from Object)
Wait() Wait() Wait() Wait()

현재 ManualResetEventSlim이 설정될 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current ManualResetEventSlim is set.

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken)

ManualResetEventSlim을 확인하면서 현재 CancellationToken이 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current ManualResetEventSlim receives a signal, while observing a CancellationToken.

Wait(Int32) Wait(Int32) Wait(Int32) Wait(Int32)

부호 있는 32비트 정수로 시간 간격을 측정하여 현재 ManualResetEventSlim이 설정될 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current ManualResetEventSlim is set, using a 32-bit signed integer to measure the time interval.

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken)

ManualResetEventSlim을 확인하면서 부호 있는 32비트 정수로 시간 간격을 측정하여 현재 CancellationToken이 설정될 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current ManualResetEventSlim is set, using a 32-bit signed integer to measure the time interval, while observing a CancellationToken.

Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

ManualResetEventSlim으로 시간 간격을 측정하여 현재 TimeSpan이 설정될 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval.

Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken)

ManualResetEventSlim을 확인하면서 TimeSpan으로 시간 간격을 측정하여 현재 CancellationToken이 설정될 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval, while observing a CancellationToken.

적용 대상

스레드 보안

모든 public 및 protected 멤버만 ManualResetEventSlim 스레드로부터 안전 하며 여러 스레드에서 동시에,만 해야 하는 Dispose 제외 하 고 사용할 수 있습니다 때 사용 되는 다른 모든 작업에는 ManualResetEventSlim 를 완료 하 고 다시 설정 해야 하는 경우에 사용 이벤트에 액세스 하는 다른 스레드가 없습니다.All public and protected members of ManualResetEventSlim are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose, which must only be used when all other operations on the ManualResetEventSlim have completed, and Reset, which should only be used when no other threads are accessing the event.

추가 정보