秒杀多线程第十四篇 关键段,事件,互斥量,信号量的“遗弃”问题

时间：2022-10-27 14:43:11
 秒杀多线程第十四篇 关键段,事件,互斥量,信号量的“遗弃”问题

在《秒杀多线程第九篇 经典线程同步总结 关键段 事件 互斥量 信号量》中对经典多线程同步互斥问题进行了回顾和总结，这篇文章对Windows系统下常用的线程同步互斥机制——关键段、事件、互斥量、信号量进行了总结。有网友问到互斥量能处理“遗弃”问题，事件和信号量是否也能处理“遗弃”问题。因此本文将对事件和信号量作个试验，看看事件和信号量能否处理“遗弃”问题。

 

一.什么是“遗弃”问题

在《秒杀多线程第七篇 经典线程同步 互斥量Mutex》讲到了互斥量能处理“遗弃”问题，下面引用原文：

互斥量常用于多进程之间的线程互斥，所以它比关键段还多一个很有用的特性——“遗弃”情况的处理。比如有一个占用互斥量的线程在调用ReleaseMutex()触发互斥量前就意外终止了（相当于该互斥量被“遗弃”了），那么所有等待这个互斥量的线程是否会由于该互斥量无法被触发而陷入一个无穷的等待过程中了？这显然不合理。因为占用某个互斥量的线程既然终止了那足以证明它不再使用被该互斥量保护的资源，所以这些资源完全并且应当被其它线程来使用。因此在这种“遗弃”情况下，系统自动把该互斥量内部的线程ID设置为0，并将它的递归计数器复置为0，表示这个互斥量被触发了。然后系统将“公平地”选定一个等待线程来完成调度（被选中的线程的WaitForSingleObject()会返回WAIT_ABANDONED_0）。

可见“遗弃”问题就是——占有某种资源的进程意外终止后，其它等待该资源的进程能否感知。

 

二．关键段的“遗弃”问题

关键段在这个问题上很简单——由于关键段不能跨进程使用，所以关键段不需要处理“遗弃”问题。

 

三．事件，互斥量，信号量的“遗弃”问题

事件，互斥量，信号量都是内核对象，可以跨进程使用。一个进程在创建一个命名的事件后，其它进程可以调用OpenEvent()并传入事件的名称来获得这个事件的句柄。因此事件，互斥量和信号量都会遇到“遗弃”问题。我们已经知道互斥量能够处理“遗弃”问题，接下来就来看看事件和信号量是否能够处理“遗弃”问题。类似于《秒杀多线程第七篇 经典线程同步互斥量Mutex》对互斥量所做的试验，下面也对事件和信号量作同样的试验：

1． 创建二个进程。

2． 进程一创建一个初始为未触发的事件，然后等待按键，按下y则触发事件后结束进程，否则直接退出表示进程一已意外终止。

3． 进程二先获得事件的句柄，然后调用WaitForSingleObject()等待这个事件10秒，在这10秒内如果事件已经触发则输出“已收到信号”，否则输出“未在规定的时间内收到信号”。如果在等待的过程中进程一意外终止，则输出“拥有事件的进程意外终止”。信号量的试验方法类似。

为了加强对比效果，将互斥量的试验结果先展示出来（代码请参见《秒杀多线程第七篇经典线程同步 互斥量Mutex》）

秒杀多线程第十四篇 关键段,事件,互斥量,信号量的“遗弃”问题

可以看出在第一个进程在没有触发互斥量就直接退出的情况下，等待这个互斥量的第二个进程是能够感知进程一所发生的意外终止的。

接下来就先完成事件的“遗弃”问题试验代码。

进程一：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <conio.h>  
  3. #include <windows.h>  
  4. const TCHAR STR_EVENT_NAME[] = TEXT("Event_MoreWindows");  
  5. int main()  
  6. {  
  7.     printf("     经典线程同步 事件的遗弃处理  进程一\n");    
  8.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");    
  9.     HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, STR_EVENT_NAME);//自动置位 当前未触发  
  10.     printf("事件已经创建，现在按y触发事件，按其它键终止进程\n");  
  11.     char ch;  
  12.     scanf("%c", &ch);  
  13.     if (ch != 'y')  
  14.         exit(0); //表示进程意外终止  
  15.     SetEvent(hEvent);  
  16.     printf("事件已经触发\n");  
  17.     CloseHandle(hEvent);  
  18.     return 0;  
  19. }  

进程二：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <windows.h>  
  3. const TCHAR STR_EVENT_NAME[] = TEXT("Event_MoreWindows");  
  4. int main()  
  5. {  
  6.     printf("     经典线程同步 事件的遗弃处理  进程二\n");    
  7.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");    
  8.   
  9.     HANDLE hEvent = OpenEvent(EVENT_ALL_ACCESS, TRUE, STR_EVENT_NAME); //打开事件  
  10.     if (hEvent == NULL)  
  11.     {  
  12.         printf("打开事件失败\n");  
  13.         return 0;  
  14.     }  
  15.     printf(" 等待中....\n");  
  16.     DWORD dwResult = WaitForSingleObject(hEvent, 10 * 1000); //等待事件被触发  
  17.     switch (dwResult)  
  18.     {  
  19.     case WAIT_ABANDONED:  
  20.         printf("拥有事件的进程意外终止\n");  
  21.         break;  
  22.   
  23.     case WAIT_OBJECT_0:  
  24.         printf("已经收到信号\n");  
  25.         break;  
  26.   
  27.     case WAIT_TIMEOUT:  
  28.         printf("未在规定的时间内收到信号\n");  
  29.         break;  
  30.     }  
  31.     CloseHandle(hEvent);  
  32.     return 0;  
  33. }  

事件Event试验结果1-进程一触发事件后正常结束：

秒杀多线程第十四篇 关键段,事件,互斥量,信号量的“遗弃”问题

事件Event试验结果2-进程一意外终止：

秒杀多线程第十四篇 关键段,事件,互斥量,信号量的“遗弃”问题

可以看出进程二没能感知进程一意外终止，说明事件不能处理“遗弃”问题。

 

下面再来试下信号量。

信号量的“遗弃”问题试验代码：

进程一：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <conio.h>  
  3. #include <windows.h>  
  4. const TCHAR STR_SEMAPHORE_NAME[] = TEXT("Semaphore_MoreWindows");  
  5. int main()  
  6. {  
  7.     printf("     经典线程同步 信号量的遗弃处理  进程一\n");    
  8.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");    
  9.   
  10.     HANDLE hSemaphore = CreateSemaphore(NULL, 0, 1, STR_SEMAPHORE_NAME);//当前0个资源，最大允许1个同时访问  
  11.     printf("信号量已经创建，现在按y触发信号量，按其它键终止进程\n");  
  12.     char ch;  
  13.     scanf("%c", &ch);  
  14.     if (ch != 'y')  
  15.         exit(0); //表示进程意外终止  
  16.     ReleaseSemaphore(hSemaphore, 1, NULL);  
  17.     printf("信号量已经触发\n");  
  18.     CloseHandle(hSemaphore);  
  19.     return 0;  
  20. }  

进程二：

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <windows.h>  
  3. const TCHAR STR_SEMAPHORE_NAME[] = TEXT("Semaphore_MoreWindows");  
  4. int main()  
  5. {  
  6.     printf("     经典线程同步 信号量的遗弃处理  进程二\n");    
  7.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");    
  8.   
  9.     HANDLE hSemaphore = OpenSemaphore (SEMAPHORE_ALL_ACCESS, TRUE, STR_SEMAPHORE_NAME); //打开信号量  
  10.     if (hSemaphore == NULL)  
  11.     {  
  12.         printf("打开信号量失败\n");  
  13.         return 0;  
  14.     }  
  15.     printf(" 等待中....\n");  
  16.     DWORD dwResult = WaitForSingleObject(hSemaphore, 10 * 1000); //等待信号量被触发  
  17.     switch (dwResult)  
  18.     {  
  19.     case WAIT_ABANDONED:  
  20.         printf("拥有信号量的进程意外终止\n");  
  21.         break;  
  22.   
  23.     case WAIT_OBJECT_0:  
  24.         printf("已经收到信号\n");  
  25.         break;  
  26.   
  27.     case WAIT_TIMEOUT:  
  28.         printf("未在规定的时间内收到信号\n");  
  29.         break;  
  30.     }  
  31.     CloseHandle(hSemaphore);  
  32.     return 0;  
  33. }  

信号量Semaphore试验结果1-进程一触发信号量后正常结束

秒杀多线程第十四篇 关键段,事件,互斥量,信号量的“遗弃”问题

信号量Semaphore试验结果2-进程一意外终止

秒杀多线程第十四篇 关键段,事件,互斥量,信号量的“遗弃”问题

可以看出进程二没能感知进程一意外终止，说明信号量与事件一样都不能处理“遗弃”问题。

 

四．“遗弃”问题总结

由本文所做的试验可知，互斥量能够处理“遗弃”情况，事件与信号量都无法解决这一情况。

再思考下互斥量能处理“遗弃”问题的原因，其实正是因为它有“线程所有权”概念。在系统中一旦有线程结束后，系统会判断是否有互斥量被这个线程占有，如果有，系统会将这互斥量对象内部的线程ID号将设置为NULL，递归计数设置为0，这表示该互斥量已经不为任何线程占用，处于触发状态。其它等待这个互斥量的线程就能顺利执行下去了。至于线程如何获取互斥量的“线程所有权”，MSDN上介绍为——A thread obtainsownership of a mutex either by creating it with the bInitialOwnerparameter set to TRUE or by specifying its handle in a call toone of the wait functions.
标签：

相关文章