读者-写者问题的实现
目录
摘要 (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)写者优先附加条件：如果一个读者申请进行读操作时已经有一个写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
2．各模块的伪码算法
读者优先算法：
设置两个互斥信号量：
rwmutex 用于写者与其他读者/写者互斥的访问共享数据
rmutex 用于读者互斥的访问
读者计数器 readcount
semaphore rwmutex=1, rmutex=1;
int readcount = 0;
reader i //读者进程i=1,2,….
do{
P(rmutex); //读者互斥
readcount++; //读者数加1
if (readcount == 1) P(rwmutex); //读者写者互斥
V(rmutex);
读者读数据;
P(rmutex);
Readcount--;
if (readcount == 0) V(rwmutex);
V(rmutex);
}while(1);
writer j //写者进程j = 1,2,….
do{
P(rwmutex);
写文件；
V(rwmutex);
}while(1);
写者优先算法：
设置三个互斥信号量：
rwmutex 用于写者与其他读者/写者互斥的访问共享数据
rmutex 用于读者互斥的访问
读者计数器readcount
nrmutex 用于写者等待已进入读者退出，所有读者退出前互斥写操作semaphore rwmutex= 1，rmutex= 1，nrmutex= 1;
int readcount = 0;
reader i //读者进程i=1,2,….
do{
P(rwmutex);
P(rmutex);
readcount++;
if (readcount == 1) P(nrmutex); //有读者进入，互斥写操作
V(rmutex);
V(rwmutex);//及时释放读写互斥信号量，允许其它读、写进程申请资源读数据;
P(rmutex);
readcount--;
if (readcount == 0) V(nrmutex); //所有读者退出，允许写更新
V(rmutex);
}while(1);
writer j //写者进程j = 1,2,….
do{
P(rwmutex); // 互斥后续其它读者、写者
P(nrmutex); //如有读者正在读，等待所有读者读完
写更新；
V(nrmutex); //允许后续新的第一个读者进入后互斥写操作
V(rwmutex); //允许后续新读者及其它写者
}while(1);
3. 函数关系调用图
图1 函数关系图
4．程序测试结果
测试数据文件包括 n 行测试数据,分别描述创建的 n 个线程是读者还是写者,以及读写操作的开始时间和持续时间.每行测试数据包括四个字段,各字段间用空格分隔。第一字段为一个正整数,表示线程序号.第二字段表示相应线程角色,R 表示读者是，W 表示写者。第三字段为一个正数,表示读写操作的开始时间。线程创建后,延时相应时间 (单位为秒) 后发出对共享资源的读写申请. 第四字段为一个正数,表示读写操作的持续时间。当线程读写申请成功后,开始对共享资源的读写操作,该操作持续相应时间后结束,并释放共享资源。
在读者写者同时在队列中等待申请资时,读者优先调用资源.而且如果一个读者申请进行读操作时已有另一读者正在进行读操作, 则该读者可直接开始读操作,即读读允许。
图2 进程1、2的测试结果
如图2所示，进程1是W操作,在时间3时进入队列,运行时间是5,即在时间8时，进程1退出。在它进入时没有进程占用资源,它既占用资源;知道它释放资源,等候的进程有3,4,5；
图3 进程3、5的测试结果
如图3所示，进程5是R操作,在时间4时进入队列,运行时间是3, 进程3是R操作,在时间5时进入队列,运行时间是 2, 在它们进入时，进程1占用资源,它等待资源,当进程1释放资源后,由于读者优先,进程 3,5 同时调运资源，因此在时间11时，进程3退出，在时间12时，进程5退出；
图4 进程2、4、6的测试结果
如图4所示，进程4是W操作,在时间5时进入队列,运行时间是5,在它
进入时进程1占用资源,它等待资源,当进程1释放资源后,由于读者优先,进程3,5占用资源,它依然等待,直到进程 3,5 都结束，即进程4在时间12时开始调用资源；进程2是R操作, 在时间16时进入队列,运行时间是5,在它进入时进程4占用资源,它等待资源,当4释放时占用资源后，进程2开始运行；进程6是R操作,在时间17时进入队列,运行时间是7,在它进入时进程2占用资源,它等待进程2释放后最后调用资源。
设计总结
课程设计是培养学生综合运用所学知识,发现,提出,分析和解决实际问题,锻炼实践能力的重要环节,是对学生实际工作能力的具体训练和考察过程。
此次操作系统课程设计，我的感慨颇多，的确，从选题到定稿，从理论到实践，在整整两星期的日子里，我学到很多的东西;同时不仅巩固了以前所学过的知识，而且学到了很多在书本上所没有学到过的知识。
通过这次课程设计我懂得了理论与实际相结合的重要性，只有理论知识是远远不够的，所以只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正的服务于社会，从而提高自己的实际动手能力和独立思考的能力。在设计的过程中遇到问题，可以说是困难重重，难免会遇到过各种各样的问题，同时在设计的过程中发现了自己的不足之处，对以前所学过的知识理解得不够深刻，掌握得不够牢固。因此，在以后的学习中要多下苦功，加强基础知识的学习，并且培养自己的动手实践能力。
参考文献
1. 汤子瀛，哲凤屏. 计算机操作系统，西安：电子科技大学学出版社，2002年
2. 王清，李光明. 计算机操作系统，北京：冶金工业出版社，2003年3月
3.孙钟秀等. 操作系统教程. 北京：高等教育出版社，2008年4月
4.曾明. Linux操作系统应用教程. 西安：陕西科学技术出版社，2005年
5. 张丽芬，刘利雄. 操作系统实验教程. 北京：清华大学出版社，2006年
6. 孟静.操作系统教程——原理和实例分析. 北京：高等教育出版社，2001年
7. 周长林. 计算机操作系统教程. 北京：高等教育出版社，2011年12月
8. 张尧学. 计算机操作系统教程.北京：清华大学出版社，2006年10月
9. 任满杰. 操作系统原理实用教程.北京：电子工业出版社，2006年1月
致谢
这次课程设计培养了我耐心、缜密、全面地思考问题的能力，从而加快了问题解决的速度、提高了个人的工作效率，以及锻炼了使问题在短时间内得以解决的品质。我从“纸上谈兵”到可以自己动脑动手分析调试程序，收获不少。
首先要感谢学校给我这次实践的机会，给了自己一个舞台。这不仅是对自身的检验，而且增加了我编写代码的功力。还有多亏了老师们从理论到上机亲自指导的辛苦教授，给予了我们最大帮助和全面指导。在这里，尤其感谢我的指导老师朱红蕾老师，你不辞辛苦的给我们耐心指导。在这里，我衷心向你们致谢！最后还要感谢热心的同学们，在我陷入误区的时候，是他们热心的帮助使我摆脱困境。
最后衷心感谢所有给予我帮助和指导的老师和同学,没有他们的帮助我的程序也不会完成得这么顺利。
源代码：
#include
#include
#include
#include
#include
#include
#define MAX_PERSON 100
#define READER 0 //读者
#define WRITER 1 //写者
#define END -1
#define R READER
#define W WRITER
typedef struct _Person {
HANDLE m_hThread; //定义处理线程的句柄int m_nType; //进程类型(读写) int m_nStartTime; //开始时间
int m_nWorkTime; //运行时间
int m_nID;//进程号
}Person;
Person g_Persons[MAX_PERSON];
int g_NumPerson = 0;
long g_CurrentTime= 0; //基本时间片数
int g_PersonLists[] = {//进程队列
1, W, 3, 5, 2, W, 16, 5, 3, R, 5, 2,
4, W, 6, 5, 5, R, 4, 3, 6, R, 17,7,
END,
};
int g_NumOfReading = 0;
int g_NumOfWriteRequest = 0; //申请写进程的个数HANDLE g_hReadSemaphore; //读者信号
HANDLE g_hWriteSemaphore; //写者信号
bool finished = false; //所有的读完成//bool wfinished = false; //所有的写完成void CreatePersonList(int *pPersonList);
bool CreateReader(int StartTime,int WorkTime,int ID);
bool CreateWriter(int StartTime,int WorkTime,int ID);
DWORD WINAPI ReaderProc(LPVOID lpParam);
DWORD WINAPI WriterProc(LPVOID lpParam);
int main()
{
g_hReadSemaphore = CreateSemaphore(NULL,1,100,NULL); //创建信号灯,当前可用的资源数为 1,最大为100
g_hWriteSemaphore = CreateSemaphore(NULL,1,100,NULL); //创建信号灯,当前可用的资源数为 1,最大为100
CreatePersonList(g_PersonLists); // 创建所有的读者和写者
printf("Created all the reader and writer\n...\n"); g_CurrentTime = 0;
while(true)
{
g_CurrentTime++;
Sleep(300); // 300 ms
printf("CurrentTime = %d\n",g_CurrentTime);
if(finished) return 0;
} // return 0;
}
void CreatePersonList(int *pPersonLists)
{
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)写者优先附加条件：如果一个读者申请进行读操作时已经有一个写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。