CreateEvent的学习

以下是对于CreateEvent函数的个人理解：

CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName)；其中的参数第一个一般默认为NULL，第二个参数用于确定对象消息是否手动产生信号，TRUE为手动，FALSE为自动，第三个参数初始化信号的值FALSE为无信号，TRUE为有信号。第四个参数为对象事件名，设置为NULL，则为内部使用无名对象事件。若不是，则可控制不同进程中同名对象事件。

当第二个参数设为TRUE时，会一直产生信号，直到调用ResetEvent函数将信号置为无信号。设为FALSE时，从处理完信号后会自动置为无信号。SetEvent函数置为有信号。

下面是一个与CreateEvent有关代码，因为SetEventData与GetEventData在PC上没有定义，所以模仿其功能，写一个类似类用于实现其函数功能，一下为代码：

Main.cpp

#include "CEvent.h"

using namespace std;  

DWORD WINAPI ThreadProc1(LPVOID lpParam);  
DWORD WINAPI ThreadProc2(LPVOID lpParam);  

HANDLE hEvent = NULL;  
HANDLE hThread1 = NULL;  
HANDLE hThread2 = NULL;  

CMUF m_event;
 
int main(int argc, char *args[])  
{  
	hEvent = m_event.CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态  
	//hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态  
	//if (SetEvent(hEvent))  
	//{  
	//  cout << "setEvent 成功" <<endl;  
	//}  
	hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);  
	Sleep(200);  

	hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);  
	Sleep(200);  

	if ( NULL == hThread1)  
	{  
		cout <<"create thread fail!";  
	}  

	// 	DWORD dCount = ResumeThread(hThread1);  
	// 	cout << LOWORD(dCount) << endl;  

	system("pause");
	return 0;  
}  

DWORD WINAPI ThreadProc1(LPVOID lpParam)  
{  
	cout <<"in thread1 before!"<<endl;  

	DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);  

	if ( WAIT_OBJECT_0 == dReturn)  
	{  
		cout <<" thread1 signaled ! "<<endl;  
	}  
	cout <<"in thread1 after"<<endl;  

	ResetEvent(hEvent);		//将对象事件信号置为无信号
	Sleep(2000);

	m_event.SetEventData(hEvent, 66);
	SetEvent(hEvent);		//将对象事件信号置为有信号
	return 0;  
}  

DWORD WINAPI ThreadProc2(LPVOID lpParam)  
{  
	cout <<"in thread2 before"<<endl;  

	DWORD dReturn = WaitForSingleObject(hEvent, INFINITE);  
	DWORD value = m_event.GetEventData(hEvent);
	cout << "GetEventData:" << value << endl;

	if ( WAIT_OBJECT_0 == dReturn)  
	{  
		cout <<"thread2 signaled ! "<<endl;  
	}  
	cout <<"in thread2 after"<<endl;  

	return 0;  
}  

</pre><pre code_snippet_id="473520" snippet_file_name="blog_20140923_3_6980506" name="code" class="cpp">

CMUF.h

</pre><pre code_snippet_id="473520" snippet_file_name="blog_20140923_4_884984" name="code" class="cpp"><pre name="code" class="cpp">#pragma once

#include <iostream>
#include <string>
#include <map> 
#include <windows.h>
#include <iostream>
#include <sstream>
#include <algorithm>

using namespace std;

#ifdef UNICODE
#define TSTRING wstring
#else
#define TSTRING string
#endif

class CMUF
{
public:
	struct MemFile
	{   
		HANDLE hFileMap;
		HANDLE pMapBuf;
		DWORD dwBufSize;
		DWORD dwCount;
	};

    static std::map<HANDLE,TSTRING> ms_mpEventHandleToName;
	static std::map<TSTRING,MemFile> ms_mpEventNameToFile;

public:
	BOOL InitMemFile(const TSTRING &strMapName,DWORD dwSize,MemFile &memFile);
	BOOL CloseHandle(HANDLE hObject);
	BOOL GetMemFile(HANDLE hEvent,MemFile &memFile);
	BOOL SetEventData(HANDLE hEvent,DWORD dwData);
	HANDLE CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName);
	DWORD GetEventData(HANDLE hEvent);

};

class value_equal
{
public:
	value_equal(TSTRING cmp_string) : m_string(cmp_string) {}
	
	BOOL operator() ( const std::map<HANDLE,TSTRING>::value_type &temp )
	{
		return (temp.second == m_string);
	}

private:
	TSTRING m_string;
};

CMUF.cpp

<pre name="code" class="cpp">#include "CEvent.h"

std::map<HANDLE,TSTRING> CMUF::ms_mpEventHandleToName;
std::map<TSTRING,CMUF::MemFile> CMUF::ms_mpEventNameToFile;

BOOL CMUF::InitMemFile(const TSTRING &strMapName,DWORD dwSize,MemFile &memFile)
{

	//创建映射文件
	HANDLE hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,dwSize,strMapName.c_str());
	if(hFileMap == NULL)
	{
		//ASSERT(hFileMap != NULL);
		return FALSE;
	}

	//从映射文件句柄获得分配的内存空间
	VOID *pMapBuf = MapViewOfFile(hFileMap,FILE_MAP_ALL_ACCESS,0,0,0); 
	if(pMapBuf == NULL)
	{
		//ASSERT(FALSE);
		CloseHandle(hFileMap);
		return FALSE;
	}

	//将内存中的数值设置为0
	DWORD dwData = 0;
	memcpy(pMapBuf,&dwData,dwSize);

	//将数值保存到结构体中
	memFile.hFileMap = hFileMap;
	memFile.pMapBuf = pMapBuf;
	memFile.dwBufSize = dwSize;
	memFile.dwCount = 1;

	return TRUE;
}


BOOL CMUF::CloseHandle(HANDLE hObject)
{
	if(hObject == NULL)
	{
		return FALSE;
	}

	//查找所关闭的句柄是否存在于记录里. 
	std::map<HANDLE,TSTRING>::iterator iterName = ms_mpEventHandleToName.find(hObject);
	if(iterName != ms_mpEventHandleToName.end())
	{

		std::map<TSTRING,MemFile>::iterator iterFile = ms_mpEventNameToFile.find(iterName->second);
		if(iterFile != ms_mpEventNameToFile.end())
		{ 
			//找到记录，数目减一
			InterlockedDecrement(reinterpret_cast<LONG *>(&iterFile->second.dwCount));


			if(iterFile->second.dwCount == 0)
			{
				//如果记数为零，则删掉映射文件.

				UnmapViewOfFile(iterFile->second.pMapBuf);
				::CloseHandle(iterFile->second.hFileMap);
				ms_mpEventNameToFile.erase(iterFile);
			}
		}

		ms_mpEventHandleToName.erase(iterName);
	}

	//调用API函数进行真正的关闭。
	return ::CloseHandle(hObject);
}


BOOL CMUF::GetMemFile(HANDLE hEvent,MemFile &memFile)
{
	if(hEvent == NULL)
	{
		return FALSE;
	}

	//根据句柄查找命名
	std::map<HANDLE,TSTRING>::iterator iterEvent = ms_mpEventHandleToName.find(hEvent);
	if(iterEvent == ms_mpEventHandleToName.end())
	{
		return FALSE;
	}

	//根据命名来查找映射文件信息
	std::map<TSTRING,MemFile>::iterator iterMem = ms_mpEventNameToFile.find(iterEvent->second);
	if(iterMem == ms_mpEventNameToFile.end())
	{
		return FALSE;
	}

	//将记录文件中的信息保存到输出变量缓存中。
	memFile = iterMem->second;

	return TRUE;
}


BOOL CMUF::SetEventData(HANDLE hEvent,DWORD dwData)
{
	MemFile memFile;
	if(GetMemFile(hEvent,memFile) == FALSE || memFile.pMapBuf == NULL)
	{
		return FALSE;
	}

	//将数值拷贝到内存中
	memcpy(memFile.pMapBuf,&dwData,memFile.dwBufSize);

	return TRUE;
}

DWORD CMUF::GetEventData(HANDLE hEvent)
{
	MemFile memFile;
	if(GetMemFile(hEvent,memFile) == FALSE || memFile.pMapBuf == NULL)
	{
		return 0;
	}

	//从内存中获取DWORD数据
	DWORD dwVal = 0;
	memcpy(&dwVal,memFile.pMapBuf,memFile.dwBufSize);

	return dwVal;
}



HANDLE CMUF::CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName)
{
	BOOL bRes = FALSE;

	//调用原生的API函数创建事件.
	HANDLE hEvent = ::CreateEvent(lpEventAttributes,bManualReset,bInitialState,lpName);
	if(hEvent == NULL)
	{
		//如果创建失败，跳转到EXIT
		goto EXIT;
	}

	//先判断当前创建的这个事件是否已经被创建，以方便后续数据的处理。.
	BOOL bIsExisting = (GetLastError() == ERROR_ALREADY_EXISTS);

	if(bIsExisting == FALSE)
	{  
		//这是一个新的的事件
		TSTRING strMemFile;

		//先判断这个类是否只是内部使用。所谓的内部使用，指的是没有名字的事件，除了通过句柄来进行使用以外，无法通过再次打开获得。
		if(lpName != NULL)
		{
			//因为内存映射文件和事件名是同一个命名空间，所以这两者的名字不能相同。故我们要创建的内存映射文件名为：EVENT_前缀 + 事件名。
			strMemFile = TEXT("EVENT_");
			strMemFile += lpName;
		}
		else
		{
			//如果该事件为内部使用，那么也就意味着这内存映射文件也是内部使用。故采用程序句柄的名字+事件名的方式进行内存映射文件的名字确定。
			ostringstream stream; 
			stream << GetModuleHandle(NULL) << TEXT("_") << hEvent;
			strMemFile = stream.str();
		}

		//通过调用InitMemFile来创建内存映射文件
		MemFile memFile;
		if(InitMemFile(strMemFile,sizeof(DWORD),memFile) == FALSE)
		{
			goto EXIT;
		}

		//ms_mpEventHandleToName和ms_mpEventNameToFile是类的静态成员，用来存储事件和映射文件的对应关系。
		if(lpName != NULL)
		{
			ms_mpEventHandleToName.insert(std::make_pair(hEvent,lpName));
			ms_mpEventNameToFile.insert(std::make_pair(lpName,memFile));
		}
		else
		{
			//因为内部使用的事件没有名字，所以采用组合的名字作为标识
			ms_mpEventHandleToName.insert(std::make_pair(hEvent,strMemFile));
			ms_mpEventNameToFile.insert(std::make_pair(strMemFile,memFile));
		}

	}
	else
	{
		//系统判断以该名字命名的事件已经被创建过，所以我们先搜索我们的数据库是否有相应的记录。
		std::map<HANDLE,TSTRING>::iterator iterName = std::find_if(ms_mpEventHandleToName.begin(),ms_mpEventHandleToName.end(),value_equal(lpName));
		if(iterName == ms_mpEventHandleToName.end())
		{
			//ASSERT(FALSE);

			goto EXIT;
		}


		std::map<TSTRING,MemFile>::iterator iterFile = ms_mpEventNameToFile.find(iterName->second);
		if(iterFile == ms_mpEventNameToFile.end())
		{
			//ASSERT(FALSE);

			goto EXIT;
		}

		//找到相应记录的话，则将记数加1
		InterlockedIncrement(reinterpret_cast<LONG *>(&iterFile->second.dwCount));

		//即使该名字命名的事件之前已经使用，但第二次创建时，句柄还是不同的，所以我们必须将其保存
		ms_mpEventHandleToName.insert(std::make_pair(hEvent,lpName));
	}

	bRes = TRUE;

EXIT:

	if(bRes == FALSE)
	{
		CloseHandle(hEvent);
	}

 	return hEvent;

}

注：这里有个比较详细介绍CreateEvent的网址： http://blog.youkuaiyun.com/skyremember/article/details/2994163可以参考