题目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.。每个读者在访
问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。然后写者执行P(r_w_w)操作，将r_w_w的值变为0，成功地获得了文件的写访问权利。第一个写者开始写文件；
其它的写者执行P(writercount_mutex)，判断writercount不是0，所以直接将writercount 加1，执行V(writercount_mutex)，然后执行P(r_w_w)操作，将r_w_w的值变为负数，写者依次被阻塞在信号量r_w_w上；
第一个读者执行P(reader_wait)，将reader_wait的值变为0，接着执行P(first_reader_wait)，将first_reader_wait的值变为负1，阻塞在信号量first_reader_wait 上；其它读者执行P(reader_wait)，将reader_wait的值变为负数，依次阻塞在reader_wait 上。
当第一个写者写完文件后，执行V(r_w_w)，唤醒一个写者并将写者计数器writercount 减1，被唤醒的写者可以写文件，写完后执行V(r_w_w)，唤醒下一个写者并将写者计数器writercount减1，直到最后一个写者将writercount减为0，才执行V(first_reader_wait)唤醒第一个阻塞的读者。
被唤醒的读者执行P(readercount_mutex)，然后判断readercount是0，从而执行P(r_w_w)，由于最后一个写者写完文件后，r_w_w的值已经还原为1，所以被唤醒的读者执行P(r_w_w)成功，将r_w_w的值变为0，获得文件的读访问权。接着将readercount的值加到1，执行V(readercount_mutex)，再执行V(reader_wait)，唤醒第二个等待的读者，第一个读者执行V(first_reader_wait)，将first_reader_wait的值还原到1。第一个读者可以读文件了。
若没有新的写者到达，则第二个读者执行P(first_reader_wait)成功，执行P(readercount_mutex)并判断readercount不是0，将readercount加到2，执行V(readercount_mutex)，再执行V(reader_wait)唤醒第三个读者，再执行V(first_reader_wait)，第二个读者也可以读文件了。
情形2 最先调度读者
第一个读者执行P(reader_wait)，将reader_wait的值变为0，执行P(first_reader_wait)，将first_reader_wait的值变为0，向写者声明有读者要读文件，接着执行P(readercount_mutex)，并判断readercount是0所以执行P(r_w_w)，将r_w_w的值变为0，成功地获得了文件的读访问权，将读者计数器readercount加到1，执行V(readercount_mutex)，V(reader_wait)，V(first_reader_wait)，将reader_wait和first_reader_wait的值依次还原为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。然后写者执行P(r_w_w)操作，（由于有读者在读文件，所以）将r_w_w的值变为负1，写者被阻塞在信号量r_w_w上；当在读文件的所有读者都读完文件后，由最后一个退出的读者执行V(r_w_w)唤醒写者。第一个写者开始写文件。
----------------------------------------------------------------------------------------------------------------
3.3.3 无优先
除了在读者优先时需要的信号量r_w_w和readercount_mutex之外，还需要设置一个信号量wait供读者和写者排队。读者和写者都排在wait队列上。若有读者在读文件，则第一个写者阻塞在r_w_w上，其它的写者和读者阻塞在wait上；若有一个写者在写文件，则其它写者和读者都阻塞在wait上。
下面对该算法的调度效果进行分析。最初没有进程在访问文件。过了一会，就会有很多读者和写者到达。对它们可能有两种调度情形。
情形1 最先调度写者
写者执行P(wait)操作成功，将wait的值变为0，再执行P(r_w_w)操作成功，将r_w_w 的值变为0，获得文件的访问权，写者可以写文件了。
其它的写者或者读者执行P(wait)操作，将wait的值变为负数，从而依次阻塞在信号量wait上；
第一个写者写完文件后，执行V(r_w_w)，将r_w_w的值还原为1，再执行V(wait)唤醒排在wait队列最前面的一个进程，可能是读者，也可能是写者。
情形2 最先调度读者
第一个读者执行P(wait)操作成功，将wait的值变为0，再执行P(readercount_mutex)成功，将信号量readercount_mutex的值变为0，接着该读者判断readercount是0，所以执行P(r_w_w)操作成功，获得文件的访问权，将r_w_w的值变为0，然后将readercount变成1，执行V(readercount_mutex)，V(wait)，将信号量readercount_mutex和wait的值还原为1，之后开始读文件；
若随后到达的仍然是读者，则这些读者将readercount各加1之后也开始读文件；
若随后到达的是写者，则写者执行P(wait)操作成功，将wait的值变为0，再执行P(r_w_w)操作将r_w_w的值变为负数，从而阻塞在r_w_w上。这使得在它之后到达的读者和写者相继阻塞在wait上。
当第一批读者读完文件后，由最后一个退出的读者执行执行V(r_w_w)，从而唤醒第一
个被阻塞的写者。
4 设计并分析测试数据
并对测试数据进行分析，总结出在该组测试数据
下，程序应该得到什么结果，然后运行程序，将
程序运行结果与分析结果相比较，如果二者一致，
则可认为程序是正确的。
作者设计的测试数据如图3-15所示，包括
10个线程，其中有5个读者线程r1~r5，另外5
个是写者线程w1~w5。读者线程r1在时刻0提
出读请求，如果请求得到允许，r1将用15秒的
时间读文件；写者线程w3在时刻6提出写请求，
如果请求得到允许，w3将用10秒的时间写文件。
从表中可以看出，10个线程提出请求的次序是：
r1,r2,w1,r3,w2,w3,r4,r5,w4,w5。
请分析一下测试数据在不同调度算法下的调度次序。
实验报告中需包含本申请序列在三种（读优先、写优先、无优先）策略中的任意两种算法上的分析过程。
5 程序功能及界面设计
字符界面显示：
**************************
1.演示读者优先算法；
2.演示写者优先算法；
3.演示无优先算法；
4.退出。
**************************
6 函数设计建议
图3-88 函数功能简述
说明：读者和写者的申请可以采用多种方式：
（1）程序运行过程中自动随机产生读、写进程并定义读写时间；（2）通过数据文件读入预先设定好的读写申请序列及读写时间；（3）程序运行过程中通过键盘输入交互式提交读写请求。
读写进程的调度过程可以动态更新显示或者通过列表统一显示。
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)写者优先附加条件：如果一个读者申请进行读操作时已经有一个写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。