读者写者问题（一）

       阅读MoreWindows大神的秒杀多线程系列至第十一篇读者写着问题，做一点小小的总结；

       读者写者问题描述：有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者在读文件时写者也不去能写文件，很简单的一个描述。

      本文对于写者开始写文件时就将可读事件（g_hEventCanRead）设置为未触发状态，结束写作时将可读事件（g_hEventCanRead）设置为触发状态；对于多个读者，使用一计数器ReadCount计数正在阅读的读者个数，当ReadCount=1时，设置可写事件（g_hEventCanWrite）为未触发状态，当ReadCount=0时，设置可写事件（g_hEventCanWrite）为触发状态。以此来保证读者与写者的同步与互斥。

程序1：

 

#include <stdio.h>
#include <windows.h>
#include <process.h>
const int READ_NUM = 5;

CRITICAL_SECTION g_cs,g_cs_reader_count;
/*
g_cs用来确保对stdout输出端的操作完整性；
g_cs_reader_count确保对readerCount计数的原子性
*/
HANDLE g_hEventCanRead,g_hEventCanWrite;
/*
g_hEventCanRead事件控制读者是否可读
g_hEventCanWrite事件控制写着是否可写
*/
int readerCount;
void WriterPrint(char *pstr)
{
    EnterCriticalSection(&g_cs);
    printf("\t%s\n",pstr);
    LeaveCriticalSection(&g_cs);
}
unsigned int __stdcall WriterFun(PVOID PM)
{
   WriterPrint("写者进入等待中。。。");
   WaitForSingleObject(g_hEventCanWrite,INFINITE);
   //Sleep(1000);
   ResetEvent(g_hEventCanRead);
   WriterPrint("写者开始写文件。。。");
   Sleep(100);
   WriterPrint("写者结束写文件。。。");

   SetEvent(g_hEventCanRead);
   return 0;
}
void ReadPrint(DWORD ID,char *pstr)
{
    EnterCriticalSection(&g_cs);
    printf("%d%s\n",ID,pstr);
    LeaveCriticalSection(&g_cs);
}
unsigned int __stdcall ReaderFun(PVOID PM)
{
     ReadPrint(GetCurrentThreadId(),"号读者进入等待。。。");
     WaitForSingleObject(g_hEventCanRead,INFINITE);
     EnterCriticalSection(&g_cs_reader_count);
     readerCount++;
     if(readerCount == 1)
        ResetEvent(g_hEventCanWrite);
     LeaveCriticalSection(&g_cs_reader_count);
     ReadPrint(GetCurrentThreadId(),"号读者开始阅读");
     ReadPrint(GetCurrentThreadId(),"号读者结束阅读");

     EnterCriticalSection(&g_cs_reader_count);
     readerCount--;
     if(readerCount == 0)
        SetEvent(g_hEventCanWrite);
     LeaveCriticalSection(&g_cs_reader_count);
     return 0;
}
int main()
{
    InitializeCriticalSection(&g_cs);
    InitializeCriticalSection(&g_cs_reader_count);

    //事件手动置位，初始为有信号TRUE
    g_hEventCanRead = CreateEvent(NULL,TRUE,TRUE,NULL);
    g_hEventCanWrite  = CreateEvent(NULL,TRUE,TRUE,NULL);
    readerCount = 0;

    int i;
    HANDLE handle[READ_NUM+1];
    for(i=1;i<=2;i++)
        handle[i] = (HANDLE)_beginthreadex(NULL,0,ReaderFun,NULL,0,NULL);

    handle[0] = (HANDLE)_beginthreadex(NULL,0,WriterFun,NULL,0,NULL);

    for(;i<=READ_NUM;i++)
        handle[i] = (HANDLE)_beginthreadex(NULL,0,ReaderFun,NULL,0,NULL);
    WaitForMultipleObjects(READ_NUM+1,handle,TRUE,INFINITE);

    for(i=0;i<=READ_NUM;i++)
        CloseHandle(handle[i]);

    CloseHandle(g_hEventCanRead);
    CloseHandle(g_hEventCanWrite);
    DeleteCriticalSection(&g_cs);
    DeleteCriticalSection(&g_cs_reader_count);
    return 0;
}

结果截图：

 

 

从运行结果可以看到：读者与写着的操作时互斥的。

      但是，接着阅读下面的游客评论，找出其中BUG，产生BUG的片段如下：

 

   WriterPrint("写者进入等待中。。。");
   WaitForSingleObject(g_hEventCanWrite,INFINITE);
   ResetEvent(g_hEventCanRead);
   WriterPrint("写者开始写文件。。。");
   Sleep(100);
   WriterPrint("写者结束写文件。。。");

   SetEvent(g_hEventCanRead);

产生BUG的原因：写着在等待到可写事件（WaitForSingleObject(g_hEventCanWrite,INFINITE)）的信号后，到置可读信号（ResetEvent(g-hEventCanRead)）为未触发之前，读者线程可能获得权限，从而进行阅读的操作，但此时写者在等待到可写信号后，也在进行写作的操作，从而，没有保证读写的互斥。

 

将BUG片段稍做更改，即可体现：

 

unsigned int __stdcall WriterFun(PVOID PM)
{
   WriterPrint("写者进入等待中。。。");
   WaitForSingleObject(g_hEventCanWrite,INFINITE);
   WriterPrint("写者开始写文件。。。");
   Sleep(1000);
   ResetEvent(g_hEventCanRead);

   Sleep(100);
   WriterPrint("写者结束写文件。。。");

   SetEvent(g_hEventCanRead);
   return 0;
}

做如此更改，并没有改变程序的功能，但运行结果：

 

从结果看出，写者开始写文件到结束写文件之间，有读者在进行阅读，即程序没有实现读写的互斥。

是什么导致程序失去了读写的互斥性呢，个人看法是，没有保证读写的同步，个人认为只能先写后读，读者只有在写者的写作任务结束之后才能进行阅读，而程序1则使读者和写着一开始就都获得了可读和可写的权限，即在创建可读可写事件时，手动将事件设置为触发状态：

 

g_hEventCanRead = CreateEvent(NULL,TRUE,TRUE,NULL);
g_hEventCanWrite  = CreateEvent(NULL,TRUE,TRUE,NULL);

这才导致了写者开始写作但还没来及通知读者不可以阅读之前，读者就进行了阅读，是程序失去了读写的互斥性，所以，在创建事件时，可读事件应该手动设置为未触发状态，而在写着完成写作之后，才将可读事件设置为触发状态，这就保证了读写的互斥性。但这只是一个写者和多个读者的解决办法。更好的办法，是如MoreWindows大神的第十四篇文章 读者写者问题继续 读写锁SRWLock中一样进行解决。按照我所想的代码实现如下：

 

程序2：

 

#include <stdio.h>
#include <windows.h>
#include <process.h>
const int READ_NUM = 5;

CRITICAL_SECTION g_cs,g_cs_reader_count;
/*
g_cs用来确保对stdout输出端的操作完整性；
g_cs_reader_count确保对readerCount计数的原子性
*/
HANDLE g_hEventCanRead,g_hEventCanWrite;
/*
g_hEventCanRead事件控制读者是否可读
g_hEventCanWrite事件控制写着是否可写
*/
int readerCount;
void WriterPrint(char *pstr)
{
    EnterCriticalSection(&g_cs);
    printf("\t%s\n",pstr);
    LeaveCriticalSection(&g_cs);
}
unsigned int __stdcall WriterFun(PVOID PM)
{
   WriterPrint("写者进入等待中。。。");
   WaitForSingleObject(g_hEventCanWrite,INFINITE);
   WriterPrint("写者开始写文件。。。");
   Sleep(1000);
   WriterPrint("写者结束写文件。。。");

   SetEvent(g_hEventCanRead);
   return 0;
}
void ReadPrint(DWORD ID,char *pstr)
{
    EnterCriticalSection(&g_cs);
    printf("%d%s\n",ID,pstr);
    LeaveCriticalSection(&g_cs);
}
unsigned int __stdcall ReaderFun(PVOID PM)
{
     ReadPrint(GetCurrentThreadId(),"号读者进入等待。。。");
     WaitForSingleObject(g_hEventCanRead,INFINITE);
     EnterCriticalSection(&g_cs_reader_count);
     readerCount++;
     if(readerCount == 1)
        ResetEvent(g_hEventCanWrite);
     LeaveCriticalSection(&g_cs_reader_count);
     ReadPrint(GetCurrentThreadId(),"号读者开始阅读");
     ReadPrint(GetCurrentThreadId(),"号读者结束阅读");

     EnterCriticalSection(&g_cs_reader_count);
     readerCount--;
     if(readerCount == 0)
        SetEvent(g_hEventCanWrite);
     LeaveCriticalSection(&g_cs_reader_count);
     return 0;
}
int main()
{
    InitializeCriticalSection(&g_cs);
    InitializeCriticalSection(&g_cs_reader_count);

    //事件手动置位，初始为有信号TRUE
    g_hEventCanRead = CreateEvent(NULL,TRUE,FALSE,NULL);
    g_hEventCanWrite  = CreateEvent(NULL,TRUE,TRUE,NULL);
    readerCount = 0;

    int i;
    HANDLE handle[READ_NUM+1];
    for(i=1;i<=2;i++)
        handle[i] = (HANDLE)_beginthreadex(NULL,0,ReaderFun,NULL,0,NULL);

    handle[0] = (HANDLE)_beginthreadex(NULL,0,WriterFun,NULL,0,NULL);

    for(;i<=READ_NUM;i++)
        handle[i] = (HANDLE)_beginthreadex(NULL,0,ReaderFun,NULL,0,NULL);
    WaitForMultipleObjects(READ_NUM+1,handle,TRUE,INFINITE);

    for(i=0;i<=READ_NUM;i++)
        CloseHandle(handle[i]);

    CloseHandle(g_hEventCanRead);
    CloseHandle(g_hEventCanWrite);
    DeleteCriticalSection(&g_cs);
    DeleteCriticalSection(&g_cs_reader_count);
    return 0;
}

结果：

 

从结果看出，读者和写着之间的操作实现了互斥操作。

       总结，以上两段程序的思想有一些出入，仅个人写下作为以后提醒复习用之。