题目3-读者与写者问题
读者-写者问题的实现
目录摘要 (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)写者优先附加条件：如果一个读者申请进行读操作时已经有一个写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
进程同步模拟设计——读者和写者问题
学号：课程设计题目进程同步模拟设计——读者和写者问题学院计算机科学与技术学院专业、班级、姓名、指导教师吴利军2013 年01 月17 日课程设计任务书学生：指导教师：吴利军工作单位：计算机科学与技术学院题目: 进程同步模拟设计——读者和写者问题初始条件：1．预备容：阅读操作系统的进程管理章节容，对进程的同步和互斥，以及信号量机制度有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟用信号量机制实现读者和写者问题。
2．设计报告容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，一律按0分记）指导教师签名：年月日系主任（或责任教师）签名：年月日1 需求分析所谓读者写者问题,是指保证一个 writer 进程必须与其他进程互斥地访问共享资源的同步问题.读者写者问题可以这样的描述,有一群写者和一群读者, 写者在写同一本书,读者也在读这本书,多个读者可以同时读这本书,但是只能有一个写者在写书,并且读者优先,也就是说,读者和写者同时提出请求时,读者优先.当读者提出请求时需要有一个互斥操作, 另外需要有一个信号量 mutex来当前是否可操作.信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制,而读者写者问题则是这一机制的一个经典例. 与记录型信号量解决读者—写者问题不同,信号量机制它增加了一个限制,即最多允许n个读者同时读.为此引入了一个信号量Rcount,并赋予初值为 0,通过执行Rcount++操作,来控制读者的数目,每当有一个读者进入时,就要执行Rcount++操作,使 Rcount 的值加1.读者离开时Rcount--;当且仅当Rcount==0时，V （Wmutex），才能进行写操作。
读者-写者问题说明书
《操作系统原理》课程设计任务书题目：读者-写者问题的实现学生姓名：李志旭学号：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 陈映霞”，内容包括任务书、设计文档。
操作系统复习题答案
1、在设备管理中，数据传送控制方式有哪几种？试比较它们各自的优缺点。
1、程序控制输入/输出方式。
控制相对简单，不需要硬件支持，CPU和I/O设备串行工作，适用于CPU执行速度较慢且外设较少的设备。
2、中断输人／输出方式。
能实现CPU和I/O设备及I/O设备间的并行，中断次数过多，数据容易丢失，适用于中断次数少且外设较少的设备。
3、直接存储器方式DMA方式。
能实现CPU和I/O设备间的并行，设备和主存之间可以直接成批传送数据，大大减少了CPU干预，需要存储器硬件支持。
4、通道控制方式。
CPU权利下放，干预更少，提高了系统资源利用率，需要硬件支持。
2、文件的物理组织结构常见的有几种？它们与文件的存取方式有什么关系？⑴、顺序结构（又称连续结构）：是顺序存取时速度较快；当文件是定长记录文件时，还可根据文件起始地址及记录长度进行随机访问。
⑵、链接（又称串联）结构：链接文件只能按照文件的指针链顺序访问，因而查找效率较低。
⑶、索引结构：是可以进行随机访问，也易于进行文件的增删。
3、文件存储空间管理的方法有哪些？它们的优缺点？①、空闲文件目录：⑴、如果文件太大，那么在空白文件目录中将没有合适的空白文件能分配给它，尽管这些空白文件的总和能满足需求。
⑵、经过多次分配和回收，空白文件目录中的小空白文件越来越多，很难分配出去，形成碎片。
②、空闲块链：⑴、可实现不连续分配。
⑵、由于每个空闲块的指针信息都是存放在上一空闲块中的，这样就不用占用额外的存储空间，与空白文件目录管理方法相比节省了存储开销。
⑶、因为链接信息是存放在每个空闲块中的，每当在链上增加或删除空白块时需要很多输入／输出操作，系统开销大。
⑷、对于大型文件系统，空闲链将会太长。
③、位示图：采用位示图的方法管理辅存空间较为简单，并且由于位示图很小，可放在内存中，访问速度较快。
4、系统中调度的层次分为几级，它们的主要任务各是什么？一般地，处理机的调度分为3级：⑴、作业调度：又称宏观调度，或高级调度。
读者写者问题描述
读者写者问题描述嘿，你问读者写者问题啊？那我给你讲讲哈。
咱就说啊，这读者写者问题呢，就好比一个图书馆。
有很多人想去看书，这就是读者。
还有人想去写书，那就是写者。
有一回啊，我去图书馆。
那里面好多人都在安静地看书呢。
这时候就相当于有很多读者在享受知识。
突然，有个作家模样的人来了，他想找个地方坐下来写书。
这就是写者出现了。
这时候问题就来了。
如果读者和写者同时在图书馆里，会咋样呢？如果读者一直在看书，写者就没办法好好写书，因为他会觉得被打扰了。
反过来，如果写者一直在写书，读者也没办法好好看书，因为他们不知道啥时候能看到新的内容。
就像我在图书馆里，我正看得入迷呢，突然那个作家开始大声地思考他的情节，哎呀，那可把我烦死了。
我就想，你能不能安静点啊，让我好好看书嘛。
这就像读者希望写者不要打扰他们一样。
那怎么办呢？就得有个规则。
比如说，让写者先等读者都看完书走了，他再开始写书。
或者让读者在写者写书的时候，稍微安静一点，不要弄出太大动静。
我记得有一次，我在图书馆里，有个写者特别有礼貌。
他进来的时候，看到很多读者，就悄悄地找了个角落坐下，等大家都看得差不多了，他才开始动笔。
这样大家都能和谐共处了。
读者写者问题就是要找到一个平衡，让读者能愉快地看书，写者也能安心地写书。
不能让一方太强势，影响了另一方。
就像在生活中，我们也会遇到类似的情况。
比如说，一个办公室里，有人在安静地工作，有人在讨论问题。
这时候就得互相体谅，不能太吵了，影响别人工作。
总之啊，读者写者问题就是要解决大家在共享资源的时候，如何和谐相处的问题。
嘿嘿，你明白了不？。
读者与写者问题
2012--2013学年第一学期______________________学院综合设计《读者与写者问题》学号：姓名：: 成绩：IIi 评语：I _____________________________________________________________________________________________________________________________________ I* 设计要求：I: 用P、V操作实现读者写者问题，写者不多于5个，读者不多于20个。
Ii 所有读者和写者访问同一个文件all.txt ，每个写者向文件添加一行，内容；是“I'm the writer number X. It is TIME. ”，其中X是pid，TIME是订访问文件的时间，格式为hh-mm-ss.ddd;每个读者读出最后一个写者的pid 和写的时间，并在屏幕上输出。
每个读者或写者的访问次数为32-100之间的随机数，同一个写者相邻两次的访问间隔不得短于0.1秒，同一个读者相邻两次的访问间隔不得短于0.05秒。
线I目录1、概述 (2)1.1 设计题目 (2)1.2 设计目的 (2)1.3 开发环境 (2)1.4 设计要求 (2)2、设计思想 (2)3、具体程序实现 (2)4、运行结果 (6)5、总结 (8)6、参考文献 (9)读者写者问题的实现1、概述1.1 设计题目读者写者问题的实现1.2 设计目的通过对操作系统内核实现代码的阅读、修改、设计，理解和掌握复杂的操作系统的工作原理。
通过研究Linux 的线程机制和信号量实现读者写者(Reader-Writer) 问题并发控制。
1.3 开发环境使用的操作系统：Linux 系统使用的编程语言：C语言1.4 设计要求用P、V操作实现读者写者问题，写者不多于5个，读者不多于20个。
所有读者和写者访问同一个文件all.txt ，每个写者向文件添加一行，内容是“ I'm the writer numberX. It is TIME. ”，其中X是pid ,TIME是访问文件的时间，格式为hh-mm-ss.ddd ；每个读者读出最后一个写者的pid 和写的时间，并在屏幕上输出。
读者写者问题
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)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。
读者写者问题写者优先参考答案完整版
读者写者问题写者优先参考答案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);写者优先有可能导致读者进程产⽣饥饿现象，当系统中不断出现写者进程时，读者进程始终⽆法进⼊临界区。
读者-写者问题解答
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)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。
操作系统之读者与写者问题(C++)
printf("第%d位读者正在读。。。\n", myid);
Sleep(2000);//模拟读操作
printf("第%d位读者已完成\n", myid);
WaitForSingleObject(rc_mutex, INFINITE);//对rc互斥访问
ReleaseMutex函数的功能是释放互斥对象的控制权，可以理解为使一个特定的内核对象变为已通知状态。
4.测试及实验结果
4.1 实验结果
图4-1 第一次运行结果图
图4-2 第二次运行结果图
4.2 结果分析
根据图4-1的运行结果来分析，当第二位读者和第二位写者同时存在时，先运行的是写者进程，只有当写者进程完成操作后才能进行读者进程，根据图4-2的运行结果来分析，第一位读者进入后需等第四位写者完成写操作后才能开始读操作。总得来看，该程序得读者与写者得优先级其实是一样的，谁先创建的就谁先运行，但必须等上一个进程完成后才能运行下一个进程。
6.参考文献
[1]张玉生、刘炎、张亚红. C语言程序设计[M].上海交通大学出版社，2004
[2]陆丽娜.计算机操作系统[M].高等教育出版社. 2015.8
[3]李春葆.数据结构教程[M].清华大学出版社，2004
[4].陈向群，向勇等. Windows操作系统原理(第二版) [M]. 机械工业出版社，2004
rc -= 1;//读者数减1
if (rc == 0)
ReleaseMutex(w);//释放写互斥信号量
ReleaseMutex(rc_mutex);//释放互斥信号量rc_mutex
return 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，则迭代唤醒等待授权的读者；⏹读者到来，首先看授权标志，如果有授权标志，则继续，否则等待授权，即写者取消授权后，新来的读者不能申请缓冲区。
计算机操作系统复习题目(2)
第二章进程管理（三）进程同步5、经典同步问题1、生产者—消费者问题生产者消费者问题是一种同步问题的抽象描述。
计算机系统中的每个进程都可以消费（使用）或生产（释放）某类资源。
这些资源可以是硬件资源，也可以是软件资源。
当某一进程使用某一资源时，可以看作是消费，称该进程为消费者。
而当某一进程释放某一资源时，它就相当于生产者。
问题1：设某计算进程CP和打印进程IOP共用一个单缓冲区，CP进程负责不断地计算数据并送入缓冲区T中，IOP进程负责不断地从缓冲区T中取出数据去打印。
通过分析可知，ＣＰ、ＩＯＰ必须遵守以下同步规则：(1)当ＣＰ进程把计算结果送入缓冲区时，IOP进程才能从缓冲区中取出结果去打印;(2)当IOP进程把缓冲区中的数据取出打印后，ＣＰ进程才能把下一个计算结果送入缓冲区.(3)为此设有两个信号量Sa=0，Sb=1，Sa表示缓冲区中有无数据，Sb表示缓冲区中有无空位置。
两个进程的同步可以描述如下：问题2：一组生产者通过具有N个缓冲区的共享缓冲池向一组消费者提供数据。
问题分析”：为解决生产者消费者问题，应该设两个同步信号量，一个说明空缓冲区的数目，用empty表示，初值为有界缓冲区的大小N，另一个说明已用缓冲区的数目，用full表示，初值为０。
由于在此问题中有M个生产者和N个消费者，它们在执行生产活动和消费活动中要对有界缓冲区进行操作。
由于有界缓冲区是一个临界资源，必须互斥使用，所以，另外还需要设置一个互斥信号量mutex，其初值为１。
问题的解：注意：在每个程序中用于实现互斥的P(mutex)和V(mutex)必须成对的出现对资源信号量empty和full的P和V操作，同样需要成对地出现，但它们分别处于不同的程序中。
在每个程序中的多个P操作顺序不能颠倒。
先同步后互斥。
生产者进程缓冲池消费者进程1┇┇i┇┇2、哲学家就餐问题有五个哲学家围坐在一圆桌旁，桌中央有一盘通心粉，每人面前有一只空盘子，每两人之间放一只筷子。
阅读者写入者问题
二、阅读者写入者问题实验目的通过经典的并发程序（同步）问题，理解临界区和进程互斥的概念，掌握用信号量和PV操作实现进程互斥的方法。
问题描述有一公用数据区，读者写者要共同访问，其中一些需要阅读其中的信息，一些需要修改其中的信息。
阅读者可以同时访问数据区，而写入者只能互斥的访问数据区，不能与任何的进程一起访问数据区。
分析：读者和写者是两组并发进程，共享一组数据区，且满足：（1）n个读者正在读，则允许多个读者同时读；（读—读允许）（2）一个写者正在写，则禁止多个写者同时写；（写—写互斥）（3）n个读者正在读，则禁止写者同时写；（读—写互斥）；（4）一个写者正在写，则禁止读者同时读；（读—写互斥）对策：对新读者：①无读者则读；②有读者则读；③无写者则读；④有写者则等。
对新写者：①无读者则写；②有读者则等；③无写者则写；④有写者则等。
伪代码：（完整代码见附录）int rdc = 0; //读者计数semaphore data, mutex; //两个信号量handle Reading, Writing; //两个事件void ReaderThreadState(char *R, ...) //读者线程输出void WriterThreadState(char *W) //写者线程输出int ReaderThread()//读者线程int WriterThread()//写者线程int main()//主函数//读者数由宏定义，序号随机//写者唯一ReaderThread://读者线程{ //读者等P(Writing); //等待写事件释放文件空间P(&mutex); //占用计数空间rdc++; //多一个读者if (rdc == 1) //第一个读者V(&mutex); //释放计数空间//读者读P(&mutex); //占用计数空间//读结束rdc--; //少一个读者if (rdc == 0) //最后一个读者V(Reading); //读完释放文件空间V1(&mutex); //释放计数空间return 0;}WriterThread://写者线程{ //写者等P(Reading);//等待读事件释放文件空间//写者写//写完V(Writing); //释放文件空间return 0;}Main//主函数{ HANDLE Event[Rd_No + 1];//所有线程集合for (i = 1; i <= 2; i++)//先启动2个读者线程（防止写者饿死）//启动写者线程for ( ; i <= Rd_No; i++)//后启动其它读者线程WaitForMultipleObjects(Rd_No + 1, Event, TRUE, INFINITE);for (i = 0; i < Rd_No + 1; i++)CloseHandle(Event[i]);//关闭进程}运行结果(#define Rd_No 7 //7个读者1个写者)心得体会这一次操作系统实验，是通过信号量和pv操作实现经典算法“阅读者与写入者问题”。
读者和写者问题
学号：课程设计课程名称操作系统学院计算机科学与技术学院专业软件工程专业班级姓名指导教师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 设计目的通过实验模拟读者和写者之间的关系，了解并掌握他们之间的关系及其原理。
实验3__读者-写者问题与进程同步
实验3 读者/写者问题与进程同步3.1 实验目的理解临界区和进程互斥的概念，掌握用信号量和PV操作实现进程互斥的方法。
3.2 实验要求在windows或者linux环境下编写一个控制台应用程序，该程序运行时能创建N个线程，其中既有读者线程又有写者线程，它们按照事先设计好的测试数据进行读写操作。
请用信号量和PV操作实现读者/写者问题。
读者/写者问题的描述如下：有一个被许多进程共享的数据区，这个数据区可以是一个文件，或者主存的一块空间，甚至可以是一组处理器寄存器。
有一些只读取这个数据区的进程（reader）和一些只往数据区中写数据的进程（writer）。
以下假设共享数据区是文件。
这些读者和写者对数据区的操作必须满足以下条件：读—读允许；读—写互斥；写—写互斥。
这些条件具体来说就是：（1）任意多的读进程可以同时读这个文件；（2）一次只允许一个写进程往文件中写；（3）如果一个写进程正在往文件中写，禁止任何读进程或写进程访问文件；（4）写进程执行写操作前，应让已有的写者或读者全部退出。
这说明当有读者在读文件时不允许写者写文件。
对于读者-写者问题，有三种解决方法：1、读者优先除了上述四个规则外，还增加读者优先的规定，当有读者在读文件时，对随后到达的读者和写者，要首先满足读者，阻塞写者。
这说明只要有一个读者活跃，那么随后而来的读者都将被允许访问文件，从而导致写者长时间等待，甚至有可能出现写者被饿死的情况。
2、写者优先除了上述四个规则外，还增加写者优先的规定，即当有读者和写者同时等待时，首先满足写者。
当一个写者声明想写文件时，不允许新的读者再访问文件。
3、无优先除了上述四个规则外，不再规定读写的优先权，谁先等待谁就先使用文件。
3.3实验步骤3.3.1 算法分析有同学认为，可以将文件视为临界资源，使用临界资源的代码就构成临界区，为了对临界区进行管理，只需设置一个互斥信号量r_w_w，读或者写之前执行P(r_w_w)，之后执行V(r_w_w)即可，从而得到图3-1所示的算法描述。
操作系统课程之“读者—写者”问题教学探讨
操作系统课程之“读者—写者”问题教学探讨操作系统课程之“读者—写者”问题教学探讨摘要：针对操作系统教学中概念多而繁杂、容易混淆，初学者存在畏难情绪等问题，文章提出采取类比、逐层解剖、层层深入、循序渐进的教学方法，并以操作系统中的进程同步互斥问题中“读者－写者”问题为例，对其概念、算法进行形象启发、分层解剖的阐述，并结合多种教学方法，说明使学生能更深刻地理解进程同步互斥问题的方法。
教学实践表明其效果良好。
关键词：操作系统；分层解剖；读者－写者问题；PV原语；教学实践操作系统是计算机专业的一门核心课程(图1)，其在计算机系统中的特殊地位，使得该课程的学习在整个计算机学科教育中显得尤为重要。
作为一门理论性和实践性并重的课程，它具有概念多、算法较抽象的特点，同时又涉及了程序设计语言、软件工程思想、算法设计、计算机系统结构、网络等相关知识。
枯燥的理论讲述往往使学生感到抽象、难懂，进而产生厌学的思想。
尽管近年来一些高校在加强理论教学的同时，引入对操作系统内核的分析，如Linux操作系统，在教学实践方面取得了一点的成效，但是对于初学者和教师而言，在一个学期内课时数不变的情况下，完成教与学的工作显得有点心有余而力不足。
为了在有限的教学时间内，提高教学效率，既让学生深入理解理论知识，又能借助PV操作原语来验证操作系统的算法思想，笔者根据以往教学经验，结合初学者学习的实际情况，以进程同步中“读者－写者”为例，探讨如何由浅入深、循序渐进地开展教学工作。
1 问题描述“读者—写者”问题是现代操作系统中经典的进程同步互斥问题，在以C/S模式为代表的多进(线)程通信系统都可以作为该模型的不同表现形式，有着广泛的应用[1]。
该问题描述如下：一个数据文件或记录可被多个进程所共享，我们将其中只要求读该文件的进程称为读者，即“Reader进程”，其他进程称为写者，即“Writer进程”。
多个Reader 进程和多个Writer进程在某个时间段内对该文件资源进行异步操作，也就是说允许多个进程同时读一个共享对象，但绝不允许一个Writer进程和其他Reader进程或Writer进程同时访问共享对象，因此，所谓“读者—写者问题”就是指必须保证一个Writer进程和其他进程(Writer进程和Reader进程)互斥地访问共享对象的同步问题[2]。
实验一 读写者问题
实验三读者-写者问题模拟实现一、实验题目模拟实现读者-写者问题二、实验目的通过模拟实现经典的读者——写者问题，巩固对同步机制的学习，学会运用信号量、PV原语处理进程间的同步和互斥。
三、实验要求设计实现读者-写者问题模拟程序。
在Windows2000环境下，创建一个控制台程序，此程序包含n个线程。
用这n个线程来表示n个读者或写者。
每个线程按相应测试数据文件(后面有介绍)的要求进行读写操作。
用信号量机制分别实现读者优先或写者优先的读者-写者问题。
[提示]：1、读者-写者问题的读写操作限制(包括读者优先和写者优先):1)写-写互斥，即不能有两个写者同时进行写操作。
2)读-写互斥，即不能同时有一个线程在读，而另一个线程在写。
，3)读-读允许，即可以有一个或多个读者在读。
•如果读者来：–无读者、写者，新读者可以读–有写者等待，但有其他读者正在读，新读者可以读–有写者写，新读者等•如果写者来：–无读者，新写者可以写–有读者，新写者等待–有其他写者，新写者等待读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。
写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
2、P、 V操作如下•读者：BEGINP(mutex);//上锁，互斥其他读者，为了保证只有一个读者改变read_count read_count:=read_count+1;IF read_count=1 //第一个读者，则上写者的锁，保证读得时候不能让写者写THEN P(writer)V(mutex);读文件；P(mutex); //同上，互斥读者，为了保证只有一个读者改变read_count read_count:=read_count-1;IF read_count=0 //最后一个读者，signal写者，可以写THEN V(write);V(mutex);END;•写者：BEGINP(write);写文件;V(write);END;四、实验报告提纲1、实验题目及要求。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验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.。
每个读者在访问readercount 之前执行P(readercount_mutex)，之后执行V(readercount_mutex)。
通过上述分析得到图3-2所示的算法描述，其中的数字表示语句对应的行号。
下面对该算法的调度效果进行分析。
假设最初没有进程在访问文件。
过了一会，就会有很多读者和写者到达。
对它们可能有两种调度情形。
情形1 最先调度写者写者执行P(r_w_w)操作成功，将r_w_w 的值变为0，获得文件的访问权；其它的写者执行P(r_w_w)将r_w_w 的值变为负数，从而阻塞在信号量r_w_w 上；第一个读者执行P(readercount_mutex)成功，将信号量readercount_mutex 的值变为0，然后判断readercount 是0，所以执行P(r_w_w)，将r_w_w 的值减1后仍然为负数从而阻塞在信号量r_w_w 上，其它的读者执行P(readercount_mutex)将信号量readercount_mutex 的值变为负数，从而阻塞在信号量readercount_mutex 上。
例如，对于请求序列w1,w2,r1,w3,r2,r3，我们用图表形象地刻画进程的活动，图表中包括读者计数器的值、信号量readercount_mutex 和r_w_w 的值和队列以及访问文件的进程。
①初始状态。
没有进程使用文件，计数器readercount 的值是0，信号量readercount_mutex 和r_w_w 的值都是1，队列都是空，参见图3-3；②w1请求写文件，所以执行语句17，将信号量r_w_w 的值减1后变成0，w1获得文件使用权，执行语句18，开始写文件，参见图3-4；③在w1尚未写完时，w2提出写请求，所以执行语句17，将信号量r_w_w 的值减1后变成负1，w2被阻塞在信号量r_w_w 上，参见图3-5；④同时r1提出读请求，所以执行语句5，将信号量readercount_mutex 的值减1后变成0，接着执行语句6，判断readercount 的值是0，所以执行P(r_w_w)，将信号量r_w_w 的值减1后变成-2，r1被阻塞在信号量r_w_w 上，参见图3-6；⑤同时w3提出写请求，所以执行语句17，将信号量r_w_w 的值减1后变成-3，w3被阻塞在信号量r_w_w 上，参见图3-7；⑥同时r2提出读请求，所以执行语句5，将信号量readercount_mutex 的值减1后变成-1，r2被阻塞在信号量readercount_mutex 上，参见图3-8；⑦同时r3提出读请求，所以执行语句5，将信号量readercount_mutex 的值减1后变成-2，r3被阻塞在信号量readercount_mutex 上，参见图3-9；⑧w1写完文件，执行语句19，将信号量r_w_w 的值加1后变成-2，并唤醒w2，w2接着执行语句18，开始写文件，参见图3-10；⑨w2写完文件，执行语句19，将信号量r_w_w 的值加1后变成-1，并唤醒r1，r1接着执行语句7，将readercount 的值加1后变成1，执行语句8，将信号量readercount_mutex 的值加1后变成-1，并唤醒r2，r1执行语句9，开始读文件；被唤醒的r2执行语句6，判断readercount 的值不是0，所以执行语句7，将readercount 的值加1后变成2，执行语句8，将信号量readercount_mutex 的值加1后变成0，并唤醒r3，r2执行语句9，开始读文件；被唤醒的r3执行语句6，判断readercount 的值不是0，所以执行语句7，将readercount 的值加1后变成3，执行语句8，将信号量readercount_mutex 的值加1后变成1，r3执行语句9，开始读文件。
这样三个读者同时读文件，参见图3-11；⑩当r1、r2和r3读完文件时，都执行语句10~14，并由最后一个执行语句10~14的读者执行V(r_w_w)，将信号量r_w_w 的值加1后变成0，并唤醒w3，w3接着执行语句18，开始写文件，参见图3-12；当w3写完文件时，执行语句19，将信号量r_w_w 的值加1后变成1，回到初始状态。
可见，对于请求序列w1,w2,r1,w3,r2,r3，实际访问文件的顺序是w1,w2,r1,r2,r3,w3。
虽然w3比r2、r3先提出请求，但是由于在此之前已经有r1在读文件，所以优先响应读者r2、r3，阻塞写者w3。
如果在w3之后不断有新的读者到达，则w3将一直被阻塞，直至被饿死。
情形2 最先调度读者第一个读者执行P(readercount_mutex)成功，将信号量readercount_mutex 的值变为0，接着该读者判断readercount 是0，所以执行P(r_w_w)操作成功，获得文件的访问权，将r_w_w 的值变为0，然后将readercount 变成1，执行V(readercount_mutex)，之后开始读文件；随后的写者执行P(r_w_w)将r_w_w 的值变为负数，从而阻塞在信号量r_w_w 上；其它的读者执行P(readercount_mutex)成功，判断readercount 不是0，所以直接将readercount 的值再加1，执行V(readercount_mutex)，之后开始读文件。
可见多个读者可以同时读文件，并在读文件时阻塞写者。
---------------------------------------------------------------------------------------------------------------- 3.3.2、写者优先通过增加信号量并修改上述程序可以得到写者优先算法。
为了实现写者优先算法，需要将写者和读者分开排队，并且第一个读者和其它读者也要分开排队。
这样就需要三个队列，一个是写者排队的地方，另一个是第一个读者排队的地方，第三个是其它读者排队的地方。
相应地需要设置三个信号量，r_w_w、first_reader_wait和reader_wait。
当一个写者声明想写文件时，可以让新的读者中的第一个到first_reader_wait上排队等待；当有读者阻塞在first_reader_wait上时，让其它读者阻塞在reader_wait上；当有一个写者在写文件时，其它写者到r_w_w上排队。
只要有活跃的写者或者写者队列不为空，则阻塞新到达的读者。
为了记录已经发出声明的写者数量，需要设置一个整数writercount，以表示声明要写文件的写者数目。
由于只要有一个写者到达，就不允许读者去读，因此仅当writercount=0，表示无写者声明写时，写者才需要执行P(first_reader_wait)操作，若操作成功，写者便可以执行P(r_w_w)去竞争写文件权利。
其它写者不需要再向读者声明，可以直接执行P(r_w_w)去竞争写文件权利。
同理仅当写者在执行writercount减1操作后其值为0时，才需要执行V(first_reader_wait)操作，以便唤醒第一个被阻塞的读者去读文件。
又因为writercount是一个可被多个写者访问的临界资源，所以，应该为它设置一个互斥信号量writer_mutex。
通过上述分析得到图3-13的算法描述。
下面对该算法的调度效果进行分析。
假设最初没有进程在访问文件。
过了一会，就会有很多读者和写者到达。
对它们可能有两种调度情形。
情形1 最先调度写者写者执行P(writercount_mutex)，将writercount_mutex的值变为0，并判断writercount 是0，从而执行P(first_reader_wait)，将first_reader_wait的值变为0，成功地向读者声明了写访问意图，接着将writercount变为1，执行V(writercount_mutex)，将writercount_mutex 的值变为1。