详细解析C#多线程同步事件及等待句柄

最近捣鼓了一下多线程的同步问题，发现其实c#关于多线程同步事件处理还是很灵活，这里主要写一下，自己测试的一些代码，涉及到了autoresetevent 和 manualresetevent，当然还有也简要提了一下system.threading.waithandle.waitone 、system.threading.waithandle.waitany和system.threading.waithandle.waitall ，下面我们一最初学者的角度来看，多线程之间的同步。

假设有这样的一个场景，主线程开了一个子线程，让子线程等着，等主线程完成了某件事情时再通知子线程去往下执行，这里关键就在于这个怎让子线程等着，主线程怎通知子线程，一般情况下我们不难想到用一个公共变量，于是咱们就有了下面的代码：

using system; 
using system.collections.generic; 
using system.text; 
using system.threading; 
 
namespace autoreseteventtest 
{ 
  class class1 
  { 
    static bool flag = true; 
 
    static void dowork() 
    { 
      console.writeline("  worker thread started, now waiting on event..."); 
      while (flag) 
      { 
 
      } 
      console.writeline("  worker thread reactivated, now exiting..."); 
    } 
 
    static void main() 
    { 
      console.writeline("main thread starting worker thread..."); 
      thread t = new thread(dowork); 
      t.start(); 
 
      console.writeline("main thrad sleeping for 1 second..."); 
      thread.sleep(1000); 
 
      console.writeline("main thread signaling worker thread..."); 
      flag = false; 
    } 
  } 
} 

虽然目的达到了，但是看着这代码就纠结，下面该是我们的主角上场了，autoresetevent 和 manualresetevent，关于这两者我们暂且认为是差不多了，稍后我会介绍他们的不同，这里以autoresetevent为例，其实很多官方的说法太过于抽象，这里通俗地讲，可以认为autoresetevent就是一个公共的变量（尽管它是一个事件），创建的时候可以设置为false，然后在要等待的线程使用它的waitone方法，那么线程就一直会处于等待状态，只有这个autoresetevent被别的线程使用了set方法，也就是要发通知的线程使用了它的set方法，那么等待的线程就会往下执行了，set就是发信号，waitone是等待信号，只有发了信号，等待的才会执行。如果不发的话，waitone后面的程序就永远不会执行。好下面看用autoresetevent改造上面的程序：

using system; 
using system.collections.generic; 
using system.text; 
using system.threading; 
 
namespace autoreseteventtest 
{ 
  class class2 
  { 
    static autoresetevent mevent=new autoresetevent(false); 
    //static manualresetevent mevent = new manualresetevent(false); 
 
    static void dowork() 
    { 
      console.writeline("  worker thread started, now waiting on event..."); 
      mevent.waitone(); 
      console.writeline("  worker thread reactivated, now exiting..."); 
    } 
 
    static void main() 
    { 
      console.writeline("main thread starting worker thread..."); 
      thread t = new thread(dowork); 
      t.start(); 
 
      console.writeline("main thrad sleeping for 1 second..."); 
      thread.sleep(1000); 
 
      console.writeline("main thread signaling worker thread..."); 
      mevent.set(); 
    } 
  } 
} 

这时代码是不是清爽多了，这里其实你还会看到，把上面的autoresetevent换成manualresetevent也是没有问题的，那么它两之间的区别是什么呢？个人认为它们最大的区别在于，无论何时，只要 autoresetevent 激活线程，它的状态将自动从终止变为非终止。相反，manualresetevent 允许它的终止状态激活任意多个线程，只有当它的 reset 方法被调用时才还原到非终止状态。开下面的代码：

using system; 
using system.collections.generic; 
using system.text; 
using system.threading; 
 
namespace autoreseteventtest 
{ 
  class class3 
  { 
    static autoresetevent mevent = new autoresetevent(false); 
    //static manualresetevent mevent = new manualresetevent(false); 
 
    static void dowork() 
    { 
      console.writeline("  worker thread started, now waiting on event..."); 
      for (int i = 0; i < 3; i++) 
      { 
        mevent.waitone(); 
        //mevent.reset(); 
        console.writeline("  worker thread reactivated, now exiting..."); 
      } 
    } 
 
    static void main() 
    { 
      console.writeline("main thread starting worker thread..."); 
      thread t = new thread(dowork); 
      t.start(); 
 
      for (int i = 0; i < 3; i++) 
      { 
        thread.sleep(1000); 
        console.writeline("main thread signaling worker thread..."); 
        mevent.set(); 
      } 
    } 
  } 
} 

如果你想仅仅把autoresetevent换成manualresetevent的话，你发现输出就会乱套了，为什么呢？

假如有autoevent.waitone()和manualevent.waitone()，当线程得到信号后都得以继续执行。差别就在调用后,autoevent.waitone()每次只允许一个线程进入，当某个线程得到信号(也就是有其他线程调用了autoevent.set()方法后)后，autoevent会自动又将信号置为不发送状态，则其他调用waitone的线程只有继续等待，也就是说,autoevent一次只唤醒一个线程。而manualevent则可以唤醒多个线程，当某个线程调用了set方法后，其他调用waitone的线程获得信号得以继续执行，而manualevent不会自动将信号置为不发送，也就是说，除非手工调用了manualevent.reset()方法，否则manualevent将一直保持有信号状态，manualevent也就可以同时唤醒多个线程继续执行。

在上面代码中，如果将autoresetevent换成manualresetevent的话，只要要在waitone后面做下reset，就会达到同样的效果。

之后咱们再来个简单的例子：

using system; 
using system.collections.generic; 
using system.text; 
using system.threading; 
 
namespace autoreseteventtest 
{ 
  class class4 
  { 
    public static autoresetevent mevent = new autoresetevent(false); 
 
    public static void trmain() 
    { 
      thread tr = thread.currentthread; 
      console.writeline("thread: waiting for an event"); 
      mevent.waitone(); 
      console.writeline("thread: got an event"); 
      for (int x = 0; x < 10; x++) 
      { 
        thread.sleep(1000); 
        console.writeline(tr.name + ": " + x); 
      } 
    } 
    static void main(string[] args) 
    { 
      thread thrd1 = new thread(new threadstart(trmain)); 
      thrd1.name = "thread1"; 
      thrd1.start(); 
      for (int x = 0; x < 10; x++) 
      { 
        thread.sleep(900); 
        console.writeline("main:" + x); 
        if (5 == x) mevent.set(); 
      } 
      while (thrd1.isalive) 
      { 
        thread.sleep(1000); 
        console.writeline("main: waiting for thread to stop"); 
      } 
    } 
  } 
} 

是不是更有感觉了？之后咱来看看另外几个东东：

system.threading.waithandle.waitone 使线程一直等待，直到单个事件变为终止状态；

system.threading.waithandle.waitany 阻止线程，直到一个或多个指示的事件变为终止状态；

system.threading.waithandle.waitall 阻止线程，直到所有指示的事件都变为终止状态。

然后再来个例子，以waitall使用为例：

using system; 
using system.collections.generic; 
using system.text; 
using system.threading; 
 
namespace autoreseteventtest 
{ 
  class other 
  { 
    static void main(string[] args) 
    { 
      random randomgenerator = new random(); 
      autoresetevent[] resets=new autoresetevent[5]; 
 
      for (int i = 0; i < 5; i++) 
      { 
        resets[i] = new autoresetevent(false); 
        int wtime = randomgenerator.next(10)+1; 
 
        worker w = new worker(wtime, resets[i]); 
 
        thread thrd1 = new thread(new threadstart(w.work)); 
        thrd1.start();  
      } 
      waithandle.waitall(resets); 
      console.writeline("all worker done - main exiting."); 
    } 
 
  } 
 
  public class worker 
  { 
    public string name; 
    public int wtime; 
    public autoresetevent mevent; 
 
    public worker(int w, autoresetevent m) 
    { 
      name = w.tostring(); 
      wtime = w * 1000; 
      mevent = m; 
    } 
 
    public void work() 
    { 
      console.writeline(name + " worker thread waiting for " + wtime + "...."); 
      thread.sleep(wtime); 
      console.writeline(name + " worker thread back..."); 
      mevent.set(); 
    } 
  } 
} 

简单来说就是，开了5个线程，每个线程随机休眠若干秒，都完成后通知主线程退出，这里就开了一个autoresetevent数组，主线程就waithandle.waitall(resets) ，子线程休眠完后就set1个autoresetevent，最后都set完后，主线程就会往下执行。最后最后再来个买书付款取货的例子，加深理解：

using system; 
using system.collections.generic; 
using system.text; 
using system.threading; 
 
namespace autoreseteventtest 
{ 
  class program 
  { 
    const int numiterations = 10; 
    static autoresetevent myresetevent = new autoresetevent(false); 
    static autoresetevent changeevent = new autoresetevent(false); 
    //static manualresetevent myresetevent = new manualresetevent(false); 
    //static manualresetevent changeevent = new manualresetevent(false); 
    static int number; //这是关键资源 
 
    static void main() 
    { 
      thread paymoneythread = new thread(new threadstart(paymoneyproc)); 
      paymoneythread.name = "付钱线程"; 
      thread getbookthread = new thread(new threadstart(getbookproc)); 
      getbookthread.name = "取书线程"; 
      paymoneythread.start(); 
      getbookthread.start(); 
 
      for (int i = 1; i <= numiterations; i++) 
      { 
        console.writeline("买书线程：数量{0}", i); 
        number = i; 
        //signal that a value has been written. 
        myresetevent.set(); 
        //changeevent.set(); 
        thread.sleep(10); 
      } 
      paymoneythread.abort(); 
      getbookthread.abort(); 
    } 
 
    static void paymoneyproc() 
    { 
      while (true) 
      { 
        myresetevent.waitone(); 
        //myresetevent.reset(); 
        console.writeline("{0}：数量{1}", thread.currentthread.name, number); 
        changeevent.set(); 
      } 
    } 
    static void getbookproc() 
    { 
      while (true) 
      { 
        changeevent.waitone(); 
        //changeevent.reset();         
        console.writeline("{0}：数量{1}", thread.currentthread.name, number); 
        console.writeline("------------------------------------------"); 
        //thread.sleep(0); 
      } 
    } 
  } 
} 

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。