事件对象就像一个开关：它仅仅有两种状态---开和关。当一个事件处于”开”状态，我们称其为”有信号”否则称为”无信号”。能够在一个线程的运行函数中创建一个事件对象，然后观察它的状态，假设是”无信号”就让该线程睡眠，这样该线程占用的CPU时间就比較少。
产生事件对象的函数例如以下：
HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes, // SD
BOOL bManualReset, // reset type
BOOL bInitialState, // initial state
LPCTSTR lpName // object name
);
该函数创建一个Event同步对象,假设CreateEvent调用成功的话，会返回新生成的对象的句柄，否则返回NULL。
參数说明：
lpEventAttributes 一般为NULL
bManualReset 创建的Event是自己主动复位还是人工复位.假设true,人工复位, 一旦该Event被设置为有信号,则它一直会等到ResetEvent()API被调用时才会恢复 为无信号. 假设为false,Event被设置为有信号,则当有一个wait到它的Thread时, 该Event就会自己主动复位,变成无信号. 假设想 在每次调用WaitForSingleObject 后让WINDOWS为您自己主动地把事件地状态恢复为”无信号”状态，必须把该參数设为FALSE,否则，您必须每次调用ResetEvent函数来清除事件 的信号。
bInitialState 初始状态,true,有信号,false无信号
lpName 事件对象的名称。您在OpenEvent函数中可能使用。
凝视：
一个Event被创建以后,能够用OpenEvent()API来获得它的Handle,用CloseHandle() 来关闭它,用SetEvent()或PulseEvent()来设置它使其有信号,用ResetEvent() 来使其无信号,用WaitForSingleObject()或WaitForMultipleObjects()来等待其变为有信号.
PulseEvent()是一个比較有意思的用法,正如这个API的名字,它使一个Event 对象的状态发生一次脉冲变化,从无信号变成有信号再变成无信号,而整个操作是原子的.
对自己主动复位的Event对象,它仅释放第一个等到该事件的thread（假设有),而对于人工复位的Event对象,它释放全部等待的thread.
这里有两个API函数用来改动事件对象的信号状态：SetEvent和ResetEvent。前者把事件对象设为”有信号”状态，而后者正好相反。
在事件对象生成后，必须调用WaitForSingleObject来让线程进入等待状态，该函数的语法例如以下：
WaitForSingleObject proto hObject:DWORD, dwTimeout:DWORD
hObject -->指向同步对象的指针。事件对象事实上是同步对象的一种。
dwTimeout--> 等待同步对象变成”有信号”前等待的时间，以毫秒计。当等待的时间超过该值后无信号同步对象仍处于”无信号”状态，线程不再等待， WaitForSingleObject函数会返回。假设想要线程一直等待，请把该參数设为INFINITE（该值等于0xffffffff)。
以前，以前研究过了java中的多线程问题，特别是加锁和同步问题，可是，在C++中，确没有这么简单了。因为C没有提供像java里的线程类，一些同步的实现必须靠自己程序实现，稍显复杂。
一般来说，在C++里面创建和终止线程的函数为：_beginthread和_endthread两个函数，当然，也能够用CreateThread和ExitThread。详细的使用方式能够查看msdn。
那么，怎么样实现加锁与同步呢？能够使用createMutex函数以及createEvent方法等来实现，详细能够參考下例：
#include < iostream>
#include < windows.h>
using namespace std;
#define BUFSIZE 5
int SharedBuffer[BUFSIZE];
int head,tail;
int count;
HANDLE hMutex;
HANDLE hNotFullEvent, hNotEmptyEvent;
void BB_Producer()
...{
int i;
for (i=20; i>=0; i--) ...{
while(1) ...{
WaitForSingleObject(hMutex,INFINITE);
if (count == BUFSIZE) ...{ // 缓冲区满
ReleaseMutex(hMutex);
// 等待直到缓冲区非满
WaitForSingleObject(hNotFullEvent,INFINITE);
continue;
}
// 得到相互排斥锁且缓冲区非满,跳出while循环
break;
}
// 得到相互排斥锁且缓冲区非满,開始产生新数据
cout << "Produce: " << i << endl;
SharedBuffer[tail] = i;
tail = (tail+1) % BUFSIZE;
count++;
ReleaseMutex(hMutex); // 结束临界区
PulseEvent(hNotEmptyEvent); // 唤醒消费者线程
}
}
void BB_Consumer()
...{
int result;
while (1) ...{
WaitForSingleObject(hMutex,INFINITE);
if (count == 0) ...{ // 没有能够处理的数据
ReleaseMutex(hMutex); // 释放相互排斥锁且等待
// 等待直到缓冲区非空
WaitForSingleObject(hNotEmptyEvent,INFINITE);
}
else if (SharedBuffer[head] == 0) ...{
cout << "Consumed 0: end of data" << endl;
ReleaseMutex(hMutex); // 结束临界区
ExitThread(0);
}
else ...{ // 获得相互排斥锁且缓冲区有数据,開始处理
result = SharedBuffer[head];
cout << "Consumed: " << result << endl;
head = (head+1) % BUFSIZE;
count--;
ReleaseMutex(hMutex); // 结束临界区
PulseEvent(hNotFullEvent); // 唤醒生产者线程
}
}
}
void main()
...{
HANDLE hThreadVector[2];
DWORD ThreadID;
count = 0;
head = 0;
tail = 0;
hMutex = CreateMutex(NULL,FALSE,NULL);
hNotFullEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
hNotEmptyEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
hThreadVector[0] = CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) BB_Producer,
NULL, 0, (LPDWORD)&ThreadID);
hThreadVector[1] = CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) BB_Consumer,
NULL, 0, (LPDWORD)&ThreadID);
WaitForMultipleObjects(2,hThreadVector,TRUE,INFINITE);
}
这是一个典型的生产者-消费者问题，它们公用的资源是SharedBuffer，当Buffer中有数据且未满时，两个线程都能够执行，当Buffer为 空时，Consumer就要等待，直到Buffer不为空，这里就是用event来实现的；相同，当Buffer为满时，Producer就要等待。
当你创建一个线程时，事实上那个线程是一个循环，不像上面那样仅仅执行一次的。这样就带来了一个问题，在那个死循环里要找到合适的条件退出那个死循环，那么是怎么样实现它的呢？在Windows里往往是採用事件的方式，当然还能够採用其他的方式。在这里先介绍採用事件的方式来通知从线程执行函数退出来，它的实现原理是这样，在那个死循环里不断地使用WaitForSingleObject函数来检查事件是否满足，假设满足就退出线程，不满足就继续执行。当在线程里执行堵塞的函数时，就须要在退出线程时，先要把堵塞状态变成非堵塞状态，比方使用一个线程去接收网络数据，同一时候使用堵塞的SOCKET时，那么要先关闭SOCKET，再发送事件信号，才干够退出线程的。以下就来演示怎么样使用事件来通知线程退出来。
函数CreateEvent声明例如以下：
WINBASEAPI
__out
HANDLE
WINAPI
CreateEventA(
__in_opt LPSECURITY_ATTRIBUTES lpEventAttributes,
__in BOOL bManualReset,
__in BOOL bInitialState,
__in_opt LPCSTR lpName
);
WINBASEAPI
__out
HANDLE
WINAPI
CreateEventW(
__in_opt LPSECURITY_ATTRIBUTES lpEventAttributes,
__in BOOL bManualReset,
__in BOOL bInitialState,
__in_opt LPCWSTR lpName
);
#ifdef UNICODE
#define CreateEvent CreateEventW
#else
#define CreateEvent CreateEventA
#endif // !UNICODE
lpEventAttributes是事件的属性。
bManualReset是指事件手动复位，还是自己主动复位状态。
bInitialState是初始化的状态是否处于有信号的状态。
lpName是事件的名称，假设有名称，能够跨进程共享事件状态。
调用这个函数的样例例如以下：
#001 #pragma once
#002
#003 //线程类。
#004 //蔡军生 2007/09/23 QQ:9073204
#005 class CThread
#006 {
#007 public:
#008
#009 CThread(void)
#010 {
#011 m_hThread = NULL;
#012 m_hEventExit = NULL;
#013 }
#014
#015 virtual ~CThread(void)
#016 {
#017 if (m_hThread)
#018 {
#019 //删除的线程资源。
#020 ::CloseHandle(m_hThread);
#021 }
#022
#023 if (m_hEventExit)
#024 {
#025 //删除事件。
#026 ::CloseHandle(m_hEventExit);
#027 }
#028
#029 }
#030
#031 //创建线程
#032 HANDLE CreateThread(void)
#033 {
#034 //创建退出事件。
#035 m_hEventExit = ::CreateEvent(NULL,TRUE,FALSE,NULL);
#036 if (!m_hEventExit)
#037 {
#038 //创建事件失败。
#039 return NULL;
#040 }
#041
#042 //创建线程。
#043 m_hThread = ::CreateThread(
#044 NULL, //安全属性使用缺省。
#045 0, //线程的堆栈大小。
#046 ThreadProc, //线程执行函数地址。
#047 this, //传给线程函数的參数。
#048 0, //创建标志。
#049 &m_dwThreadID); //成功创建后的线程标识码。
#050
#051 return m_hThread;
#052 }
#053
#054 //等待线程结束。
#055 void WaitFor(DWORD dwMilliseconds = INFINITE)
#056 {
#057 //发送退出线程信号。
#058 ::SetEvent(m_hEventExit);
#059
#060 //等待线程结束。
#061 ::WaitForSingleObject(m_hThread,dwMilliseconds);
#062 }
#063
#064 protected:
#065 //
#066 //线程执行函数。
#067 //蔡军生 2007/09/21
#068 //
#069 static DWORD WINAPI ThreadProc(LPVOID lpParameter)
#070 {
#071 //转换传送入来的參数。
#072 CThread* pThread = reinterpret_cast<CThread *>(lpParameter);
#073 if (pThread)
#074 {
#075 //线程返回码。
#076 //调用类的线程处理函数。
#077 return pThread->Run();
#078 }
#079
#080 //
#081 return -1;
#082 }
#083
#084 //线程执行函数。
#085 //在这里能够使用类里的成员，也能够让派生类实现更强大的功能。
#086 //蔡军生 2007/09/25
#087 virtual DWORD Run(void)
#088 {
#089 //输出到调试窗体。
#090 ::OutputDebugString(_T("Run()线程函数执行/r/n"));
#091
#092 //线程循环。
#093 for (;;)
#094 {
#095 DWORD dwRet = WaitForSingleObject(m_hEventExit,0);
#096 if (dwRet == WAIT_TIMEOUT)
#097 {
#098 //能够继续执行。
#099 TCHAR chTemp[128];
#100 wsprintf(chTemp,_T("ThreadID=%d/r/n"),m_dwThreadID);
#101 ::OutputDebugString(chTemp);
#102
#103 //眼下没有做什么事情，就让线程释放一下CPU。
#104 Sleep(10);
#105 }
#106 else if (dwRet == WAIT_OBJECT_0)
#107 {
#108 //退出线程。
#109 ::OutputDebugString(_T("Run() 退出线程/r/n"));
#110 break;
#111 }
#112 else if (dwRet == WAIT_ABANDONED)
#113 {
#114 //出错。
#115 ::OutputDebugString(_T("Run() 线程出错/r/n"));
#116 return -1;
#117 }
#118 }
#119
#120 return 0;
#121 }
#122
#123 protected:
#124 HANDLE m_hThread; //线程句柄。
#125 DWORD m_dwThreadID; //线程ID。
#126
#127 HANDLE m_hEventExit; //线程退出事件。
#128 };
#129
上面在第35行创建线程退出事件，第95行检查事件是否可退出线程执行，第58行设置退出线程的事件。
【事件】
事件用处多是控制线程间的同步。
最典型的应用就是CreateThread之后等待线程函数的启动。如Main线程里CreateThread，它之后的操作依赖于子线程，那么它通常会 在CreateThread之后推断HANDLE是否有效，然后进入等待。（当然在这之前，一个Event是已经创建好的，并初始化为未通知状态）子线程 启动后完毕了初始化操作，并设置Event为已通知状态。这时，一直在等待该事件的Main线程发现该事件已经得到通知，因此它就变成可调度线程。这时 Main线程知道子线程已经完毕了初始化操作。
CreateEvent函数用于创建一个Event，其原型例如以下：
HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPTSTR lpName
);
參数说明：
- 第一个參数同CreateThread相似，也是安全级别相关，通常被被设置为NULL，以获得默认的安全级别。
- 第二个參数是个布尔值，它可以告诉系统是创建一个人工重置的事件（TRUE）还是创建一个自己主动重置的事件（ FALSE）。
- 第三个參数也是布尔值，用于指明该事件是要初始化为已通知状态（TRUE）还是未通知状态（FALSE）。
- 第四个參数是一个字符串，用于标示这个事件的名字。
下面是具体说明：
- 已通知状态和未通知状态
事件仅仅有两种状态，已通知表示这个事件已经被设置过了（能够理解为发生了），未通知表示还没有发生。一般设置为未通知状态，并由SetEvent设置为已 通知状态。当然也能够反着做，CreateEvent时设置为已通知状态，然后由ResetEvent设置为未通知状态。 - 人工重置与自己主动重置
自己主动重置的事件定义了应该成功等待的副作用规则，即当线程成功地等待到该对象时，自己主动重置的事件就会自己主动重置到未通知状态。
人工重置则须要调用ResetEvent函数设置为未通知状态。 - 名字共享
这个參数非常重要，Win32 API中有非常多方法有这个參数，它遵从一种按名字共享的规则。
假设传入一个非NULL字符串（最多260个字符），那么在全局空间，共享该HANDLE，这个全局可以是跨进程的名字空间，即在还有一个进程中依旧可以使用该名字的HANDLE。
假设希望避免这样的全局范围内的共享，那么应该传入NULL，以一种匿名的方式创建Event等，这样，它仅仅在当前线程内可见。
当进程A创建了一个Event后，如CreateEvent（NULL，FALSE，FLASE，_T(“UniqueEvent”)）；进程B相同创建 了一个Event，也想起名字为UniqueEvent，那么就会出现故障：CreateEvent（NULL，FALSE，FALSE，_T (“UniqueEvent”)）；系统会首先查看是否已经存在了一个名字为“UniqueEvent”的对象，因为确实存在了一个带有改名字的内核对 象，因此内核要检查对象类型，相同是一 个Event，那么系统会运行一次安全检查，以确定调用者是否拥有对该对象的完整訪问权。假设有这样的訪问权，系统会在进程B的句柄表里找到一个空项目，对 其初始化，使得该项指向现有的内核对象。假设类型不匹配，或者拒绝訪问，那么进程B的CreateEvent会失败。
应用程序可以确定它是否确实创建了一个新内核对象，而不是打开了一个现有的对象。方法是在调用C r e a t e *函数后马上调用G e t L a s t E r r o r：假设为ERROR_ALREADY_EXISTS，那么表示系统内已经存在了这样名字的对象。
Open*是去查看名字空间中是否有这个名字的内核对象存在调用C r e a t e *函数与调用O p e n *函数之间的主要区别是，假设对象并不存在，那么C r e a t e *函数将创建该对象，而O p e n *函数则执行失败。
PulseEvent函数使得事件变为已通知状态，然后马上又变为未通知状态，这就像在调用SetEvent后又马上调用ResetEvent函数一样。 假设在人工重置的事件上调用PulseEvent函数，那么在发出该事件时，等待该事件的不论什么一个线程或全部线程将变为可调度线程。假设在自己主动重置事件上 调用P u l s e E v e n t函数，那么仅仅有一个等待该事件的线程变为可调度线程。假设在发出事件时没有不论什么线程在等待该事件，那么将不起不论什么作用。
【等待函数】
等待函数用来监听事件的已通知状态。WaitForSingleObject和WaitForMultipleObjects两个函数分别用以等待单个事件和多个事件。
DWORD WaitForSingleObject(
HANDLE hHandle,
DWORD dwMilliseconds
);
DWORD WaitForMultipleObjects(
DWORD nCount,
const HANDLE* lpHandles,
BOOL bWaitAll,
DWORD dwMilliseconds
);
从函数原型上来看可知，事件的含义是可以支持被通知/未通知的内核对象（比如进程和线程，当传入的是进程或者线程句柄时，他表示等该线程或进程被标识为终止执行为止。）。
dwMilliseconds參数表明等待的时间，假设在这个时间段中事件为已通知状态，那么对于Single版本号将返回WAIT_OBJECT_0，对于Multiple版本号将返回 WAIT_OBJECT_0 to (WAIT_OBJECT_0 + nCount– 1)。假设没有等到将返回WAIT_TIMEOUT。
Multiple版本号中的bWaitAll表示想要让它使用何种方式等待。假设为该參数传递TRUE，那么在全部对象变为已通知状态之前，该函数将不同意调用线程执行。通常是FALSE，即仅仅要有一个事件被对应，则线程可调度。
