读者写者问题（一）

最新推荐文章于 2024-02-08 19:08:19 发布
最新推荐文章于 2024-02-08 19:08:19 发布
阅读量1.5k 收藏
点赞数
分类专栏： 多线程学习 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wy_kath/article/details/9097345
版权

       阅读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;
}
结果：



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

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

wy_kath
关注
专栏目录
读者写者问题
03-03
利用多线程对读者写着问题的模拟，有可视化界面，能对读者，写者信息编辑。
读者写者问题读写公平
10-10
读者写者问题是一种典型的进程同步问题，旨在解决多个读者和写者进程之间的访问冲突，以确保读写操作的公平性和正确性。本资源摘要信息将对读者写者问题的解决方案进行详细的解释。 读者写者问题的描述 读者写者...
读者与写者问题
最新发布
m0_71146337的博客
02-08 1504
一个数据文件或记录，可被多个进程共享，我们把只要求读该文件的进程称为“读者进程”，其他进程则称为“写者进程”。允许多个进程同时读一个共享对象，因为读操作不会使数据文件混乱。但不允许一个写者进程和其他读者进程或写者进程同时访问共享对象。因为这种访问将会引起混乱。
操作系统——读者写者问题
weixin_30675247的博客
09-18 427
一、问题描述 要求： 1、允许多个读者可以同时对文件执行读操作。 2、只允许一个写者往文件中写信息。 3、任一写者在完成写操作之前不允许其他读者或写者工作。 4、写者执行写操作前，应让已有的读者和写者全部退出。 二、问题分析 读者写者问题最核心的问题是如何处理多个读者可以同时对文件的读操作。 三、如何实现 s...
操作系统读者写者问题 详细
03-21
在操作系统中，读者写者问题是一种经典的同步问题。它描述了多个读者进程和写者进程同时访问共享资源的场景，要求读者进程和写者进程之间、读者进程之间、写者进程之间的互斥访问共享资源。 问题描述 在读者写者...
linux 操作系统 多线程编程 经典同步算法--读者写者问题
07-06
有读者和写者两组并发进程，共享一个文件，当两个或以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。因此要求：①允许多...
writerandreader.rar_读者写者_读者写者问题
09-22
"读者写者问题"是操作系统领域中的一个经典同步问题，主要涉及到多线程并发控制，以确保多个读者和一个写者能安全地访问共享资源。在这个问题中，多个读者可以同时读取数据，而写者在任何时候只能有一个，并且写者在...
pc.rar_PC问题_读者写者_读者写者问题
09-24
《读者-写者问题在操作系统中的解析》 操作系统设计中，多线程和多进程的同步与互斥问题一直是核心议题。"读者-写者问题"（Reader-Writer Problem）作为一个经典的并发控制问题，旨在解决多个读者和一个写者如何...
读者-写者问题C++程序
04-24
规则：多个读者和多个写者共同操作一个文件，当有一个写者在进行写操作时其他读者或写者都不能操作该文件，当有一个读者在进行读操作时，允许其他读者读，但不允许其他写者写。读者和写者都是每隔5秒操作一次，每次操作时间都是3秒。(此例为3个读者，2个写者)
读者写者问题PPT加讲稿
05-30
学习操作系统必须要学会的经典进程同步问题，pv操作，经典解析
操作系统 读者写者问题c++
01-04
操作系统 读者写者问题c++
读者写者问题c++实现
06-19
实现操作系统经典PCI问题：读者写者问题，c++代码实现
C++实现读者写者问题模拟
01-01
用C++实现的读者写者问题，对理解同步互斥问题很有帮助的
读者-写者问题(读者优先、写者优先、公平竞争)
OAOII的博客
10-15 8314
教材中提供的读者-写者问题的解决方案存在读者优先问题，即当有一个读进程比较活跃时，随后而来的读进程都将被允许访问资源。这样，会导致写进程可能长时间等待。而这种情况往往与实际应用需求相背。请认真分析、研究读者-写者问题，给出对读者和写者都较为公平的同步解决方案。...
读者-写者问题（Reader-Writer Problem）
ValDC_Morning的博客
06-18 8907
一、读者---写者问题（Reader-Writer Problem）      允许多个进程同时读一个共享对象，因为读操作不会使数据文件混乱。但不允许一个Writer进程和其他Reader进程或Writer进程同时访问共享对象，这样访问会引起混乱，此时读或写的区域就相当于一份临界资源。      所谓“读者-写者问题”是指保证一个Writer进程必须与其他进程互斥地访问共享对象的同步问题。
c++读者写者问题
10-10 856
利用boost库： class rw_data{ private: int m_x; shared_mutex rw_mu; public: rw_data():m_x(0){} void write(){ unique_lock ul(rw_mu); ++m_x; } void read(int* x){ shared_lock sl(rw_mu); *
读者-写者问题
keep coding
11-07 265
问题描述 有读者和写者两组并发进程，共享一个文件，当两个或以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。因此要求：①允许多个读者可以同时对文件执行读操作；②只允许一个写者往文件中写信息；③任一写者在完成写操作之前不允许其他读者或写者工作；④写者执行写操作前，应让已有的读者和写者全部退出。 问题分析 关系分析...
操作系统中读者优先的读者写者问题详解
资源摘要信息:"操作系统中的读者写者问题是一个经典的同步问题，它用于描述在多线程环境下，对共享资源的读写访问控制。该问题涉及两类并发进程：读者（Reader）和写者（Writer）。读者进程的主要任务是读取共享资源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值