用C++实现Win32事件对象，同步线程
在Win32环境下编写多线程应用程序，经常要用到事件对象Event，来进行线程同步。与其相关的一组API包括：CreateEvent，SetEvent，ResetEvent，WaitForSingleObject，和CloseHandle。关于这些API的功能以及参数意义等这里就不多说了。下边，我封装了一个事件对象类，以及测试代码。已由本人在VS2005环境下编译，测试通过。
MyEvent.h
#ifndef My_Event_Header
#define My_Event_Header
#include <iostream>
#ifdef WIN32
#include <Windows.h>
#endif
using namespace std;
//---------------------------------------------------------------
class CEventImpl
{
protected:
/*
创建一个匿名事件对象
`bAutoReset true 人工重置
false 自动重置
*/
CEventImpl(bool bManualReset);
/*
销毁一个事件对象
*/
~CEventImpl();
/*
将当前事件对象设置为有信号状态
若自动重置，则等待该事件对象的所有线程只有一个可被调度
若人工重置，则等待该事件对象的所有线程变为可被调度
*/
void SetImpl();
/*
以当前事件对象，阻塞线程，将其永远挂起
直到事件对象被设置为有信号状态
*/
bool WaitImpl();
/*
以当前事件对象，阻塞线程，将其挂起指定时间间隔
之后线程自动恢复可调度
*/
bool WaitImpl(long lMilliseconds);
/*
将当前事件对象设置为无信号状态
*/
void ResetImpl();
private:
HANDLE h_Event;
};
inline void CEventImpl::SetImpl()
{
if (!SetEvent(h_Event))
{
cout<<"cannot signal event"<<endl;
}
}
inline void CEventImpl::ResetImpl()
{
if (!ResetEvent(h_Event))
{
cout<<"cannot reset event"<<endl;
}
}
//---------------------------------------------------------------
class CMyEvent: private CEventImpl
{
public:
CMyEvent(bool bManualReset = true);
~CMyEvent();
void Set();
bool Wait();
bool Wait(long milliseconds);
bool TryWait(long milliseconds);
void Reset();
private:
CMyEvent(const CMyEvent&);
CMyEvent& operator = (const CMyEvent&);
};
inline void CMyEvent::Set()
{
SetImpl();
}
inline bool CMyEvent::Wait()
{
return WaitImpl();
}
inline bool CMyEvent::Wait(long milliseconds)
{
if (!WaitImpl(milliseconds))
{
cout<<"time out"<<endl;
return false;
}
else
{
return true;
}
}
inline bool CMyEvent::TryWait(long milliseconds)
{
return WaitImpl(milliseconds);
}
inline void CMyEvent::Reset()
{
ResetImpl();
}
#endif
MyEvent.cpp
#include "MyEvent.h"
CEventImpl::CEventImpl(bool bManualReset)
{
h_Event = CreateEvent(NULL, bManualReset, FALSE, NULL);
if (!h_Event)
cout<<"cannot create event"<<endl;
}
CEventImpl::~CEventImpl()
{
CloseHandle(h_Event);
}
bool CEventImpl::WaitImpl()
{
switch (WaitForSingleObject(h_Event, INFINITE))
{
case WAIT_OBJECT_0:
return true;
default:
cout<<"wait for event failed"<<endl;
}
return false;
}
bool CEventImpl::WaitImpl(long lMilliseconds)
{
switch (WaitForSingleObject(h_Event, lMilliseconds + 1))
{
case WAIT_TIMEOUT:
return false;
case WAIT_OBJECT_0:
return true;
default:
cout<<"wait for event failed"<<endl;
return false;
}
}
CMyEvent::CMyEvent(bool bManualReset): CEventImpl(bManualReset)
{
}
CMyEvent::~CMyEvent()
{
}
下边是测试代码
// CEvent.cpp : 定义控制台应用程序的入口点。
//
#include "MyEvent.h"
#include <process.h>
#define PRINT_TIMES 10
//创建一个人工自动重置事件对象
CMyEvent g_myEvent(true);
int g_iNum = 0;
//线程函数1
unsigned int __stdcall ThreadProc1(void *pParam)
{
for (int i = 0; i < PRINT_TIMES; i++)
{
g_iNum++;
cout<<"ThreadProc1 do print, Num = "<<g_iNum<<endl;
//设置事件为有信号状态
g_myEvent.Set();
Sleep(1000);
}
return (unsigned int)0;
}
//线程函数2
unsigned int __stdcall ThreadProc2(void *pParam)
{
bool bRet = false;
while ( 1 )
{
if ( g_iNum >= PRINT_TIMES )
{
break;
}
//以当前事件对象阻塞本线程，将其挂起
bRet = g_myEvent.Wait();
if ( bRet )
{
cout<<"ThreadProc2 do print, Num = "<<g_iNum<<endl;
//设置事件为无信号状态
g_myEvent.Reset();
}
else
{
cout<<"ThreadProc2 system exception"<<endl;
}
}
return (unsigned int)0;
}
int main(int argc, char* argv[])
{
HANDLE hThread1, hThread2;
unsigned int uiThreadId1, uiThreadId2;
//创建两个工作线程
hThread1 = (HANDLE)_beginthreadex(NULL, 0, &ThreadProc1, NULL, 0, &uiThreadId1);
hThread2 = (HANDLE)_beginthreadex(NULL, 0, &ThreadProc2, NULL, 0, &uiThreadId2);
//等待线程结束
DWORD dwRet = WaitForSingleObject(hThread1,INFINITE);
if ( dwRet == WAIT_TIMEOUT )
{
TerminateThread(hThread1,0);
}
dwRet = WaitForSingleObject(hThread2,INFINITE);
if ( dwRet == WAIT_TIMEOUT )
{
TerminateThread(hThread2,0);
}
//关闭线程句柄，释放资源
CloseHandle(hThread1);
CloseHandle(hThread2);
system("pause");
return 0;
}
测试代码中使用全局事件对象g_myEvent，对线程1和2进行同步，每当线程1函数对全局变量g_iNum做加1之后，通知线程2，立即将该变量值打印出来。如此循环10，线程1和2分别结束自己。
编译，运行
欢迎转载！麻烦带上链接：chexlong的专栏，谢谢合作！