读者写者问题

北理工操作系统实验二读者写者问题

本科实验报告实验名称：操作系统原理实验（读者写者问题）课程名称：操作系统原理实验时间：2015.10.30 任课教师：王耀威实验地点：10#102实验教师：苏京霞实验类型：原理验证□综合设计□自主创新学生姓名：孙嘉明学号/班级：1120121474/05611202 组号：学院：信息与电子学院同组搭档：专业：信息对抗技术成绩：实验二：读者写者问题一、实验目的1.通过编写和调试程序以加深对进程、线程管理方案的理解；2.熟悉Windows多线程程序设计方法；二、实验要求在Windows环境下，创建一个控制台进程，此进程包含n个线程。

用这n个线程来表示n个读者或写者。

每个线程按相应测试数据文件（后面介绍）的要求进行读写操作。

用信号量机制分别实现读者优先和写者优先问题。

读者-写者问题的读写操作限制（包括读者优先和写者优先）1）写-写互斥：不能有两个写者同时进行写操作2）读-写互斥：不能同时有一个线程在读，而另一个线程在写。

3）读-读允许：可以有一个或多个读者在读。

读者优先的附加限制：如果读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。

运行结果显示要求：要求在每个线程创建、发出读写申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确定所有处理都遵守相应的读写操作限制。

测试数据文件包括 n行测试数据，分别描述创建的n个线程是读者还是写者，以及读写操作的开始时间和持续时间。

每行测试数据包括四个字段，每个字段间用空格分隔。

第1个字段为正整数，表示线程的序号。

第2个字段表示线程的角色，R表示读者，W表示写者。

第3个字段为一个正数，表示读写开始时间：线程创建后，延迟相应时间（单位为秒）后发出对共享资源的读写申请。

第4个字段为一个正数，表示读写操作的延迟时间。

当线程读写申请成功后，开始对共享资源进行读写操作，该操作持续相应时间后结束，释放该资源。

下面是一个测试数据文件的例子(在记事本手工录入数据)：1 R 3 52 W 4 53 R 5 24 R 6 55 W 5.1 3三、实验环境硬件设备：个人计算机。

操作系统实验-读者写者问题

《计算机操作系统》实验报告题目读者写者问题学院（部）信息学院专业计算机科学与技术班级、学生姓名学号指导教师（签字）一、《二、问题描述一个数据文件或者记录，可以被多个进程共享，我们把只要求读该文件的进程称为“Reader进程”，其他进程则称为“Writer进程”。

允许多个进程同时读一个共享对象，因为读操作不会是数据文件混乱。

但不允许一个Writer进程和其他Reader进程或者Writer进程同时访问共享对象，因为这种访问将会引起混乱。

所谓“读者——写着问题（Reader—Writer Problem）”是指保证一个Writer进程必须与其他进程互斥地访问共享对象的同步问题三、解决问题为实现Reader与Writer进程间在读或写是的互斥而设置了一个互斥的信号量Wmutex。

另外，在设置一个整型变量Readcount表示正在读的进程数目。

由于只要有一个Reader进程在读，便不允许Writer去写。

因此，仅当Readercount=0时，表示尚无Reader进程在读时，Reader进程才需要进行Wait（wmutex）操作。

若Wait（Wmutex）操作成功，Reader 进程便可去读，相应地，做Readcount+1操作。

同理，仅当Reader进程在执行了Readercount-1操作后其值为0时，才执行Signal（Wmutex）操作，以便让Writer进程写。

又因为Readercount是一个可被多个Reader 进程访问的临界资源，因此也应该为它设置一个互斥信号量rmutex。

四、代码实现1、读者优先#include<iostream>#include<>using namespace std;CRITICAL_SECTION rmutex,wmutex;int wr;$int readernum;DWORD WINAPI reader(LPVOID IpParamter){cout<<"读者申请\n";wr++;EnterCriticalSection(&rmutex);if(readernum==0)EnterCriticalSection(&wmutex);readernum++;cout<<"读者进入成功正在读取\n";LeaveCriticalSection(&rmutex);Sleep(2000);—EnterCriticalSection(&rmutex);readernum--;cout<<"读者退出\n";wr--;if(readernum==0)LeaveCriticalSection(&wmutex);LeaveCriticalSection(&rmutex);return 0;}DWORD WINAPI writer(LPVOID PM){cout<<"写者申请\n";&while(wr!=0){}EnterCriticalSection(&wmutex);cout<<"写者已进入正在写入\n";Sleep(500);cout<<"写者退出\n";LeaveCriticalSection(&wmutex);return 0;}int main(){readernum=0;#wr=0;InitializeCriticalSection(&rmutex);InitializeCriticalSection(&wmutex);HANDLE hr[5];//定义读者线程HANDLE hw[5];//定义写者线程//int thnum;int drn=0; //输入的读者个数int dwn=0; //输入的写者个数cout<<"输入读者写者线程 1代表读者 2代表写者 0代表结束"<<endl;int th[10];int num=0;^cin>>th[num];while(th[num]){if(th[num]==1){drn++;}if(th[num]==2){dwn++;}num++;cin>>th[num];}&int hr1=0,hw1=0;for(int j=0;j!=num;j++){if(th[j]==1){hr[hr1]=CreateThread(NULL,0,reader,NULL,0,NULL);hr1++;}if(th[j]==2){hw[hw1]=CreateThread(NULL,0,writer,NULL,0,NULL);hw1++;}}>WaitForMultipleObjects(drn, hr, TRUE, INFINITE);WaitForMultipleObjects(dwn, hw, TRUE, INFINITE);for(int i=0;i!=drn;i++){CloseHandle(hr[i]);}for(int i=0;i!=dwn;i++){CloseHandle(hw[i]);}DeleteCriticalSection(&rmutex);DeleteCriticalSection(&wmutex);return 0;（}2、写者优先#include<iostream>#include<>using namespace std;CRITICAL_SECTION rmutex,wmutex;int ww;int readernum;DWORD WINAPI reader(LPVOID IpParamter){cout<<"读者申请\n";!while(ww!=0){}EnterCriticalSection(&rmutex);if(readernum==0){EnterCriticalSection(&wmutex);}cout<<"读者进入成功正在读取\n";readernum++;LeaveCriticalSection(&rmutex);Sleep(2000);EnterCriticalSection(&rmutex);-readernum--;if(readernum==0)LeaveCriticalSection(&wmutex);cout<<"读者退出\n";LeaveCriticalSection(&rmutex);return 0;}DWORD WINAPI writer(LPVOID PM){ww++;cout<<"写者申请\n";EnterCriticalSection(&wmutex);{cout<<"写者已进入正在写入\n";Sleep(1000);cout<<"写者退出\n";ww--;LeaveCriticalSection(&wmutex);return 0;}int main(){readernum=0;ww=0;InitializeCriticalSection(&rmutex);|InitializeCriticalSection(&wmutex);HANDLE hr[5];//定义读者线程HANDLE hw[5];//定义写者线程int drn=0; //输入的读者个数int dwn=0; //输入的写者个数cout<<"输入读者写者线程 1代表读者 2代表写者 0代表结束"<<endl;int th[10];int num=0;cin>>th[num];while(th[num]){if(th[num]==1){、drn++;}if(th[num]==2){dwn++;}num++;cin>>th[num];}int hr1=0,hw1=0;for(int j=0;j!=num;j++){if(th[j]==1){》hr[hr1]=CreateThread(NULL,0,reader,NULL,0,NULL);Sleep(10);hr1++;}if(th[j]==2){hw[hw1]=CreateThread(NULL,0,writer,NULL,0,NULL);Sleep(10);hw1++;}}WaitForMultipleObjects(drn, hr, TRUE, INFINITE);*WaitForMultipleObjects(dwn, hw, TRUE, INFINITE);for(int i=0;i!=drn;i++){CloseHandle(hr[i]);}for(int i=0;i!=dwn;i++){CloseHandle(hw[i]);}DeleteCriticalSection(&rmutex);DeleteCriticalSection(&wmutex);return 0;}3、执行结果读者优先在读者优先中先两个读者申请，再一个写者申请，再有两个读者申请。

课程设计读者写者问题

课程设计读者写者问题一、教学目标本课程的学习目标包括知识目标、技能目标和情感态度价值观目标。

知识目标要求学生掌握读者写者问题的基本概念和相关原理；技能目标要求学生能够运用所学知识解决实际问题，如设计并发控制算法；情感态度价值观目标要求学生培养团队合作意识，提高解决复杂问题的信心。

教学目标的具体、可衡量性体现在：学生能够准确地描述读者写者问题的定义和特点；能够运用基本的并发控制算法解决读者写者问题；在团队项目中，能够有效地协作，共同完成任务。

二、教学内容根据课程目标，本课程的教学内容主要包括读者写者问题的基本概念、并发控制算法及其应用。

教学大纲按照以下顺序安排：1.读者写者问题的定义、特点及分类；2.基本并发控制算法：锁、信号量、管程等；3.读者写者问题的解决方案及评价；4.实际应用案例分析。

教材选用《计算机操作系统》一书，章节安排与教学大纲相对应。

三、教学方法本课程采用多种教学方法，以激发学生的学习兴趣和主动性。

主要包括：1.讲授法：讲解基本概念、原理和算法；2.讨论法：分组讨论解决方案，促进学生思考；3.案例分析法：分析实际应用案例，提高学生解决实际问题的能力；4.实验法：动手实现并发控制算法，培养实际操作能力。

四、教学资源教学资源包括教材、参考书、多媒体资料和实验设备。

教材《计算机操作系统》提供理论知识；参考书补充拓展相关内容；多媒体资料生动展示原理和算法；实验设备支持学生动手实践。

教学资源的选择和准备旨在支持教学内容和教学方法的实施，丰富学生的学习体验，提高学习效果。

五、教学评估本课程的评估方式包括平时表现、作业、考试等，以全面反映学生的学习成果。

平时表现主要评估学生在课堂讨论、提问等方面的参与度；作业分为课后练习和实验报告，评估学生对知识的掌握和实际操作能力；考试则评估学生对课程知识的全面理解。

评估方式力求客观、公正，确保学生在各个方面的努力和进步都能得到合理的评价。

评估结果将作为学生课程成绩的重要组成部分，以激发学生的学习积极性。

读者写者问题共52页

•
30、风俗可以造就法律，也可以废除法律。 ——塞·约翰逊
读者写者问题
6、最大的骄傲于最大的自卑都表示心灵的最软弱无力。——斯宾诺莎 7、自知之明是最难得的知识。——西班牙 8、勇气通往天堂，怯懦通往地狱。——塞内加 9、有时候读书是一种巧妙地避开思考的方法。——赫尔普斯 10、阅读一切好书如同和过去最杰出的人谈话。——笛卡儿
•
26、我们像鹰一样，生来就是自由的，但是为了生存，我们不得不为自己编织一个笼子，然后把自己关在里面。 ——博莱索
•
27、法律如果不讲道理，即使延续时间再长，也还是没有制约力的。— —爱·科克
•
28、好法律是由坏风俗创造出来的。 ——马克罗维乌斯
•
29、在一切能够接受法律支配的人类的状态中，哪里没有法律，那里就没有自由。— —洛克
Thank you
ห้องสมุดไป่ตู้

读者写者问题描述

读者写者问题描述嘿，你问读者写者问题啊？那我给你讲讲哈。

咱就说啊，这读者写者问题呢，就好比一个图书馆。

有很多人想去看书，这就是读者。

还有人想去写书，那就是写者。

有一回啊，我去图书馆。

那里面好多人都在安静地看书呢。

这时候就相当于有很多读者在享受知识。

突然，有个作家模样的人来了，他想找个地方坐下来写书。

这就是写者出现了。

这时候问题就来了。

如果读者和写者同时在图书馆里，会咋样呢？如果读者一直在看书，写者就没办法好好写书，因为他会觉得被打扰了。

反过来，如果写者一直在写书，读者也没办法好好看书，因为他们不知道啥时候能看到新的内容。

就像我在图书馆里，我正看得入迷呢，突然那个作家开始大声地思考他的情节，哎呀，那可把我烦死了。

我就想，你能不能安静点啊，让我好好看书嘛。

这就像读者希望写者不要打扰他们一样。

那怎么办呢？就得有个规则。

比如说，让写者先等读者都看完书走了，他再开始写书。

或者让读者在写者写书的时候，稍微安静一点，不要弄出太大动静。

我记得有一次，我在图书馆里，有个写者特别有礼貌。

他进来的时候，看到很多读者，就悄悄地找了个角落坐下，等大家都看得差不多了，他才开始动笔。

这样大家都能和谐共处了。

读者写者问题就是要找到一个平衡，让读者能愉快地看书，写者也能安心地写书。

不能让一方太强势，影响了另一方。

就像在生活中，我们也会遇到类似的情况。

比如说，一个办公室里，有人在安静地工作，有人在讨论问题。

这时候就得互相体谅，不能太吵了，影响别人工作。

总之啊，读者写者问题就是要解决大家在共享资源的时候，如何和谐相处的问题。

嘿嘿，你明白了不？。

操作系统课程之“读者—写者”问题教学探讨

操作系统课程之“读者—写者”问题教学探讨操作系统课程之“读者—写者”问题教学探讨摘要：针对操作系统教学中概念多而繁杂、容易混淆，初学者存在畏难情绪等问题，文章提出采取类比、逐层解剖、层层深入、循序渐进的教学方法，并以操作系统中的进程同步互斥问题中“读者－写者”问题为例，对其概念、算法进行形象启发、分层解剖的阐述，并结合多种教学方法，说明使学生能更深刻地理解进程同步互斥问题的方法。

教学实践表明其效果良好。

关键词：操作系统；分层解剖；读者－写者问题；PV原语；教学实践操作系统是计算机专业的一门核心课程(图1)，其在计算机系统中的特殊地位，使得该课程的学习在整个计算机学科教育中显得尤为重要。

作为一门理论性和实践性并重的课程，它具有概念多、算法较抽象的特点，同时又涉及了程序设计语言、软件工程思想、算法设计、计算机系统结构、网络等相关知识。

枯燥的理论讲述往往使学生感到抽象、难懂，进而产生厌学的思想。

尽管近年来一些高校在加强理论教学的同时，引入对操作系统内核的分析，如Linux操作系统，在教学实践方面取得了一点的成效，但是对于初学者和教师而言，在一个学期内课时数不变的情况下，完成教与学的工作显得有点心有余而力不足。

为了在有限的教学时间内，提高教学效率，既让学生深入理解理论知识，又能借助PV操作原语来验证操作系统的算法思想，笔者根据以往教学经验，结合初学者学习的实际情况，以进程同步中“读者－写者”为例，探讨如何由浅入深、循序渐进地开展教学工作。

1 问题描述“读者—写者”问题是现代操作系统中经典的进程同步互斥问题，在以C/S模式为代表的多进(线)程通信系统都可以作为该模型的不同表现形式，有着广泛的应用[1]。

该问题描述如下：一个数据文件或记录可被多个进程所共享，我们将其中只要求读该文件的进程称为读者，即“Reader进程”，其他进程称为写者，即“Writer进程”。

多个Reader 进程和多个Writer进程在某个时间段内对该文件资源进行异步操作，也就是说允许多个进程同时读一个共享对象，但绝不允许一个Writer进程和其他Reader进程或Writer进程同时访问共享对象，因此，所谓“读者—写者问题”就是指必须保证一个Writer进程和其他进程(Writer进程和Reader进程)互斥地访问共享对象的同步问题[2]。

2)读-写互斥,即不能同时有一个读者在读,同时却有一个写者在写
3)读读允许,即可以有2个以上的读者同时读
将所有的读者与所有的写者分别放进两个等待队列中,当读允许时就让读者队列释放一个或多个读者,当写允许时,释放第一个写者操作。读者写者问题的定义如下:有一个许多进程共享的数据区,这个数据区可以就是一个文件或者主存的一块空间;有一些只读取这个数据区的进程(Reader)与一些只往数据区写数据的进程(Writer),此外还需要满足以下条件:1)任意多个读进程可以同时读这个文件;2)一次只有一个写进程可以往文件中写;3)如果一个写进程正在进行操作,禁止任何读进程度文件。我们需要分两种情况实现该问题:
一设计概述
所谓读者写者问题,就是指保证一个writer进程必须与其她进程互斥地访问共享对象的同步问题。
读者写者问题可以这样的描述,有一群写者与一群读者,写者在写同一本书,读者也在读这本书,多个读者可以同时读这本书,但就是,只能有一个写者在写书,并且,读者必写者优先,也就就是说,读者与写者同时提出请求时,读者优先。当读者提出请求时需要有一个互斥操作,另外,需要有一个信号量S来当前就是否可操作。
信号量机制就是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制,而读者写者问题则就是这一机制的一个经典范例。
与记录型信号量解决读者—写者问题不同,信号量机制它增加了一个限制,即最多允许RN个读者同时读。为此,又引入了一个信号量L,并赋予初值为RN,通过执行wait(L,1,1)操作,来控制读者的数目,每当有一个读者进入时,就要执行wait(L,1,1)操作,使L的值减1。当有RN个读者进入读后,L便减为0,第RN+1个读者要进入读时,必然会因wait(L,1,1)操作失败而堵塞。对利用信号量来解决读者—写者问题的描述如下:

读者-写者问题解答

2.读者—写者问题读者—写者问题（Readers-Writers problem）也是一个经典的并发程序设计问题，是经常出现的一种同步问题。

计算机系统中的数据（文件、记录）常被多个进程共享，但其中某些进程可能只要求读数据（称为读者Reader）；另一些进程则要求修改数据（称为写者Writer）。

就共享数据而言，Reader和Writer是两组并发进程共享一组数据区，要求：（1）允许多个读者同时执行读操作；（2）不允许读者、写者同时操作；（3）不允许多个写者同时操作。

Reader和Writer的同步问题分为读者优先、弱写者优先（公平竞争）和强写者优先三种情况，它们的处理方式不同。

（1）读者优先。

对于读者优先，应满足下列条件：如果新读者到：①无读者、写者，新读者可以读；②有写者等待，但有其它读者正在读，则新读者也可以读；③有写者写，新读者等待。

如果新写者到：①无读者，新写者可以写；②有读者，新写者等待；③有其它写者，新写者等待。

单纯使用信号量不能解决读者与写者问题，必须引入计数器rc 对读进程计数；rc_mutex 是用于对计数器rc 操作的互斥信号量；write表示是否允许写的信号量；于是读者优先的程序设计如下：int rc=0; //用于记录当前的读者数量semaphore rc_mutex=1; //用于对共享变量rc 操作的互斥信号量semaphore write=1; //用于保证读者和写者互斥地访问的信号量void reader() /*读者进程*/do{P(rc_mutex); //开始对rc共享变量进行互斥访问rc ++; //来了一个读进程，读进程数加1if (rc==1) P(write)；//如是第一个读进程，判断是否有写进程在临界区，//若有，读进程等待，若无，阻塞写进程V(rc_mutex); //结束对rc共享变量的互斥访问读文件；P(rc_mutex); //开始对rc共享变量的互斥访问r c--; //一个读进程读完，读进程数减1if (rc == 0) V(write)；//最后一个离开临界区的读进程需要判断是否有写进程//需要进入临界区，若有，唤醒一个写进程进临界区V(rc_mutex); //结束对rc共享变量的互斥访问} while(1)void writer() /*写者进程*/do{P(write); //无读进程，进入写进程；若有读进程，写进程等待写文件;V(write); //写进程完成；判断是否有读进程需要进入临界区，//若有，唤醒一个读进程进临界区} while(1)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。

写优先”策略的“读者-写者”问题

采用“写优先”策略的“读者-写者”问题学院计算机科学与技术专业计算机科学与技术学号学生姓名指导教师姓名2014-3-11目录一、设计目的与内容 ................................................ 错误!未定义书签。

(1 )、课程设计的目的 (1)(2 ) 、课程设计的内容 (1)(3 ) 、课程设计的要求 (1)二、算法的基本思想 ................................................ 错误!未定义书签。

三、模块流程图......................................................... 错误!未定义书签。

四、测试结果............................................................. 错误!未定义书签。

五、结论..................................................................... 错误!未定义书签。

六、源程序................................................................. 错误!未定义书签。

一、设计目的与内容(1)课程设计的目的：操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决问题的机会。

●进一步巩固和复习操作系统的基础知识。

●培养学生结构化程序、模块化程序设计的方法和能力。

●提高学生调试程序的技巧和软件设计的能力。

●提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。

(2) 课程设计的内容：用高级语言编写和调试一个采用“写优先”策略的“读者—写者”问题的模拟程序。

(3) 课程设计的要求：1.读者与写者至少包括ID、进入内存时间、读写时间三项内容，可在界面上进行输入。

4.9 经典进程同步问题：读者-写者问题

4.9 经典进程同步问题：读者－写者问题（the readers-writers problem）
问题描述：对共享资源的读写操作，任一时刻“写者”最多只允许一个，而“读者”则允许多个，要求：
●“读－写” 互斥
●“写－写” 互斥
●“读－读” 允许
设置如下信号量：
Wmutex表示“允许写”，初值是1；
Rmutex表示对Rcount的互斥操作，初值是1。

公共变量Rcount表示“正在读”的进程数，初值是0。

由问题描述，我们可以分析出：
只要一个reader进程在读，便不允许writer进程去写；
仅当Rcount=0，reader进程才需要执行P(Wmutex)操作；
仅当reader进程执行了Rcount减1操作后，其值为0时，才须执行V(Wmutex)操作。

用信号量和P、V原语解决读者－写者问题如下：。

读者写者问题_写者优先参考答案

V(Rmutex);
}
}
void writer() /*写者进程*/
{
if(Rcount>0)
authFlag=0；
P(Wmutex);
......;
write; /* 执行写操作 */
......;
P(Wmutex);
P(Amutex)
while(waitAuthCount>0){
v(mutexAuth);
waitAuthCou
【vc++代码】
// testsemaphore.cpp : Defines the entry point for the console application.
// by西南大学计算机科学系周竹荣
//
#include"stdafx.h"
#include"windows.h"
Rmutex=CreateSemaphore(NULL,1,1,NULL);
Authmutex=CreateSemaphore(NULL,1,1,NULL);
Amutex=CreateSemaphore(NULL,1,1,NULL);
while(1){
Sleep(100);
srand((unsigned)time(NULL));
允许任意多的读进程同时读；
一次只允许一个写进程进行写操作；
如果有一个写进程正在进行写操作，禁止任何读进程进行读操作。
为了解决该问题，我们只需解决“写者与写者”和“写者与第一个读者”的互斥问题即
可，为此我们引入一个互斥信号量Wmutex，为了记录谁是第一个读者，我们用一个共享整
型变量Rcount 作一个计数器。而在解决问题的过程中，由于我们使用了共享变量Rcount，

读者写者问题写者优先参考答案完整版

读者写者问题写者优先参考答案HUA system office room 【HUA16H-TTMS2A-HUAS8Q8-HUAH1688】【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。

给出读者、写者问题的另一个解决方案：即保证当有一个写者进程想写时，不允许读者进程再进入，直到写者写完为止，即写者优先。

让我们先回顾读者写者问题[1]：一个数据对象若被多个并发进程所共享，且其中一些进程只要求读该数据对象的内容，而另一些进程则要求写操作，对此，我们把只想读的进程称为“读者”，而把要求写的进程称为“写者”。

在读者、写者问题中，任何时刻要求“写者”最多只允许有一个执行，而“读者”则允许有多个同时执行。

因为多个“读者”的行为互不干扰，他们只是读数据，而不会改变数据对象的内容，而“写者”则不同，他们要改变数据对象的内容，如果他们同时操作，则数据对象的内容将会变得不可知。

所以对共享资源的读写操作的限制条件是：允许任意多的读进程同时读；一次只允许一个写进程进行写操作；如果有一个写进程正在进行写操作，禁止任何读进程进行读操作。

为了解决该问题，我们只需解决“写者与写者”和“写者与第一个读者”的互斥问题即可，为此我们引入一个互斥信号量Wmutex，为了记录谁是第一个读者，我们用一个共享整型变量Rcount 作一个计数器。

而在解决问题的过程中，由于我们使用了共享变量Rcount，该变量又是一个临界资源，对于它的访问仍需要互斥进行，所以需要一个互斥信号量Rmutex，算法如下：}}现在回到【写者优先】优先问题【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。

给出读者、写者问题的另一个解决方案：即保证当有一个写者进程想写时，不允许读者进程再进入，直到写者写完为止，即写者优先。

经典同步问题读者-写者问题

经典同步问题读者-写者问题读者-写者问题在读者-写者问题中，只对共享数据进⾏读取的进程为读者进程，修改共享数据的进程称为写者进程。

多个读者可同时读取共享数据⽽不会导致出现错误，但是任何时刻多个写者进程不能同时修改数据，写者进程和读者进程也不能同时访问共享数据。

读者-写者问题的解决策略有不同的倾向。

读者优先需要⽤到的共享变量：semaphore rw_mutex = 1; // 读者与写者互斥访问共享数据的互斥信号量semaphore mutex = 1; // 多个读者进程互斥修改当前读者进程数量的信号量int read_count = 0; // 系统当前读者进程数量写者进程结构do {wait(rw_mutex);.../* 修改共享数据 */...signal(rw_mutex);}while(true);读者进程结构do {wait(mutex); // 获取修改读者进程数量的互斥信号量，该操作在请求rw_mutex之前，防⽌出现死锁read_count++;if(read_count == 1) // 判断当前是否为第⼀个读者进程wait(rw_mutex); // 如果是就需要请求访问共享数据的互斥信号量signal(mutex); // read_count修改后释放信号量.../* 读取数据 */...wait(mutex); // 获取修改读者进程数量的互斥信号量read_count--;if(read_count == 0) // 判断当前进程是否为最后⼀个读者进程signal(rw_mutex); // 如果是则释放共享数据的互斥信号量，以允许写者进程操作共享数据signal(mutex);}while(true);读者优先有可能导致写者进程产⽣饥饿现象，当系统中不断出现读者进程时，写者进程始终⽆法进⼊临界区。

写者优先需要⽤到的共享变量：semaphore rw_mutex = 1; // 读者与写者互斥访问共享数据的互斥信号量semaphore r_mutex = 1; // 互斥修改当前读取⽂件的进程数semaphore w_mutex = 1; // 互斥修改当前修改⽂件的进程数semaphore enter_mutex = 1; // 获取申请访问⽂件的权限int read_count = 0; // 系统当前读者进程数量int write_count = 0; // 系统当前写者进程数量写者进程结构do {wait(w_mutex); // 新的写者进程进⼊，获取修改写者进程数量的权限write_count++;if(write_count == 1) // 判断当前是否为第⼀个写者进程wait(enter_mutex); // 阻断后续到达的读者进程signal(w_mutex);wait(rw_mutex); // 获取访问⽂件的权限，⽂件可能被其它写者进程占⽤，或者等待最后⼀个读者进程释放.../* 修改数据 */...wait(rw_mutex);wait(w_mutex);write_count--;if(write_count == 0) // 当所有写者进程都放弃使⽤⽂件时，运⾏读者进程申请访问⽂件signal(enter_mutex);signal(mutex);}while(true);读者进程结构do {wait(enter_mutex); // 获取申请访问⽂件的权限wait(r_mutex);read_count++;if(read_count == 1) // 判断当前是否为第⼀个读者进程wait(rw_mutex); // 占⽤⽂件signal(r_mutex);signal(enter_mutex);.../* 读取数据 */...wait(r_mutex);read_count--;if(read_count == 0)signal(rw_mutex);signal(r_mutex);}while(true);写者优先有可能导致读者进程产⽣饥饿现象，当系统中不断出现写者进程时，读者进程始终⽆法进⼊临界区。

读者写者问题

读者写者也是一个非常著名的同步问题。

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

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

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

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

找完“等待”情况后，再看看有没有要互斥访问的资源。

由于只有一个写者而读者们是可以共享的读文件，所以按题目要求并没有需要互斥访问的资源。

类似于上一篇中美观的彩色输出，我们对生产者输出代码进行了颜色设置。

因此在这里要加个互斥访问，不然很有可能在写者线程将控制台颜色设置还原之前，读者线程就已经有输出了。

所以要对输出语句作个互斥访问处理，修改后的读者及写者的输出函数如下所示：//读者线程输出函数void ReaderPrintf(char *pszFormat, ...){va_list pArgList;va_start(pArgList, pszFormat);EnterCriticalSection(&g_cs);vfprintf(stdout, pszFormat, pArgList);LeaveCriticalSection(&g_cs);va_end(pArgList);}//写者线程输出函数void WriterPrintf(char *pszStr){EnterCriticalSection(&g_cs);SetConsoleColor(FOREGROUND_GREEN);printf(" %s\n", pszStr);SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);LeaveCriticalSection(&g_cs);}解决了互斥输出问题，接下来再考虑如何实现同步问题。

读者-写者问题解答

2.读者—写者问题读者—写者问题（Readers-Writers problem）也是一个经典的并发程序设计问题，是经常出现的一种同步问题。

计算机系统中的数据（文件、记录）常被多个进程共享，但其中某些进程可能只要求读数据（称为读者Reader）；另一些进程则要求修改数据（称为写者Writer）。

就共享数据而言，Reader和Writer是两组并发进程共享一组数据区，要求：（1）允许多个读者同时执行读操作；（2）不允许读者、写者同时操作；（3）不允许多个写者同时操作。

Reader和Writer的同步问题分为读者优先、弱写者优先（公平竞争）和强写者优先三种情况，它们的处理方式不同。

（1）读者优先。

对于读者优先，应满足下列条件：如果新读者到：①无读者、写者，新读者可以读；②有写者等待，但有其它读者正在读，则新读者也可以读；③有写者写，新读者等待。

如果新写者到：①无读者，新写者可以写；②有读者，新写者等待；③有其它写者，新写者等待。

单纯使用信号量不能解决读者与写者问题，必须引入计数器rc 对读进程计数；rc_mutex 是用于对计数器rc 操作的互斥信号量；write表示是否允许写的信号量；于是读者优先的程序设计如下：int rc=0; //用于记录当前的读者数量semaphore rc_mutex=1; //用于对共享变量rc 操作的互斥信号量semaphore write=1; //用于保证读者和写者互斥地访问的信号量void reader() /*读者进程*/do{P(rc_mutex); //开始对rc共享变量进行互斥访问rc ++; //来了一个读进程，读进程数加1if (rc==1) P(write)；//如是第一个读进程，判断是否有写进程在临界区，//若有，读进程等待，若无，阻塞写进程V(rc_mutex); //结束对rc共享变量的互斥访问读文件；P(rc_mutex); //开始对rc共享变量的互斥访问r c--; //一个读进程读完，读进程数减1if (rc == 0) V(write)；//最后一个离开临界区的读进程需要判断是否有写进程//需要进入临界区，若有，唤醒一个写进程进临界区V(rc_mutex); //结束对rc共享变量的互斥访问} while(1)void writer() /*写者进程*/do{P(write); //无读进程，进入写进程；若有读进程，写进程等待写文件;V(write); //写进程完成；判断是否有读进程需要进入临界区，//若有，唤醒一个读进程进临界区} while(1)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。

读者和写者问题

学号：课程设计课程名称操作系统学院计算机科学与技术学院专业软件工程专业班级姓名指导教师2014——2015学年第1学期目录目录 ....................................................................................................................................... 错误!未定义书签。

1 设计概述 (3)1.1问题描述： (3)1.2问题解读及规则制定 (3)2课程设计目的及功能 (3)2.1 设计目的 (3)2.2 设计功能 (3)3模块介绍 (3)3.1函数原型 (3)3.2 PV操作代码 (4)4测试用例，运行结果与运行情况分析 (6)4.1测试用例 (6)4.2运行结果 (7)4.3运行情况分析 (9)5自我评价与总结 (9)6 参考文献 (10)7 附录：（完整代码） (10)实现读者写者(Reader-Writer Problem)问题1 设计概述1.1问题描述：通过研究Linux的线程机制和信号量实现读者写者(Reader-Writer)问题并发控制。

1.2问题解读及规则制定一个数据文件或记录可被多个进程所共享,我们将其中只要求读该文件的进程称为读者,其他进程称为写者.多个读者和多个写者进程在某个时间段内对该文件资源进行异步操作,也就是说允许多个进程同时读一个共享对象,但不允许一个写进程和其他读进程或写进程同时访问共享对象,因此,所谓"读者--写者问题"就是指必须保证一个写进程和其他进程(写进程或者读进程)互斥地访问共享对象的同步问题.两者的读写操作限制规则如下:(1)写--写互斥,即不允许多个写着同时对文件进行写操作(2)读--写互斥,即不允许读者和写者同时对文件分别进行读写操作(3)读—读允许,即允许多个读者同时对文件进行读操作2课程设计目的及功能2.1 设计目的通过实验模拟读者和写者之间的关系，了解并掌握他们之间的关系及其原理。

读者写者问题-写者优先参考答案

读者写者问题-写者优先参考答案【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。

给出读者、写者问题的另一个解决方案：即保证当有一个写者进程想写时，不允许读者进程再进入，直到写者写完为止，即写者优先。

让我们先回顾读者写者问题[1]：一个数据对象若被多个并发进程所共享，且其中一些进程只要求读该数据对象的内容，而另一些进程则要求写操作，对此，我们把只想读的进程称为“读者”，而把要求写的进程称为“写者”。

在读者、写者问题中，任何时刻要求“写者”最多只允许有一个执行，而“读者”则允许有多个同时执行。

因为多个“读者”的行为互不干扰，他们只是读数据，而不会改变数据对象的内容，而“写者”则不同，他们要改变数据对象的内容，如果他们同时操作，则数据对象的内容将会变得不可知。

所以对共享资源的读写操作的限制条件是：⏹允许任意多的读进程同时读；⏹一次只允许一个写进程进行写操作；如果有一个写进程正在进行写操作，禁止⋯⋯;P(Rmutex);Rcount = Rcount - 1;if (Rcount == 0) V(wmutex);V(Rmutex);}}void writer() /*写者进程*/{while (true){P(Wmutex);⋯⋯;write; /* 执行写操作 */⋯⋯;P(Wmutex);}}现在回到【写者优先】优先问题【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。

给出读者、写者问题的另一个解决方案：即保证当有一个写者进程想写时，不允许读者进程再进入，直到写者写完为止，即写者优先。

【解题思路】在上面的读者写者问题基础上，做以下修改：⏹增加授权标志authFlag，当写者到来，发现有读者在读，则取消授权，然后等待缓冲区；⏹增加“等待授权计数器waitAuthCount”，写者离开时，如果waitAuthCount大于0，则迭代唤醒等待授权的读者；⏹读者到来，首先看授权标志，如果有授权标志，则继续，否则等待授权，即写者取消授权后，新来的读者不能申请缓冲区。