一 Windows编程之CreateEvent，WaitForSingleObject，SetEvent，ResetEvent函数
1 CreateEvent
HANDLE
WINAPI
CreateEventW(
_In_opt_ LPSECURITY_ATTRIBUTES lpEventAttributes,
_In_ BOOL bManualReset,
_In_ BOOL bInitialState,
_In_opt_ LPCWSTR lpName
);
/*
*
* 功能：创建一个事件对象。(有人说创建或打开一个命名的或无名的事件对象，当名字为参4时，会返回已打开的事件对象，但是我下面的案例测试是无法根据参4(无论是否为NULL都不行)获取已打开的对象)。
* 返回值：返回一个句柄HANDLE。
* 参1：属性，一般传NULL即可。
* 参2：是否设置手动改变事件状态。false自动，true手动。
* 参3：状态的初始值，分为无状态和有状态，false代表无状态，true代表有状态。
* 参4：事件的名字，可以为NULL。
*/
2 SetEvent
WINBASEAPI
BOOL
WINAPI
SetEvent(
_In_ HANDLE hEvent
);
/*
*
* 功能：设置状态为有状态。
* 返回值：1成功，0失败，该返回值实际意义不大。
* 参1：一个内核对象的句柄，不过主要是Event(其它没试过)。
*/
3 ResetEvent
WINBASEAPI
BOOL
WINAPI
ResetEvent(
_In_ HANDLE hEvent
);
/*
*
* 功能：设置状态为无状态。
* 返回值：1成功，0失败，该返回值实际意义不大。
* 参1：一个内核对象的句柄，不过主要是Event(其它没试过)。
4 WaitForSingleObject
WINBASEAPI
DWORD
WINAPI
WaitForSingleObject(
_In_ HANDLE hHandle,
_In_ DWORD dwMilliseconds
);
/*
*
* 功能：阻塞等待状态改变返回，具体看下面。
* 返回值：返回DWORD的值，一般使用宏去判断，若立即返回，返回值为WAIT_OBJECT_0；超时返回WAIT_TIMEOUT；失败返回WAIT_FAILED。
* 参1：一个内核对象的句柄，可以是Event，Mutex，Semaphore(信号量)，Process，Thread。
* 参2：等待时长，单位ms。
*
* 注意：参2的取值：
* 1）传0：表示不阻塞，立即返回，返回值为WAIT_OBJECT_0。
* 2）传>0：阻塞时长，超时时返回WAIT_TIMEOUT。
* 3）传INFINITE：表示一直阻塞，直到等待句柄的状态发生改变。
*/
5 WaitForSingleObject
WINBASEAPI
DWORD
WINAPI
WaitForMultipleObjects(
_In_ DWORD nCount,
_In_reads_(nCount) CONST HANDLE* lpHandles,
_In_ BOOL bWaitAll,
_In_ DWORD dwMilliseconds
);
/*
*
* 功能：同样是阻塞等待状态改变返回，具体看下面。
* 返回值：返回DWORD的值，一般使用宏去判断，若立即返回，返回值为WAIT_OBJECT_0；超时返回WAIT_TIMEOUT；失败返回WAIT_FAILED。
* 参1：句柄的数量，最大值为MAXIMUM_WAIT_OBJECTS（64），可以是Event，Mutex，Semaphore(信号量)，Process，Thread。
* 参2：句柄数组的指针。
* 参3：等待的类型，如果为TRUE 则等待所有信号量有效再往下执行，FALSE 当有其中一个信号量有效时就向下执行。
* 参4：等待时长，单位ms。
*
* 注意：参4的取值：
* 1）传0：表示不阻塞，立即返回，返回值为WAIT_OBJECT_0。
* 2）传>0：阻塞时长，超时时返回WAIT_TIMEOUT。
* 3）传INFINITE：表示一直阻塞，直到等待句柄的状态发生改变。
*/
5 案例
案例1
下面的案例我想做的是，主线程通过唤醒线程2后退出while循环，然后while循环唤醒线程1，并且由于线程1是设置手动
改变状态，调用完WaitForSingleObject是无法自动改变状态为无状态，所以最后退出时必须手动调用ResetEvent将状态改变为无状态。
最后主线程由于两个线程都退出后，主线程就会退出循环，并且回收句柄。注意主线程阻塞等待的是两个线程，而两个线程等待的是事件。
#include <iostream>
#include <string>
#include <windows.h>
#include <tchar.h>
using namespace std;
HANDLE h_event1 = NULL;
HANDLE h_event2 = NULL;
DWORD WINAPI FunProc1(LPVOID lpParameter);
DWORD WINAPI FunProc2(LPVOID lpParameter);
/*
总结1）：
h_event1初始状态为无信号时，WaitForSingleObject(h_event1, 300)
*/
DWORD WINAPI FunProc1(LPVOID lpParameter)
{
cout << "线程1开始运行。\n" << endl;
while (1)
{
int ret = WaitForSingleObject(h_event1, 7000);
if (WAIT_OBJECT_0 == ret) {
cout << "线程1等到event1\n" << endl;
break;
}
else if (WAIT_TIMEOUT == ret) {
cout << "线程1等待event1超时\n" << endl;
}
else if (WAIT_FAILED == ret) {
cout << "线程1调用WaitForSingleObject失败\n" << endl;
}
else {
cout << "线程1调用WaitForSingleObject返回未知结果\n" << endl;
break;
}
}
cout << "线程1等到了event1，线程1结束。\n" << endl;
ResetEvent(h_event1);//因为创建事件时信号改变设置为手动改变，所以必须自动调用改变为无信号
return 0;
}
DWORD WINAPI FunProc2(LPVOID lpParameter)
{
cout << "线程2开始运行。\n" << endl;
while (1){
int ret = WaitForSingleObject(h_event2, 3000);//因为创建事件设置为自动，收到信号不阻塞后，该函数返回自动将状态改为无信号状态
if (WAIT_OBJECT_0 == ret) {
cout << "线程2等到event2\n" << endl;
break;
}else if (WAIT_TIMEOUT == ret) {
cout << "线程2等待event2超时\n" << endl;
}
else if (WAIT_FAILED == ret) {
cout << "线程2调用WaitForSingleObject失败\n" << endl;
}
else {
cout << "线程2调用WaitForSingleObject返回未知结果\n" << endl;
break;
}
}
cout << "线程2等到了event2，线程2结束，并唤醒线程1。\n" << endl;
Sleep(350);
SetEvent(h_event1);
return 0;
}
int main(int argc, char** argv)
{
h_event1 = CreateEvent(NULL, true, false, _T("event_one"));//参2代表设置手动改变状态，参3代表初始状态为无状态
h_event2 = CreateEvent(NULL, false, false, _T("event_two"));//参2代表设置自动改变状态
HANDLE hThread1;
hThread1 = CreateThread(NULL, 0, FunProc1, NULL, 0, NULL);
HANDLE hThread2;
hThread2 = CreateThread(NULL, 0, FunProc2, NULL, 0, NULL);
Sleep(5000);
SetEvent(h_event2);
//线程1或者线程2都没退出继续等待，注意每个线程阻塞过程中收到信号改变立马不阻塞，并且结束的线程下次调用WaitForSingleObject直接返回
while (WaitForSingleObject(hThread1, 150) != WAIT_OBJECT_0 || WaitForSingleObject(hThread2, 150) != WAIT_OBJECT_0)
{
cout << "线程还没有结束，主程序等了150ms。\n" << endl;
}
cout << "主线程等待两个子线程结束完毕" << endl;
CloseHandle(hThread1);
CloseHandle(hThread2);
CloseHandle(h_event1);
CloseHandle(h_event2);
system("pause");
}
结果：
下图是之前错误的截图，应该是我把线程1的7000毫秒改成低于主线程的5000毫秒，导致比主线程先超时，所以下面的打印和上面的结果不一样。这里可以不管它，因为我也忘了。
案例2
此案例主要是测试一下两点：
- 1）测试能否根据名字获取已创建的事件对象
- 2）测试能否根据NULL获取已创建的事件对象。
- 结果：结果是均不能根据名字获取(CreateEvent的参4)。
#include <iostream>
#include <string>
#include <windows.h>
#include <tchar.h>
using namespace std;
HANDLE h_event1 = NULL;
HANDLE h_event2 = NULL;
HANDLE h_event3 = NULL;
HANDLE tmp1 = NULL;
HANDLE tmp2 = NULL;
DWORD WINAPI FunProc1(LPVOID lpParameter);
DWORD WINAPI FunProc2(LPVOID lpParameter);
/*
总结1）：
h_event1初始状态为无信号时，WaitForSingleObject(h_event1, 300)
*/
DWORD WINAPI FunProc1(LPVOID lpParameter)
{
cout << "线程1开始运行。\n" << endl;
while (1)
{
int ret = WaitForSingleObject(h_event1, 7000);
if (WAIT_OBJECT_0 == ret) {
cout << "线程1等到event1\n" << endl;
break;
}
else if (WAIT_TIMEOUT == ret) {
cout << "线程1等待event1超时\n" << endl;
}
else if (WAIT_FAILED == ret) {
cout << "线程1调用WaitForSingleObject失败\n" << endl;
}
else {
cout << "线程1调用WaitForSingleObject返回未知结果\n" << endl;
break;
}
}
cout << "线程1等到了event1，线程1结束。\n" << endl;
ResetEvent(h_event1);//因为创建事件时信号改变设置为手动改变，所以必须自动调用改变为无信号
return 0;
}
DWORD WINAPI FunProc2(LPVOID lpParameter)
{
cout << "线程2开始运行。\n" << endl;
while (1){
int ret = WaitForSingleObject(h_event2, 3000);//因为创建事件设置为自动，收到信号不阻塞后，该函数返回自动将状态改为无信号状态
if (WAIT_OBJECT_0 == ret) {
cout << "线程2等到event2\n" << endl;
break;
}else if (WAIT_TIMEOUT == ret) {
cout << "线程2等待event2超时\n" << endl;
}
else if (WAIT_FAILED == ret) {
cout << "线程2调用WaitForSingleObject失败\n" << endl;
}
else {
cout << "线程2调用WaitForSingleObject返回未知结果\n" << endl;
break;
}
}
cout << "线程2等到了event2，线程2结束，并唤醒线程1。\n" << endl;
Sleep(350);
SetEvent(h_event1);
return 0;
}
int main(int argc, char** argv)
{
//h_event1 = CreateEvent(NULL, true, false, _T("event_one"));//参2代表设置手动改变状态，参3代表初始状态为无状态
//h_event2 = CreateEvent(NULL, false, false, _T("event_two"));//参2代表设置自动改变状态
h_event1 = CreateEvent(NULL, true, false, _T("event_one"));//参2代表设置手动改变状态，参3代表初始状态为无状态
h_event2 = CreateEvent(NULL, false, false, _T("event_two"));//参2代表设置自动改变状态
//测试根据获取已创建的事件对象
tmp1 = CreateEvent(NULL, true, false, _T("event_one"));
if (&tmp1 == &h_event1) {
cout << "获取到事件event_one" << endl;
}
//测试能否根据NULL获取已创建的事件对象
h_event3 = CreateEvent(NULL, false, false, NULL);
tmp2 = CreateEvent(NULL, true, false, NULL);
if (&tmp2 == &h_event3) {
cout << "获取到事件NULL" << endl;
}
HANDLE hThread1;
hThread1 = CreateThread(NULL, 0, FunProc1, NULL, 0, NULL);
HANDLE hThread2;
hThread2 = CreateThread(NULL, 0, FunProc2, NULL, 0, NULL);
Sleep(5000);
SetEvent(h_event2);
//线程1或者线程2都没退出继续等待，注意每个线程阻塞过程中收到信号改变立马不阻塞，并且结束的线程下次调用WaitForSingleObject直接返回
while (WaitForSingleObject(hThread1, 150) != WAIT_OBJECT_0 || WaitForSingleObject(hThread2, 150) != WAIT_OBJECT_0)
{
cout << "线程还没有结束，主程序等了150ms。\n" << endl;
}
cout << "主线程等待两个子线程结束完毕" << endl;
CloseHandle(hThread1);
CloseHandle(hThread2);
CloseHandle(h_event1);
CloseHandle(h_event2);
system("pause");
}
案例3
下面案例主要是想测试WaitForSingleObject的参2传INFINITE，INFINITE会使函数一直阻塞。实际上和案例1过程类似，只不过一个会超时返回。
流程是两个线程创建后先阻塞，然后主线程睡眠5s后唤醒线程2，主线程也阻塞等待两个线程结束，然后线程2唤醒线程1，线程1结束后，由于两个线程都结束了，主线程退出。
#include <iostream>
#include <string>
#include <windows.h>
#include <tchar.h>
using namespace std;
HANDLE h_event1 = NULL;
HANDLE h_event2 = NULL;
DWORD WINAPI FunProc1(LPVOID lpParameter);
DWORD WINAPI FunProc2(LPVOID lpParameter);
DWORD WINAPI FunProc1(LPVOID lpParameter)
{
cout << "线程1开始运行。\n" << endl;
while (1)
{
int ret = WaitForSingleObject(h_event1, INFINITE);//INFINITE会一直阻塞
if (WAIT_OBJECT_0 == ret) {
cout << "线程1等到event1\n" << endl;
break;
}
else if (WAIT_TIMEOUT == ret) {
cout << "线程1等待event1超时\n" << endl;
}
else if (WAIT_FAILED == ret) {
cout << "线程1调用WaitForSingleObject失败\n" << endl;
}
else {
cout << "线程1调用WaitForSingleObject返回未知结果\n" << endl;
break;
}
}
cout << "线程1等到了event1，线程1结束。\n" << endl;
ResetEvent(h_event1);//因为创建事件时信号改变设置为手动改变，所以必须自动调用改变为无信号
return 0;
}
DWORD WINAPI FunProc2(LPVOID lpParameter)
{
cout << "线程2开始运行。\n" << endl;
while (1){
int ret = WaitForSingleObject(h_event2, INFINITE);//INFINITE会一直阻塞
if (WAIT_OBJECT_0 == ret) {
cout << "线程2等到event2\n" << endl;
break;
}else if (WAIT_TIMEOUT == ret) {
cout << "线程2等待event2超时\n" << endl;
}
else if (WAIT_FAILED == ret) {
cout << "线程2调用WaitForSingleObject失败\n" << endl;
}
else {
cout << "线程2调用WaitForSingleObject返回未知结果\n" << endl;
break;
}
}
cout << "线程2等到了event2，线程2结束，并唤醒线程1。\n" << endl;
Sleep(350);
SetEvent(h_event1);
return 0;
}
int main(int argc, char** argv)
{
h_event1 = CreateEvent(NULL, true, false, _T("event_one"));//参2代表设置手动改变状态，参3代表初始状态为无状态
h_event2 = CreateEvent(NULL, false, false, _T("event_two"));//参2代表设置自动改变状态
HANDLE hThread1;
hThread1 = CreateThread(NULL, 0, FunProc1, NULL, 0, NULL);
HANDLE hThread2;
hThread2 = CreateThread(NULL, 0, FunProc2, NULL, 0, NULL);
Sleep(5000);
SetEvent(h_event2);
//INFINITE会一直阻塞
while (WaitForSingleObject(hThread1, INFINITE) != WAIT_OBJECT_0 || WaitForSingleObject(hThread2, INFINITE) != WAIT_OBJECT_0)
{
cout << "线程还没有结束，主程序等了150ms。\n" << endl;
}
cout << "主线程等待两个子线程结束完毕" << endl;
CloseHandle(hThread1);
CloseHandle(hThread2);
CloseHandle(h_event1);
CloseHandle(h_event2);
system("pause");
}
结果：
案例4
WaitForMultipleObjects的简单示例。
m_threadShow = std::thread(std::mem_fn(&MainWindow::ShowData), this);
MainWindow::~MainWindow()
{
SetEvent(m_KillEvent);
if(m_threadShow.joinable())
m_threadShow.join();
delete ui;
}
void MainWindow::ShowData()
{
while(1)
{
HANDLE sigs[2] = {m_KillEvent, m_showEvent};
const DWORD ret = WaitForMultipleObjects(2, sigs, false, dwMilliseconds);
switch (ret) {
case WAIT_OBJECT_0: {
//数组的第一个事件：m_KillEvent发生会来到这里
break;
}
case WAIT_OBJECT_0 + 1: {
//数组的第二个事件：m_showEvent发生会来到这里
break;
}
case WAIT_TIMEOUT: {
// 超时来到这里
}
default: {
// 其它未知返回值的处理
}
}
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
