c++CreateEvent函数在多线程中使用及实例

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. }  

执行结果:

c++CreateEvent函数在多线程中使用及实例_第1张图片

从结果中看,执行完线程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;
}

执行结果:

c++CreateEvent函数在多线程中使用及实例_第2张图片

可见,线程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. }  

执行结果:

c++CreateEvent函数在多线程中使用及实例_第3张图片

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

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

你可能感兴趣的:(多线程,C++,object,测试,null,attributes)