.NET中ManualResetEvent和AutoResetEvent的区别是什么?

我已经阅读了关于这方面的文档，我想我明白了。AutoResetEvent在代码经过event.WaitOne()时重置，而ManualResetEvent则不会。

这对吗?

194627 次浏览
小开

简短的回答是肯定的。最重要的区别是AutoResetEvent只允许一个等待线程继续。另一方面，ManualResetEvent将继续允许线程，甚至同时允许几个线程继续，直到您告诉它停止(重置它)。

小开
最佳答案

是的。这就像收费站和门的区别。ManualResetEvent是门，需要手动关闭(重置)。AutoResetEvent是一个收费站，允许一辆车通过，在下一辆车通过之前自动关闭。

小开

是的。这是绝对正确的。

您可以将ManualResetEvent视为指示状态的一种方式。某些东西打开(设置)或关闭(重置)。有一定持续时间的事件任何等待该状态发生的线程都可以继续。

AutoResetEvent更类似于信号。这是发生了什么事的一个迹象。没有任何持续时间的事件。通常情况下(但不一定)发生的“事情”很小，需要由单个线程处理——因此在单个线程消耗事件后自动重置。

小开

想象一下，AutoResetEvent将WaitOne()和Reset()作为单个原子操作执行。

AutoResetEvent还保证只释放一个等待线程。

小开

摘自c# 3.0果壳书，由 约瑟夫Albahari < / p >

c# Threading - Free E-Book

ManualResetEvent是AutoResetEvent的变体。它的不同之处在于它不会在线程通过WaitOne调用后自动重置，因此功能类似于gate:调用Set打开gate，允许WaitOne在gate处通过任意数量的线程;调用Reset会关闭大门，可能会导致排队等候的人越来越多，直到下一个门被打开。

可以使用布尔值“gateOpen”字段(使用volatile关键字声明)结合“spin-sleep”来模拟此功能——重复检查标志，然后小睡一小段时间。

ManualResetEvents有时用于表示特定操作已完成，或线程已完成初始化并准备执行工作。

小开

是的，没错。

你可以通过这两者的用法得到一个概念。

如果你需要告诉别人你已经完成了一些工作，其他(线程)可以继续等待，你应该使用ManualResetEvent。

如果需要对任何资源进行互斥访问，则应该使用AutoResetEvent。

小开

我创建了简单的例子来澄清对ManualResetEvent和AutoResetEvent的理解。

AutoResetEvent:让我们假设你有3个工人线程。如果其中任何一个线程调用WaitOne()，所有其他两个线程将停止执行并等待信号。我假设他们正在使用WaitOne()。它就像;如果我不工作，没人会工作。在第一个例子中你可以看到

autoReset.Set();
Thread.Sleep(1000);
autoReset.Set();

当您调用Set()时，所有线程都将工作并等待信号。1秒后，我发送第二个信号，他们执行并等待(WaitOne())。想想这些家伙是足球队的球员，如果一个球员说我会等到经理叫我，其他人会等到经理告诉他们继续(Set())

public class AutoResetEventSample
{
private AutoResetEvent autoReset = new AutoResetEvent(false);


public void RunAll()
{
new Thread(Worker1).Start();
new Thread(Worker2).Start();
new Thread(Worker3).Start();
autoReset.Set();
Thread.Sleep(1000);
autoReset.Set();
Console.WriteLine("Main thread reached to end.");
}


public void Worker1()
{
Console.WriteLine("Entered in worker 1");
for (int i = 0; i < 5; i++) {
Console.WriteLine("Worker1 is running {0}", i);
Thread.Sleep(2000);
autoReset.WaitOne();
}
}
public void Worker2()
{
Console.WriteLine("Entered in worker 2");


for (int i = 0; i < 5; i++) {
Console.WriteLine("Worker2 is running {0}", i);
Thread.Sleep(2000);
autoReset.WaitOne();
}
}
public void Worker3()
{
Console.WriteLine("Entered in worker 3");


for (int i = 0; i < 5; i++) {
Console.WriteLine("Worker3 is running {0}", i);
Thread.Sleep(2000);
autoReset.WaitOne();
}
}
}

在这个例子中，你可以清楚地看到，当你第一次点击Set()时，它会让所有线程离开，然后在1秒后，它会通知所有线程等待!一旦你再次设置它们，不管它们在内部调用WaitOne()，它们都会继续运行，因为你必须手动调用Reset()来停止它们。

manualReset.Set();
Thread.Sleep(1000);
manualReset.Reset();
Console.WriteLine("Press to release all threads.");
Console.ReadLine();
manualReset.Set();

这更多的是裁判和球员之间的关系，不管任何球员受伤了，等待比赛，其他人都将继续工作。如果裁判说等待(Reset())，那么所有球员将等待下一次信号。

public class ManualResetEventSample
{
private ManualResetEvent manualReset = new ManualResetEvent(false);


public void RunAll()
{
new Thread(Worker1).Start();
new Thread(Worker2).Start();
new Thread(Worker3).Start();
manualReset.Set();
Thread.Sleep(1000);
manualReset.Reset();
Console.WriteLine("Press to release all threads.");
Console.ReadLine();
manualReset.Set();
Console.WriteLine("Main thread reached to end.");
}


public void Worker1()
{
Console.WriteLine("Entered in worker 1");
for (int i = 0; i < 5; i++) {
Console.WriteLine("Worker1 is running {0}", i);
Thread.Sleep(2000);
manualReset.WaitOne();
}
}
public void Worker2()
{
Console.WriteLine("Entered in worker 2");


for (int i = 0; i < 5; i++) {
Console.WriteLine("Worker2 is running {0}", i);
Thread.Sleep(2000);
manualReset.WaitOne();
}
}
public void Worker3()
{
Console.WriteLine("Entered in worker 3");


for (int i = 0; i < 5; i++) {
Console.WriteLine("Worker3 is running {0}", i);
Thread.Sleep(2000);
manualReset.WaitOne();
}
}
}
小开

# EYZ0

类似于

try
{
manualResetEvent.WaitOne();
}
finally
{
manualResetEvent.Reset();
}

作为原子操作

小开

AutoResetEvent在内存中维护一个布尔变量。如果布尔变量为假，则阻塞线程，如果布尔变量为真，则解除阻塞线程。

实例化AutoResetEvent对象时，在构造函数中传递默认值布尔值。下面是实例化AutoResetEvent对象的语法。

AutoResetEvent autoResetEvent = new AutoResetEvent(false);

WaitOne方法

该方法阻塞当前线程，等待其他线程发出信号。WaitOne方法将当前线程置于Sleep线程状态。WaitOne方法如果接收到信号则返回true，否则返回false。

autoResetEvent.WaitOne();

WaitOne方法的秒重载等待指定的秒数。如果它没有得到任何信号，线程继续它的工作。

static void ThreadMethod()
{
while(!autoResetEvent.WaitOne(TimeSpan.FromSeconds(2)))
{
Console.WriteLine("Continue");
Thread.Sleep(TimeSpan.FromSeconds(1));
}


Console.WriteLine("Thread got signal");
}

我们通过传递2秒作为参数来调用WaitOne方法。在while循环中，它等待信号2秒，然后继续它的工作。当线程得到信号时，WaitOne返回true并退出循环并打印“线程得到信号”。

设置方法

方法将信号发送给等待线程以继续其工作。下面是调用Set方法的语法。

autoResetEvent.Set();

ManualResetEvent在内存中维护一个布尔变量。当布尔变量为false时，它阻塞所有线程，当布尔变量为true时，它解除阻塞所有线程。

当我们实例化ManualResetEvent时，我们用默认的布尔值初始化它。

ManualResetEvent manualResetEvent = new ManualResetEvent(false);

在上面的代码中，我们用false值初始化ManualResetEvent，这意味着所有调用WaitOne方法的线程都将阻塞，直到一些线程调用Set()方法。

如果我们初始化ManualResetEvent的值为true，那么所有调用WaitOne方法的线程都不会阻塞，可以继续执行。

WaitOne方法

该方法阻塞当前线程，等待其他线程发出信号。如果它接收到信号，则返回true否则返回false。

下面是调用WaitOne方法的语法。

manualResetEvent.WaitOne();

在WaitOne方法的第二次重载中，我们可以指定当前线程等待信号的时间间隔。如果在time internal内，它没有接收到信号，则返回false并进入下一行方法。

下面是按时间间隔调用WaitOne方法的语法。

bool isSignalled = manualResetEvent.WaitOne(TimeSpan.FromSeconds(5));

我们已经在WaitOne方法中指定了5秒。如果manualResetEvent对象在5秒内没有接收到信号，它将issignals变量设置为false。

设置方法

此方法用于向所有等待线程发送信号。Set()方法将ManualResetEvent对象布尔变量设置为true。所有等待的线程都被解除阻塞并继续执行。

下面是调用Set()方法的语法。

manualResetEvent.Set();

复位方法

一旦我们在ManualResetEvent对象上调用Set()方法，它的布尔值仍然为true。要重置值，可以使用reset()方法。重置方法将布尔值更改为false。

下面是调用Reset方法的语法。

manualResetEvent.Reset();

如果要多次向线程发送信号，必须在调用Set方法后立即调用Reset方法。

小开

好吧，通常在同一个线程中添加2个答案不是一个好的做法，但我不想编辑/删除我之前的答案，因为它可以在另一种方式上有所帮助。

现在，我创建了一个更全面、更容易理解的控制台应用程序片段。

只需在两个不同的控制台上运行示例，并观察行为。你会对幕后发生的事情有更清楚的了解。

手动复位事件

using System;
using System.Threading;


namespace ConsoleApplicationDotNetBasics.ThreadingExamples
{
public class ManualResetEventSample
{
private readonly ManualResetEvent _manualReset = new ManualResetEvent(false);


public void RunAll()
{
new Thread(Worker1).Start();
new Thread(Worker2).Start();
new Thread(Worker3).Start();
Console.WriteLine("All Threads Scheduled to RUN!. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("Main Thread is waiting for 15 seconds, observe 3 thread behaviour. All threads run once and stopped. Why? Because they call WaitOne() internally. They will wait until signals arrive, down below.");
Thread.Sleep(15000);
Console.WriteLine("1- Main will call ManualResetEvent.Set() in 5 seconds, watch out!");
Thread.Sleep(5000);
_manualReset.Set();
Thread.Sleep(2000);
Console.WriteLine("2- Main will call ManualResetEvent.Set() in 5 seconds, watch out!");
Thread.Sleep(5000);
_manualReset.Set();
Thread.Sleep(2000);
Console.WriteLine("3- Main will call ManualResetEvent.Set() in 5 seconds, watch out!");
Thread.Sleep(5000);
_manualReset.Set();
Thread.Sleep(2000);
Console.WriteLine("4- Main will call ManualResetEvent.Reset() in 5 seconds, watch out!");
Thread.Sleep(5000);
_manualReset.Reset();
Thread.Sleep(2000);
Console.WriteLine("It ran one more time. Why? Even Reset Sets the state of the event to nonsignaled (false), causing threads to block, this will initial the state, and threads will run again until they WaitOne().");
Thread.Sleep(10000);
Console.WriteLine();
Console.WriteLine("This will go so on. Everytime you call Set(), ManualResetEvent will let ALL threads to run. So if you want synchronization between them, consider using AutoReset event, or simply user TPL (Task Parallel Library).");
Thread.Sleep(5000);
Console.WriteLine("Main thread reached to end! ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);


}


public void Worker1()
{
for (int i = 1; i <= 10; i++)
{
Console.WriteLine("Worker1 is running {0}/10. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(5000);
// this gets blocked until _autoReset gets signal
_manualReset.WaitOne();
}
Console.WriteLine("Worker1 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
}
public void Worker2()
{
for (int i = 1; i <= 10; i++)
{
Console.WriteLine("Worker2 is running {0}/10. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(5000);
// this gets blocked until _autoReset gets signal
_manualReset.WaitOne();
}
Console.WriteLine("Worker2 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
}
public void Worker3()
{
for (int i = 1; i <= 10; i++)
{
Console.WriteLine("Worker3 is running {0}/10. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(5000);
// this gets blocked until _autoReset gets signal
_manualReset.WaitOne();
}
Console.WriteLine("Worker3 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
}
}


}

Manual Reset Event Output

自动重置事件

using System;
using System.Threading;


namespace ConsoleApplicationDotNetBasics.ThreadingExamples
{
public class AutoResetEventSample
{
private readonly AutoResetEvent _autoReset = new AutoResetEvent(false);


public void RunAll()
{
new Thread(Worker1).Start();
new Thread(Worker2).Start();
new Thread(Worker3).Start();
Console.WriteLine("All Threads Scheduled to RUN!. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("Main Thread is waiting for 15 seconds, observe 3 thread behaviour. All threads run once and stopped. Why? Because they call WaitOne() internally. They will wait until signals arrive, down below.");
Thread.Sleep(15000);
Console.WriteLine("1- Main will call AutoResetEvent.Set() in 5 seconds, watch out!");
Thread.Sleep(5000);
_autoReset.Set();
Thread.Sleep(2000);
Console.WriteLine("2- Main will call AutoResetEvent.Set() in 5 seconds, watch out!");
Thread.Sleep(5000);
_autoReset.Set();
Thread.Sleep(2000);
Console.WriteLine("3- Main will call AutoResetEvent.Set() in 5 seconds, watch out!");
Thread.Sleep(5000);
_autoReset.Set();
Thread.Sleep(2000);
Console.WriteLine("4- Main will call AutoResetEvent.Reset() in 5 seconds, watch out!");
Thread.Sleep(5000);
_autoReset.Reset();
Thread.Sleep(2000);
Console.WriteLine("Nothing happened. Why? Becasuse Reset Sets the state of the event to nonsignaled, causing threads to block. Since they are already blocked, it will not affect anything.");
Thread.Sleep(10000);
Console.WriteLine("This will go so on. Everytime you call Set(), AutoResetEvent will let another thread to run. It will make it automatically, so you do not need to worry about thread running order, unless you want it manually!");
Thread.Sleep(5000);
Console.WriteLine("Main thread reached to end! ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);


}


public void Worker1()
{
for (int i = 1; i <= 5; i++)
{
Console.WriteLine("Worker1 is running {0}/5. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(500);
// this gets blocked until _autoReset gets signal
_autoReset.WaitOne();
}
Console.WriteLine("Worker1 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
}
public void Worker2()
{
for (int i = 1; i <= 5; i++)
{
Console.WriteLine("Worker2 is running {0}/5. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(500);
// this gets blocked until _autoReset gets signal
_autoReset.WaitOne();
}
Console.WriteLine("Worker2 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
}
public void Worker3()
{
for (int i = 1; i <= 5; i++)
{
Console.WriteLine("Worker3 is running {0}/5. ThreadId: {1}.", i, Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(500);
// this gets blocked until _autoReset gets signal
_autoReset.WaitOne();
}
Console.WriteLine("Worker3 is DONE. ThreadId: {0}", Thread.CurrentThread.ManagedThreadId);
}
}


}

Auto Reset Event Output

小开

如果你想理解AutoResetEvent和ManualResetEvent，你需要理解的不是线程，而是中断!

. net希望尽可能地实现底层编程。

中断是在低级编程中使用的，它相当于一个信号从低电平变成高电平(反之亦然)。当这种情况发生时，程序中断正常执行，并将执行指针移到处理事件的函数上。

当中断发生时，要做的第一件事是重置它的状态，因为硬件是这样工作的:

  1. 一个引脚连接到一个信号，硬件监听它的变化(信号可能只有两种状态)。
  2. 如果信号改变意味着发生了什么事情，硬件将内存变量置于发生的状态(即使信号再次改变，它也会保持这样)。
  3. 程序注意到变量改变状态，并将执行移动到处理函数。
  4. 这里要做的第一件事，能够再次监听这个中断，是重置这个内存变量的状态没有发生。

ManualResetEvent和AutoResetEvent的区别 如果ManualResetEvent发生了，我没有重置它，下一次它发生时，我将无法收听它


提交答案