lResetEvent 允许线程通过发信号互相通信。通常，此通信涉及一个线程在其他线程进行之前必须完成的任务。

当线程开始一个活动（此活动必须在其他线程进行之前完成）时，它调用 Reset 将ManualResetEvent 设置为非终止状态。此线程可被视为控制 ManualResetEvent。
调用 ManualResetEvent 上的 WaitOne 的线程将阻塞，并等待信号。
当控制线程完成活动时，它调用 Set 以发出等待线程可以继续进行的信号。并释放所有等待线程。
一旦它被终止，ManualResetEvent 将保持终止状态，直到它被手动重置。即对 WaitOne 的调用将立即返回。

可以通过将布尔值传递给构造函数来控制 ManualResetEvent 的初始状态，如果初始状态处于终止状态，为 true；否则为 false。

ManualResetEvent 还可以和静态（在 Visual Basic 中为 Shared）WaitAll 和 WaitAny 方法一起使用。

摘自http://msdn.microsoft.com/library/chs/default.asp?url=/library/CHS/cpref/html/frlrfsystemthreadingmanualreseteventclasstopi

AutoResetEvent 与 ManualResetEvent区别

在C#多线程编程中，这两个类几乎是不可或缺的,他们的用法\声明都很类似，那么区别在哪里了?

Set方法将信号置为发送状态 Reset方法将信号置为不发送状态 WaitOne等待信号的发送

其实,从名字就可以看出一点端倪   ,一个手动,一个自动，这个手动和自动实际指的是在Reset方法的处理上,如下面例子

public AutoResetEvent autoevent=new AutoResetEvent(true);

public ManualResetEvent manualevent=new ManualResetEvent(true);

默认信号都处于发送状态,

autoevent.WaitOne();

manualevent.WaitOne();

如果 某个线程调用上面该方法,则当信号处于发送状态时,该线程会得到信号,得以继续执行

差别就在调用后,autoevent.WaitOne()每次只允许一个线程进入,当某个线程得到信号(也就是有其他线程调用了autoevent.Set()方法后)后,autoevent会自动又将信号置为不发送状态,则其他调用WaitOne的线程只有继续等待.也就是说,autoevent一次只唤醒一个线程

而 manualevent则可以唤醒多个线程,因为当某个线程调用了set方法后,其他调用waitone的线程获得信号得以继续执行,而 manualevent不会自动将信号置为不发送.也就是说,除非手工调用了anualevent.Reset().方法,则manualevent将一 直保持有信号状态,manualevent也就可以同时唤醒多个线程继续执行

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=547166

AutoResetEvent：自动调用this.Reset()，设置不发送信号，则等待信号(waitone())的线程将不执行。
ManualResetEvent：需要编程者调用this.Reset来设置不发送信号状态，以阻止其他线程的执行。

这个在SOCKET编程中的异步套接字的时候   
   private    static    ManualResetEvent    connectDone    =    new    ManualResetEvent(false);   
   private    static    ManualResetEvent    sendDone    =    new    ManualResetEvent(false);   
   private    static    ManualResetEvent    receiveDone    =    new    ManualResetEvent(false);   
    
   public    void    StartClient()   
   {   
   IPAddress    ipAddress    =    IPAddress.Parse(strIPAddress);   
   IPEndPoint    remoteEP    =    new    IPEndPoint(ipAddress,vodPort);   
   Socket    client    =    new    Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);   
    
   client.BeginConnect(remoteEP,new    AsyncCallback(ConnectCallBack),client);   
   connectDone.WaitOne();   
    
   Send(client,((VodMsg)SendMsg[0]).ToString());   
   SendMsg.Remove(SendMsg[0]);   
   sendDone.WaitOne();   
    
   Receive(client);   
   receiveDone.WaitOne();   
    
   client.Shutdown(SocketShutdown.Both);   
   client.Close();   
   }   
    
   然后在Connect、Send、Receive、的回调函数里分别设置状态为.Set()，以便线程继续运行。   
   这样，Send以前可以保证连接已经建立，Receive前可以保证消息已经发送，关闭前可以保证消息已经接收。不会出现运行Receive的回调函数的时候Socket已经关闭了。

在串口类里面：   
    
   //    Delegate    class    declarations.   
   public    delegate    void    VoidFunc();   
   public    delegate    void    BoolFunc(bool    b);   
   public    delegate    void    StrnFunc(string    s);   
   public    delegate    void    ByteFunc(byte[]    b);   
    
   ///    <summary>   
   ///    This    structure    contains    one    delegate    method    for    each    override    event   
   ///    method    in    the    serial    port    base    class.    Each    delegate    provides    a    hook   
   ///    that    can    be    used    by    any    application    that    wishes    to    connect    to    the   
   ///    asynchronous    OnXXX    methods.   
   ///    </summary>   
   public    struct    WithEvents   
   {   
   public    VoidFunc    Break;   
   public    VoidFunc    TxDone;   
   public    StrnFunc    Error;   
   public    ByteFunc    RxChar;   
   public    BoolFunc    CtsSig;   
   public    BoolFunc    DsrSig;   
   public    BoolFunc    RlsdSig;   
   public    BoolFunc    RingSig;   
   }   
    
   ...   
   public    class    SerialPort   
   {   
   private    WithEvents    ev;   
   private    ManualResetEvent    recvrEvent;//接收数据线程启动的信号   
   private    ManualResetEvent    writeEvent;   
   private    Thread    rxThread;    //接收数据的线程   
   public    SerialPort(WithEvents    ev)   
   {   
         this.ev    =    ev;   
   }   
   //打开串口   
   protected    bool    Open(...)    //就是我前面调用的this.Port.Open   
   {   
         ...   
         this.recvrEvent    =    new    ManualResetEvent(false);   
         ...   
         //启动线程     
         this.rxThread    =    new    Thread(new    ThreadStart(ReceiveThread));   
         this.rxThread.Priority    =    ThreadPriority.AboveNormal;   
         this.rxThread.Start();   
         //    Wait    for    receive    thread    to    start.   
         this.recvrEvent.WaitOne(500,    false);   
         //成功打开了串口   
          
   }   
   private    void    ReceiveThread()   
   {   
           //接收数据   
           //触发事件   
           ...   
           this.OnRxChar(buf);   
   }   
   }   

System;
using System.Threading;

namespace ManualReset
{

class Reset
{

[STAThread]
static void Main()
{
ManualResetEvent manRE;
manRE = new ManualResetEvent(true); // 赋给信号量
bool state = manRE.WaitOne(1000, true);
Console.WriteLine("ManualResetEvent After first waitone " + state);

manRE.Reset(); //设置ManualResetEvent状态为无信号量
state = manRE.WaitOne(5000, true);
Console.WriteLine("ManualResetEvent After second waitone " + state);

Console.Read();
}
}
}


using System;
using System.Threading;
namespace ManualSet
{

class Set
{

[STAThread]
static void Main(string[] args)
{
ManualResetEvent manRE;
manRE = new ManualResetEvent(false);
Console.WriteLine("Before waitone");
bool state = manRE.WaitOne(5000, true);
Console.WriteLine("ManualResetEvent After first waitone " + state);

manRE.Set(); //将其状态设为有信号量
Thread.Sleep(3000);
state = manRE.WaitOne(5000, true);
Console.WriteLine("ManualResetEvent After second waitone " + state);
Console.Read();
}
}<