Windows环境下多线程编程原理与应用读书笔记（7）————事件及其应用

<一>事件

事件主要用于线程间传递消息，通过事件来控制一个线程是处于执行状态还是处于挂起状态。

事件和互斥量之间的差别：

1. 事件主要用于协调两个或者多个线程之间的动作，使其协调一致，符合逻辑。一个线程等待某个事件的发生，另一个线程则在事件发生后产生一个信号，通知那个正在等待的线程（我的理解：线程A等待键盘输入，线程B在有键盘输入后发送一个信号给A，使得A可以执行，事件就是“键盘输入”）。
2. 互斥量主要是为了保证在任何时刻只有一个线程在使用共享资源，线程的运行次序是随机的，有操作系统决定，因此互斥量不能使两个线程按一定的顺序执行。
3. 互斥量有信号状态是指线程正在拥有该互斥量，无信号是指没有线程拥有这个互斥量；对事件来说，当等待的事件发生时，事件对象处于活动状态，叫有信号状态，相反的，当等待的事件没有发生时，事件对象处于无信号状态。
4. 事件一般分为两种：手动事件和自动事件。手动事件是指当事件对象处于活动状态时它会一直处于这个状态，直到显示地将其置为无信号状态；自动事件是指当事件处于有信号状态并有一个线程接收到该事件后，事件立即变为无信号状态。

<二>与事件有关的函数

函数名	作用
CreateEvent	创建一个事件
OpenEvent	打开一个已经创建的事件
SetEvent	触发一个事件
ResetEvent	复位一个事件
PulseEvent	触发并重置一个事件
WaitForSingleObject	等待单个事件
WaitForMultipleObject	等待多个事件

#include <windows.h>
#include <process.h> /* _beginthread, _endthread */
#include <iostream>
#include <fstream>
using namespace std;

HANDLE hEvent;

unsigned long _stdcall MyThread1(LPVOID lpParam)
{
    cout<<"Wait for event\n";
    WaitForSingleObject(hEvent,INFINITE);
    cout<<"Get the event\n";
    return ;
}

unsigned long _stdcall MyThread2(LPVOID lpParam)
{
    Sleep();
    cout<<"Signal the event\n";
    SetEvent(hEvent);
    return ;
}

int main()
{
    HANDLE handle1,handle2;
    DWORD dw1,dw2;
    hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
    handle1 =CreateThread(NULL,NULL,MyThread1,NULL,NULL,&dw1);
    handle2 =CreateThread(NULL,NULL,MyThread2,NULL,NULL,&dw2);

    Sleep();

    CloseHandle(handle1);
    CloseHandle(handle2);
    CloseHandle(hEvent);

    return ;
}

再看一个难一点的例子：两个读线程，一个写线程。

#include <windows.h>
#include <process.h> /* _beginthread, _endthread */
#include <iostream>
#include <fstream>
using namespace std;

HANDLE hWriteEvent;
HANDLE hReadEvent[];

int buff[];

CRITICAL_SECTION cs;
BOOL isRunning = true;

unsigned long _stdcall WriteThread(LPVOID lpParam)
{
    hWriteEvent = CreateEvent(NULL,TRUE,FALSE,NULL);//创建一个写事件，并处于有信号状态
    int k = ;
    while (isRunning)
    {
        if(WAIT_OBJECT_0==WaitForMultipleObjects(,hReadEvent,true,))
        {
            for (int i = ;i<;i++)
            {
                buff[i]=(i+)*k;
            }
            k++;
            PulseEvent(hWriteEvent);
        }
    }
    return ;
}

unsigned long _stdcall ReadThread1(LPVOID lpParam)
{
    hReadEvent[] = CreateEvent(NULL,FALSE,TRUE,NULL);
    while (isRunning)
    {
        WaitForSingleObject(hWriteEvent,INFINITE);
        EnterCriticalSection(&cs);
        cout<<"Print from Thread #1:";
        for (int i = ;i<;i++)
            cout<<buff[i]<<"  ";

        cout<<endl;
        LeaveCriticalSection(&cs);
        SetEvent(hReadEvent[]);

    }
    return ;
}

unsigned long _stdcall ReadThread2(LPVOID lpParam)
{
    hReadEvent[] = CreateEvent(NULL,FALSE,TRUE,NULL);
    while (isRunning)
    {
        WaitForSingleObject(hWriteEvent,INFINITE);
        EnterCriticalSection(&cs);
        cout<<"Print from Thread #2:";
        for (int i = ;i<;i++)
            cout<<buff[i]<<"  ";

        cout<<endl;
        LeaveCriticalSection(&cs);
        SetEvent(hReadEvent[]);

    }
    return ;
}

unsigned long _stdcall ControlThread(LPVOID lpParam)
{
    isRunning = FALSE;
    return ;
}

int main()
{
    HANDLE handle1,handle2,handle3,handle4;
    DWORD dw1,dw2,dw3,dw4;
    InitializeCriticalSection(&cs);

    handle1 = CreateThread(NULL,,WriteThread,NULL,,&dw1);
    handle2 = CreateThread(NULL,,ReadThread1,NULL,,&dw2);
    handle3 = CreateThread(NULL,,ReadThread2,NULL,,&dw3);
    Sleep();
    handle4 = CreateThread(NULL,,ControlThread,NULL,,&dw4);

    CloseHandle(handle1);
    CloseHandle(handle2);
    CloseHandle(handle3);
    CloseHandle(handle4);
    CloseHandle(hWriteEvent);
    CloseHandle(hReadEvent[]);
    CloseHandle(hReadEvent[]);

    return ;
}