blocks|key|5327694|text|简短的回答是肯定的。最重要的区别是，AutoResetEvent只允许一个等待线程继续运行。另一方面，ManualResetEvent将继续允许线程，甚至是多个线程同时继续，直到您告诉它停止(重置)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5327695|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The short answer is yes. The most important difference is that an AutoResetEvent will only allow one single waiting thread to continue. A ManualResetEvent on the other hand will keep allowing threads, several at the same time even, to continue until you tell it to stop (Reset it).

blocks|key|791889|text|是。就像收费站和门的区别。ManualResetEvent是门，需要手动关闭(重置)。AutoResetEvent是一个收费站，允许一辆车经过，并在下一辆车通过之前自动关闭。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|791890|entityMap^0|D|G|17|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Yes. It's like the difference between a tollbooth and a door. The <code>ManualResetEvent</code> is the door, which needs to be closed (reset) manually. The <code>AutoResetEvent</code> is a tollbooth, allowing one car to go by and automatically closing before the next one can get through.

blocks|key|3072470|text|是。这是完全正确的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3072471|您可以将ManualResetEvent视为指示状态的一种方式。某些东西是开(设置)或关(重置)。具有一定持续时间的事件。等待该状态发生的任何线程都可以继续。|3072472|AutoResetEvent更类似于信号。一枪表示发生了什么事。没有任何持续时间的事件。通常，但不一定发生的“某些事情”很小，需要由单个线程处理-因此在单个线程消费事件后自动重置。|3072473|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Yes. This is absolutely correct.

You could see ManualResetEvent as a way to indicate state. Something is on (Set) or off (Reset). An occurrence with some duration. Any thread waiting for that state to happen can proceed.

An AutoResetEvent is more comparable to a signal. A one shot indication that something has happened. An occurrence without any duration. Typically but not necessarily the "something" that has happened is small and needs to be handled by a single thread - hence the automatic reset after a single thread have consumed the event.

blocks|key|3072507|text|想象一下，AutoResetEvent将WaitOne()和Reset()作为单个原子操作执行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3072508|entityMap^0|5|E|K|9|U|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

Just imagine that the <code>AutoResetEvent</code> executes <code>WaitOne()</code> and <code>Reset()</code> as a single atomic operation.

blocks|key|791970|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|791971|摘自C#+3.0+Nutshell一书，作者:+Joseph+Albahari|blockquote|791972|791973|791974|Threading+in+C#+-+Free+E-Book|offset|length|791975|ManualResetEvent是AutoResetEvent的变体。它的不同之处在于，在线程通过WaitOne调用后，它不会自动重置，因此它的功能类似于门:调用Set打开门，允许任意数量的线程在门上被重置通过；调用WaitOne关闭门，这可能会导致等待队列累积，直到下次打开。|791976|可以使用布尔型"gateOpen“字段(用volatile关键字声明)和”旋转休眠“(反复检查标志，然后休眠一小段时间)来模拟此功能。|791977|ManualResetEvents有时用于发出特定操作已完成或线程已完成初始化并准备好执行工作的信号。|791978|entityMap|0|LINK|mutability|MUTABLE|url|http://www.albahari.com/threading/^0|0|0|0|0|0|T|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|X|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|Y|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|Z|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|10|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|11|7|@]|8|@$H|12|I|13|1|14]]|9|$]]|$1|J|3|K|4|5|6|15|7|@]|8|@]|9|$]]|$1|L|3|M|4|5|6|16|7|@]|8|@]|9|$]]|$1|N|3|O|4|5|6|17|7|@]|8|@]|9|$]]|$1|P|3|-4|4|5|6|18|7|@]|8|@]|9|$]]]|Q|$R|$4|S|T|U|9|$V|W]]]]

<blockquote>
 Taken from C# 3.0 Nutshell book, by
 Joseph Albahari
</blockquote>

<a href="http://www.albahari.com/threading/" rel="noreferrer">Threading in C# - Free E-Book</a>

A ManualResetEvent is a variation on AutoResetEvent. It differs in that it doesn't automatically reset after a thread is let through on a WaitOne call, and so functions like a gate: calling Set opens the gate, allowing any number of threads that WaitOne at the gate through; calling Reset closes the gate, causing, potentially, a queue of waiters to accumulate until its next opened.

One could simulate this functionality with a boolean "gateOpen" field (declared with the volatile keyword) in combination with "spin-sleeping" – repeatedly checking the flag, and then sleeping for a short period of time.

ManualResetEvents are sometimes used to signal that a particular operation is complete, or that a thread's completed initialization and is ready to perform work.

blocks|key|3072593|text|是的，没错。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3072594|你可以通过使用这两个来得到一个概念。|3072595|如果你需要告诉你已经完成了一些工作，并且其他(线程)现在可以继续等待，你应该使用ManualResetEvent。|3072596|如果您需要拥有对任何资源的互斥访问权限，则应该使用AutoResetEvent。|3072597|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Yes, thats right.

You can get an idea by the usage of these two.

If you need to tell that you are finished with some work and other (threads) waiting for this can now proceed, you should use ManualResetEvent.

If you need to have mutual exclusive access to any resource, you should use AutoResetEvent.

blocks|key|3072662|text|我创建了一些简单的示例来澄清对ManualResetEvent和AutoResetEvent的理解。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3072663|AutoResetEvent：假设你有3个工作线程。如果这些线程中的任何一个将调用WaitOne()，那么所有其他两个线程都将停止执行并等待信号。我假设他们使用的是WaitOne()。这就像，如果我不工作，就没有人工作。在第一个示例中，您可以看到|3072664|autoReset.Set();
Thread.Sleep(1000);
autoReset.Set();|code-block|syntax|javascript|3072665|当你调用Set()时，所有的线程都会工作并等待信号。1秒后，我发送第二个信号，他们执行并等待(WaitOne())。想想这些人是足球队的球员，如果一个球员说我会等经理叫我，其他人会等经理叫他们继续(Set())|3072666|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%2B%2B)+{
++++++++++++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%2B%2B)+{
++++++++++++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%2B%2B)+{
++++++++++++Console.WriteLine("Worker3+is+running+{0}",+i);
++++++++++++Thread.Sleep(2000);
++++++++++++autoReset.WaitOne();
++++++++}
++++}
}|3072667|在这个例子中，你可以清楚地看到，当你第一次点击Set()时，它会释放所有的线程，然后在1秒后，它会向所有线程发出等待的信号！一旦您再次设置它们，无论它们在内部调用WaitOne()，它们都将继续运行，因为您必须手动调用Reset()来停止所有它们。|3072668|manualReset.Set();
Thread.Sleep(1000);
manualReset.Reset();
Console.WriteLine("Press+to+release+all+threads.");
Console.ReadLine();
manualReset.Set();|3072669|这更多的是关于裁判/球员的关系，无论任何一个球员受伤了，等待上场，其他人都会继续工作。如果裁判员说等待(Reset())，那么所有的球员都将等待到下一个信号。|3072670|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%2B%2B)+{
++++++++++++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%2B%2B)+{
++++++++++++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%2B%2B)+{
++++++++++++Console.WriteLine("Worker3+is+running+{0}",+i);
++++++++++++Thread.Sleep(2000);
++++++++++++manualReset.WaitOne();
++++++++}
++++}
}|3072671|entityMap^0|F|G|W|E|0|0|E|15|9|2A|9|0|0|4|5|1B|9|2R|5|0|0|N|5|29|9|31|7|0|0|1G|7|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1L|8|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1S|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1T|8|@$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|W|3|X|5|J|7|1W|8|@]|D|@]|E|$K|L]]|$1|Y|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|Z|$]]

I created simple examples to clarify understanding of <code>ManualResetEvent</code> vs <code>AutoResetEvent</code>.

<code>AutoResetEvent</code>: lets assume you have 3 workers thread. If any of those threads will call <code>WaitOne()</code> all other 2 threads will stop execution and wait for signal. I am assuming they are using <code>WaitOne()</code>. It is like; if I do not work, nobody works. In first example you can see that

<pre><code>autoReset.Set();
Thread.Sleep(1000);
autoReset.Set();
</code></pre>

When you call <code>Set()</code> all threads will work and wait for signal. After 1 second I am sending second signal and they execute and wait (<code>WaitOne()</code>). Think about these guys are soccer team players and if one player says I will wait until manager calls me, and others will wait until manager tells them to continue (<code>Set()</code>)

<pre><code>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 &lt; 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 &lt; 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 &lt; 5; i++) {
 Console.WriteLine("Worker3 is running {0}", i);
 Thread.Sleep(2000);
 autoReset.WaitOne();
 }
 }
}
</code></pre>

In this example you can clearly see that when you first hit <code>Set()</code> it will let all threads go, then after 1 second it signals all threads to wait! As soon as you set them again regardless they are calling <code>WaitOne()</code> inside, they will keep running because you have to manually call <code>Reset()</code> to stop them all. 

<pre><code>manualReset.Set();
Thread.Sleep(1000);
manualReset.Reset();
Console.WriteLine("Press to release all threads.");
Console.ReadLine();
manualReset.Set();
</code></pre>

It is more about Referee/Players relationship there regardless of any of the player is injured and wait for playing others will continue to work. If Referee says wait (<code>Reset()</code>) then all players will wait until next signal.

<pre><code>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 &lt; 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 &lt; 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 &lt; 5; i++) {
 Console.WriteLine("Worker3 is running {0}", i);
 Thread.Sleep(2000);
 manualReset.WaitOne();
 }
 }
}
</code></pre>

blocks|key|789079|text|autoResetEvent.WaitOne()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|789080|类似于|789081|try
{
+++manualResetEvent.WaitOne();
}
finally
{
+++manualResetEvent.Reset();
}|code-block|syntax|javascript|789082|作为原子操作|789083|entityMap^0|0|O|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

<code>autoResetEvent.WaitOne()</code> 

is similar to

<pre><code>try
{
 manualResetEvent.WaitOne();
}
finally
{
 manualResetEvent.Reset();
}
</code></pre>

as an atomic operation

blocks|key|789126|text|AutoResetEvent在内存中维护一个布尔变量。如果boolean变量为false，则阻塞线程，如果boolean变量为true，则取消阻塞线程。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|789127|当我们实例化一个AutoResetEvent对象时，我们在构造函数中传递布尔值的默认值。下面是实例化AutoResetEvent对象的语法。|789128|AutoResetEvent+autoResetEvent+=+new+AutoResetEvent(false);|code-block|syntax|javascript|789129|WaitOne方法|789130|此方法阻塞当前线程并等待其他线程的信号。WaitOne方法将当前线程置于休眠线程状态。如果WaitOne方法接收到信号，则返回true，否则返回false。|789131|autoResetEvent.WaitOne();|789132|WaitOne方法的第二个重载等待指定的秒数。如果它没有得到任何信号，线程继续它的工作。|789133|static+void+ThreadMethod()
{
++++while(!autoResetEvent.WaitOne(TimeSpan.FromSeconds(2)))
++++{
++++++++Console.WriteLine("Continue");
++++++++Thread.Sleep(TimeSpan.FromSeconds(1));
++++}

++++Console.WriteLine("Thread+got+signal");
}|789134|我们通过传递2秒作为参数来调用WaitOne方法。在while循环中，它等待信号2秒，然后继续它的工作。当线程获取信号时，WaitOne返回true并退出循环并打印“线程获取信号”。|789135|设置方法|789136|AutoResetEvent+Set方法将信号发送给等待线程以继续其工作。下面是调用Set方法的语法。|789137|autoResetEvent.Set();|789138|789139|ManualResetEvent在内存中维护一个布尔变量。当boolean变量为false时，它会阻塞所有线程；当boolean变量为true时，它会解除所有线程的阻塞。|789140|当我们实例化一个ManualResetEvent时，我们用默认的布尔值来初始化它。|789141|ManualResetEvent+manualResetEvent+=+new+ManualResetEvent(false);|789142|在上面的代码中，我们用False值初始化ManualResetEvent，这意味着所有调用WaitOne方法的线程都将阻塞，直到某个线程调用了Set()方法。|789143|如果我们用TRUE值初始化ManualResetEvent，所有调用WaitOne方法的线程都不会阻塞，可以继续执行。|789144|789145|此方法阻塞当前线程并等待其他线程的信号。如果它接收到信号，则返回true，否则返回false。|789146|下面是调用WaitOne方法的语法。|789147|manualResetEvent.WaitOne();|789148|在WaitOne方法的第二个重载中，我们可以指定当前线程等待信号的时间间隔。如果在时间internal内，它没有收到返回false的信号，并进入下一行方法。|789149|下面是带时间间隔调用WaitOne方法的语法。|789150|bool+isSignalled+=+manualResetEvent.WaitOne(TimeSpan.FromSeconds(5));|789151|我们在WaitOne方法中指定了5秒。如果manualResetEvent对象在5秒内没有收到信号，它会将isSignalled变量设置为false。|789152|Set方法|789153|此方法用于向所有等待线程发送信号。Set()方法将ManualResetEvent对象布尔变量设置为true。所有等待的线程都被解锁，并继续进行。|789154|下面是调用Set()方法的语法。|789155|manualResetEvent.Set();|789156|重置方法|789157|一旦我们在ManualResetEvent对象上调用了Set()方法，它的布尔值就保持为真。要重置该值，我们可以使用Reset()方法。Reset方法将布尔值更改为false。|789158|下面是调用Reset方法的语法。|789159|manualResetEvent.Reset();|789160|如果我们想多次向线程发送信号，就必须在调用Set方法后立即调用Reset方法。|789161|entityMap^0|0|E|0|0|0|0|9|0|0|0|0|0|0|0|4|0|0|0|0|0|G|0|0|0|0|0|0|9|0|0|0|0|0|0|0|0|0|0|0|0|0|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2E|8|@$9|2F|A|2G|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|2H|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|2I|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|2J|8|@$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|2M|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|2N|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|2O|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|2P|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2R|8|@$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|2U|8|@]|D|@]|E|$]]|$1|12|3|13|5|J|7|2V|8|@]|D|@]|E|$K|L]]|$1|14|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|17|3|18|5|6|7|30|8|@]|D|@]|E|$]]|$1|19|3|1A|5|J|7|31|8|@]|D|@]|E|$K|L]]|$1|1B|3|1C|5|6|7|32|8|@]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|33|8|@]|D|@]|E|$]]|$1|1F|3|N|5|6|7|34|8|@$9|35|A|36|B|C]]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|37|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|38|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|J|7|39|8|@]|D|@]|E|$K|L]]|$1|1M|3|1N|5|6|7|3A|8|@]|D|@]|E|$]]|$1|1O|3|1P|5|6|7|3B|8|@]|D|@]|E|$]]|$1|1Q|3|1R|5|J|7|3C|8|@]|D|@]|E|$K|L]]|$1|1S|3|1T|5|6|7|3D|8|@]|D|@]|E|$]]|$1|1U|3|1V|5|6|7|3E|8|@]|D|@]|E|$]]|$1|1W|3|1X|5|6|7|3F|8|@]|D|@]|E|$]]|$1|1Y|3|1Z|5|6|7|3G|8|@]|D|@]|E|$]]|$1|20|3|21|5|J|7|3H|8|@]|D|@]|E|$K|L]]|$1|22|3|23|5|6|7|3I|8|@$9|3J|A|3K|B|C]]|D|@]|E|$]]|$1|24|3|25|5|6|7|3L|8|@]|D|@]|E|$]]|$1|26|3|27|5|6|7|3M|8|@]|D|@]|E|$]]|$1|28|3|29|5|J|7|3N|8|@]|D|@]|E|$K|L]]|$1|2A|3|2B|5|6|7|3O|8|@]|D|@]|E|$]]|$1|2C|3|-4|5|6|7|3P|8|@]|D|@]|E|$]]]|2D|$]]

AutoResetEvent maintains a boolean variable in memory. If the boolean variable is false then it blocks the thread and if the boolean variable is true it unblocks the thread.

When we instantiate an AutoResetEvent object, we pass the default value of boolean value in the constructor. Below is the syntax of instantiate an AutoResetEvent object.

<pre><code>AutoResetEvent autoResetEvent = new AutoResetEvent(false);
</code></pre>

WaitOne method

This method blocks the current thread and wait for the signal by other thread. WaitOne method puts the current thread into a Sleep thread state. WaitOne method returns true if it receives the signal else returns false.

<pre><code>autoResetEvent.WaitOne();
</code></pre>

Second overload of WaitOne method wait for the specified number of seconds. If it does not get any signal thread continues its work.

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

 Console.WriteLine("Thread got signal");
}
</code></pre>

We called WaitOne method by passing the 2 seconds as arguments. In the while loop, it wait for the signal for 2 seconds then it continues its work. When the thread got the signal WaitOne returns true and exits the loop and print the "Thread got signal".

Set method

AutoResetEvent Set method sent the signal to the waiting thread to proceed its work. Below is the syntax of calling Set method.

<pre><code>autoResetEvent.Set();
</code></pre>

<hr>

ManualResetEvent maintains a boolean variable in memory. When the boolean variable is false then it blocks all threads and when the boolean variable is true it unblocks all threads.

When we instantiate a ManualResetEvent, we initialize it with default boolean value.

<pre><code>ManualResetEvent manualResetEvent = new ManualResetEvent(false);
</code></pre>

In the above code, we initialize the ManualResetEvent with false value, that means all the threads which calls the WaitOne method will block until some thread calls the Set() method.

If we initialize ManualResetEvent with true value, all the threads which calls the WaitOne method will not block and free to proceed further.

WaitOne Method

This method blocks the current thread and wait for the signal by other thread. It returns true if its receives a signal else returns false.

Below is the syntax of calling WaitOne method.

<pre><code>manualResetEvent.WaitOne();
</code></pre>

In the second overload of WaitOne method, we can specify the time interval till the current thread wait for the signal. If within time internal, it does not receives a signal it returns false and goes into the next line of method.

Below is the syntax of calling WaitOne method with time interval.

<pre><code>bool isSignalled = manualResetEvent.WaitOne(TimeSpan.FromSeconds(5));
</code></pre>

We have specify 5 seconds into the WaitOne method. If the manualResetEvent object does not receives a signal between 5 seconds, it set the isSignalled variable to false.

Set Method

This method is used for sending the signal to all waiting threads. Set() Method set the ManualResetEvent object boolean variable to true. All the waiting threads are unblocked and proceed further.

Below is the syntax of calling Set() method.

<pre><code>manualResetEvent.Set();
</code></pre>

Reset Method

Once we call the Set() method on the ManualResetEvent object, its boolean remains true. To reset the value we can use Reset() method. Reset method change the boolean value to false.

Below is the syntax of calling Reset method.

<pre><code>manualResetEvent.Reset();
</code></pre>

We must immediately call Reset method after calling Set method if we want to send signal to threads multiple times.

blocks|key|3918647|text|好吧，通常情况下，在同一主题中添加两个答案并不是一个好的做法，但我不想编辑/删除我之前的答案，因为它可以从另一种方式提供帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3918648|现在，我在下面创建了更全面、更容易理解的run-+to+-learn控制台应用程序片段。|3918649|只需在两个不同的控制台上运行示例，并观察其行为。你会对幕后发生的事情有更清楚的了解。|3918650|手动重置事件|offset|length|style|BOLD|3918651|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%2B%2B)
++++++++++++{
++++++++++++++++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%2B%2B)
++++++++++++{
++++++++++++++++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%2B%2B)
++++++++++++{
++++++++++++++++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);
++++++++}
++++}

}|code-block|syntax|javascript|3918652|​|3918653|📷|atomic|3918654|3918655|自动重置事件|3918656|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%2B%2B)
++++++++++++{
++++++++++++++++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%2B%2B)
++++++++++++{
++++++++++++++++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%2B%2B)
++++++++++++{
++++++++++++++++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);
++++++++}
++++}

}|3918657|3918658|3918659|3918660|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/8ba7d3552aa77f9ae4fd200bd2432c94.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/faee409e8805b962277e94bc13b5f0c2.png^0|0|0|0|0|6|0|0|0|0|1|0|0|0|0|6|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1F|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1G|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1H|8|@$H|1I|I|1J|J|K]]|9|@]|A|$]]|$1|L|3|M|5|N|7|1K|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|1M|8|@]|9|@$H|1N|I|1O|1|1P]]|A|$]]|$1|V|3|R|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1R|8|@$H|1S|I|1T|J|K]]|9|@]|A|$]]|$1|Y|3|Z|5|N|7|1U|8|@]|9|@]|A|$O|P]]|$1|10|3|R|5|6|7|1V|8|@]|9|@]|A|$]]|$1|11|3|T|5|U|7|1W|8|@]|9|@$H|1X|I|1Y|1|1Z]]|A|$]]|$1|12|3|R|5|6|7|20|8|@]|9|@]|A|$]]|$1|13|3|-4|5|6|7|21|8|@]|9|@]|A|$]]]|14|$15|$5|16|17|18|A|$19|1A|1B|-4]]|1C|$5|16|17|18|A|$19|1D|1B|-4]]]]

OK, normally it does not a good practice to add 2 answers in same thread, but I did not want to edit/delete my previous answer, since it can help on another manner.

Now, I created, much more comprehensive, and easy to understand, run-to-learn console app snippet below.

Just run the examples on two different consoles, and observe behaviour. You will get much more clear idea there what is happening behind the scenes.

Manual Reset Event

<pre><code>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 &lt;= 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 &lt;= 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 &lt;= 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);
 }
 }

}
</code></pre>

<a href="https://i.stack.imgur.com/tvKU2.png" rel="noreferrer"><img src="https://i.stack.imgur.com/tvKU2.png" alt="Manual Reset Event Output"></a>

Auto Reset Event

<pre><code>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 &lt;= 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 &lt;= 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 &lt;= 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);
 }
 }

}
</code></pre>

<a href="https://i.stack.imgur.com/hyLp4.png" rel="noreferrer"><img src="https://i.stack.imgur.com/hyLp4.png" alt="Auto Reset Event Output"></a>

blocks|key|792200|text|如果你想理解AutoResetEvent和ManualResetEvent，你需要理解的不是线程，而是中断！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|792201|.NET希望召唤出尽可能远的低级编程。|792202|中断是在低级编程中使用的东西，它等于一个信号从低变高(或反之亦然)。当这种情况发生时，程序会中断其正常执行，并将执行指针移动到处理此事件的函数。|792203|当中断发生时，要做的第一件事是对其状态进行，因为硬件是这样工作的：|792204|如果信号发生变化，硬件就会监听它的变化(该信号可能只有两种状态)。|792205|如果信号发生变化，则表示发生了什么事情，硬件将内存变量设置为已发生的状态(即使信号再次发生变化，也会保持这种状态)。|ordered-list-item|792206|程序会注意到该变量的状态发生了变化，并将执行转移到一个处理|792207|的状态。为了能够再次侦听此中断，请将此内存变量重置为状态not-happened.|792208|792209|这就是ManualResetEvent和AutoResetEvent之间的区别。|792210|如果发生ManualResetEvent而我没有重置它，下一次它发生时我将无法收听它。|offset|length|style|BOLD|792211|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|17|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|L|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|L|7|18|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1A|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1B|8|@$V|1C|W|1D|X|Y]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|10|$]]

If you want to understand AutoResetEvent and ManualResetEvent you need to understand not threading but interrupts!

.NET wants to conjure up low-level programming the most distant possible.

An interrupts is something used in low-level programming which equals to a signal that from low became high (or viceversa). When this happens the program interrupt its normal execution and move the execution pointer to the function that handles this event.

The first thing to do when an interrupt happend is to reset its state, becosa the hardware works in this way:

<ol>
<li>a pin is connected to a signal and the hardware listen for it to change (the signal could have only two states).</li>
<li>if the signal changes means that something happened and the hardware put a memory variable to the state happened (and it remain like this even if the signal change again).</li>
<li>the program notice that variable change states and move the execution to a handling function.</li>
<li>here the first thing to do, to be able to listen again this interrupt, is to reset this memory variable to the state not-happened.</li>
</ol>

This is the difference between ManualResetEvent and AutoResetEvent. 
If a ManualResetEvent happen and I do not reset it, the next time it happens I will not be able to listen it.

I have read the documentation on this and I think I understand. An <a href="http://msdn.microsoft.com/en-us/library/system.threading.autoresetevent.aspx" rel="noreferrer"><code>AutoResetEvent</code></a> resets when the code passes through <code>event.WaitOne()</code>, but a <a href="http://msdn.microsoft.com/en-us/library/system.threading.manualresetevent.aspx" rel="noreferrer"><code>ManualResetEvent</code></a> does not.

Is this correct?

What is the difference between ManualResetEvent and AutoResetEvent in .NET?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我已经阅读了关于这方面的文档，我想我理解了。当代码通过event.WaitOne()时，会重置，但不会。这是正确的吗？

问在.NET中，ManualResetEvent和AutoResetEvent有什么不同？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在.NET中，ManualResetEvent和AutoResetEvent有什么不同？EN