ManualResetEventSlim 类

定义

表示线程同步事件,收到信号时,必须手动重置该事件。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
public class ManualResetEventSlim : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class ManualResetEventSlim : IDisposable
type ManualResetEventSlim = class
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(false)>]
type ManualResetEventSlim = class
    interface IDisposable
Public Class ManualResetEventSlim
Implements IDisposable
继承
ManualResetEventSlim
属性
实现

示例

下面的示例演示如何使用 ManualResetEventSlimThe 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 类的新实例。Initializes a new instance of the ManualResetEventSlim class with an initial state of nonsignaled.

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 类的新实例。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

获取是否已设置事件。Gets whether the event is set.

SpinCount

获取在回退到基于内核的等待操作之前将发生的自旋等待数量。Gets the number of spin waits that will occur before falling back to a kernel-based wait operation.

WaitHandle

获取此 WaitHandle 的基础 ManualResetEventSlim 对象。Gets the underlying WaitHandle object for this ManualResetEventSlim.

方法

Dispose()

释放 ManualResetEventSlim 类的当前实例所使用的所有资源。Releases all resources used by the current instance of the ManualResetEventSlim class.

Dispose(Boolean)

释放由 ManualResetEventSlim 占用的非托管资源,还可以另外再释放托管资源。Releases the unmanaged resources used by the ManualResetEventSlim, and optionally releases the managed resources.

Equals(Object)

确定指定对象是否等于当前对象。Determines whether the specified object is equal to the current object.

(继承自 Object)
GetHashCode()

作为默认哈希函数。Serves as the default hash function.

(继承自 Object)
GetType()

获取当前实例的 TypeGets the Type of the current instance.

(继承自 Object)
MemberwiseClone()

创建当前 Object 的浅表副本。Creates a shallow copy of the current Object.

(继承自 Object)
Reset()

将事件状态设置为非终止,从而导致线程受阻。Sets the state of the event to nonsignaled, which causes threads to block.

Set()

将事件状态设置为有信号,从而允许一个或多个等待该事件的线程继续。Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed.

ToString()

返回表示当前对象的字符串。Returns a string that represents the current object.

(继承自 Object)
Wait()

阻止当前线程,直到设置了当前 ManualResetEventSlim 为止。Blocks the current thread until the current ManualResetEventSlim is set.

Wait(CancellationToken)

阻止当前线程,直到当前 ManualResetEventSlim 收到信号为止,同时观察 CancellationTokenBlocks the current thread until the current ManualResetEventSlim receives a signal, while observing a CancellationToken.

Wait(Int32)

阻止当前线程,直到设置了当前 ManualResetEventSlim 为止,同时使用 32 位带符号整数测量时间间隔。Blocks the current thread until the current ManualResetEventSlim is set, using a 32-bit signed integer to measure the time interval.

Wait(Int32, CancellationToken)

阻止当前线程,直到设置了当前 ManualResetEventSlim 为止,并使用 32 位带符号整数测量时间间隔,同时观察 CancellationTokenBlocks 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)

阻止当前线程,直到设置了当前 ManualResetEventSlim 为止,同时使用 TimeSpan 测量时间间隔。Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval.

Wait(TimeSpan, CancellationToken)

阻止当前线程,直到设置了当前 ManualResetEventSlim 为止,并使用 TimeSpan 测量时间间隔,同时观察 CancellationTokenBlocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval, while observing a CancellationToken.

适用于

线程安全性

的所有公共和受保护的成员 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.

另请参阅