window下线程同步之（Event Objects（事件）)

转载自：http://www.cnblogs.com/staring-hxs/p/3666655.html

Event 方式是最具弹性的同步机制，因为他的状态完全由你去决定，不会像 Mutex 和 Semaphores 的状态会由类似：WaitForSingleObject 一类的函数的调用而改变，所以你可以精确的告诉 Event 对象该做什么事？以及什么时候去做！

HANDLE CreateEvent( 
  LPSECURITY_ATTRIBUTES lpEventAttributes,          

  BOOL bManualReset,                      

  BOOL bInitialState,                    

  LPCTSTR lpName                           // object name 
);

View Code

lpEventAttributes : 一个指向SECURITY_ATTRIBUTES结构的指针，确定返回的句柄是否可被子进程继承。如果lpEventAttributes是NULL，此句柄不能被继承。
bManualReset : 创建一个人工重置的事件（TRUE）使用ResetEvent()手动重置为无信号状态，
创建一个自动重置的事件（FALSE）。当一个等待线程被释放时,自动重置状态为无信号状态。
bInitialState : 用于指明该事件是要初始化为已通知状态（TRUE）还是未通知状态（FALSE）

bManualReset为TRUE时：人工重置事件，当一个等待线程被释放时，必须使用ResetEvent()手动重置为无型号状态

当人工重置的事件得到通知时，等待该事件的所有线程均变为可调度线程。

bManualReset为FALSE时：自动重置事件，当一个等待线程被释放时，自动重置状态为无信号状态
　　当自动重置的事件得到通知时，等待该事件的线程中只有一个线程变为可调度线程。

自动重置事件（通常没有必要为自动重置的事件调用ResetEvent函数）。

使用方法：
1、创建一个事件对象：CreateEvent；
2、打开一个已经存在的事件对象：OpenEvent；
3、获得事件的占有权：WaitForSingleObject 等函数（可能造成阻塞）；
4、释放事件的占有权（设置为激发（有信号）状态，以让其他等待中的线程苏醒）：SetEvent；
5、手动置为非激发（无信号）状态：ResetEvent
6、关闭事件对象句柄：CloseHandle；

固有特点(优点+缺点)：
1、是一个系统核心对象，所以有安全描述指针，用完了要 CloseHandle 关闭句柄，这些是内核对象的共同特征；
2、因为是核心对象，所以执行速度稍慢（当然只是相比较而言）；
3、因为是核心对象，而且可以命名，所以可以跨进程使用；
4、通常被用于 overlapped I/O 或被用来设计某些自定义的同步对象。

1 BOOL WINAPI SetEvent( __in HANDLE hEvent );  把event对象设置为激活状态
2 
3 BOOL WINAPI ResetEvent( __in HANDLE hEvent );  把event对象设置为非激活状态
4 
5 BOOL WINAPI PulseEvent( __in HANDLE hEvent ); 
6 如果是一个人工重置事件：把event对象设置为激活状态，唤醒“所有”等待中的线程，然后event恢复为非激活状态
7 如果是一个自动重置事件：把event对象设置为激活状态，唤醒 “一个”等待中的线程，然后event恢复为非激活状态

下面主要演示一下采用CreateEvent实现线程同步。

例子很简单，主要测试CreateEvent中bManualReset 和 bInitialState 参数的取值在线程调用中信号状态的情况。

1、bManualReset：TRUE
bInitialState：TRUE
CreateEvent(NULL, TRUE, TRUE, NULL); //人工重置事件：使用手动重置为无信号状态，初始化时有信号状态

 1 #include <iostream> 
 2 #include <windows.h> 
 3 using namespace std;
 4 
 5 DWORD WINAPI ThreadProc1(LPVOID lpParam); 
 6 DWORD WINAPI ThreadProc2(LPVOID lpParam);
 7 
 8 HANDLE hEvent = NULL; 
 9 HANDLE hThread1 = NULL; 
10 HANDLE hThread2 = NULL;
11 
12 int main(int argc, char *args[]) 
13 { 
14     
15     hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态 
16     
17     hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL); 
18     hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL); 
19     
20     WaitForSingleObject( hThread1, INFINITE ); 
21     WaitForSingleObject( hThread2,INFINITE );
22 
23     return 0; 
24 } 
25 DWORD WINAPI ThreadProc1(LPVOID lpParam) 
26 {
27 
28     if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
29     { 
30         cout <<"线程1被调用!\n"; 
31         ResetEvent(hEvent);
32     }
33 
34     return 0; 
35 } 
36 DWORD WINAPI ThreadProc2(LPVOID lpParam) 
37 { 
38     if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
39     { 
40         cout <<"线程2被调用!\n"; 
41         ResetEvent(hEvent);
42     } 
43     return 0; 
44 }

2、bManualReset：TRUE
bInitialState：FALSE
CreateEvent(NULL, TRUE, FALSE, NULL);//人工重置事件：使用手动重置为无信号状态，初始化时为无信号状态

 1 #include <iostream> 
 2 #include <windows.h> 
 3 using namespace std;
 4 
 5 DWORD WINAPI ThreadProc1(LPVOID lpParam); 
 6 DWORD WINAPI ThreadProc2(LPVOID lpParam);
 7 
 8 HANDLE hEvent = NULL; 
 9 HANDLE hThread1 = NULL; 
10 HANDLE hThread2 = NULL;
11 
12 int main(int argc, char *args[]) 
13 { 
14     
15     hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); //使用手动重置为无信号状态，初始化时无信号状态 
16          
17     hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0,NULL); 
18     hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0,NULL); 
19     
20     WaitForSingleObject( hThread1, INFINITE ); 
21     WaitForSingleObject( hThread2,INFINITE );
22 
23     return 0; 
24 } 
25 DWORD WINAPI ThreadProc1(LPVOID lpParam) 
26 {
27 
28     if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
29     { 
30         cout <<"线程1被调用!\n"; 
31     }
32 
33     return 0; 
34 } 
35 DWORD WINAPI ThreadProc2(LPVOID lpParam) 
36 { 
37     if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
38     { 
39         cout <<"线程2被调用!\n"; 
40     } 
41     return 0; 
42 }

当创建手动重置事件时初始化为无信号 hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); 得到的结果是：

在hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); 之后添加

SetEvent( hEvent );设置为有信号，因为bManualReset为TRUE时，等待该事件的所有线程均变为可调度线程

当我们在线程一中添加ResetEvent(hEvent);时运行程序发现线程1被调用，线程2没有被调用：

3、
bManualReset：FALSE
bInitialState：TRUE
CreateEvent(NULL, FALSE, TRUE, NULL); //自动重置事件：当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态

 1 #include <iostream> 
 2 #include <windows.h> 
 3 using namespace std;
 4 
 5 DWORD WINAPI ThreadProc1(LPVOID lpParam); 
 6 DWORD WINAPI ThreadProc2(LPVOID lpParam);
 7 
 8 HANDLE hEvent = NULL; 
 9 HANDLE hThread1 = NULL; 
10 HANDLE hThread2 = NULL;
11 
12 int main(int argc, char *args[]) 
13 { 
14     
15     hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //使用自动重置为无信号状态，初始化时有信号状态 
16     
17     hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0,NULL); 
18     hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0,NULL); 
19     
20     WaitForSingleObject( hThread1, INFINITE ); 
21     WaitForSingleObject( hThread2,INFINITE );
22 
23     return 0; 
24 } 
25 DWORD WINAPI ThreadProc1(LPVOID lpParam) 
26 {
27 
28     if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
29     { 
30         cout <<"线程1被调用!\n"; 
31     } 
32     return 0; 
33 } 
34 DWORD WINAPI ThreadProc2(LPVOID lpParam) 
35 { 
36     if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
37     { 
38         cout <<"线程2被调用!\n"; 
39     } 
40     return 0; 
41 }

从结果可以看到线程1被调用，线程2一直在等待。由于CreateEvent(NULL, FALSE, TRUE, NULL)//使用自动重置为无信号状态，初始化时有信号状态

所以当线程1执行的时候hEvent是有信号的，线程1正常运行，又由于bManualReset为FALSE时：当一个等待线程被释放时，自动重置状态为无信号状态

因此线程2一直在等待，由于主线程加了WaitForSingleObject( hThread2,INFINITE ); 所以主线程也在一直等待

4、
bManualReset：FALSE
bInitialState：FALSE
CreateEvent(NULL, FALSE, FALSE, NULL);//自动重置事件：线程释放后自动重置为无信号状态，初始化时为无信号状态

 1 #include <iostream> 
 2 #include <windows.h> 
 3 using namespace std;
 4 
 5 DWORD WINAPI ThreadProc1(LPVOID lpParam); 
 6 DWORD WINAPI ThreadProc2(LPVOID lpParam);
 7 
 8 HANDLE hEvent = NULL; 
 9 HANDLE hThread1 = NULL; 
10 HANDLE hThread2 = NULL;
11 
12 int main(int argc, char *args[]) 
13 { 
14     
15     hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); //使用自动重置为无信号状态，初始化时无信号状态 
16     SetEvent(hEvent);
17 
18     hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0,NULL); 
19     hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0,NULL); 
20     
21     WaitForSingleObject( hThread1, INFINITE ); 
22     WaitForSingleObject( hThread2,INFINITE );
23 
24     return 0; 
25 } 
26 DWORD WINAPI ThreadProc1(LPVOID lpParam) 
27 {
28 
29     if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
30     { 
31         cout <<"线程1被调用!\n"; 
32     } 
33     return 0; 
34 } 
35 DWORD WINAPI ThreadProc2(LPVOID lpParam) 
36 { 
37     if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
38     { 
39         cout <<"线程2被调用!\n"; 
40     } 
41     return 0; 
42 }

由于CreateEvent(NULL, FALSE, FALSE, NULL);//使用手动重置为无信号状态，初始化时为无信号状态

由于调用SetEvent，hEvent为有信号状态，线程1正常执行，又由于bManualReset为FALSE时：当一个等待线程被释放时，自动重置状态为无信号状态，调用完线程1后，hEvent自动重置为无信号状态，所以线程2只能在等待

posted on 2014-11-02 23:06 归海一刀阅读(290) 评论(0) 收藏举报