c++中CreateEvent函数详解及实例

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

 

view source

 

print ?

01. #include "iostream"

02. #include "windows.h"

03. using namespace std;

04.   

05. DWORD WINAPI ThreadProc1(LPVOID lpParam);

06. DWORD WINAPI ThreadProc2(LPVOID lpParam);

07. HANDLE hEvent = NULL;

08. HANDLE hThread1 = NULL;

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

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

 

example2.cpp

 

expand source view source

 

print ?

01. #include "iostream"

02. #include "windows.h"

03. using namespace std;

04.   

05. DWORD WINAPI ThreadProc1(LPVOID lpParam);

06. DWORD WINAPI ThreadProc2(LPVOID lpParam);

07. HANDLE hEvent = NULL;

08. HANDLE hThread1 = NULL;

09. 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中，

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

测试3：

bManualReset：TRUE
bInitialState：FALSE

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

example3.cpp

 

view source

 

print ?

01. #include "iostream"

02. #include "windows.h"

03. using namespace std;

04.   

05. DWORD WINAPI ThreadProc1(LPVOID lpParam);

06. DWORD WINAPI ThreadProc2(LPVOID lpParam);

07. HANDLE hEvent = NULL;

08. HANDLE hThread1 = NULL;

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

 

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

in thread1@! 
in thread1@![cpp] view plaincopyprint?in thread2@! 
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

 

view source

 

print ?

01. #include "iostream"

02. #include "windows.h"

03. using namespace std;

04.   

05. DWORD WINAPI ThreadProc1(LPVOID lpParam);

06. DWORD WINAPI ThreadProc2(LPVOID lpParam);

07. HANDLE hEvent = NULL;

08. HANDLE hThread1 = NULL;

09. 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 都会执行。

<artcle Linker : http://www.it165.net/pro/html/201204/2221.html>

 

转载于:https://www.cnblogs.com/MMLoveMeMM/articles/3195295.html