读者-写者问题说明书
《操作系统原理》课程设计任务书
题目：读者-写者问题的实现
学生姓名：李志旭学号：13740113 班级：_13级软件工程_
题目类型：软件工程（R）指导教师：陈文娟、马生菊一、设计目的
学生通过该题目的设计过程，掌握读者、写者问题的原理、软件开发方法并提高解决实际问题的能力。
二、设计任务
编写程序实现读者优先和写者优先问题:
读者-写者问题的读写操作限制（包括读者优先和写者优先）
写-写互斥：不能有两个写者同时进行写操作
读-写互斥：不能同时有一个线程在读，而另一个线程在写。
读-读允许：可以有一个或多个读者在读。
三、设计要求
1.分析设计要求，给出解决方案（要说明设计实现所用的原理、采用的数
据结构）。
2.设计合适的测试用例，对得到的运行结果要有分析。
3.设计中遇到的问题，设计的心得体会。
4.文档：课程设计打印文档每个学生一份，并装在统一的资料袋中，资料
袋前面要贴有学校统一的资料袋封面。
四、提交的成果
1. 课程设计说明书内容包括
(1) 封面（学院统一印制）；
(2) 课程设计任务书；
(3) 中文摘要150字；关键词3-5个；
(4) 目录；
(5) 正文；（设计思想；各模块的伪码算法；函数的调用关系图；测试结果等）
(6) 设计总结；
(7) 参考文献；
(8) 致谢等。
注：每一部分是单独的一章，要另起一页写。
2. 排版要求
(1) 所有一级标题为宋体三号加粗（即上面写的2～8部分，单独一行，居中）
(2) 所有二级标题为宋体四号加粗（左对齐）
(3) 所有三级标题为宋体小四加粗（左对齐）
(4) 除标题外所有正文为宋体小四，行间距为固定值22磅，每个段落首行缩进2字符
(5) 目录只显示3级标题，目录的最后一项是无序号的“参考文献资料”。
3. 其他要求（班长负责，务必按照以下方式建文件夹）
(1) 以班级为单位刻录光盘一张，光盘以班级命名，例如：“10级计算机科学与技术1班”；
(2) 光盘内每人一个文件夹，以学号姓名命名——如“10730101 陈映霞”，内容包括任务书、设计文档。
五、各阶段时间安排（共2周）
根据教学计划安排，于2014年12月8日～2014年12月19日安排为期二周的操作系统课程设计。
六、考勤、纪律及注意事项
1．每日准时教室设计，不得无故缺席、早退。
2．独立、按时完成课程设计任务，准时上交资料。
七、主要参考文献
1. 汤子瀛，哲凤屏.《计算机操作系统》[M].西安：西安电子科技大学学出版社.1996年
2. 王万森.《计算机操作系统原理》[M].北京：高等教育出版社.2001年
3. 周长林，左万历. 《计算机操作系统教程》[M].北京：高等教育出版社.1994年
4. 黄廷辉，王宇英.《计算机操作系统实践教程》[M].北京：清华大学出版社. 2007年5月
5. 殷兆麟.《计算机操作系统》[M].北京：清华大学出版社.2007年3月
6. 张尧学，史美林，张高.《计算机操作系统教程》[M].北京：清华大学出版社.1993年
摘要
读者写者问题，是指保证一个writer进程必须与其他进程互斥地访问共享对象的同步问题。
读者写者问题可以这样的描述，有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书，并且，读者必写者优先，也就是说，读者和写者同时提出请求时，读者优先。当读者提出请求时需要有一个互斥操作，另外，需要有一个信号量S来当前是否可操作。
信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制，而读者写者则是这一机制的一个经典范例。
关键字：信号量；读者优先；写者优先；线程；互斥。
目录
1概述 (1)
1.1设计内容 (1)
1.2实验目的 (2)
1.3设计思想 (2)
1.4设计方案 (3)
2.总体设计 (4)
2.1系统总体框架 (4)
2.2函数调用关系图 (5)
2.3数据结构定义 (5)
3详细设计 (7)
3.1读者进程优先算法 (7)
3.2写者进程优先算法 (8)
4调试分析 (10)
4.1程序分析 (10)
4.2调试结果 (10)
4.3调试出现的问题 (12)
总结 (13)
参考文献 (14)
致谢 (15)
附录 (16)
1概述
1.1 设计内容
读者-写者问题可以这样的描述，有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书，并且，读者必写者优先，也就是说，读者和写者同时提出请求时，读者优先。当读者提出请求时需要有一个互斥操作，另外，需要有一个信号量S来当前是否可操作。
读者-写者问题（Readers-Writers problem）也是一个经典的并发程序设计问题，是经常出现的一种同步问题。计算机系统中的数据（文件、记录）常被多个进程共享，但其中某些进程可能只要求读数据（称为读者Reader）；另一些进程则要求修改数据（称为写者Writer）。就共享数据而言，Reader和Writer是两组并发进程共享一组数据区，要求：
（1）允许多个读者同时执行读操作；
（2）不允许读者、写者同时操作；
（3）不允许多个写者同时操作。
Reader和Writer的同步问题分为读者优先、弱写者优先（公平竞争）和强写者优先三种情况，它们的处理方式不同。
（1）读者优先。对于读者优先，应满足下列条件：
如果新读者到：
①无读者、写者，新读者可以读；
②有写者等待，但有其它读者正在读，则新读者也可以读；
③有写者写，新读者等待。
如果新写者到：
①无读者，新写者可以写；
②有读者，新写者等待；
③有其它写者，新写者等待。
信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制，而读者写者问题则是这一机制的一个经典范例。
与记录型信号量解决读者—写者问题不同，信号量机制它增加了一个限制，即最多允许RN个读者同时读。为此，又引入了一个信号量L,并赋予初值为RN，
通过执行wait（L,1,1）操作，来控制读者的数目，每当有一个读者进入时，就要执行wait（L,1,1）操作，使L的值减1。当有RN个读者进入读后，L便减为0，第RN+1 个读者要进入读时，必然会因wait（L,1,1）操作失败而堵塞。
1.2 设计目的
理解临界区和进程互斥的概念，掌握用信号量和PV操作实现进程互斥的方法。
1.3设计思想
读者-写者的读写限制（包括读者优先和写者优先）
1）写-写互斥，即不能有两个写者同时进行写操作；
2）读-写互斥，即不能同时有一个读者在读，同时却有一个写者在写；
3）读读允许，即可以有2个以上的读者同时读。
将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者，当写允许时，释放第一个写者操作。读者写者问题的定义如下：有一个许多进程共享的数据区，这个数据区可以是一个文件或者主存的一块空间；有一些只读取这个数据区的进程（Reader）和一些只往数据区写数据的进程(Writer)，此外还需要满足以下条件：
1)任意多个读进程可以同时读这个文件；
2) 一次只有一个写进程可以往文件中写；
3）如果一个写进程正在进行操作，禁止任何读进程读文件。
我们需要分两种情况实现该问题：
读优先：要求指一个读者试图进行读操作时，如果这时正有其他读者在进行操作，他可直接开始读操作，而不需要等待。
写优先：一个读者试图进行读操作时，如果有其他写者在等待进行写操作或正在进行写操作，他要等待该写者完成写操作后才开始读操作。
程序由三部分组成：
1)读者模块：包括系统调用接口，读者活动描述主程序。系统接口主要功能
是通过管道向父进程发送系统调用命令，并读取父进程送来的返回值。
2)写者模块：包括系统调用接口，写者活动描述主程序。
读者-写者活动程序根据临界资源的共享，互斥原则编制。
3）主控模块：主控模块实现系统初始化系统调用命令接收与解释执行，系统调用功能的实现（包括信号量机制），及读者-写者活动过程记录与显示。
1.4设计方案
团队合作方案：
主要成员：李荣，李龙，李志旭。
成员分工：
李荣：实施设计计划，统筹安排任务。
李荣、李志旭、李龙：查阅资料，设计流程图,调试程序，。
李志旭、李龙、李荣：设计分析程序，撰写报告册。
程序设计方案：
主要函数：
WINAPI ReaderProc(LPVOID lpParam); //创建读进程函数WINAPI WriterProc(LPVOID lpParam); //创建写进程函数CreatePersonList(g_PersonLists); //创建进程队列函数
主要变量：
m_nType;//进程类型（读写）
int m_nStartTime;//开始时间
int m_nWorkTime;//运行时间
int m_nID;//进程号
2总体分析
2.1系统总体框架：
读者-写者问题与进程同步。理解临界区和进程互斥的概念，掌握用信号量和PV操作实现进程互斥的方法。要求学生用信号量和PV操作实现读者/写者问题的读者优先算法、写者优先算法和无优先算法
图2-1 程序主框架图
2.2函数调用关系图：
图2-2 函数调用关系图2.3数据结构定义：
创建Person结构体
typedef struct _Person
{
HANDLE m_hThread;//定义处理线程的句柄
int m_nType;//进程类型（读写）
int m_nStartTime;//开始时间
int m_nWorkTime;//运行时间
int m_nID;//进程号
}Person;
int g_PersonLists[] = {//进程队列
1, W, 4, 5, 2, W, 16, 4, 3, R, 5, 2,
4, W, 6, 5, 5, R, 4, 3,
END,
};
Var RN integer;L,mx:semaphore: =RN,1；
Begin
Parbegin
Reader :begin
Repeat
Swait（L,1,1）;
Swait（mx,1,0）;
.
Perform reader operation;
Ssignal(L,1);
Until false;
End
Writer ：begin
Repeat
Swait(mx ,1,1,l,RN,0);
Perform writer operation;
Ssignal(mx,1);
Until false;
End
Parend
End
其中，Swait（mx,1,0）语句起着开关作用，只要无Writer进程进入些，mx=1，reader进程就都可以进入读。但是要一旦有Writer进程进入写时，其MX=0，则任何reader进程就都无法进入读。Swait(mx ,1,1,l,RN,0)语句表示仅当既无Writer 进程在写（mx=1），又无Reader进程在读（L=RN）时，Writer进程才能进入临界区写。
3详细设计
Reader和Writer的同步问题分为读者优先、写者优先（公平竞争）两种情况，它们的处理方式不同。
3.1读者优先
1. 读者优先流程图
读优先：要求指一个读者试图进行读操作时，如果这时正有其他读者在进行操作，他可直接开始读操作，而不需要等待。让读者进程优先执行，其他进程滞后。
图3-1 读者优先算法程序流程图
2．程序实现
DWORD WINAPI ReaderProc(LPVOID lpParam)//读过程
{
Person *pPerson = (Person*)lpParam;
// wait for the start time
while(g_CurrentTime != pPerson->m_nStartTime)
{ }
3.2写者优先
1. 写者优先流程图
写优先：写者在等待进行写操作或正在进行写操作，读者要等待该写者完成写操作后才开始读操作。让写者进程优先执行，其他进程滞后。
图3-2 写者优先算法程序流程图
2. 程序实现
WaitForSingleObject(g_hWriteSemaphore,INFINITE); // modify the writer's real start time
pPerson->m_nStartTime = g_CurrentTime;
DWORD WINAPI WriterProc(LPVOID lpParam) {
Person *pPerson = (Person*)lpParam;
// wait for the start time
while(g_CurrentTime != pPerson->m_nStartTime) {}
4调试分析
4.1程序分析
测试数据文件包括n 行测试数据，分别描述创建的n 个线程是读者还是写者，以及读写操作的开始时间和持续时间。每行测试数据包括四个字段，各字段间用空格分隔。第一字段为一个正整数，表示线程序号。第二字段表示相应线程角色，R 表示读者是，W 表示写者。第三字段为一个正数，表示读写操作的开始时间。线程创建后，延时相应时间（单位为秒）后发出对共享资源的读写申请。第四字段为一个正数，表示读写操作的持续时间。当线程读写申请成功后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。下面是一个测试数据文件的例子：
1, W，4, 5,
2, W, 16, 4,
3, R, 5, 2,
4, W, 6, 5,
4.2调试结果
图4.1进程进入队列
5, R, 4, 3,
图4.2读进程释放内存
写进程1申请资源，而进程3正在使用进程
图4.3读进程退出写进程进入队列
进程5,3依次释放资源
图4.4写进程请求资源
进程1释放资源，进程4正在使用资源。
在读者写者同时在队列中等待申请资时，读者优先调用资源。而且如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作，即读读允许。
进程1是W操作，在时间4时进入队列,运行时间是5,在它进入时没有进程占用资源，它既占用资源；直到它释放资源，等候的进程有3，4，5；其他进程如截图所示。
4.3 调试出现的问题
在程序调试过程中出现的问题有因为不细心连接的时候没有找对相应的函数名；定义一个类，但类的成员函数不小心被注释掉了；读者写着优先级判断错误；申请资源这部分对资源调用的先后次序没有做出正确的判断。
总结
这一次课程设计，我们组完成了“读者-写者问题与进程同步”问题，更加系统地理解和掌握了临界区和进程互斥的概念掌握用信号量和PV操作实现进程互斥的方法。要求学生用信号量和PV操作实现读者/写者问题的读者优先算法、写者优先算法和无优先算法。经过读者写者问题的编写，我对同步机构应用有了深入的了解，懂得了运用信号量实现进程间的互斥，实现了不让共享资源同时修改。用信号量上的原语操作使临界段问题的解决比较简单明了了。读者写者问题的编写，花的时间很多，也学到很多东西。了解在支持多道程序的并发操作系统设计中，如何解决资源共享时进程间的同步与互斥的信号量机制。
课程设计提高了我们对所学知识的综合应用能力，全面检查并掌握所学的内容，培养独立思考、刻苦钻研的精神，在分析问题、解决问题的过程中，更是获得一种成功的喜悦，进而增加学习和应用的兴趣。同时也要督促自己在学习的过程中不断的完善自我，加强自己的动手操作能力，培养我的独立思考的那种思维方式。
总之，这一次课程设计我们深刻的理解操作系统，而且锻炼了实际编程能力和思维方式，虽然有难度过程中遇到很多问题，经过深刻细致的理解问题、剖析问题、解决问题使我们深刻的认识理解了读者/写者问题与进程同步。
参考文献
[1] 汤子瀛，哲凤屏.《计算机操作系统》[M].西安：西安电子科技大学学出版社.1996年
[2] 王万森.《计算机操作系统原理》[M].北京：高等教育出版社.2001年
[3] 周长林，左万历. 《计算机操作系统教程》[M].北京：高等教育出版社.1994年
[4] 黄廷辉，王宇英.《计算机操作系统实践教程》[M].北京：清华大学出版社. 2007.5.
[5]殷兆麟.《计算机操作系统》[M].北京：清华大学出版社.2007年3月
[6]张尧学，史美林，张高.《计算机操作系统教程》[M].北京：清华大学出版社.1993年
[7] 张丽芬等，操作系统实验教程[M]，北京清华大学出版社，2006.10.
[8] 屠祁等，操作系统基础（第三版）[M]，北京清华大学出版社，2000.7.
[9] 冯耀霖等，操作系统[M]，西安电子科技大学出版社，2001.9.
[10] 左万历，计算机操作系统教程（第二版）[M]，北京高等教育出版社 2007
致谢
本次课设在选题及进行过程中得到老师的悉心指导。论文行文过程中，老师多次帮助我分析思路，开拓视角，在我遇到困难想放弃的时候给予我最大的支持和鼓励。老师严谨求实的治学态度，踏实坚韧的工作精神，将使我终生受益。再多华丽的言语也显苍白。在此，谨向老师致以诚挚的谢意和崇高的敬意。同时感谢学校给了我这次实践的机会让我知道了自己的不足。也非常感谢和我一个组的其他两位同学，我们作为一个团队，在我遇到问题的时候他们给了我很大的帮助和支持，谢谢你们！在我陷入误区的时候，是热心的老师和同学们帮助使我摆脱困境，在此再次感谢他们。
经过两个星期的艰苦拼搏，在设计程序的过程中，让我认识到光学习书本知识是远远不够的，但在此基础上更要加强自己动脑动手分析调试程序的能力，这次课设我收获很多。
最应该感谢的就是我的父母，感谢他们不辞辛苦供我上大学，养育我成人。
在课设过程中，感谢所有给予我帮助和指导的老师和同学,没有他们的帮助我的程序也不会得到这样好的完善，也不能学到这么多的知识以及经验，真的非常感谢。
经过两个星期的艰苦拼搏，在设计程序的过程中，让我认识到光学习书本知识是远远不够的，但在此基础上更要加强自己动脑动手分析调试程序的能力，这次课设我收获很多。
java实现读者写者问题(写着优先)
实验一实验报告 学号：20092128 姓名：徐卓远 实验序号：1 实验名称：用信号量来实现读者-写者问题 实验目的：理解进程同步与互斥的概念，掌握用信号量来实现进程的同步与互斥。 实验设计及实现: 为了实现读者和写者的读写过程,将每个读者和每个写者作为了一个单独的线程,所以设置了两个类,一个是读者类Reader,一个是写者类Writer.以读者类为例: 一个读者的动作过程为由睡眠->等待->开始读->结束读->睡眠的一个循环过程,而一个写者的动作过程也为此. 读者调用方法napping()进行等待,调用startRead()方法开始读,最后在调用endReading()方法结束读入,释放运行空间.写者同读者. 但是为了实现读者写者之间的写-写互斥,读-写互斥,读-读允许,需要另外一个类Database,类中分别用关于读者的方法和写者的方法来控制读写之间的这种关系. 首先要实现睡眠的方法napping(),读者和写者在睡眠过程都应该是一样的,只是他们睡眠的时间不同,所以只需写出一个方法: public static void napping() {
int sleepTime = (int) (NAP_TIME * Math.random()); try { Thread.sleep(sleepTime * 1000); } catch (Exception e) { e.printStackTrace(); } } 在方法中,控制线程休眠随机的时间,由于每个读者或写者都是一个线程,而每个读者或写者他们工作休眠的时间都不一定相同,他们请求工作的时间也不一定相同,所以取了随机时间其次设置了读者的两个方法,开始读和结束读,由于这只是个模拟读写问题,所以只需要知道结果就行,就不用显示出他是怎么读的. 在开始读中,当有写者在写时,读者需要等待wait(),在没有人在工作时,如果有写者和读者同时请求,那么就让写者先进,这是写者优先.所以这就归纳于一种情况, 当读者布尔变量dbReading为FALSE时,如果有需要工作的写者,那么读者就等待. 当读者请求读入后,计数有多少读者需要工作的变量readerCount +1,如果这是第一个进入工作的读者就需要将显示是否有读者在工作的读者布尔变量变为TRUE. public synchronized int startRead() { if (dbReading == false) {
读者和写者问题
学 号： 课 程 设 计 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）掌握基本的同步互斥算法，理解读者和写者模型 2）了解多线程的并发执行机制，线程间的同步和互斥 2.2 设计功能： 利用模拟用信号量机制实现读者和写者问题：通过用户控制读进程和写进程，反应读者和写者问题中所涉及的进程的同步与互斥。 3模块介绍 3.1函数原型 读者和写者进程由11个函数组成,分别如下: (附件包含全部具体实现) void P_write(int); void write(int); void V_write(int); void P_radd(int);
请用PV操作解决读者和写者问题
请用PV操作解决读者和写者问题。有两组并发进程：读者和写者，共享一个文件，要求：（1）允许多个读者同时执行读操作（2）在任意写者在完成写操作之前，不允许其他任意的读者和写者工作 3写者预工作，但在它之前已有读者在执行读操作，那么，待现有读者完成读操作后在执行写操作，新的读者和写者均被拒绝。Samapher matex=1/*对文件互斥*/ S1=1/*对Readcount互斥*/ Readcount=0读者记数器。 Reader: Writer: P(S1); P(mutex); Readcount++; Write a file; V(S1); V(mutex); Read a file; P(S1); Readcount--; If(Readcount==0) V(mutex); V(S1); 设由n个缓冲区组成缓冲池，每个缓冲区可以存放一个消息，有两类进程：x个生产者和y 个消费者，且只要缓冲池未满，生产者便可以将消息送入缓冲池，而只要缓冲池未空，消费者就可以取走一个消息。各个进程对缓冲池进行互斥访问，用信号量实现协调过程。要求写出使用的信号量、初值及其作用，并写出生产者进程和消费者进程的处理流程（10分）
某寺庙共有老和尚和小和尚若干人，庙外有一口井，只能容一人打水，庙内有6只水桶和一口缸，缸内最多能装30桶水，每只桶每次只能由一人使用，缸每次只能由一人使用。小和尚负责从庙外的井里打水，老和尚使用缸里的水，老和尚取水的单位是桶。请利用信号量和P、V操作描述老和尚和小和尚的活动。semaphore empty=30; // 表示缸中目前还能装多少桶水，初始时能装30桶水 semaphore full=0; // 表示缸中有多少桶水，初始时缸中没有水 semaphore buckets=6; // 表示有多少只空桶可用，初始时有6只桶可用 semaphore mutex_well=1; // 用于实现对井的互斥操作 semaphore mutex_bigjar=1; // 用于实现对缸的互斥操作 semaphore mutex_buchet=1; // 用于实现对桶的互斥操作，防止多人同时拿同一只桶yongermonk(){ while(1){P(empty); P(buckets); P(mutex_bucket); get a bucket; V(mutex_bucket); go to the well; P(mutex_well); get water; V(mutex_well); go to the temple; P(mutex_bigjar); pure the water into the big jar; V(mutex_bigjar); V(buckets); V(full);}} oldmonk(){ while(1){P(full); P(buckets); P(mutex_bucket); get a bucket; V(mutex_bucket); P(mutex_bigjar); get water; V(mutex_bigjar); V(buckets); V(empty); } }
读者写者问题课程设计说明书
-- 数学与计算机学院 课程设计说明书 课程名称: 操作系统原理-课程设计课程代码： 题目：读者写者问题 年级／专业/班: 学生姓名: 学号: 开始时间：20１1 年12月05日完成时间:20１1 年12月25 日课程设计成绩： 学习态度及平时成绩(30) 技术水平与实际 能力(20） 创新（5）说明书撰写质量(45） 总分 (100） 指导教师签名：年月日
目录 1 引言?错误!未定义书签。 1．1问题的提出?错误!未定义书签。 1.2任务于分析?错误!未定义书签。 ２程序的主要功能?错误!未定义书签。 2.1测试文本录入功能.................................... 错误!未定义书签。 2.2读者优先判断功能.................................... 错误!未定义书签。2．3写者优先判断功能.................................. 错误!未定义书签。 3 程序运行平台........................................... 错误!未定义书签。 4 总体设计............................................... 错误!未定义书签。5模块分析 ............................................... 错误!未定义书签。 5.1测试文本录入模块.................................... 错误!未定义书签。 5.2读者优先判断模块.................................... 错误!未定义书签。 5.3写者优先判断模块.................................... 错误!未定义书签。６系统测试............................................. 错误!未定义书签。 7 结论................................................................. ８致谢.................................................. 错误!未定义书签。参考文献 (10)
实验二 读者写者问题实验报告..
实验二读者写者问题实验报告 一、实验目的 Windows2000/XP提供了互斥量(mutex)、信号量(semapore)、事件(event)等三种同步对象和相应的系统调用，用于线程的互斥与同步。通过对读者写者问题的调试，了解Windows2000/XP中的同步机制。 二、实验内容及实验步骤 利用Windows2000/XP信号量机制，实现读者写者问题。 在Windows 2000环境下，创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件（后面有介绍）的要求进行读写操作。用信号量机制分别实现读者优先和写者优先的读者-写者问题。 读者-写者问题的读写操作限制（包括读者优先和写者优先）： 写-写互斥，即不能有两个写者同时进行写操作。 读-写互斥，即不能同时有一个线程在读，而另一个线程在写。 读-读允许，即可以有一个或多个读者在读。 读者优先的附加限制：如果一个读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。 写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态才能开始读操作。 运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结果读写操作时分别显示一行提示信息，以确定所有处理都遵守相应的读写操作限制。 三、实验结果及分析 图2.1 选择界面 第一字段为一个正整数，表示线程序号。第二字段表示相应线程角色，R 表示读者是，W 表示写者。第三字段为一个正数，表示读写操作的开始时间。线程创建
后，延时相应时间（单位为秒）后发出对共享资源的读写申请。第四字段为一个正数，表示读写操作的持续时间。当线程读写申请成功后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。下面是一个测试数据文件的例子： 1 R 3 5 2 W 4 5 3 R 5 2 4 R 6 5 5 W 5.1 3 测试结果如下： 图2.2 读者优先运行结果
操作系统OS报告读者与写者问题(进程同步问题)
目录 一、课程设计目的及要求 (1) 二、相关知识 (1) 三、题目分析 (2) 四、概要设计 (4) 五、代码及流程 (5) 六、运行结果 (11) 七、设计心得 (12) 八、参考文献 (12)
一、课程设计目的及要求 读者与写者问题（进程同步问题） 用n 个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求，进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者-写者问题。 读者-写者问题的读写操作限制： 1）写-写互斥； 2）读-写互斥； 3）读-读允许； 写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。 二、相关知识 Windows API： 在本实验中涉及的API 有： 1线程控制： CreateThread 完成线程创建，在调用进程的地址空间上创建一个线程，以执行指定的函数；它的返回值为所创建线程的句柄。 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD DWORD dwStackSize, // initial stack size LPTHREAD_START_ROUTINE lpStartAddress, // thread function LPVOID lpParameter, // thread argument DWORD dwCreationFlags, // creation option LPDWORD lpThreadId // thread identifier ); 2 ExitThread 用于结束当前线程。 VOID ExitThread( DWORD dwExitCode // exit code for this thread ); 3Sleep 可在指定的时间内挂起当前线程。 VOID Sleep( DWORD dwMilliseconds // sleep time ); 4信号量控制： WaitForSingleObject可在指定的时间内等待指定对象为可用状态； DWORD WaitForSingleObject( HANDLE hHandle, // handle to object DWORD dwMilliseconds // time-out interval );
操作系统课程设计--读者-写者问题
操作系统课程设计报告 一、操作系统课程设计任务书 读者- 写者问题实现 1设计目的通过实现经典的读者写者问题，巩固对线程及其同步机制的学习效果，加深对相关基本概念的理解，并学习如何将基本原理和实际设计有机的结合。 2设计要求 在Windows 2000/XP 环境下，使用多线程和信号量机制实现经典的读者写者问题，每个线程代表一个读者或一个写者。每个线程按相应测试数据文件的要求，进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者- 写者问题。 读者-写者问题的读写操作限制： (1)写-写互斥，即不能有两个写者同时进行写操作 (2)读-写互斥，即不能同时有一个读者在读，同时却有一个写者在写 (3)读-读允许，即可以有二个以上的读者同时读读者优先的附加限制：如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作。 写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。 运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确信所有处理都遵守相应的读写操作限制。 3测试数据文件格式 测试数据文件包括n 行测试数据，分别描述创建的n 个线程是读者还是写者，以及读写操作的开始时间和持续时间。每行测试数据包括四个字段，各字段间用空格分隔。第一字段为一个正整数，表示线程序号。第二字段表示相应线程角色，R 表示读者是，W 表示写者。第三字段为一个正数，表示读写操作的开始时间。线程创建后，延时相应时间(单位为秒)后发出对共享资源的读写申请。第四字段为一个正数，表示读写操作的持续时
操作系统课程设计-读者写者问题
操作系统课程设计报告
一、开题报告 （一）该项课程设计的意义； 1.更加深入的了解读者写者问题的算法； 2.加深对线程，进程的理解； 3.加深对“线程同步”概念的理解，理解并应用“信号量机制”； 4.熟悉计算机对处理机的管理，了解临界资源的访问方式； 5.了解C++中线程的实现方式，研读API。 （二）课程设计的任务 多进程/线程编程：读者-写者问题。 ●设置两类进程/线程，一类为读者，一类为写者； ●随机启动读者或写者； ●显示读者或写者执行状态； ●随着进程/线程的执行，更新显示； （三）相关原理及算法描述； 整体概况： 该程序从大体上来分只有两个模块,即“读者优先”和“写者优先”模块. 读者优先： 如果没有写者正在操作，则读者不需要等待，用一个整型变量readcount记录读者数目，用于确定是否释放读者线程，readcount的初值为0.当线程开始调入时. 每个读者准备读. 等待互斥信号,保证对readcount 的访问,修改互斥.即readcount++. 而当读者线程进行读操作时,则读者数目减少(readcount--).当readcout=0 时，说明所 有的读者都已经读完，离开临界区唤醒写者(LeaveCriticalSection(&RP_Write);), 释 放互斥信号(ReleaseMutex(h_Mutex)). 还需要一个互斥对象mutex来实现对全局变量Read_count修改时的互斥. 另外，为了实现写-写互斥，需要增加一个临界区对象Write。当写者发出写请求时， 必须申请临界区对象的所有权。通过这种方法，可以实现读-写互斥，当 Read_count=1时（即第一个读者到来时），读者线程也必须申请临界区对象的所有 权 写者优先： 写者优先与读者不同之处在于一旦一个写者到来，它应该尽快对文件进行写操作，如果有一个写者在等待，则新到来的读者不允许进行读操作。为此应当填加 一个整形变量write_count，用于记录正在等待的写者的数目，write_count的初值 为0.当线程开始调入时.只允许一个写者准备读. 等待互斥信号,保证对write_count 的访问,修改互斥.即write_count++.而当写者线程进行读操作时,则相应写者数目减 少(write_count--).当write_count=0 时，说明所有的读者都已经读完，离开临界区唤 醒读者,释放互斥信号. 为了实现写者优先，应当填加一个临界区对象read，当有写者在写文件或等待时，读者必须阻塞在read上。
面向对象OS读者-写者问题
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 ++; //来了一个读进程，读进程数加1 if (rc==1) P(write)；//如是第一个读进程，判断是否有写进程在临界区， //若有，读进程等待，若无，阻塞写进程 V(rc_mutex); //结束对rc共享变量的互斥访问 读文件； P(rc_mutex); //开始对rc共享变量的互斥访问 r c--; //一个读进程读完，读进程数减1 if (rc == 0) V(write)；//最后一个离开临界区的读进程需要判断是否有写进程//需要 进入临界区，若有，唤醒一个写进程进临界区 V(rc_mutex); //结束对rc共享变量的互斥访问 } while(1) void writer() /*写者进程*/ do{ P(write); //无读进程，进入写进程；若有读进程，写进程等待写文件; V(write); //写进程完成；判断是否有读进程需要进入临界区， //若有，唤醒一个读进程进临界区 } while(1) 读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。该算法只要还有一个读者在活动，就允许后续的读者进来，该策略的结果是，如果有一个稳定的读者流存在，那么这些读者将在到达后被允许进入。而写者就始终被挂起，直到没有读者为止。
读者写者问题写者优先代码
读者写者问题-写者优先代码 #include<stdio.h> #include<stdlib.h> int rcount=0;//正在读的读者数量 int wcount=0;//写者队列中等待写操作的写者数量 int rid=0;//读进程号 int wid=0;//写进程号 int w=1;//读写互斥信号量 char temp[300] = {'\0'}; int sign; //标识temp空的信号量0表示temp空 void WFwakeup(); void RFwakeup(); struct rqueue{//读者等待队列 int readers[200]; int index; }rq; struct wqueue{//写者等待队列 int writers[200]; int index; }wq; void read(){ int i = 0; rid++; if(rcount == 0){//当前没有读进程在读可能有写进程在写可能CPU空闲if(w==1) {//如果CPU空闲，读者拿到CPU w--;// 相当于一个P操作 rcount++; if(temp[0] == '\0'){ sign = 0; rq.readers[rq.index++]=rid;//将读者进程加入等待队列 WFwakeup(); return; }//if printf("读者%d正在读\n",rid);
for(i = 0;i < 300;i++){//读取temp内容即写者写的内容 if(temp[i] == '\0'){ printf("\n"); return; }//if printf("%c",temp[i]); }//for }//if else{//写者线程正在执行 printf("有写者在写不能读！\n"); rq.readers[rq.index++]=rid;//将读者进程加入等待队列 }//else }//if else{//rcount !=1 则知道当前已经有读者在读，读读不互斥，则这个读者可以直接进来了读 printf("读者%d正在读\n",rid); for(i = 0;i < 300;i++){ if(temp[i] == '\0'){ printf("\n"); return; } printf("%c",temp[i]); }//for }//else } //***************************写进程写操作 void write(){ wid++; if(w == 0){ if(rcount != 0 ){//有读者进程在执行 printf("有读者在读不能写！\n"); wq.writers[wq.index++]=wid;//将写者进程加入等待队列 wcount++; return; } if(rcount == 0 ){//rcount == 0则当前无读者，但w = 0，所以有写者在写 printf("有写者在写不能写！\n"); wq.writers[wq.index++]=wid;//将写者进程加入等待队列 wcount++; return; } }
操作系统实验 读者写者问题
《计算机操作系统》实验报告 题目读者写者问题 学院（部）信息学院 专业计算机科学与技术 班级 学生姓名 学号 指导教师（签字）
一、问题描述 一个数据文件或者记录，可以被多个进程共享，我们把只要求读该文件的进程称为“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
题目3-读者与写者问题
实验3 读者/写者问题与进程同步 3.1 实验目的 理解临界区和进程互斥的概念，掌握用信号量和PV操作实现进程互斥的方法。 3.2 实验要求 在linux环境下编写一个控制台应用程序，该程序运行时能创建N个线程，其中既有读者线程又有写者线程，它们按照事先设计好的测试数据进行读写操作。请用信号量和PV操作实现读者/写者问题。 读者/写者问题的描述如下： 有一个被许多进程共享的数据区，这个数据区可以是一个文件，或者主存的一块空间，甚至可以是一组处理器寄存器。有一些只读取这个数据区的进程（reader）和一些只往数据区中写数据的进程（writer）。以下假设共享数据区是文件。这些读者和写者对数据区的操作必须满足以下条件：读—读允许；读—写互斥；写—写互斥。这些条件具体来说就是：（1）任意多的读进程可以同时读这个文件； （2）一次只允许一个写进程往文件中写； （3）如果一个写进程正在往文件中写，禁止任何读进程或写进程访问文件； （4）写进程执行写操作前，应让已有的写者或读者全部退出。这说明当有读者在读文件时不允许写者写文件。 对于读者-写者问题，有三种解决方法： 1、读者优先 除了上述四个规则外，还增加读者优先的规定，当有读者在读文件时，对随后到达的读者和写者，要首先满足读者，阻塞写者。这说明只要有一个读者活跃，那么随后而来的读者都将被允许访问文件，从而导致写者长时间等待，甚至有可能出现写者被饿死的情况。 2、写者优先 除了上述四个规则外，还增加写者优先的规定，即当有读者和写者同时等待时，首先满足写者。当一个写者声明想写文件时，不允许新的读者再访问文件。 3、无优先 除了上述四个规则外，不再规定读写的优先权，谁先等待谁就先使用文件。 3.3算法分析 3.3.1读者优先 对于相继到达的一批读者，并不是每个读者都需要执行P(r_w_w)和V(r_w_w)。在这批读者中，只有最先到达的读者才需要执行P(r_w_w)，与写者竞争对文件的访问权，若执行P(r_w_w)成功则获得了文件的访问权，其他的读者可直接访问文件；同理，只有最后退出临界区的读者需要执行V(r_w_w)来归还文件访问权。 为了记录正在读文件的一批读者的数量，需要设置一个整型变量readercount，每一个读者到达时都要将readercount加1，退出时都要将readercount减1。 由于只要有一个读者在读文件，便不允许写者写文件，所以，仅当readercount=0时，即尚无读者在读文件时，读者才需要执行P(r_w_w)操作。若P(r_w_w)操作成功，读者便可去读文件，相应地，readercount+1。同理，仅当在执行了readercount减1操作后其值为0时，才需要执行V(r_w_w)操作，以便让写者写文件。又因为readercount是一个可被多个读者访问的临界资源，所以应该为它设置一个互斥信号量readercount_mutex.。每个读者在访
读者写者问题
一设计概述 所谓读者写者问题，是指保证一个writer进程必须与其他进程互斥地访问共享对象的同步问题。 读者写者问题可以这样的描述，有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书，并且，读者必写者优先，也就是说，读者和写者同时提出请求时，读者优先。当读者提出请求时需要有一个互斥操作，另外，需要有一个信号量S来当前是否可操作。 信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制，而读者写者问题则是这一机制的一个经典范例。 与记录型信号量解决读者—写者问题不同，信号量机制它增加了一个限制，即最多允许RN个读者同时读。为此，又引入了一个信号量L,并赋予初值为RN，通过执行wait（L,1,1）操作，来控制读者的数目，每当有一个读者进入时，就要执行wait（L,1,1）操作，使L的值减1。当有RN个读者进入读后，L便减为0，第RN+1 个读者要进入读时，必然会因wait（L,1,1）操作失败而堵塞。对利用信号量来解决读者—写者问题的描述如下： Var RN integer;L,mx:semaphore: =RN,1； Begin Parbegin Reader :begin Repeat Swait（L,1,1）; Swait（mx,1,0）; . Perform reader operation; Ssignal(L,1); Until false; End
Writer ：begin Repeat Swait(mx ,1,1,l,RN,0); Perform writer operation; Ssignal(mx,1); Until false; End Parend End 其中，Swait（mx,1,0）语句起着开关作用，只要无Writer进程进入些，mx=1，reader进程就都可以进入读。但是要一旦有Writer进程进入写时，其MX=0，则任何reader进程就都无法进入读。Swait(mx ,1,1,l,RN,0)语句表示仅当既无Write 进程在写（mx=1），又无reader进程在读（L=RN）时，writer进程才能进入临界区写。 本设计方案就是通过利用记录型信号量对读者写者问题的解决过程进行模拟演示，形象地阐述记录型信号量机制的工作原理。 二设计目的与内容 一实验目的 l. 用信号量来实现读者写者问题。 2. 理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。二、二实验内容 读者写者问题的定义如下：有一个许多进程共享的数据区，这个数据区可以是一个文件或者主存的一块空间；有一些只读取这个数据区的进程（Reader）和一些只往数据区写数据的进程(Writer)，此外还需要满足以下条件：（1）任意多个读进程可以同时读这个文件； （2）一次只有一个写进程可以往文件中写； （3）如果一个写进程正在进行操作，禁止任何读进程度文件。
操作系统课程设计读者写者问题
计算机与信息学院 操作系统课程设计报告一、开题报告 （一）该项课程设计的意义； 1.更加深入的了解读者写者问题的算法； 2.加深对线程，进程的理解； 3.加深对“线程同步”概念的理解，理解并应用“信号量机制”； 4.熟悉计算机对处理机的管理，了解临界资源的访问方式； 5.了解C++中线程的实现方式，研读API。 （二）课程设计的任务 多进程/线程编程：读者-写者问题。 ●设置两类进程/线程，一类为读者，一类为写者； ●随机启动读者或写者； ●显示读者或写者执行状态； ●随着进程/线程的执行，更新显示； （三）相关原理及算法描述； 整体概况： 该程序从大体上来分只有两个模块,即“读者优先”和“写者优先”模块. 读者优先： 如果没有写者正在操作，则读者不需要等待，用一个整型变量readcount记录读者数目，用于确定是否释放读者线程，readcount的初值为0.当线程开始调入时.每个读者准备读. 等待互斥信号,保证对readcount 的访问,修改互斥.即readcount++.而当读者线程进行读操作时,则读者数目减少(readcount--).当readcout=0 时，说明所有的读者都已经读完，离开临界区唤醒写者(LeaveCriticalSection(&RP_Write);), 释放互斥信号(ReleaseMutex(h_Mutex)). 还需要一个互斥对象mutex来实现对全局变量Read_count修改时的互斥. 另外，为了实现写-写互斥，需要增加一个临界区对象Write。当写者发出写请求时，必须申请临界区对象的所有权。 通过这种方法，可以实现读-写互斥，当Read_count=1时（即第一个读者到来时），读者线程也必须申请临界区对象的所有权 写者优先： 写者优先与读者不同之处在于一旦一个写者到来，它应该尽快对文件进行写操作，如果有一个写者在等待，则新到来的读者不允许进行读操作。为此应当填加一个整形变量write_count，用于记录正在等待的写者的数目，write_count的初值为0.当线程开始调入时.只允许一个写者准备读. 等待互斥信号,保证对write_count 的访问,修改互斥.即write_count++.而当写者线程进行读操作时,则相应写者数目减少(write_count--).当write_count=0 时，说明所有的读者都已经读完，离开临界区唤醒读者,释放互斥信号. 为了实现写者优先，应当填加一个临界区对象read，当有写者在写文件或等待时，读者必须阻塞在read上。
读者写者问题写者优先参考答案
【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。给出读者、写者问题的另一个解决方案：即保证当有一个写者进程想写时，不允许读者进程再进入，直到写者写完为止，即写者优先。 让我们先回顾读者写者问题[1]： 一个数据对象若被多个并发进程所共享，且其中一些进程只要求读该数据对象的内容，而另一些进程则要求写操作，对此，我们把只想读的进程称为“读者”，而把要求写的进程称为“写者”。在读者、写者问题中，任何时刻要求“写者”最多只允许有一个执行，而“读者”则允许有多个同时执行。因为多个“读者”的行为互不干扰，他们只是读数据，而不会改变数据对象的内容，而“写者”则不同，他们要改变数据对象的内容，如果他们同时操作，则数据对象的内容将会变得不可知。所以对共享资源的读写操作的限制条件是： 允许任意多的读进程同时读； 一次只允许一个写进程进行写操作； 如果有一个写进程正在进行写操作，禁止任何读进程进行读操作。 为了解决该问题，我们只需解决“写者与写者”和“写者与第一个读者”的互斥问题即 可，为此我们引入一个互斥信号量Wmutex，为了记录谁是第一个读者，我们用一个共享整 型变量Rcount 作一个计数器。而在解决问题的过程中，由于我们使用了共享变量Rcount，
该变量又是一个临界资源，对于它的访问仍需要互斥进行，所以需要一个互斥信号量Rmutex， 算法如下：
void writer() /*写者进程*/ { while (true) { P(Wmutex); ??; write; /* 执行写操作 */ ??; P(Wmutex); } } 现在回到【写者优先】优先问题 【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。给出读者、写者问题的另一个解决方案：即保证当有一个写者进程想写时，不允许读者进程再进入，直到写者写完为止，即写者优先。 【解题思路】在上面的读者写者问题基础上，做以下修改： 增加授权标志authFlag，当写者到来，发现有读者在读，则取消授权，然后等待缓冲区； 增加“等待授权计数器waitAuthCount”，写者离开时，如果 waitAuthCount大于0，则迭代唤醒等待授权的读者； 读者到来，首先看授权标志，如果有授权标志，则继续，否则等待授权，
读者写者问题,操作系统课程设计
某某大学 课程设计报告课程名称：操作系统课程设计 设计题目：读者写者问题 系别：计算机系 专业：计算机科学与技术 组别：第四组 学生姓名: 某某某学号: 起止日期: 指导教师:
目录 1、需求分析 (1) 1.1 课程设计题目 (1) 1.2课程任务及要求 (1) 1.3课程设计思想 (1) 1.4软硬件运行环境及开发工具 (2) 2、概要设计 (2) 2.1程序流程图 (2) 2.2所用原理 (3) 2.2.1 并发原理 (3) 2.2.2 互斥操作原理 (4) 2.2.3 面向对象编程编程原理 (4) 2.2.4 锁机制原理 (5) 2.2.5 线程的原理 (6) 2.2.6 读者写者问题的一般应用 (6) 3、详细设计 (6) 4、调试与操作说明 (11) 5、课程设计总结与体会 (12) 6、致谢 (13) 7、参考文献 (13)
1、需求分析 1.1课程设计题目 课程设计题目：读者写者问题 1.2课程任务及要求 编写程序实现读者写者算法（读_写互斥，读_读允许，写写互斥） 给出解决方案（包括说明设计实现的原理，采用的数据结构等） 画出程序的基本结构框图和流程图 分析说明每一部分程序的的设计思路 实现源代码 按期提交完整的程序代码和可执行程序 根据要求完成课程设计报告 总结 1.3课程设计思想 读者-写者问题是一个经典的并发程序设计问题。有两组并发进程：读者和写者，共享文件F，要求： (1)允许多个读者同时对文件执行读操作； (2)只允许一个写者对文件执行写操作； (3)任何写者在完成写操作之前不允许其他读者或写者工作； (4)写者在执行写操作前，应让已有的写者和读者全部退出。 单纯使用信号量不能解决此问题，必须引入计数器readcount对读进程记数。 为了有效的解决读者写者问题，需要引进读者-写者锁，允许多名读者同时以只读的方式存取有锁保护的对象；或一位写者以写方式存取有锁保护的对象。当一名或多名读者上锁后，此时形成读锁，写者将不能访问有锁保护的对象；当锁被请求者用于写操作时，形成写锁，其他进程的读写操作必须等待。
读者-写者问题的实现
目录 摘要 (1) 1．设计思想 (2) 2．各模块的伪码算法 (3) 3. 函数关系调用图 (5) 4．程序测试结果 (6) 设计总结 (9) 参考文献 (10) 致谢 (11)
摘要 本设计的读者写者问题，是指一些进程共享一个数据区。数据区可以使一个文件、一块内存空间或者一组寄存器。Reader进程只能读数据区中的数据，而writer进程必须与其他进程互斥地访问共享对象的同步问题。 读者写者问题可以这样的描述, 有一群写者和一群读者, 写者在写同一本书, 读者也在读这本书, 多个读者可以同时读这本书。但是,只能有一个写者在写书, 并且,读者必写者优先,也就是说，读者和写者同时提出请求时,读者优先。当读者提出请求时需要有一个互斥操作, 另外, 需要有一个信号量S来确定当前是否可操作。 本设计方案就是通过利用记录型信号量对读者写者问题的解决过程进行模拟演示，形象地阐述记录型信号量机制的工作原理。 关键词：共享对象，互斥，同步，信号量
1．设计思想 本设计借助C语言实现进程同步和互斥的经典问题--读者写者问题，用高级语言编写和调试一个进程同步程序，以加深对进程同步机制的理解。通过用C 语言模拟进程同步实现，加深理解有关进程同步和互斥机制的概念及P、V操作的应用。学生通过该题目的设计过程，掌握读者、写者问题的原理、软件开发方法并提高解决实际问题的能力。 在 Windows环境下,创建一个包含n个线程的控制台进程。用这n个线每个线程按相应测试数据文件的要求，进行读写操作。程来表示 n 个读者或写者。请用信号量机制分别实现读者优先和写者优先的读者-写者问题。 将所有的读者和所有的写者分别放进两个等待队列中，当读允许时就让读者队列释放一个或多个读者,当写允许时，释放第一个写者操作。 读者-写者的读写限制(包括读者优先和写者优先) 1)写-写互斥,即不能有两个写者同时进行写操作； 2)读-写互斥,即不能同时有一个读者在读,同时却有一个写者在写； 3)读读允许,即可以有 2 个以上的读者同时读； 4)读者优先附加条件：如果一个读者申请进行读操作，同时又有一个读操作正在进行读操作，则该读者可以直接开始读操作； 5)写者优先附加条件：如果一个读者申请进行读操作时已经有一个写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。