window下线程同步之（Event Objects（事件）)

时间 2019-11-11

标签 window 线程同步 event objects 事件栏目 Windows 繁體版

原文原文链接

Event 方式是最具弹性的同步机制，由于他的状态彻底由你去决定，不会像 Mutex 和 Semaphores 的状态会由相似：WaitForSingleObject 一类的函数的调用而改变，因此你能够精确的告诉 Event 对象该作什么事？以及何时去作！ios

HANDLE CreateEvent( 
  LPSECURITY_ATTRIBUTES lpEventAttributes,          

  BOOL bManualReset,                      

  BOOL bInitialState,                    

  LPCTSTR lpName                           // object name 
);

lpEventAttributes : 一个指向SECURITY_ATTRIBUTES结构的指针，肯定返回的句柄是否可被子进程继承。若是lpEventAttributes是NULL，此句柄不能被继承。
bManualReset : 建立一我的工重置的事件（TRUE）使用ResetEvent()手动重置为无信号状态，
建立一个自动重置的事件（FALSE）。当一个等待线程被释放时,自动重置状态为无信号状态。
bInitialState : 用于指明该事件是要初始化为已通知状态（TRUE）仍是未通知状态（FALSE） windows

bManualReset为TRUE时：人工重置事件，当一个等待线程被释放时，必须使用ResetEvent()手动重置为无型号状态安全

当人工重置的事件获得通知时，等待该事件的全部线程均变为可调度线程。app

bManualReset为FALSE时：自动重置事件，当一个等待线程被释放时，自动重置状态为无信号状态
　　当自动重置的事件获得通知时，等待该事件的线程中只有一个线程变为可调度线程。函数

自动重置事件（一般没有必要为自动重置的事件调用ResetEvent函数）。测试

使用方法：
一、建立一个事件对象：CreateEvent；
二、打开一个已经存在的事件对象：OpenEvent；
三、得到事件的占有权：WaitForSingleObject 等函数（可能形成阻塞）；
四、释放事件的占有权（设置为激发（有信号）状态，以让其余等待中的线程苏醒）：SetEvent；
五、手动置为非激发（无信号）状态：ResetEvent
六、关闭事件对象句柄：CloseHandle；spa

固有特色(优势+缺点)：
一、是一个系统核心对象，因此有安全描述指针，用完了要 CloseHandle 关闭句柄，这些是内核对象的共同特征；
二、由于是核心对象，因此执行速度稍慢（固然只是相比较而言）；
三、由于是核心对象，并且能够命名，因此能够跨进程使用；
四、一般被用于 overlapped I/O 或被用来设计某些自定义的同步对象。线程

相关函数：设计

BOOL WINAPI SetEvent( __in HANDLE hEvent );  把event对象设置为激活状态

BOOL WINAPI ResetEvent( __in HANDLE hEvent );  把event对象设置为非激活状态

BOOL WINAPI PulseEvent( __in HANDLE hEvent ); 
若是是一我的工重置事件：把event对象设置为激活状态，唤醒“全部”等待中的线程，而后event恢复为非激活状态
若是是一个自动重置事件：把event对象设置为激活状态，唤醒 “一个”等待中的线程，而后event恢复为非激活状态

下面主要演示一下采用CreateEvent实现线程同步。指针

例子很简单，主要测试CreateEvent中bManualReset 和 bInitialState 参数的取值在线程调用中信号状态的状况。

一、bManualReset：TRUE
bInitialState：TRUE
CreateEvent(NULL, TRUE, TRUE, NULL); //人工重置事件：使用手动重置为无信号状态，初始化时有信号状态

#include <iostream> 
#include <windows.h> 
using namespace std;

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

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

int main(int argc, char *args[]) 
{ 
    
    hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); //使用手动重置为无信号状态，初始化时有信号状态 
    
    hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL); 
    hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL); 
    
    WaitForSingleObject( hThread1, INFINITE ); 
    WaitForSingleObject( hThread2,INFINITE );

    return 0; 
} 
DWORD WINAPI ThreadProc1(LPVOID lpParam) 
{

    if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
    { 
        cout <<"线程1被调用!\n"; 
        ResetEvent(hEvent);
    }

    return 0; 
} 
DWORD WINAPI ThreadProc2(LPVOID lpParam) 
{ 
    if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
    { 
        cout <<"线程2被调用!\n"; 
        ResetEvent(hEvent);
    } 
    return 0; 
}

二、bManualReset：TRUE
bInitialState：FALSE
CreateEvent(NULL, TRUE, FALSE, NULL);//人工重置事件：使用手动重置为无信号状态，初始化时为无信号状态

#include <iostream> 
#include <windows.h> 
using namespace std;

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

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

int main(int argc, char *args[]) 
{ 
    
    hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); //使用手动重置为无信号状态，初始化时无信号状态 
         
    hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0,NULL); 
    hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0,NULL); 
    
    WaitForSingleObject( hThread1, INFINITE ); 
    WaitForSingleObject( hThread2,INFINITE );

    return 0; 
} 
DWORD WINAPI ThreadProc1(LPVOID lpParam) 
{

    if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
    { 
        cout <<"线程1被调用!\n"; 
    }

    return 0; 
} 
DWORD WINAPI ThreadProc2(LPVOID lpParam) 
{ 
    if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
    { 
        cout <<"线程2被调用!\n"; 
    } 
    return 0; 
}

当建立手动重置事件时初始化为无信号 hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); 获得的结果是：

在hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); 以后添加

SetEvent( hEvent );设置为有信号，由于bManualReset为TRUE时，等待该事件的全部线程均变为可调度线程

当咱们在线程一中添加ResetEvent(hEvent);时运行程序发现线程1被调用，线程2没有被调用：

三、
bManualReset：FALSE
bInitialState：TRUE
CreateEvent(NULL, FALSE, TRUE, NULL); //自动重置事件：当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态

#include <iostream> 
#include <windows.h> 
using namespace std;

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

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

int main(int argc, char *args[]) 
{ 
    
    hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //使用自动重置为无信号状态，初始化时有信号状态 
    
    hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0,NULL); 
    hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0,NULL); 
    
    WaitForSingleObject( hThread1, INFINITE ); 
    WaitForSingleObject( hThread2,INFINITE );

    return 0; 
} 
DWORD WINAPI ThreadProc1(LPVOID lpParam) 
{

    if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
    { 
        cout <<"线程1被调用!\n"; 
    } 
    return 0; 
} 
DWORD WINAPI ThreadProc2(LPVOID lpParam) 
{ 
    if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
    { 
        cout <<"线程2被调用!\n"; 
    } 
    return 0; 
}

从结果能够看到线程1被调用，线程2一直在等待。因为CreateEvent(NULL, FALSE, TRUE, NULL)//使用自动重置为无信号状态，初始化时有信号状态

因此当线程1执行的时候hEvent是有信号的，线程1正常运行，又因为bManualReset为FALSE时：当一个等待线程被释放时，自动重置状态为无信号状态

所以线程2一直在等待，因为主线程加了WaitForSingleObject( hThread2,INFINITE ); 因此主线程也在一直等待

四、
bManualReset：FALSE
bInitialState：FALSE
CreateEvent(NULL, FALSE, FALSE, NULL);//自动重置事件：线程释放后自动重置为无信号状态，初始化时为无信号状态

#include <iostream> 
#include <windows.h> 
using namespace std;

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

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

int main(int argc, char *args[]) 
{ 
    
    hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); //使用自动重置为无信号状态，初始化时无信号状态 
    SetEvent(hEvent);

    hThread1 = CreateThread(NULL, 0, ThreadProc1, NULL, 0,NULL); 
    hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0,NULL); 
    
    WaitForSingleObject( hThread1, INFINITE ); 
    WaitForSingleObject( hThread2,INFINITE );

    return 0; 
} 
DWORD WINAPI ThreadProc1(LPVOID lpParam) 
{

    if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
    { 
        cout <<"线程1被调用!\n"; 
    } 
    return 0; 
} 
DWORD WINAPI ThreadProc2(LPVOID lpParam) 
{ 
    if ( WAIT_OBJECT_0 ==  WaitForSingleObject(hEvent,INFINITE) ) 
    { 
        cout <<"线程2被调用!\n"; 
    } 
    return 0; 
}

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

因为调用SetEvent，hEvent为有信号状态，线程1正常执行，又因为bManualReset为FALSE时：当一个等待线程被释放时，自动重置状态为无信号状态，调用完线程1后，hEvent自动重置为无信号状态，因此线程2只能在等待