ManualResetEvent 类

定义

命名空间:

System.Threading

程序集:

netstandard.dll, System.Threading.dll

Source:

ManualResetEvent.cs

表示必须手动重置信号的线程同步事件。 无法继承此类。

public ref class ManualResetEvent sealed : System::Threading::EventWaitHandle

public sealed class ManualResetEvent : System.Threading.EventWaitHandle

type ManualResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle

继承

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

示例

以下示例演示了工作原理 ManualResetEvent 。 该示例以无对齐状态（即false传递给构造函数）开头ManualResetEvent。 该示例创建三个线程，每个线程通过调用其WaitOne方法阻止ManualResetEvent。 当用户按下 Enter 键时，该示例将调用 Set 该方法，该方法释放所有三个线程。 这与类的行为形成鲜明对比，该类 AutoResetEvent 一次释放一个线程，在每个发布后自动重置。

再次按 Enter 键表明， ManualResetEvent 在调用信号状态之前 Reset ，该保留状态为：本示例再启动两个线程。 这些线程在调用 WaitOne 该方法时不会阻止，而是运行到完成。

再次按 Enter 键会导致示例调用 Reset 该方法并启动一个线程，这会在调用 WaitOne时阻止它。 按 Enter 键最后一次调用 Set 释放最后一个线程，程序结束。

using System;
using System.Threading;

public class Example
{
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    private static ManualResetEvent mre = new ManualResetEvent(false);

    static void Main()
    {
        Console.WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <= 2; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                          "\nto release all the threads.\n");
        Console.ReadLine();

        mre.Set();

        Thread.Sleep(500);
        Console.WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                          "\ndo not block. Press Enter to show this.\n");
        Console.ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                          "\nwhen they call WaitOne().\n");
        Console.ReadLine();

        mre.Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread t5 = new Thread(ThreadProc);
        t5.Name = "Thread_5";
        t5.Start();

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console.ReadLine();

        mre.Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console.ReadLine();
    }

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

        Console.WriteLine(name + " starts and calls mre.WaitOne()");

        mre.WaitOne();

        Console.WriteLine(name + " ends.");
    }
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre.WaitOne()
Thread_1 starts and calls mre.WaitOne()
Thread_2 starts and calls mre.WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_0 ends.
Thread_1 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre.WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre.WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre.WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

Imports System.Threading

Public Class Example

    ' mre is used to block and release threads manually. It is
    ' created in the unsignaled state.
    Private Shared mre As New ManualResetEvent(False)

    <MTAThreadAttribute> _
    Shared Sub Main()

        Console.WriteLine(vbLf & _
            "Start 3 named threads that block on a ManualResetEvent:" & vbLf)

        For i As Integer = 0 To 2
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When all three threads have started, press Enter to call Set()" & vbLf & _
            "to release all the threads." & vbLf)
        Console.ReadLine()

        mre.Set()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When a ManualResetEvent is signaled, threads that call WaitOne()" & vbLf & _
            "do not block. Press Enter to show this." & vbLf)
        Console.ReadLine()

        For i As Integer = 3 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "Press Enter to call Reset(), so that threads once again block" & vbLf & _
            "when they call WaitOne()." & vbLf)
        Console.ReadLine()

        mre.Reset()

        ' Start a thread that waits on the ManualResetEvent.
        Dim t5 As New Thread(AddressOf ThreadProc)
        t5.Name = "Thread_5"
        t5.Start()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & "Press Enter to call Set() and conclude the demo.")
        Console.ReadLine()

        mre.Set()

        ' If you run this example in Visual Studio, uncomment the following line:
        'Console.ReadLine()

    End Sub


    Private Shared Sub ThreadProc()

        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine(name & " starts and calls mre.WaitOne()")

        mre.WaitOne()

        Console.WriteLine(name & " ends.")

    End Sub

End Class

' This example produces output similar to the following:
'
'Start 3 named threads that block on a ManualResetEvent:
'
'Thread_0 starts and calls mre.WaitOne()
'Thread_1 starts and calls mre.WaitOne()
'Thread_2 starts and calls mre.WaitOne()
'
'When all three threads have started, press Enter to call Set()
'to release all the threads.
'
'
'Thread_2 ends.
'Thread_0 ends.
'Thread_1 ends.
'
'When a ManualResetEvent is signaled, threads that call WaitOne()
'do not block. Press Enter to show this.
'
'
'Thread_3 starts and calls mre.WaitOne()
'Thread_3 ends.
'Thread_4 starts and calls mre.WaitOne()
'Thread_4 ends.
'
'Press Enter to call Reset(), so that threads once again block
'when they call WaitOne().
'
'
'Thread_5 starts and calls mre.WaitOne()
'
'Press Enter to call Set() and conclude the demo.
'
'Thread_5 ends.

注解

使用 ManualResetEvent、 AutoResetEvent用于 EventWaitHandle 线程交互（或线程信号）。 有关详细信息，请参阅同步基元概述文章的 Thread 交互或信号部分。

当线程开始必须在其他线程继续之前完成的活动时，它会调用 ManualResetEvent.Reset 以置于 ManualResetEvent 非信号状态。 此线程可视为控制 ManualResetEvent。 调用 ManualResetEvent.WaitOne 块的线程，等待信号。 当控制线程完成活动时，它会调用 ManualResetEvent.Set 来指示等待线程可以继续。 所有等待的线程都会释放。

发出信号后，在通过调用Reset()该方法手动重置之前，ManualResetEvent保持信号。 也就是说，要立即返回的 WaitOne 调用。

可以通过将布尔值传递给构造函数来控制初始状态 ManualResetEvent ： true 如果发出初始状态，则 false 为该状态。

ManualResetEvent还可以与和方法一起使用staticWaitAll。WaitAny

从 .NET Framework 版本 2.0 开始，ManualResetEvent派生自 EventWaitHandle 类。 A ManualResetEvent 在功能上等效于 EventWaitHandle 使用 EventResetMode.ManualReset.

注意

与类 ManualResetEvent 不同，该 EventWaitHandle 类提供对命名系统同步事件的访问权限。

从 .NET Framework 版本 4.0 开始，System.Threading.ManualResetEventSlim 类是 ManualResetEvent 的轻型替代方法。

构造函数

名称	说明
ManualResetEvent(Boolean)	使用布尔值初始化类的新实例 ManualResetEvent ，该值指示是否将初始状态设置为信号。

字段

名称	说明
WaitTimeout	指示操作 WaitAny(WaitHandle[], Int32, Boolean) 在发出任何等待句柄之前超时。 此字段为常量。 (继承自 WaitHandle)

属性

名称	说明
Handle	已过时. 获取或设置本机操作系统句柄。 (继承自 WaitHandle)
SafeWaitHandle	获取或设置本机操作系统句柄。 (继承自 WaitHandle)

方法

名称	说明
Close()	释放当前 WaitHandle持有的所有资源。 (继承自 WaitHandle)
Dispose()	释放类的 WaitHandle 当前实例使用的所有资源。 (继承自 WaitHandle)
Dispose(Boolean)	在派生类中重写时，释放由派生类使用 WaitHandle的非托管资源，并选择性地释放托管资源。 (继承自 WaitHandle)
Equals(Object)	确定指定的对象是否等于当前对象。 (继承自 Object)
GetHashCode()	用作默认哈希函数。 (继承自 Object)
GetLifetimeService()	已过时. 检索控制此实例的生存期策略的当前生存期服务对象。 (继承自 MarshalByRefObject)
GetType()	获取当前实例的 Type。 (继承自 Object)
InitializeLifetimeService()	已过时. 获取生存期服务对象来控制此实例的生存期策略。 (继承自 MarshalByRefObject)
MemberwiseClone()	创建当前 Object的浅表副本。 (继承自 Object)
MemberwiseClone(Boolean)	创建当前 MarshalByRefObject 对象的浅表副本。 (继承自 MarshalByRefObject)
Reset()	将事件的状态设置为非对齐状态，导致线程被阻止。 (继承自 EventWaitHandle)
Set()	将事件的状态设置为信号，允许一个或多个等待线程继续。 (继承自 EventWaitHandle)
ToString()	返回一个表示当前对象的字符串。 (继承自 Object)
WaitOne()	阻止当前线程，直到当前 WaitHandle 接收信号。 (继承自 WaitHandle)
WaitOne(Int32, Boolean)	阻止当前线程，直到当前 WaitHandle 接收信号，使用 32 位有符号整数指定时间间隔，并指定是否在等待之前退出同步域。 (继承自 WaitHandle)
WaitOne(Int32)	阻止当前线程，直到当前 WaitHandle 接收信号，使用 32 位有符号整数指定时间间隔（以毫秒为单位）。 (继承自 WaitHandle)
WaitOne(TimeSpan, Boolean)	阻止当前线程，直到当前实例收到信号，使用指定 TimeSpan 时间间隔并指定是否在等待之前退出同步域。 (继承自 WaitHandle)
WaitOne(TimeSpan)	阻止当前线程，直到当前实例收到信号，并使用 TimeSpan 指定时间间隔。 (继承自 WaitHandle)

扩展方法

名称	说明
GetAccessControl(EventWaitHandle)	返回指定 handle的安全描述符。
GetSafeWaitHandle(WaitHandle)	获取本机操作系统等待句柄的安全句柄。
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	设置指定事件等待句柄的安全描述符。
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	设置本机操作系统等待句柄的安全句柄。

线程安全性

此类是线程安全的。

另请参阅

• WaitHandle
• 托管线程
• 同步基元概述