12.[个人]C++线程入门到进阶(12)----读者写者问题&读写锁SRWLock

与上一篇《秒杀多线程第十篇 生产者消费者问题》的生产者消费者问题一样,读者写者也是一个非常著名的同步问题。读者写者问题描述非常简单,有一个写者很多读者,多个读者可以同时读文件,但写者在写文件时不允许有读者在读文件,同样有读者在读文件时写者也不去能写文件。

上面是读者写者问题示意图,类似于生产者消费者问题的分析过程,首先来找找哪些是属于“等待”情况。

第一.写者要等到没有读者时才能去写文件。

第二.所有读者要等待写者完成写文件后才能去读文件。

找完“等待”情况后,再看看有没有要互斥访问的资源。由于只有一个写者而读者们是可以共享的读文件,所以按题目要求并没有需要互斥访问的资源。类似于上一篇中美观的彩色输出,我们对生产者输出代码进行了颜色设置(在控制台输出颜色设置参见《VC 控制台颜色设置》)。因此在这里要加个互斥访问,不然很有可能在写者线程将控制台颜色设置还原之前,读者线程就已经有输出了。所以要对输出语句作个互斥访问处理,修改后的读者及写者的输出函数如下所示:

[cpp] view plain copy
  1. //读者线程输出函数  
  2. void ReaderPrintf(char *pszFormat, ...)  
  3. {  
  4.     va_list   pArgList;  
  5.     va_start(pArgList, pszFormat);  
  6.     EnterCriticalSection(&g_cs);  
  7.     vfprintf(stdout, pszFormat, pArgList);  
  8.     LeaveCriticalSection(&g_cs);  
  9.     va_end(pArgList);  
  10. }  
  11. //写者线程输出函数  
  12. void WriterPrintf(char *pszStr)  
  13. {  
  14.     EnterCriticalSection(&g_cs);  
  15.     SetConsoleColor(FOREGROUND_GREEN);  
  16.     printf("     %s\n", pszStr);  
  17.     SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);  
  18.     LeaveCriticalSection(&g_cs);  
  19. }  

读者线程输出函数所使用的可变参数详见《C,C++中使用可变参数》。

       解决了互斥输出问题,接下来再考虑如何实现同步问题。可以设置一个变量来记录正在读文件的读者个数,第一个开始读文件的读者要负责将关闭允许写者进入的标志,最后一个结束读文件的读者要负责打开允许写者进入的标志。这样第一种“等待”情况就解决了。第二种“等待”情况是有写者进入时所以读者不能进入,使用一个事件就可以完成这个任务了——所有读者都要等待这个事件而写者负责触发事件和设置事件为未触发。详细见代码中注释:

[cpp] view plain copy
  1. //读者与写者问题  
  2. #include <stdio.h>  
  3. #include <process.h>  
  4. #include <windows.h>  
  5. //设置控制台输出颜色  
  6. BOOL SetConsoleColor(WORD wAttributes)  
  7. {  
  8.     HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);  
  9.     if (hConsole == INVALID_HANDLE_VALUE)  
  10.         return FALSE;  
  11.       
  12.     return SetConsoleTextAttribute(hConsole, wAttributes);  
  13. }  
  14. const int READER_NUM = 5;  //读者个数  
  15. //关键段和事件  
  16. CRITICAL_SECTION g_cs, g_cs_writer_count;  
  17. HANDLE g_hEventWriter, g_hEventNoReader;  
  18. int g_nReaderCount;  
  19. //读者线程输出函数(变参函数的实现)  
  20. void ReaderPrintf(char *pszFormat, ...)  
  21. {  
  22.     va_list   pArgList;  
  23.       
  24.     va_start(pArgList, pszFormat);  
  25.     EnterCriticalSection(&g_cs);  
  26.     vfprintf(stdout, pszFormat, pArgList);  
  27.     LeaveCriticalSection(&g_cs);  
  28.     va_end(pArgList);  
  29. }  
  30. //读者线程函数  
  31. unsigned int __stdcall ReaderThreadFun(PVOID pM)  
  32. {  
  33.     ReaderPrintf("     编号为%d的读者进入等待中...\n", GetCurrentThreadId());  
  34.     //等待写者完成  
  35.     WaitForSingleObject(g_hEventWriter, INFINITE);  
  36.   
  37.     //读者个数增加  
  38.     EnterCriticalSection(&g_cs_writer_count);  
  39.     g_nReaderCount++;  
  40.     if (g_nReaderCount == 1)  
  41.         ResetEvent(g_hEventNoReader);  
  42.     LeaveCriticalSection(&g_cs_writer_count);  
  43.   
  44.     //读取文件  
  45.     ReaderPrintf("编号为%d的读者开始读取文件...\n", GetCurrentThreadId());  
  46.   
  47.     Sleep(rand() % 100);  
  48.   
  49.     //结束阅读,读者个数减小,空位增加  
  50.     ReaderPrintf(" 编号为%d的读者结束读取文件\n", GetCurrentThreadId());  
  51.   
  52.     //读者个数减少  
  53.     EnterCriticalSection(&g_cs_writer_count);  
  54.     g_nReaderCount--;  
  55.     if (g_nReaderCount == 0)  
  56.         SetEvent(g_hEventNoReader);  
  57.     LeaveCriticalSection(&g_cs_writer_count);  
  58.   
  59.     return 0;  
  60. }  
  61. //写者线程输出函数  
  62. void WriterPrintf(char *pszStr)  
  63. {  
  64.     EnterCriticalSection(&g_cs);  
  65.     SetConsoleColor(FOREGROUND_GREEN);  
  66.     printf("     %s\n", pszStr);  
  67.     SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);  
  68.     LeaveCriticalSection(&g_cs);  
  69. }  
  70. //写者线程函数  
  71. unsigned int __stdcall WriterThreadFun(PVOID pM)  
  72. {  
  73.     WriterPrintf("写者线程进入等待中...");  
  74.     //等待读文件的读者为零  
  75.     WaitForSingleObject(g_hEventNoReader, INFINITE);  
  76.     //标记写者正在写文件  
  77.     ResetEvent(g_hEventWriter);  
  78.           
  79.     //写文件  
  80.     WriterPrintf("  写者开始写文件.....");  
  81.     Sleep(rand() % 100);  
  82.     WriterPrintf("  写者结束写文件");  
  83.   
  84.     //标记写者结束写文件  
  85.     SetEvent(g_hEventWriter);  
  86.     return 0;  
  87. }  
  88. int main()  
  89. {  
  90.     printf("  读者写者问题\n");  
  91.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
  92.   
  93.     //初始化事件和信号量  
  94.     InitializeCriticalSection(&g_cs);  
  95.     InitializeCriticalSection(&g_cs_writer_count);  
  96.   
  97.     //手动置位,初始已触发  
  98.     g_hEventWriter = CreateEvent(NULL, TRUE, TRUE, NULL);  
  99.     g_hEventNoReader  = CreateEvent(NULL, FALSE, TRUE, NULL);  
  100.     g_nReaderCount = 0;  
  101.   
  102.     int i;  
  103.     HANDLE hThread[READER_NUM + 1];  
  104.     //先启动二个读者线程  
  105.     for (i = 1; i <= 2; i++)  
  106.         hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);  
  107.     //启动写者线程  
  108.     hThread[0] = (HANDLE)_beginthreadex(NULL, 0, WriterThreadFun, NULL, 0, NULL);  
  109.     Sleep(50);  
  110.     //最后启动其它读者结程  
  111.     for ( ; i <= READER_NUM; i++)  
  112.         hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);  
  113.     WaitForMultipleObjects(READER_NUM + 1, hThread, TRUE, INFINITE);  
  114.     for (i = 0; i < READER_NUM + 1; i++)  
  115.         CloseHandle(hThread[i]);  
  116.   
  117.     //销毁事件和信号量  
  118.     CloseHandle(g_hEventWriter);  
  119.     CloseHandle(g_hEventNoReader);  
  120.     DeleteCriticalSection(&g_cs);  
  121.     DeleteCriticalSection(&g_cs_writer_count);  
  122.     return 0;  
  123. }  

运行结果如下所示:

根据结果可以看出当有读者在读文件时,写者线程会进入等待状态中。当写者线程在写文件时,读者线程也会排队等待,说明读者和写者已经完成了同步。

 

本系列通过经典线程同步问题来列举线程同步手段的关键段事件互斥量信号量,并作对这四种方法进行了总结。然后又通过二个著名的线程同步实例——生产者消费者问题读者写者问题来强化对多线程同步互斥的理解与运用。希望读者们能够熟练掌握,从而在笔试面试中能够顺利的“秒杀”多线程的相关试题,获得自己满意的offer

 

从《秒杀多线程第十篇生产者消费者问题》到《秒杀多线程第十一篇读者写者问题》可以得出多线程问题的关键在于找到所有“等待”情况和判断有无需要互斥访问的资源。那么如何从实际问题中更好更快更全面的找出这些了?请看《秒杀多线程第十二篇多线程同步内功心法——PV操作上》和《秒杀多线程第十三篇多线程同步内功心法——PV操作下》这二篇以加强解决多线程同步问题的“内功”。  

---------------------------------------------------------------------------------------------------------------

    在《秒杀多线程第十一篇读者写者问题》文章中我们使用事件和一个记录读者个数的变量来解决读者写者问题。问题虽然得到了解决,但代码有点复杂。本篇将介绍一种新方法——读写锁SRWLock来解决这一问题。读写锁在对资源进行保护的同时,还能区分想要读取资源值的线程(读取者线程)和想要更新资源的线程(写入者线程)。对于读取者线程,读写锁会允许他们并发的执行。当有写入者线程在占有资源时,读写锁会让其它写入者线程和读取者线程等待。因此用读写锁来解决读者写者问题会使代码非常清晰和简洁。

 

    下面就来看看如何使用读写锁,要注意编译读写锁程序需要VS2008,运行读写锁程序要在VistaWindows Server2008系统(比这两个更高级的系统也可以)。读写锁的主要函数就五个,分为初始化函数,写入者线程申请和释放函数,读取者线程申请和释放函数,以下是详细的函数使用说明:

第一个 InitializeSRWLock

函数功能:初始化读写锁

函数原型:VOID InitializeSRWLock(PSRWLOCK SRWLock);

函数说明:初始化(没有删除或销毁SRWLOCK的函数,系统会自动清理)

 

第二个 AcquireSRWLockExclusive

函数功能:写入者线程申请写资源。

函数原型:VOID AcquireSRWLockExclusive(PSRWLOCK SRWLock);

 

第三个 ReleaseSRWLockExclusive

函数功能:写入者线程写资源完毕,释放对资源的占用。

函数原型:VOID ReleaseSRWLockExclusive(PSRWLOCK SRWLock);

 

第四个 AcquireSRWLockShared

函数功能:读取者线程申请读资源。

函数原型:VOID AcquireSRWLockShared(PSRWLOCK SRWLock);

 

第五个 ReleaseSRWLockShared

函数功能:读取者线程结束读取资源,释放对资源的占用。

函数原型:VOID ReleaseSRWLockShared(PSRWLOCK SRWLock);

 

注意一个线程仅能锁定资源一次,不能多次锁定资源。

 

使用读写锁精简后的代码如下(代码中变参函数的实现请参阅《C,C++中使用可变参数》,控制台颜色设置请参阅《VC 控制台颜色设置》):

[cpp] view plain copy
  1. //读者与写者问题继 读写锁SRWLock  
  2. #include <stdio.h>  
  3. #include <process.h>  
  4. #include <windows.h>  
  5. //设置控制台输出颜色  
  6. BOOL SetConsoleColor(WORD wAttributes)  
  7. {  
  8.     HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);  
  9.     if (hConsole == INVALID_HANDLE_VALUE)  
  10.         return FALSE;  
  11.     return SetConsoleTextAttribute(hConsole, wAttributes);  
  12. }  
  13. const int READER_NUM = 5;  //读者个数  
  14. //关键段和事件  
  15. CRITICAL_SECTION g_cs;  
  16. SRWLOCK          g_srwLock;   
  17. //读者线程输出函数(变参函数的实现)  
  18. void ReaderPrintf(char *pszFormat, ...)  
  19. {  
  20.     va_list   pArgList;  
  21.     va_start(pArgList, pszFormat);  
  22.     EnterCriticalSection(&g_cs);  
  23.     vfprintf(stdout, pszFormat, pArgList);  
  24.     LeaveCriticalSection(&g_cs);  
  25.     va_end(pArgList);  
  26. }  
  27. //读者线程函数  
  28. unsigned int __stdcall ReaderThreadFun(PVOID pM)  
  29. {  
  30.     ReaderPrintf("     编号为%d的读者进入等待中...\n", GetCurrentThreadId());  
  31.     //读者申请读取文件  
  32.     AcquireSRWLockShared(&g_srwLock);  
  33.   
  34.     //读取文件  
  35.     ReaderPrintf("编号为%d的读者开始读取文件...\n", GetCurrentThreadId());  
  36.     Sleep(rand() % 100);  
  37.     ReaderPrintf(" 编号为%d的读者结束读取文件\n", GetCurrentThreadId());  
  38.   
  39.     //读者结束读取文件  
  40.     ReleaseSRWLockShared(&g_srwLock);  
  41.     return 0;  
  42. }  
  43. //写者线程输出函数  
  44. void WriterPrintf(char *pszStr)  
  45. {  
  46.     EnterCriticalSection(&g_cs);  
  47.     SetConsoleColor(FOREGROUND_GREEN);  
  48.     printf("     %s\n", pszStr);  
  49.     SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);  
  50.     LeaveCriticalSection(&g_cs);  
  51. }  
  52. //写者线程函数  
  53. unsigned int __stdcall WriterThreadFun(PVOID pM)  
  54. {  
  55.     WriterPrintf("写者线程进入等待中...");  
  56.     //写者申请写文件  
  57.     AcquireSRWLockExclusive(&g_srwLock);  
  58.           
  59.     //写文件  
  60.     WriterPrintf("  写者开始写文件.....");  
  61.     Sleep(rand() % 100);  
  62.     WriterPrintf("  写者结束写文件");  
  63.   
  64.     //标记写者结束写文件  
  65.     ReleaseSRWLockExclusive(&g_srwLock);  
  66.     return 0;  
  67. }  
  68. int main()  
  69. {  
  70.     printf("  读者写者问题继 读写锁SRWLock\n");  
  71.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
  72.   
  73.     //初始化读写锁和关键段  
  74.     InitializeCriticalSection(&g_cs);  
  75.     InitializeSRWLock(&g_srwLock);  
  76.   
  77.     HANDLE hThread[READER_NUM + 1];  
  78.     int i;  
  79.     //先启动二个读者线程  
  80.     for (i = 1; i <= 2; i++)  
  81.         hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);  
  82.     //启动写者线程  
  83.     hThread[0] = (HANDLE)_beginthreadex(NULL, 0, WriterThreadFun, NULL, 0, NULL);  
  84.     Sleep(50);  
  85.     //最后启动其它读者结程  
  86.     for ( ; i <= READER_NUM; i++)  
  87.         hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);  
  88.     WaitForMultipleObjects(READER_NUM + 1, hThread, TRUE, INFINITE);  
  89.     for (i = 0; i < READER_NUM + 1; i++)  
  90.         CloseHandle(hThread[i]);  
  91.   
  92.     //销毁关键段  
  93.     DeleteCriticalSection(&g_cs);  
  94.     return 0;  
  95. }  

对比下《秒杀多线程第十一篇读者写者问题》中的代码就可以发现这份代码确实清爽许多了。这个程序用VS2008编译可以通过,但在XP系统下运行会导致报错。

Win7系统下能够正确的运行,结果如图所示:

 

 

最后总结一下读写锁SRWLock

1.读写锁声明后要初始化,但不用销毁,系统会自动清理读写锁。

2.读取者和写入者分别调用不同的申请函数和释放函数。


展开阅读全文

没有更多推荐了,返回首页