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

冷不防 2022-08-12 09:29 116阅读 0赞

[点击打开链接][Link 1]

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

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

**\[csharp\]**  [view plain][] [copy][view plain]

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 plain][] [copy][view plain]

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 plain][] [copy][view plain]

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 plain][] [copy][view plain]

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 plain][] [copy][view plain]

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 plain][] [copy][view plain]

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_www.cnblogs.com_freshman0216_archive_2008_07_30_1252345.html]

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

[Link 1]: http://blog.csdn.net/wangqiuyun/article/details/13509225
[view plain]: http://blog.csdn.net/wangqiuyun/article/details/13509225#
[http_www.cnblogs.com_freshman0216_archive_2008_07_30_1252345.html]: http://www.cnblogs.com/freshman0216/archive/2008/07/30/1252345.html