读者写者问题写者优先代码
操作系统——读者-写者问题的解决方法

操作系统——读者-写者问题的解决⽅法问题描述不允许Write进程和Read进程或其他Write进程同时访问⽂件,Read进程可以和其他Read进程同时访问。
分为三种类型。
读者优先要求:1.多个读者可以同时访问⽂件2.同⼀时间只允许⼀个写者访问⽂件3.读者和写者进程互斥解决⽅法:⽤⼀个readcounter记录是第⼏个读者在读,如果是第⼀个读者,则不能让写者写,需要⼀个锁。
因为readcounter是临界资源,也需要⼀个互斥量。
semaphore rc_mutex = 1, wmutex = 1;readcounter = 0;void writer{do{wait(wmutex);//writesignal(wmutex);}while(TRUE);}void reader{do{wait(rc_mutex);if(readcounter == 0) wait(wmutex);readcounter ++;signal(rc_mutex);// readwait(rc_mutex);readcounter --;if(!readcounter) signal(wmutex);signal(rc_mutex);}while(TRUE);}写者优先要求:1.读者写者互斥2.写者读者同时等待时,所有等待的写者优先,等所有写者结束后,读者才能读3.没有写者时,读者能同时读4.写者到来时,不会终⽌已经进⾏的读者操作解决⽅法:semaphore wc_mutex = 1, prior = 1; //写者计数器,优先信号量readcounter = 0, writercounter = 0;void writer{do{wait(wc_mutex); //申请更改wc的权限if(writercounter == 0) //如果是第⼀个写者,就申请优先权限wait(prior);writercounter ++;signal(wc_mutex);wait(wmutex);//writesignal(wmutex);wait(wc_mutex);writercounter --;if(!writercounter)signal(prior); //当最后⼀个写者操作完成后,释放优先级权限 signal(wc_mutex);}while(TRUE);}void reader{do{wait(prior); //先申请优先级权限,如果前⾯还有写者就等待wait(rc_mutex);if(readcounter == 0) wait(wmutex);readcounter ++;signal(rc_mutex);signal(prior); //释放优先级权限// readwait(rc_mutex);readcounter --;if(!readcounter) signal(wmutex);signal(rc_mutex);}while(TRUE);}读写均等semaphore prior = 1; //读者和写者都等待在⼀个队列上,实现读写均等readcounter = 0, writercounter = 0;void writer{do{wait(prior);wait(wmutex);//writesignal(wmutex);signal(prior);}while(TRUE);}void reader{do{wait(prior);wait(rc_mutex);if(readcounter == 0) wait(wmutex);readcounter ++;signal(rc_mutex);signal(prior);//readwait(rc_mutex);readcounter --;if(!readcounter) signal(wmutex);signal(rc_mutex);}while(TRUE);}有错误请指出!。
北理工操作系统实验二读者写者问题

本科实验报告实验名称:操作系统原理实验(读者写者问题)课程名称:操作系统原理实验时间:2015.10.30 任课教师:王耀威实验地点:10#102实验教师:苏京霞实验类型: 原理验证□综合设计□自主创新学生姓名:孙嘉明学号/班级:1120121474/05611202 组号:学院:信息与电子学院同组搭档:专业:信息对抗技术成绩:实验二:读者写者问题一、实验目的1.通过编写和调试程序以加深对进程、线程管理方案的理解;2.熟悉Windows多线程程序设计方法;二、实验要求在Windows环境下,创建一个控制台进程,此进程包含n个线程。
用这n个线程来表示n个读者或写者。
每个线程按相应测试数据文件(后面介绍)的要求进行读写操作。
用信号量机制分别实现读者优先和写者优先问题。
读者-写者问题的读写操作限制(包括读者优先和写者优先)1)写-写互斥:不能有两个写者同时进行写操作2)读-写互斥:不能同时有一个线程在读,而另一个线程在写。
3)读-读允许:可以有一个或多个读者在读。
读者优先的附加限制:如果读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。
运行结果显示要求:要求在每个线程创建、发出读写申请、开始读写操作和结束读写操作时分别显示一行提示信息,以确定所有处理都遵守相应的读写操作限制。
测试数据文件包括 n行测试数据,分别描述创建的n个线程是读者还是写者,以及读写操作的开始时间和持续时间。
每行测试数据包括四个字段,每个字段间用空格分隔。
第1个字段为正整数,表示线程的序号。
第2个字段表示线程的角色,R表示读者,W表示写者。
第3个字段为一个正数,表示读写开始时间:线程创建后,延迟相应时间(单位为秒)后发出对共享资源的读写申请。
第4个字段为一个正数,表示读写操作的延迟时间。
当线程读写申请成功后,开始对共享资源进行读写操作,该操作持续相应时间后结束,释放该资源。
下面是一个测试数据文件的例子(在记事本手工录入数据):1 R 3 52 W 4 53 R 5 24 R 6 55 W 5.1 3三、实验环境硬件设备:个人计算机。
读者-写者问题解答

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)读者优先的设计思想是读进程只要看到有其它读进程正在读,就可以继续进行读;写进程必须等待所有读进程都不读时才能写,即使写进程可能比一些读进程更早提出申请。
读者写者问题实验报告

读者写者问题实验报告引言读者写者问题是计算机科学中经典的同步问题之一,它涉及多线程编程中的资源竞争与同步机制。
通过对读者写者问题的研究,我们可以深入理解线程同步的重要性,并掌握解决并发编程中可能出现的竞争条件和死锁等问题的方法。
在本实验中,我们将设计并实现一个简单的读者写者问题的解决方案,并通过模拟多个读者和写者的并发访问来验证方案的正确性和效果。
问题描述读者写者问题可描述为:有一共享资源(如文件、数据库等),读者可同时访问共享资源进行读取操作,但写者在进行写入操作时,不可同时被其他任何读者或写者访问。
读者和写者的并发访问需要由线程同步机制来保证共享资源的一致性和完整性。
实验设计与实现为了解决读者写者问题,我们需要考虑以下几个关键点:1. 共享资源的访问控制我们可以使用互斥量(Mutex)来实现对共享资源的访问控制。
当一个线程访问共享资源时,它需要先获得互斥量的锁,如果锁已被其他线程占用,则线程进入等待状态,直到锁可用。
一旦线程完成对共享资源的访问,它将释放锁,以便其他线程继续访问。
2. 读者与写者的优先级在读者写者问题中,我们往往需要设定某个优先级规则,以确定读者和写者之间的调度顺序。
一种常见的策略是给予写者优先级,即当一个写者在等待访问共享资源时,其他读者都必须等待。
这样做是为了避免写者长时间等待,以免造成饥饿问题。
3. 记录读者和写者的数量为了控制读者和写者的并发访问,我们需要记录当前同时访问共享资源的读者和写者的数量。
我们可以使用整数变量来记录读者和写者的数量,并通过信号量来保证对这些计数变量的互斥访问。
4. 同步机制的设计在实现读者写者问题的解决方案时,我们需要考虑如何合理地使用互斥量和信号量,并结合优先级规则来实现读者和写者的同步。
这需要通过仔细的设计和调试来确保解决方案的正确性。
实验结果与分析我们基于上述设计实现了一个读者写者问题的解决方案,并进行了多次仿真实验。
实验环境•操作系统:Windows 10•编程语言:C++•编译器:GCC实验步骤1.编写读者和写者线程的代码,其中涉及到对共享资源的读取和写入操作,以及对计数变量和互斥量的访问操作。
操作系统例题汇总

1.2例题精选例1.1如何理解虚拟机的概念?解:一台仅靠由硬件组成的计算机一般被称为裸机,不易使用。
操作系统为用户使用计算机提供了许多服务,从而把一台难于使用的裸机改造成了功能更强大、使用更方便的计算机系统,这种计算机系统称为虚拟机。
所谓虚拟,是指把一个物理上的实体变为若干个逻辑上的对应物。
前者是实际存在的,而后者是虚的,只是用户的一种感觉。
在单CPU的计算机系统中能同时运行多道程序,好像每个程序都独享一个CPU,这就是虚拟。
在构造操作系统时,把操作系统分成若干层,每层完成特定的功能,从而形成一个虚拟机。
下层的虚拟机为上层的虚拟机提供服务,这样逐次扩充以完成操作系统的功能。
讨论“虚拟”的概念体现在操作系统的方方面面。
例如,虚拟存储器,使一台只有4MB 内存的计算机可以运行总容量远远超过4 MB的程序;虚拟外设,能够使多个用户同时访问该外设等。
例1.2什么是多道程序设计,它的主要优点是什么?解: 所谓多道程序设计是指把一个以上的程序存放在内存中,并且同时处于运行状态,这些程序共享CPU和其他计算机资源。
其主要优点是:(1)CPU的利用率高:在单道程序环境下,程序独占计算机资源,当程序等待I/O操作时CPU空闲,造成CPU资源的浪费。
在多道程序环境下,多个程序共享计算机资源,当某个程序等待I/O操作时,CPU可以执行其他程序,这大大地提高了CPU的利用率。
(2)设备利用率高:在多道程序环境下,内存和外设也由多个程序共享,无疑也会提高内存和外设的利用率。
(3)系统吞吐量大:在多道程序环境下,资源的利用率大幅度提高,减少了程序的等待时间,提高了系统的吞吐量。
讨论多道程序在计算机中并发地运行是现代计算机系统的重要特征。
早期的单道批处理系统与人工操作相比自动化程度大大提高,但系统中仍有较多的空闲资源,系统的性能较差。
多遭批处理系统虽有很多优点,但这种系统交互能力差,作业的平均周转时间长。
多道程序处理系统要解决的主要问题是,如何使多个程序合理、有序地共事处理机、内存、外设等资源。
读写者问题

设计一读者写者问题实习环境:系统为Windows XP + VC 6.0一、实验目的:1、加深对进程概念的理解,明确进程和程序的区别,进一步认识并发执行的实质;2、理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。
二、设计要求在Windows XP下创建一个控制台进程,该进程应包含n个线程。
用这n个线程来表示n个读者或写者。
每个线程按相应测试数据文件(后面介绍)的要求进行读写操作。
用信号量机制分别实现读者优先和写者优先的读者-写者问题。
读者-写者问题的操作限制(包括读者优先和写者优先):1)写-写互斥,即不能有两个写者同时进行写操作。
2)读-写互斥,即不能同时有一个线程在读,而另一个线程在写。
3)读-读互斥,即可以有一个或多个读者在读。
读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。
写者优先的附加限制:如果一个读者申请进行读操作时已有另一个写者在等待访问共享资源,则该读者必须等到没有写者出于等待状态后才能开始读操作。
测试文件格式说明,下面是一个测试数据文件的例子:1 R 3 52 W 4 53 R 5 24 R 6 55 W 5.1 36 R 15 47 R 15 4三、设计说明1、读者优先指除非有写者在写文件,否则读者不需要等待。
所以可以用一个整形变量readnum记录当前的读者数目,用于确定是否需要唤醒正在等待的写者进程(当readnum==读者人数时,表明所有的读者读完,需要唤醒写者等待队列中的第一个写者)。
每一个读者开始读文件时,必须修改readnum变量。
因此需要一个互斥对象rnum[]来实现对全局变量readnum修改时的互斥。
另外,为了实现写写互斥,需要增加一个临界区对象wstate。
当写者发出写请求时,必须申请临界区对象的所有权。
通过这种方法,也可以实现读写互斥,当readnum=2时(即第一个读者到来时),读者进程也必须申请临界区对象的所有权。
读者写者问题写者优先参考答案完整版

读者写者问题写者优先参考答案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);写者优先有可能导致读者进程产⽣饥饿现象,当系统中不断出现写者进程时,读者进程始终⽆法进⼊临界区。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
读者写者问题-写者优先代码
#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;
}
}
if(w == 1){
w--;
printf("写者%d正在写\n请输入要写的内容",wid);
scanf("%s",temp);
//while
}//if
}
//******************************************写者优先唤醒
void WFwakeup(){
int i = 0;
int j = 0;
int m;
m = rq.index;
//n = wq.index;
if(rcount == 0){//当前无读进程,是写者在写--》停止运行写进程
bool writer_wait=false;
w=1;
printf("写者已经写完\n");
sign = 1;//temp中已经有内容要置1
for(i=0;i<=wq.index;i++){// index为当前写者队列中的等待进程数
if(wq.writers[i]!=0){
writer_wait=true; //确实有写者在等待
printf("等待的写者%d正在写\n 请输入要写的内容\n",wq.writers[i]); w = 0;
scanf("%s",temp);
wq.writers[i]=0;
wcount--;
break;
}
}
if(!writer_wait){//没有写者等待,看是
否有读者等待
for(int i=0;i<=m;i++){//检查写者等待队列
if(rq.readers[i]!=0){
w = 0;
printf("等待的读者%d正在读\n",rq.readers[i]);
for(j = 0;j < 300;j++){
if(temp[j] == '\0'){
printf("\n");
rq.index--;
break;
}//if
printf("%c",temp[j]);
}//for
rq.readers[i]=0;
rcount++;
}//if
}//for
}//if
// return;
}//if
else{//rcount != 0读者正在读,stop读此时若有等待必为写者
rcount=0;
w = 1;
printf("读者已经读完\n");
for(int i=0;i<=wq.index;i++){// 检查写者等待队列
if(wq.writers[i]!=0){
w = 0;
printf("等待的写者%d正在写\n请输入要写入的内容",wq.writers[i]);
scanf("%s",temp);
wq.writers[i]=0;
wcount--;
break;
}//if
}//for
}
}
void main(){
char i;
printf("=====================\n 0.显示主菜单\n 1.创建读者进程\n 2.创建写者进程\n 3.结束当前执行的进程\n 4.退出程序\n=====================\n");
do{
printf("当前队列中有读者:%d个写者:%d个\n",rq.index,wcount); scanf("%s",&i);
switch(i){
case '0':
printf("=====================\n 0.显示主菜单\n 1.创建读者进程\n 2.创建写者进程\n 3.结束当前执行的进程\n 4.退出程序\n=====================\n"); break;
case '1':
read();
break;
case '2':
write();
break;
case '3':
WFwakeup();
break;
case '4':
exit(0);
default:
printf("输入错误请重新输入\n"); }
}while(true);
}。