C#多线程同步事件及等待句柄

点击打开链接

最近捣鼓了一下多线程的同步问题,发现其实C#关于多线程同步事件处理还是很灵活,这里主要写一下,自己测试的一些代码,涉及到了AutoResetEvent 和 ManualResetEvent,当然还有也简要提了一下System.Threading.WaitHandle.WaitOne 、System.Threading.WaitHandle.WaitAny和System.Threading.WaitHandle.WaitAll ,下面我们一最初学者的角度来看,多线程之间的同步。

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

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Threading;  
  5.   
  6. namespace AutoResetEventTest  
  7. {  
  8.     class Class1  
  9.     {  
  10.         static bool flag = true;  
  11.   
  12.         static void DoWork()  
  13.         {  
  14.             Console.WriteLine("   worker thread started, now waiting on event...");  
  15.             while (flag)  
  16.             {  
  17.   
  18.             }  
  19.             Console.WriteLine("   worker thread reactivated, now exiting...");  
  20.         }  
  21.   
  22.         static void Main()  
  23.         {  
  24.             Console.WriteLine("main thread starting worker thread...");  
  25.             Thread t = new Thread(DoWork);  
  26.             t.Start();  
  27.   
  28.             Console.WriteLine("main thrad sleeping for 1 second...");  
  29.             Thread.Sleep(1000);  
  30.   
  31.             Console.WriteLine("main thread signaling worker thread...");  
  32.             flag = false;  
  33.         }  
  34.     }  
  35. }  

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

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Threading;  
  5.   
  6. namespace AutoResetEventTest  
  7. {  
  8.     class Class2  
  9.     {  
  10.         static AutoResetEvent mEvent=new AutoResetEvent(false);  
  11.         //static ManualResetEvent mEvent = new ManualResetEvent(false);  
  12.   
  13.         static void DoWork()  
  14.         {  
  15.             Console.WriteLine("   worker thread started, now waiting on event...");  
  16.             mEvent.WaitOne();  
  17.             Console.WriteLine("   worker thread reactivated, now exiting...");  
  18.         }  
  19.   
  20.         static void Main()  
  21.         {  
  22.             Console.WriteLine("main thread starting worker thread...");  
  23.             Thread t = new Thread(DoWork);  
  24.             t.Start();  
  25.   
  26.             Console.WriteLine("main thrad sleeping for 1 second...");  
  27.             Thread.Sleep(1000);  
  28.   
  29.             Console.WriteLine("main thread signaling worker thread...");  
  30.             mEvent.Set();  
  31.         }  
  32.     }  
  33. }  

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

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Threading;  
  5.   
  6. namespace AutoResetEventTest  
  7. {  
  8.     class Class3  
  9.     {  
  10.         static AutoResetEvent mEvent = new AutoResetEvent(false);  
  11.         //static ManualResetEvent mEvent = new ManualResetEvent(false);  
  12.   
  13.         static void DoWork()  
  14.         {  
  15.             Console.WriteLine("   worker thread started, now waiting on event...");  
  16.             for (int i = 0; i < 3; i++)  
  17.             {  
  18.                 mEvent.WaitOne();  
  19.                 //mEvent.Reset();  
  20.                 Console.WriteLine("   worker thread reactivated, now exiting...");  
  21.             }  
  22.         }  
  23.   
  24.         static void Main()  
  25.         {  
  26.             Console.WriteLine("main thread starting worker thread...");  
  27.             Thread t = new Thread(DoWork);  
  28.             t.Start();  
  29.   
  30.             for (int i = 0; i < 3; i++)  
  31.             {  
  32.                 Thread.Sleep(1000);  
  33.                 Console.WriteLine("main thread signaling worker thread...");  
  34.                 mEvent.Set();  
  35.             }  
  36.         }  
  37.     }  
  38. }  
如果你想仅仅把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,就会达到同样的效果。

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

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Threading;  
  5.   
  6. namespace AutoResetEventTest  
  7. {  
  8.     class Class4  
  9.     {  
  10.         public static AutoResetEvent mEvent = new AutoResetEvent(false);  
  11.   
  12.         public static void trmain()  
  13.         {  
  14.             Thread tr = Thread.CurrentThread;  
  15.             Console.WriteLine("thread: waiting for an event");  
  16.             mEvent.WaitOne();  
  17.             Console.WriteLine("thread: got an event");  
  18.             for (int x = 0; x < 10; x++)  
  19.             {  
  20.                 Thread.Sleep(1000);  
  21.                 Console.WriteLine(tr.Name + ": " + x);  
  22.             }  
  23.         }  
  24.         static void Main(string[] args)  
  25.         {  
  26.             Thread thrd1 = new Thread(new ThreadStart(trmain));  
  27.             thrd1.Name = "thread1";  
  28.             thrd1.Start();  
  29.             for (int x = 0; x < 10; x++)  
  30.             {  
  31.                 Thread.Sleep(900);  
  32.                 Console.WriteLine("Main:" + x);  
  33.                 if (5 == x) mEvent.Set();  
  34.             }  
  35.             while (thrd1.IsAlive)  
  36.             {  
  37.                 Thread.Sleep(1000);  
  38.                 Console.WriteLine("Main: waiting for thread to stop");  
  39.             }  
  40.         }  
  41.     }  
  42. }  

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

System.Threading.WaitHandle.WaitOne 使线程一直等待,直到单个事件变为终止状态;

System.Threading.WaitHandle.WaitAny 阻止线程,直到一个或多个指示的事件变为终止状态;

System.Threading.WaitHandle.WaitAll 阻止线程,直到所有指示的事件都变为终止状态。

然后再来个例子,以WaitAll使用为例:

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Threading;  
  5.   
  6. namespace AutoResetEventTest  
  7. {  
  8.     class other  
  9.     {  
  10.         static void Main(string[] args)  
  11.         {  
  12.             Random randomGenerator = new Random();  
  13.             AutoResetEvent[] resets=new AutoResetEvent[5];  
  14.   
  15.             for (int i = 0; i < 5; i++)  
  16.             {  
  17.                 resets[i] = new AutoResetEvent(false);  
  18.                 int wTime = randomGenerator.Next(10)+1;  
  19.   
  20.                 worker w = new worker(wTime, resets[i]);  
  21.   
  22.                 Thread thrd1 = new Thread(new ThreadStart(w.work));  
  23.                 thrd1.Start();    
  24.             }  
  25.             WaitHandle.WaitAll(resets);  
  26.             Console.WriteLine("ALL worker done - main exiting.");  
  27.         }  
  28.   
  29.     }  
  30.   
  31.     public class worker  
  32.     {  
  33.         public string name;  
  34.         public int wTime;  
  35.         public AutoResetEvent mEvent;  
  36.   
  37.         public worker(int w, AutoResetEvent m)  
  38.         {  
  39.             name = w.ToString();  
  40.             wTime = w * 1000;  
  41.             mEvent = m;  
  42.         }  
  43.   
  44.         public void work()  
  45.         {  
  46.             Console.WriteLine(name + " worker thread waiting for " + wTime + "....");  
  47.             Thread.Sleep(wTime);  
  48.             Console.WriteLine(name + " worker thread back...");  
  49.             mEvent.Set();  
  50.         }  
  51.     }  
  52. }  

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

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Threading;  
  5.   
  6. namespace AutoResetEventTest  
  7. {  
  8.     class Program  
  9.     {  
  10.         const int numIterations = 10;  
  11.         static AutoResetEvent myResetEvent = new AutoResetEvent(false);  
  12.         static AutoResetEvent ChangeEvent = new AutoResetEvent(false);  
  13.         //static ManualResetEvent myResetEvent = new ManualResetEvent(false);  
  14.         //static ManualResetEvent ChangeEvent = new ManualResetEvent(false);  
  15.         static int number; //这是关键资源  
  16.   
  17.         static void Main()  
  18.         {  
  19.             Thread payMoneyThread = new Thread(new ThreadStart(PayMoneyProc));  
  20.             payMoneyThread.Name = "付钱线程";  
  21.             Thread getBookThread = new Thread(new ThreadStart(GetBookProc));  
  22.             getBookThread.Name = "取书线程";  
  23.             payMoneyThread.Start();  
  24.             getBookThread.Start();  
  25.   
  26.             for (int i = 1; i <= numIterations; i++)  
  27.             {  
  28.                 Console.WriteLine("买书线程:数量{0}", i);  
  29.                 number = i;  
  30.                 //Signal that a value has been written.  
  31.                 myResetEvent.Set();  
  32.                 //ChangeEvent.Set();  
  33.                 Thread.Sleep(10);  
  34.             }  
  35.             payMoneyThread.Abort();  
  36.             getBookThread.Abort();  
  37.         }  
  38.   
  39.         static void PayMoneyProc()  
  40.         {  
  41.             while (true)  
  42.             {  
  43.                 myResetEvent.WaitOne();  
  44.                 //myResetEvent.Reset();  
  45.                 Console.WriteLine("{0}:数量{1}", Thread.CurrentThread.Name, number);  
  46.                 ChangeEvent.Set();  
  47.             }  
  48.         }  
  49.         static void GetBookProc()  
  50.         {  
  51.             while (true)  
  52.             {  
  53.                 ChangeEvent.WaitOne();  
  54.                 //ChangeEvent.Reset();                 
  55.                 Console.WriteLine("{0}:数量{1}", Thread.CurrentThread.Name, number);  
  56.                 Console.WriteLine("------------------------------------------");  
  57.                 //Thread.Sleep(0);  
  58.             }  
  59.         }  
  60.     }  
  61. }  

本文部分资料来源于网络,特此声明!

相关链接:http://www.cnblogs.com/freshman0216/archive/2008/07/30/1252345.html

http://msdn.microsoft.com/zh-cn/library/z6w25xa6%28VS.80%29.aspx



阅读更多
换一批

没有更多推荐了,返回首页