CreateEvent http://blog.csdn.net/richerg85/article/details/7471426

版权声明：本文为博主原创文章，未经博主允许不得转载。

CreateEvent函数详解参见本博客文章：

c++中CreateEvent函数解析(2)

HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset, 
BOOL bInitialState,
LPCSTR lpName
);
bManualReset:TRUE，使用ResetEvent()手动重置为无信号状态；FALSE，当一个等待线程被释放时,自动重置状态为无信号状态。

bInitialState：指定事件对象的初始状态，当TRUE,初始状态为有信号状态；当FALSE,初始状态为无信号状态。

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

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

测试1：

bManualReset：TRUE
bInitialState：TRUE

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

example.cpp

[cpp]  view plain copy

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. HANDLE hEvent = NULL;  
8. HANDLE hThread1 = NULL;  
9. HANDLE hThread2 = NULL;  
10. int main(int argc, char *args[])  
11. {  
12.     <span style="color:#ff0000;">hEvent = CreateEvent(NULL, TRUE, TRUE, NULL)</span>; //使用手动重置为无信号状态，初始化时有信号状态  
13.     //hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
14.     //if (SetEvent(hEvent))  
15.     //{  
16.     //  cout << "setEvent 成功" <<endl;  
17.     //}  
18.     hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
19.     Sleep(200);  
20.     hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
21.     Sleep(200);  
22.     if ( NULL == hThread1)  
23.     {  
24.         cout <<"create thread fail!";  
25.     }  
26.     //DWORD dCount = ResumeThread(hThread);  
27.     //cout << LOWORD(dCount) << endl;  
28.     return 0;  
29. }  
30. DWORD WINAPI ThreadProc1(LPVOID lpParam)  
31. {  
32.     cout <<"in thread1@!"<<endl;  
33.       
34.     DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
35.       
36.     if ( WAIT_OBJECT_0 == dReturn)  
37.     {  
38.         cout <<" thread1 signaled ! "<<endl;  
39.     }  
40.     cout <<"in thread1 --signal"<<endl;  
41.       
42.     //SetEvent(hEvent);  
43.     return 0;  
44. }  
45. DWORD WINAPI ThreadProc2(LPVOID lpParam)  
46. {  
47.     cout <<"in thread2@!"<<endl;  
48.       
49.     DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
50.       
51.     if ( WAIT_OBJECT_0 == dReturn)  
52.     {  
53.         cout <<"thread2 signaled ! "<<endl;  
54.     }  
55.     cout <<"in thread2--signal"<<endl;  
56.       
57.     return 0;  
58. }  

执行结果：

从结果中看，执行完线程1又执行了线程2.

由于hEvent = CreateEvent(NULL, TRUE, TRUE, NULL)，使用手动重置为无信号状态，初始化时有信号状态

所以hEvent一直处于有信号状态，无论是线程1释放后，hEvent仍处于有信号状态，所以线程2正常执行了。

测试2：

bManualReset：FALSE
bInitialState：TRUE

[cpp]  view plain copy

1. hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  

example2.cpp

[cpp]  view plain copy

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. HANDLE hEvent = NULL;  
8. HANDLE hThread1 = NULL;  
9. HANDLE hThread2 = NULL;  
10. int main(int argc, char *args[])  
11. {  
12.     //hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态  
13.     <span style="color:#ff0000;">hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); </span>//当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
14.     //if (SetEvent(hEvent))  
15.     //{  
16.     //  cout << "setEvent 成功" <<endl;  
17.     //}  
18.     hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
19.     Sleep(200);  
20.     hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
21.     Sleep(200);  
22.     if ( NULL == hThread1)  
23.     {  
24.         cout <<"create thread fail!";  
25.     }  
26.     //DWORD dCount = ResumeThread(hThread);  
27.     //cout << LOWORD(dCount) << endl;  
28.     return 0;  
29. }  
30. DWORD WINAPI ThreadProc1(LPVOID lpParam)  
31. {  
32.     cout <<"in thread1@!"<<endl;  
33.       
34.     DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
35.       
36.     if ( WAIT_OBJECT_0 == dReturn)  
37.     {  
38.         cout <<" thread1 signaled ! "<<endl;  
39.     }  
40.     cout <<"in thread1 --signal"<<endl;  
41.       
42.     //SetEvent(hEvent);  
43.     return 0;  
44. }  
45. DWORD WINAPI ThreadProc2(LPVOID lpParam)  
46. {  
47.     cout <<"in thread2@!"<<endl;  
48.       
49.     DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
50.       
51.     if ( WAIT_OBJECT_0 == dReturn)  
52.     {  
53.         cout <<"thread2 signaled ! "<<endl;  
54.     }  
55.     cout <<"in thread2--signal"<<endl;  
56.       
57.     return 0;  
58. }  

执行结果：

从执行结果中分析，执行了线程1，线程2一直在等待，直到主线程结束。

由于hEvent = CreateEvent(NULL, FALSE, TRUE, NULL)，当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态

初始执行线程1的时候，hEvent是有信号的，所以线程1正常执行；又由于bManualReset=FALSE，所以执行完线程1后，hEvent自动重置为无信号状态，所以在线程2中，

[cpp]  view plain copy

1. WaitForSingleObject(hEvent,INFINITE);  

函数一直在等待hEvent变为有信号状态，但是当主线程执行完，还没等待到，线程2程序一直没有走下去。

测试3：

bManualReset：TRUE
bInitialState：FALSE

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

example3.cpp

[cpp]  view plain copy

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. HANDLE hEvent = NULL;  
8. HANDLE hThread1 = NULL;  
9. HANDLE hThread2 = NULL;  
10. int main(int argc, char *args[])  
11. {  
12.     //hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态  
13.     //hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
14.     <span style="color:#ff0000;">hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);//使用手动重置为无信号状态，初始化时为无信号状态</span>  
15.     //if (SetEvent(hEvent))  
16.     //{  
17.     //  cout << "setEvent 成功" <<endl;  
18.     //}  
19.     hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
20.     Sleep(200);  
21.     hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
22.     Sleep(200);  
23.     if ( NULL == hThread1)  
24.     {  
25.         cout <<"create thread fail!";  
26.     }  
27.     //DWORD dCount = ResumeThread(hThread);  
28.     //cout << LOWORD(dCount) << endl;  
29.     return 0;  
30. }  
31. DWORD WINAPI ThreadProc1(LPVOID lpParam)  
32. {  
33.     cout <<"in thread1@!"<<endl;  
34.       
35.     DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
36.       
37.     if ( WAIT_OBJECT_0 == dReturn)  
38.     {  
39.         cout <<" thread1 signaled ! "<<endl;  
40.     }  
41.     cout <<"in thread1 --signal"<<endl;  
42.       
43.     //SetEvent(hEvent);  
44.     return 0;  
45. }  
46. DWORD WINAPI ThreadProc2(LPVOID lpParam)  
47. {  
48.     cout <<"in thread2@!"<<endl;  
49.       
50.     DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
51.       
52.     if ( WAIT_OBJECT_0 == dReturn)  
53.     {  
54.         cout <<"thread2 signaled ! "<<endl;  
55.     }  
56.     cout <<"in thread2--signal"<<endl;  
57.       
58.     return 0;  
59. }  

执行结果，可想而知，只能输出：

[cpp]  view plain copy

1. in thread1@!  

[cpp]  view plain copy

1. in thread2@!  

因为初始为无信号状态，所以hEvent一直处于无信号状态，因此这两个线程一直在等待，直到主线程结束。

修改：放开例子中的注释部分：

if (SetEvent(hEvent))//设置信号为有信号状态
{
cout << "setEvent 成功" <<endl;
}

执行结果：

可见，线程1和线程2都执行了。

因为调用SetEvent，事件变为有信号状态，线程1执行；又由于线程1释放后，hEvent仍旧处于有信号状态，所以线程2也执行了。

再修改:在线程1中，添加ResetEvent(hEvent)（手动设置事件为无信号状态），则线程2不会执行。

测试4：

bManualReset：FALSE
bInitialState：FALSE

hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);//线程释放后自动重置为无信号状态，初始化时为无信号状态

example4.cpp

[cpp]  view plain copy

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. HANDLE hEvent = NULL;  
8. HANDLE hThread1 = NULL;  
9. HANDLE hThread2 = NULL;  
10. int main(int argc, char *args[])  
11. {  
12.     //hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态  
13.     //hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
14.     //hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);//使用手动重置为无信号状态，初始化时为无信号状态  
15.     hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);//使用手动重置为无信号状态，初始化时为无信号状态  
16.     if (SetEvent(hEvent))  
17.     {  
18.         cout << "setEvent 成功" <<endl;  
19.     }  
20.     hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
21.     Sleep(200);  
22.     hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
23.     Sleep(200);  
24.     if ( NULL == hThread1)  
25.     {  
26.         cout <<"create thread fail!";  
27.     }  
28.     //DWORD dCount = ResumeThread(hThread);  
29.     //cout << LOWORD(dCount) << endl;  
30.     return 0;  
31. }  
32. DWORD WINAPI ThreadProc1(LPVOID lpParam)  
33. {  
34.     cout <<"in thread1@!"<<endl;  
35.       
36.     DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
37.       
38.     if ( WAIT_OBJECT_0 == dReturn)  
39.     {  
40.         cout <<" thread1 signaled ! "<<endl;  
41.     }  
42.     cout <<"in thread1 --signal"<<endl;  
43.       
44.     //SetEvent(hEvent);  
45.     return 0;  
46. }  
47. DWORD WINAPI ThreadProc2(LPVOID lpParam)  
48. {  
49.     cout <<"in thread2@!"<<endl;  
50.       
51.     DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  
52.       
53.     if ( WAIT_OBJECT_0 == dReturn)  
54.     {  
55.         cout <<"thread2 signaled ! "<<endl;  
56.     }  
57.     cout <<"in thread2--signal"<<endl;  
58.       
59.     return 0;  
60. }  

执行结果：

由于调用SetEvent，hEvent为有信号状态，线程1正常执行，又由于调用完线程1后，hEvent自动重置为无信号状态，所以线程2只能在等待，直到主线程退出。

修改：线程1中的SetEvent(hEvent);的注释去掉，再运行，则线程1和线程2 都会执行。

• 上一篇c++多线程函数----AfxBeginThread
• 下一篇c++多线程同步（1）