zoukankan      html  css  js  c++  java

  • 转--- 秒杀多线程第六篇 经典线程同步 事件Event

    阅读本篇之前推荐阅读以下姊妹篇：

    《秒杀多线程第四篇 一个经典的多线程同步问题》

    《秒杀多线程第五篇 经典线程同步关键段CS》

     

    上一篇中使用关键段来解决经典的多线程同步互斥问题，由于关键段的“线程所有权”特性所以关键段只能用于线程的互斥而不能用于同步。本篇介绍用事件Event来尝试解决这个线程同步问题。

    首先介绍下如何使用事件。事件Event实际上是个内核对象，它的使用非常方便。下面列出一些常用的函数。

     

    第一个 CreateEvent

    函数功能：创建事件

    函数原型：

    HANDLECreateEvent(

     LPSECURITY_ATTRIBUTESlpEventAttributes,

     BOOLbManualReset,

     BOOLbInitialState,

     LPCTSTRlpName

    );

    函数说明：

    第一个参数表示安全控制，一般直接传入NULL。

    第二个参数确定事件是手动置位还是自动置位，传入TRUE表示手动置位，传入FALSE表示自动置位。如果为自动置位，则对该事件调用WaitForSingleObject()后会自动调用ResetEvent()使事件变成未触发状态。打个小小比方，手动置位事件相当于教室门，教室门一旦打开（被触发），所以有人都可以进入直到老师去关上教室门（事件变成未触发）。自动置位事件就相当于医院里拍X光的房间门，门打开后只能进入一个人，这个人进去后会将门关上，其它人不能进入除非门重新被打开（事件重新被触发）。

    第三个参数表示事件的初始状态，传入TRUR表示已触发。

    第四个参数表示事件的名称，传入NULL表示匿名事件。

     

    第二个 OpenEvent

    函数功能：根据名称获得一个事件句柄。

    函数原型：

    HANDLEOpenEvent(

     DWORDdwDesiredAccess,

     BOOLbInheritHandle,

     LPCTSTRlpName     //名称

    );

    函数说明：

    第一个参数表示访问权限，对事件一般传入EVENT_ALL_ACCESS。详细解释可以查看MSDN文档。

    第二个参数表示事件句柄继承性，一般传入TRUE即可。

    第三个参数表示名称，不同进程中的各线程可以通过名称来确保它们访问同一个事件。

     

    第三个SetEvent

    函数功能：触发事件

    函数原型：BOOLSetEvent(HANDLEhEvent);

    函数说明：每次触发后，必有一个或多个处于等待状态下的线程变成可调度状态。

     

    第四个ResetEvent

    函数功能：将事件设为末触发

    函数原型：BOOLResetEvent(HANDLEhEvent);

     

    最后一个事件的清理与销毁

    由于事件是内核对象，因此使用CloseHandle()就可以完成清理与销毁了。

     

    在经典多线程问题中设置一个事件和一个关键段。用事件处理主线程与子线程的同步，用关键段来处理各子线程间的互斥。详见代码：

    [cpp] view plaincopy
    1. #include <stdio.h>  
    2. #include <process.h>  
    3. #include <windows.h>  
    4. long g_nNum;  
    5. unsigned int __stdcall Fun(void *pPM);  
    6. const int THREAD_NUM = 10;  
    7. //事件与关键段  
    8. HANDLE  g_hThreadEvent;  
    9. CRITICAL_SECTION g_csThreadCode;  
    10. int main()  
    11. {  
    12.     printf("     经典线程同步 事件Event ");  
    13.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) -- ");  
    14.     //初始化事件和关键段 自动置位,初始无触发的匿名事件  
    15.     g_hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);   
    16.     InitializeCriticalSection(&g_csThreadCode);  
    17.   
    18.     HANDLE  handle[THREAD_NUM];   
    19.     g_nNum = 0;  
    20.     int i = 0;  
    21.     while (i < THREAD_NUM)   
    22.     {  
    23.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);  
    24.         WaitForSingleObject(g_hThreadEvent, INFINITE); //等待事件被触发  
    25.         i++;  
    26.     }  
    27.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  
    28.   
    29.     //销毁事件和关键段  
    30.     CloseHandle(g_hThreadEvent);  
    31.     DeleteCriticalSection(&g_csThreadCode);  
    32.     return 0;  
    33. }  
    34. unsigned int __stdcall Fun(void *pPM)  
    35. {  
    36.     int nThreadNum = *(int *)pPM;   
    37.     SetEvent(g_hThreadEvent); //触发事件  
    38.       
    39.     Sleep(50);//some work should to do  
    40.       
    41.     EnterCriticalSection(&g_csThreadCode);  
    42.     g_nNum++;  
    43.     Sleep(0);//some work should to do  
    44.     printf("线程编号为%d  全局资源值为%d ", nThreadNum, g_nNum);   
    45.     LeaveCriticalSection(&g_csThreadCode);  
    46.     return 0;  
    47. }  

    运行结果如下图：

    可以看出来，经典线线程同步问题已经圆满的解决了——线程编号的输出没有重复，说明主线程与子线程达到了同步。全局资源的输出是递增的，说明各子线程已经互斥的访问和输出该全局资源。

     

    现在我们知道了如何使用事件，但学习就应该要深入的学习，何况微软给事件还提供了PulseEvent()函数，所以接下来再继续深挖下事件Event，看看它还有什么秘密没。

    先来看看这个函数的原形：

    第五个PulseEvent

    函数功能：将事件触发后立即将事件设置为未触发，相当于触发一个事件脉冲。

    函数原型：BOOLPulseEvent(HANDLEhEvent);

    函数说明：这是一个不常用的事件函数，此函数相当于SetEvent()后立即调用ResetEvent();此时情况可以分为两种：

    1.对于手动置位事件，所有正处于等待状态下线程都变成可调度状态。

    2.对于自动置位事件，所有正处于等待状态下线程只有一个变成可调度状态。

    此后事件是末触发的。该函数不稳定，因为无法预知在调用PulseEvent ()时哪些线程正处于等待状态。

     

           下面对这个触发一个事件脉冲PulseEvent ()写一个例子，主线程启动7个子线程，其中有5个线程Sleep(10)后对一事件调用等待函数（称为快线程），另有2个线程Sleep(100)后也对该事件调用等待函数（称为慢线程）。主线程启动所有子线程后再Sleep(50)保证有5个快线程都正处于等待状态中。此时若主线程触发一个事件脉冲，那么对于手动置位事件，这5个线程都将顺利执行下去。对于自动置位事件，这5个线程中会有中一个顺利执行下去。而不论手动置位事件还是自动置位事件，那2个慢线程由于Sleep(100)所以会错过事件脉冲，因此慢线程都会进入等待状态而无法顺利执行下去。

    代码如下：

    [cpp] view plaincopy
    1. //使用PluseEvent()函数  
    2. #include <stdio.h>  
    3. #include <conio.h>  
    4. #include <process.h>  
    5. #include <windows.h>  
    6. HANDLE  g_hThreadEvent;  
    7. //快线程  
    8. unsigned int __stdcall FastThreadFun(void *pPM)  
    9. {  
    10.     Sleep(10); //用这个来保证各线程调用等待函数的次序有一定的随机性  
    11.     printf("%s 启动 ", (PSTR)pPM);  
    12.     WaitForSingleObject(g_hThreadEvent, INFINITE);  
    13.     printf("%s 等到事件被触发 顺利结束 ", (PSTR)pPM);  
    14.     return 0;  
    15. }  
    16. //慢线程  
    17. unsigned int __stdcall SlowThreadFun(void *pPM)  
    18. {  
    19.     Sleep(100);  
    20.     printf("%s 启动 ", (PSTR)pPM);  
    21.     WaitForSingleObject(g_hThreadEvent, INFINITE);  
    22.     printf("%s 等到事件被触发 顺利结束 ", (PSTR)pPM);  
    23.     return 0;  
    24. }  
    25. int main()  
    26. {  
    27.     printf("  使用PluseEvent()函数 ");  
    28.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) -- ");  
    29.   
    30.     BOOL bManualReset = FALSE;  
    31.     //创建事件 第二个参数手动置位TRUE，自动置位FALSE  
    32.     g_hThreadEvent = CreateEvent(NULL, bManualReset, FALSE, NULL);  
    33.     if (bManualReset == TRUE)  
    34.         printf("当前使用手动置位事件 ");  
    35.     else  
    36.         printf("当前使用自动置位事件 ");  
    37.   
    38.     char szFastThreadName[5][30] = {"快线程1000", "快线程1001", "快线程1002", "快线程1003", "快线程1004"};  
    39.     char szSlowThreadName[2][30] = {"慢线程196", "慢线程197"};  
    40.   
    41.     int i;  
    42.     for (i = 0; i < 5; i++)  
    43.         _beginthreadex(NULL, 0, FastThreadFun, szFastThreadName[i], 0, NULL);  
    44.     for (i = 0; i < 2; i++)  
    45.         _beginthreadex(NULL, 0, SlowThreadFun, szSlowThreadName[i], 0, NULL);  
    46.       
    47.     Sleep(50); //保证快线程已经全部启动  
    48.     printf("现在主线程触发一个事件脉冲 - PulseEvent() ");  
    49.     PulseEvent(g_hThreadEvent);//调用PulseEvent()就相当于同时调用下面二句  
    50.     //SetEvent(g_hThreadEvent);  
    51.     //ResetEvent(g_hThreadEvent);  
    52.       
    53.     Sleep(3000);   
    54.     printf("时间到，主线程结束运行 ");  
    55.     CloseHandle(g_hThreadEvent);  
    56.     return 0;  
    57. }  

    对自动置位事件，运行结果如下：

    对手动置位事件，运行结果如下：

     

     

    最后总结下事件Event

    1．事件是内核对象，事件分为手动置位事件和自动置位事件。事件Event内部它包含一个使用计数（所有内核对象都有），一个布尔值表示是手动置位事件还是自动置位事件，另一个布尔值用来表示事件有无触发。

    2．事件可以由SetEvent()来触发，由ResetEvent()来设成未触发。还可以由PulseEvent()来发出一个事件脉冲。

    3．事件可以解决线程间同步问题，因此也能解决互斥问题。

     

    后面二篇《秒杀多线程第七篇 经典线程同步 互斥量Mutex》和《秒杀多线程第八篇 经典线程同步 信号量Semaphore》将介绍如何使用互斥量和信号量来解决这个经典线程同步问题。欢迎大家继续秒杀多线程之旅。
  • 相关阅读:
    团队项目-第一阶段冲刺7
    团队项目-第一阶段冲刺6
    Spring Boot 揭秘与实战（七） 实用技术篇
    Spring Boot 揭秘与实战（七） 实用技术篇
    Spring Boot 揭秘与实战（六） 消息队列篇
    Spring Boot 揭秘与实战（五） 服务器篇
    Spring Boot 揭秘与实战（五） 服务器篇
    Spring Boot 揭秘与实战（五） 服务器篇
    Spring Boot 揭秘与实战（五） 服务器篇
    Spring Boot 揭秘与实战（四） 配置文件篇
  • 原文地址：https://www.cnblogs.com/deman/p/4075803.html
Copyright © 2011-2022 走看看