实验二读者写者问题实验报告完整版

合集下载

读者写者实验报告

读者写者实验报告

读者写者实验报告
读者写者问题是指一个共享固定大小缓冲区的进程间通信问题,其中固定大小的缓冲区被多个读者进程和写者进程所共享。

读者进程从缓冲区中读取数据,而写者进程将数据写入缓冲区。

本实验目的是通过使用互斥锁、条件变量和信号量等同步机制,构建一个读者写者问题的解决方案。

实验环境:
- 操作系统:Linux
-编程语言:C语言
实验步骤:
1.创建共享内存缓冲区,用于读者和写者的数据传递。

2.创建互斥锁,用于保护共享内存缓冲区的访问。

3.创建条件变量,用于读者和写者之间的协调。

4.创建读者进程和写者进程,模拟读者写者的并发操作。

5.在读者进程中,通过互斥锁保护共享内存缓冲区,读取数据,并更新计数器。

6.在写者进程中,通过互斥锁保护共享内存缓冲区,写入数据,并更新计数器。

7.使用条件变量实现读者优先或写者优先的策略。

实验结果:
通过实验,我成功实现了读者写者问题的解决方案。

使用互斥锁可以保护共享资源的访问,防止读者和写者同时访问。

使用条件变量可以实现读者优先或写者优先的策略。

实验总结:
通过本次实验,我深入了解了读者写者问题,并且掌握了使用互斥锁、条件变量和信号量等同步机制来解决读者写者问题的方法。

在实现过程中,我遇到了一些困难,例如死锁和竞争条件等问题。


过调试和改进代码,我成功解决了这些问题,提高了程序的稳定性和性能。

在以后的工作中,我会更加注重并发编程的实践,提高自己解决问题
的能力。

(完整word版)操作系统实验报告.实验一 WINDOWS进程初识

(完整word版)操作系统实验报告.实验一 WINDOWS进程初识

操作系统教程实验指导书实验一WINDOWS进程初识1、实验目的(1)学会使用VC编写基本的Win32 Consol Application(控制台应用程序)。

(2)掌握WINDOWS API的使用方法。

(3)编写测试程序,理解用户态运行和核心态运行。

2、实验内容和步骤(1)编写基本的Win32 Consol Application步骤1:登录进入Windows,启动VC++ 6.0。

步骤2:在“FILE”菜单中单击“NEW”子菜单,在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名,在“Location”处输入工程目录。

创建一个新的控制台应用程序工程。

步骤3:在“FILE”菜单中单击“NEW”子菜单,在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。

步骤4:将清单1-1所示的程序清单复制到新创建的C/C++源程序中。

编译成可执行文件。

步骤5:在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令,进入Windows “命令提示符”窗口,然后进入工程目录中的debug子目录,执行编译好的可执行程序:E:\课程\os课\os实验\程序\os11\debug>hello.exe运行结果 (如果运行不成功,则可能的原因是什么?) :答:运行成功,结果:(2)计算进程在核心态运行和用户态运行的时间步骤1:按照(1)中的步骤创建一个新的“Win32 Consol Application”工程,然后将清单1-2中的程序拷贝过来,编译成可执行文件。

步骤2:在创建一个新的“Win32 Consol Application”工程,程序的参考程序如清单1-3所示,编译成可执行文件并执行。

步骤3:在“命令提示符”窗口中运行步骤1中生成的可执行文件,测试步骤2中可执行文件在核心态运行和用户态运行的时间。

北理工操作系统实验二读者写者问题

北理工操作系统实验二读者写者问题

本科实验报告实验名称:操作系统原理实验(读者写者问题)课程名称:操作系统原理实验时间: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三、实验环境硬件设备:个人计算机。

读者写者问题实验报告

读者写者问题实验报告

读者写者问题实验报告1. 引言读者写者问题是操作系统中的经典同步问题,用于研究多线程环境下对共享资源的访问和保护。

在该问题中,有多个读者和写者同时对一个共享资源进行操作,需要保证并发访问时的正确性和效率。

通过本实验,我们将探讨读者写者问题的解决方案,并比较不同算法的性能差异。

2. 实验目标本实验的主要目标是通过实现和比较不同的读者写者问题算法,深入了解并发访问的挑战和解决方案。

具体而言,我们将研究以下几个方面:•设计并实现读者写者问题的解决方案•比较不同算法的性能差异•分析可能的优化策略3. 实验方法我们将使用Python编程语言来实现读者写者问题的解决方案。

在实验过程中,我们将尝试以下几种常见的算法:3.1. 读者优先算法在读者优先算法中,当有读者在访问共享资源时,其他读者可以同时访问,但写者需要等待。

只有当所有读者完成访问后,写者才能获得访问权限。

3.2. 写者优先算法在写者优先算法中,当有写者在访问共享资源时,其他读者和写者都需要等待。

只有当写者完成访问后,其他读者或写者才能获得访问权限。

3.3. 公平算法在公平算法中,读者和写者的访问权限是公平的,先到先得。

无论读者还是写者,都需要按照到达的顺序依次获取访问权限。

4. 实验步骤下面是我们实施实验的具体步骤:4.1. 实现基本的读者写者问题解决方案我们首先实现基本的读者写者问题解决方案,包括读者和写者的线程逻辑和共享资源的访问控制。

我们将使用互斥锁和条件变量来保证并发访问的正确性。

4.2. 实现读者优先算法在已有的基本解决方案的基础上,我们实现读者优先算法。

我们将通过优化访问控制的逻辑来实现读者优先的特性。

4.3. 实现写者优先算法类似地,我们在基本解决方案的基础上实现写者优先算法。

我们将调整访问控制的逻辑,使得写者优先于其他读者和写者。

4.4. 实现公平算法最后,我们实现公平算法。

我们将结合队列和条件变量等技术来确保读者和写者的访问顺序是公平的。

读者-写者问题解答计算机操作系统实验报告指导资料

读者-写者问题解答计算机操作系统实验报告指导资料

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. XXX型实验仪器2. XXX材料13. XXX材料24. XXX试剂5. 实验记录表格实验步骤:1. 材料准备在实验前,首先需要准备好所需的材料和试剂。

确保所有材料和试剂的质量和数量均符合实验要求。

2. 实验操作2.1 步骤一:XXX操作根据实验原理,操作XXX设备,将材料1与材料2进行混合,并设置相应的条件和参数。

注意在操作过程中保持安全和环境卫生。

2.2 步骤二:XXX操作根据实验原理,进行XXX操作,如加热、冷却、搅拌等,以促使反应发生,并观察反应情况。

2.3 步骤三:XXX操作根据实验原理,对实验结果进行采集和记录。

注意准确记录所用的仪器、试剂、操作条件等信息。

3. 数据处理与分析根据实验记录表格中的数据,进行数据处理和分析。

计算相关的实验参数,并绘制相应的图表和曲线。

对实验结果进行解读和讨论,提出可能的误差来源,并进行系统误差和随机误差的分析。

4. 实验结论经过实验数据的分析和讨论,得出以下结论:(1)总结实验结果的主要发现和规律。

(2)分析实验结果与预期目标之间的差异,并给出可能的原因和解释。

(3)对实验中存在的问题和改进的方向提出建议。

5. 实验总结通过本次实验,我深入理解了实验原理,并掌握了实验操作技巧。

同时,我也学会了如何正确记录和分析实验结果。

实验过程中的困难和挑战,让我更好地理解了科学研究的严谨性和耐心性。

通过对实验结果的评估和讨论,我可以应用所学的知识和技能,为将来的实验工作提供参考和改进方向。

6. 参考文献[1] 作者1. 文章标题1. 期刊名称,年份,卷号(期号):起止页码。

[2] 作者2. 文章标题2. 期刊名称,年份,卷号(期号):起止页码。

...以上实验报告按照一般实验报告的格式进行编写,旨在使读者能迅速了解实验目的、步骤、结果和结论。

实验报告2(Answer)

实验报告2(Answer)

************************************************************************** 9. 定义一个图形类,其中有保护类型的成员数据:高度好宽度,一个公有的构造函数。

由该图形类建立两个派生类:矩形类和等腰三角形类。

在每个派生类中都包含一个函数Area(),分别用来计算矩形和等腰三角形的面积。

#include<iostream.h>class pic{protected:float high,broad;public:pic(float x,float y){high=x;broad=y;}};class recg:public pic{public:recg(float x,float y):pic(x,y){}float area(){return high*broad; }};class tag:public pic{public:tag(float x,float y):pic(x,y){}float area(){return high*broad/2;}};void main(){cout<<"请输入矩形的长和宽:"<<endl;float x, y;cin>>x>>y;recg re( x, y);cout<<"矩形的面积为:"<<re.area()<<endl;cout<<"请输入等腰三角形的底边长和高:"<<endl;cin>>x>>y;tag ta( x, y);cout<<"等腰三角形的面积为:"<<ta.area()<<endl;}************************************************************************** 10. 定义一个人员类CPeople,其属性有(保护类型):姓名、性别、年龄;从中派生出学生类CStudent,添加属性:学号、入学时间和入学成绩;从CPeople 类再派生出教师类CTeacher, 添加属性:职务、部门、工作时间;由Cstudent 类派生究生类CGraduate,添加属性:研究方向和导师,由CGraduate 和CTeacher 共同派生出在职研究生类CGradOnWork,分别定义其中的构造函数和输出函数。

读写者实验报告

读写者实验报告

《Linux系统分析》实验报告报告提交日期:姓名:程志超学号: 128355003 班级:交换生一、实验题目采用多线程互斥与同步机制,实现读者、写者问题二、实验目的掌握使用POSIX接口提供的互斥变量、条件变量实现多线程同步三、实验要求有一个文件为多个并发线程所共享,其中读线程只要求读取文件内容,写线程则要求修改文件容,允许多个线程同时读取文件内容。

但若有一个写线程在写,则其他读线程不能读;若有一个写线程在写或有其他读线程在读,则其他写线程均被拒绝。

当一个写线程正在写,而有多个读线程与写线程在等待时,写线程应优先唤醒。

读线程进去读、等待,写线程进去写、等待等状态均在屏幕上打印出来四、设计思路和流程图(对于涉及算法的实验,需要提供数据结构及其说明、测试数据的设计及测试结果分析)数据结构的说明struct prodcons{int buffer[BUFFERSIZE]; //缓冲区pthread_mutex_t lock; //互斥锁int readpos,writepos; //读写的游标pthread_cond_t notempty; //缓冲区非空条件判断pthread_cond_t notfull; //缓冲区非满条件判断};测试结果:读和写的线程交互进行五、实验体会(包括实验中遇到的问题及解决过程、产生的错误及原因分析)对线程条件变量控制相关函数pthread_cond_init()、pthread_cond_wait()和pthread_cond_signal()的原型及用法不是很了解,上网查阅相关资料,明白第一个是初始化一个条件变量,第二个等待线程,尤其要注意线程状态和条件变量的加解锁过程是/*block-->unlock-->wait() return-->lock*/六、程序清单(包括源程序、makefile、readme)/***multithread.c***/#include<stdio.h>#include<pthread.h>#define BUFFERSIZE 100#define OVER (-1)struct prodcons{int buffer[BUFFERSIZE];pthread_mutex_t lock;int readpos,writepos;pthread_cond_t notempty;pthread_cond_t notfull;};void init(struct prodcons *b){pthread_mutex_init(&b->lock,NULL);pthread_cond_init(&b->notempty,NULL);pthread_cond_init(&b->notfull,NULL);b->readpos = 0;b->writepos = 0;}void put(struct prodcons *b,int data){pthread_mutex_lock(&b->lock);if((b->writepos + 1) % BUFFERSIZE == b->readpos){ pthread_cond_wait(&b->notfull,&b->lock);}b->buffer[b->writepos] = data;b->writepos++;if(b->writepos >= BUFFERSIZE)b->writepos = 0;pthread_cond_signal(&b->notempty);pthread_mutex_unlock(&b->lock);}int get(struct prodcons *b){int data;pthread_mutex_lock(&b->lock);if(b->writepos == b->readpos){pthread_cond_wait(&b->notempty,&b->lock);}data = b->buffer[b->readpos];b->readpos++;if(b->readpos >= BUFFERSIZE)b->readpos = 0;pthread_cond_signal(&b->notfull);pthread_mutex_unlock(&b->lock);return data;}struct prodcons buffer;void *producer1(void *data){int n;for(n = 0;n < 10000;n++){//printf("%d\n",n);printf("producer1 is writing\n");put(&buffer,n);}put(&buffer,OVER);return NULL;}void *producer2(void *data){int n;for(n = 0;n < 10000;n++){//printf("%d\n",n);printf("producer2 is writing\n");put(&buffer,n);}put(&buffer,OVER);return NULL;}void *consumer1(void * data){int d;while(1){d = get(&buffer);if(d == OVER)break;//printf("%d\n",d);printf("consumer1 is reading\n");}return NULL;}void *consumer2(void * data){int d;while(1){d = get(&buffer);if(d == OVER)break;//printf("%d\n",d);printf("consumer2 is reading\n");}return NULL;}int main(void){pthread_t writer1,reader1,writer2,reader2;void *retval;init(&buffer);pthread_create(&writer1,NULL,producer1,0);pthread_create(&reader1,NULL,consumer1,0);pthread_create(&writer2,NULL,producer2,0);pthread_create(&reader2,NULL,consumer2,0);pthread_join(writer1,&retval);pthread_join(reader1,&retval);pthread_join(writer2,&retval);pthread_join(reader2,&retval);return 0;}。

“读写平等”策略的“读者--写者”问题实验报告

“读写平等”策略的“读者--写者”问题实验报告

淮北师范大学程序设计课程设计采用“读写平等”策略的“读者--写者”问题学院计算机科学与技术专业计算机科学与技术(师范)学号 ***********学生姓名 ***指导教师姓名 ***2012年6月16 日一、设计目的与内容课程设计的目的:操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决问题的机会。

●进一步巩固和复习操作系统的基础知识。

●培养学生结构化程序、模块化程序设计的方法和能力。

●提高学生调试程序的技巧和软件设计的能力。

●提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。

设计内容:用高级语言编写和调试一个采用“读写平等”策略的“读者—写者”问题的模拟程序。

设计的要求:1.读者与写者至少包括ID、进入内存时间、读写时间三项内容,可在界面上进行输入。

2.读者与写者均有两个以上,可在程序运行期间进行动态增加读者与写者。

3.可读取样例数据(要求存放在外部文件中),进行读者/写者、进入内存时间、读写时间的初始化。

4.要求将运行过程用可视化界面动态显示,可随时暂停,查看阅览室中读者/写者数目、读者等待队列、读写时间、等待时间。

5.读写策略:读写互斥、写写互斥、读写平等(严格按照读者与写者到达的顺序进入阅览室,有写着到达,则阻塞后续到达的读者;有读者到达,则阻塞后续到达的写者)。

有一个被许多进程共享的数据区,这个数据区可以是一个文件,或者主存的一块空间,甚至可以是一组处理器寄存器。

有一些只读取这个数据区的进程(reader)和一些只往数据区中写数据的进程(writer)。

以下假设共享数据区是文件。

这些读者和写者对数据区的操作必须满足以下条件:读—读允许;读—写互斥;写—写互斥。

这些条件具体来说就是:(1)任意多的读进程可以同时读这个文件;(2)一次只允许一个写进程往文件中写;(3)如果一个写进程正在往文件中写,禁止任何读进程或写进程访问文件;(4)写进程执行写操作前,应让已有的写者或读者全部退出。

操作系统原理实验报告

操作系统原理实验报告

《操作系统原理》实验报告班级::学号:指导老师:目录:实验题目:实验一线程创建与撤销 (2)实验题目:实验二线程同步 (6)实验题目:实验三线程互斥 (11)实验题目:实验四进程通信 (17)实验题目:实验五读者-写者问题 (22)实验题目:实验六进程调度 (38)实验题目:实验七存储管理之动态库 (52)实验题目:实验八存储管理之存分配 (57)实验题目:实验九存储管理之页面置换算法 (70)实验题目:实验十设备管理 (85)实验题目:实验十一文件管理之文件读写 (99)实验题目:实验一线程创建与撤销完成人:XXX报告日期:2018年3月31日一、实验容简要描述(1)熟悉VC++、Visual Studio开发环境。

(2)使用相关函数创建和撤销线程。

(3)在一个进程中创建3个线程,名字分别为threada、threadb、threadc。

threada输出“hello world! ”。

threadb输出“My name is …”。

threadc输出“Please wait…”,然后sleep 5秒钟,接着输出“I wake up”。

二、程序设计1、设计思路该函数创建一个在调用进程的地址空间中执行的线程。

2、主要数据结构HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,DWORD dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId);VOID ExitThread(DWORD dwExitCode);VOID Sleep(DWORD dwMilliseconds);VOID Sleep(DWORD dwMilliseconds);三、实验结果1、基本数据lpThreadAttributes:指向一个SECURITY_ATTRIBUTES结构,该结构决定了返回的句柄是否可被子进程继承。

读者写者问题实验报告

读者写者问题实验报告

读者写者问题实验报告引言读者写者问题是计算机科学中经典的同步问题之一,它涉及多线程编程中的资源竞争与同步机制。

通过对读者写者问题的研究,我们可以深入理解线程同步的重要性,并掌握解决并发编程中可能出现的竞争条件和死锁等问题的方法。

在本实验中,我们将设计并实现一个简单的读者写者问题的解决方案,并通过模拟多个读者和写者的并发访问来验证方案的正确性和效果。

问题描述读者写者问题可描述为:有一共享资源(如文件、数据库等),读者可同时访问共享资源进行读取操作,但写者在进行写入操作时,不可同时被其他任何读者或写者访问。

读者和写者的并发访问需要由线程同步机制来保证共享资源的一致性和完整性。

实验设计与实现为了解决读者写者问题,我们需要考虑以下几个关键点:1. 共享资源的访问控制我们可以使用互斥量(Mutex)来实现对共享资源的访问控制。

当一个线程访问共享资源时,它需要先获得互斥量的锁,如果锁已被其他线程占用,则线程进入等待状态,直到锁可用。

一旦线程完成对共享资源的访问,它将释放锁,以便其他线程继续访问。

2. 读者与写者的优先级在读者写者问题中,我们往往需要设定某个优先级规则,以确定读者和写者之间的调度顺序。

一种常见的策略是给予写者优先级,即当一个写者在等待访问共享资源时,其他读者都必须等待。

这样做是为了避免写者长时间等待,以免造成饥饿问题。

3. 记录读者和写者的数量为了控制读者和写者的并发访问,我们需要记录当前同时访问共享资源的读者和写者的数量。

我们可以使用整数变量来记录读者和写者的数量,并通过信号量来保证对这些计数变量的互斥访问。

4. 同步机制的设计在实现读者写者问题的解决方案时,我们需要考虑如何合理地使用互斥量和信号量,并结合优先级规则来实现读者和写者的同步。

这需要通过仔细的设计和调试来确保解决方案的正确性。

实验结果与分析我们基于上述设计实现了一个读者写者问题的解决方案,并进行了多次仿真实验。

实验环境•操作系统:Windows 10•编程语言:C++•编译器:GCC实验步骤1.编写读者和写者线程的代码,其中涉及到对共享资源的读取和写入操作,以及对计数变量和互斥量的访问操作。

操作系统读者写者实验报告

操作系统读者写者实验报告

g_hReadSemaphore = CreateSemaphore(NULL,1,100,NULL); //创建信号 灯,当前可用的资源数为1,最大为100 g_hWriteSemaphore = CreateSemaphore(NULL,1,100,NULL); //创建信号 灯,当前可用的资源数为1,最大为100 CreatePersonList(g_PersonLists); // Create All the reader and writers 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) { int i=0; int *pList = pPersonLists; bool Ret; while(pList[0] != END) { switch(pList[1]) { case R: Ret = CreateReader(pList[2],pList[3],pList[0]);//351,w452,523,654 break; case W: Ret = CreateWriter(pList[2],pList[3],pList[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进程才能进入临界区写。 本设计方案就是通过利用记录型信号量对读者写者问题的解决过程 进行模拟演示,形象地阐述记录型信号量机制的工作原理。

信号量读者写者问题

信号量读者写者问题

成绩:实验报告课程名称:Unix下C实验项目:读者写者问题姓名:专业:网络工程班级:网络学号:指导老师:计算机科学与技术学院实验教学中心2013 年 12 月 22目录一课程设计目的及意义 (1)二课程设计内容 (1)三总体设计 (1)四详细设计 (2)五系统实现 (3)六总结 (5)七源代码 (6)一、课程设计目的及意义l.用信号量来实现读者写者问题。

2.理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。

3.通过研究Linux的线程机制和信号量实现读者写者(Reader-Writer)问题并发控制。

二、课程设计内容在windows或者linux环境下编写一个控制台应用程序,本次课程设计在操作系统:Linux下,使用的编程语言为C语言。

该程序运行时能创建N个线程,其中既有读者线程又有写者线程,它们按照事先设计好的测试数据进行读写操作。

用信号量和PV操作实现读者/写者问题。

三、总体设计读者/写者问题的描述如下:有一个被许多进程共享的数据区,这个数据区可以是一个文件,或者主存的一块空间,甚至可以是一组处理器寄存器。

有一些只读取这个数据区的进程(reader)和一些只往数据区中写数据的进程(writer)。

以下假设共享数据区是文件。

这些读者和写者对数据区的操作必须满足以下条件:读—读允许;读—写互斥;写—写互斥。

这些条件具体来说就是:(1)任意多的读进程可以同时读这个文件;(2)一次只允许一个写进程往文件中写;程访问文件;(4)写进程执行写操作前,应让已有的写者或读者全部退出。

这说明当有读者在读文件时不允许写者写文件。

四、详细设计读者-写者的读写限制1)写-写互斥,即不能有两个写者同时进行写操作2)读-写互斥,即不能同时有一个读者在读,同时却有一个写者在写3)读读允许,即可以有2个以上的读者同时读将所有的读者和所有的写者分别放进两个等待队列中,当读允许时就让读者队列释放一个或多个读者,当写允许时,释放第一个写者操作。

读者写者问题实验报告

读者写者问题实验报告

实验二:读者写者问题一、实验要求在Windows 环境下,创建一个控制台进程,此进程包含n个线程。

用这n 个线程来表示n个读者或写者。

每个线程按相应测试数据文件的要求进行读写操作。

用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的读写操作限制(包括读者优先和写者优先):1、写-写互斥,即不能有两个写者同时进行写操作。

2、读-写互斥,即不能同时有一个线程在读,而另一个线程在写。

3、读-读允许,即可以有一个或多个读者在读。

读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。

写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态才能开始读操作。

运行结果显示要求:要求在每个线程创建、发出读写操作申请、开始读写操作和结果读写操作时分别显示一行提示信息,以确定所有处理都遵守相应的读写操作限制。

流程图如图1、图2、图3、图4所示。

图1 流程图1图2 流程图2图3 流程图3图4 流程图4二、测试数据文件格式测试数据文件包括n行测试数据,分别描述创建的n个线程是读者还是写者,以及读写操作的开始时间和持续时间。

每行测试数据包括四个字段,各个字段间用空格分隔。

第一字段为一个正整数,表示线程序号。

第二字段表示相应线程角色,R表示读者,W表示写者。

第三字段为一个正数,表示读写操作的开始时间:线程创建后,延迟相应时间(单位为秒)后发出对共享资源的读写申请。

第四字段为一个正数,表示读写操作的持续时间。

当线程读写申请成功后,开始对共享资源的读写操作,该操作持续相应时间后结束,并释放共享资源。

下面是一个测试数据文件的例子:1 R 3 52 W 4 53 R 5 24 R 6 55 W 5.1 3三、实验结果1、初始化界面2、读者优先3、写者优先。

读者写者实验报告

读者写者实验报告

操作系统原理实验报告实验名称:操作系统姓名: XXX学号: xxxxxxxxxx班级: xxx指导老师: xxx一、实验内容在Windows2000环境下,创建一个控制台进程,此进程包含n个线程。

用这n个线程来表示n个读者或写者。

每个线程按相应测试数据文件(后面有介绍)的要求进行读写操作。

用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的读写操作限制(包括读者优先和写者优先):1)写-写互斥,即不能有两个写者同时进行写操作。

2)读-写互斥,即不能同时有一个线程在读,而另一个线程在写。

,3)读-读允许,即可以有一个或多个读者在读。

读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。

写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。

运行结果显示要求:要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息,以确定所有处理都遵守相应的读写操作限制。

二、实验目的在Windows2000环境下,创建一个控制台进程,此进程包含n个线程。

用这n 个线程来表示n个读者或写者。

每个线程按相应测试数据文件(后面有介绍)的要求进行读写操作。

用信号量机制分别实现读者优先和写者优先的读者-写者问题。

三、实验原理1).读者优先读者优先指的是除非有写者在写文件,否则读者不需要等待。

所以可以用一个整型变量read_count记录当前的读者数目,用于确定是否需要释放正在等待的写者线程(当read_count=O时,表明所有的读者读完,需要释放写者等待队列中的一个写者)。

每一个读者开始读文件时,必须修改read_count变量。

因此需要一个互斥对象mutex来实现对全局变量read_count修改时的互斥。

另外,为了实现写-写互斥,需要增加一个临界区对象write。

操作系统读者写者实验报告

操作系统读者写者实验报告

《操作系统原理》课程设计课程设计起止时间:2009年11月30日至12月11日指导教师:成绩:课程设计成绩评定表一.设计说明(四号,宋体,加粗)通过学习操作系统,与之前的语句基础相结合,用C语言来编写读者写着问题。

读者写者问题(read—write problem)是一个经典的并发程序设计问题。

有两组并发进程:读者和写者,共享一个问题F,要求:(1)允许多个读者可同时对之执行读操作;(2)只允许一个写者往文件中写信息;(3)任一写者在完成写操作之前不允许其他读者或者写者工作;(4)写者执行写操作前,应让已有的写者和读者全部退出。

二.工作原理(四号,宋体,加粗)读者和写者问题是典型是经典的进程同步问题,进程同步任务是使并发的诸进程之间有效的共享资源,相互合作,从而保证程序的可再现性。

在读者—写者问题中,允许多个读者同时读一个数据对象,因为读文件不会使数据发生混乱,但绝不允许一个写者进程与其他读者进程或写者进程同时访问该数据对象。

文件是诸进程能互斥访问临界资源,读者进程和写者进程,写者进程和写者进程之间的互斥。

在读者进程中,可以有多个读者在读数据库,在读者进程的计数要互斥,以免发生错误,同时注意当第一个读者进程读时,一定要封锁写者进程。

当读者进程逐渐撤离时,也要针对计数变量进行互斥操作,若当前为最后一个读者进程时,读完后,则唤醒写者进程。

当写者进程在进行写操作时,可以封锁其他读者或写者进程,当写操作完成时,唤醒其他读者或写者进程。

所以分析了以下4种可能发生的情况:第 1 种情况: 读者的优先权比写者高,而且,不用调配。

所有读者的优先权都比写者的优先权高,而且,不用调配。

一个读者需要等待的唯一情况是,一个写者已经占用了文件。

一个写者可以取得文件的条件是,没有一个读者处在等待状态或正在读文件。

允许读者们结盟,以便能长期占用文件,而禁止写者的写。

第 2 种情况: 在一个读者已经占有了文件的时候,全体读者的优先权才比写者高。

读者写者实验报告

读者写者实验报告

操作系统原理实验报告实验名称:操作系统姓名: XXX学号: xxxxxxxxxx班级: xxx指导老师: xxx一、实验内容在Windows2000环境下,创建一个控制台进程,此进程包含n个线程。

用这n个线程来表示n个读者或写者。

每个线程按相应测试数据文件(后面有介绍)的要求进行读写操作。

用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的读写操作限制(包括读者优先和写者优先):1)写-写互斥,即不能有两个写者同时进行写操作。

2)读-写互斥,即不能同时有一个线程在读,而另一个线程在写。

,3)读-读允许,即可以有一个或多个读者在读。

读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。

写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。

运行结果显示要求:要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息,以确定所有处理都遵守相应的读写操作限制。

二、实验目的在Windows2000环境下,创建一个控制台进程,此进程包含n个线程。

用这n 个线程来表示n个读者或写者。

每个线程按相应测试数据文件(后面有介绍)的要求进行读写操作。

用信号量机制分别实现读者优先和写者优先的读者-写者问题。

三、实验原理1).读者优先读者优先指的是除非有写者在写文件,否则读者不需要等待。

所以可以用一个整型变量read_count记录当前的读者数目,用于确定是否需要释放正在等待的写者线程(当read_count=O时,表明所有的读者读完,需要释放写者等待队列中的一个写者)。

每一个读者开始读文件时,必须修改read_count变量。

因此需要一个互斥对象mutex来实现对全局变量read_count修改时的互斥。

另外,为了实现写-写互斥,需要增加一个临界区对象write。

读者写者问题-操作系统实验报告

读者写者问题-操作系统实验报告

实验内容1、定义一个数据缓存buffer 及用于实现同步互斥的信号量。

2、定义一个读者函数:● 当有写者在占用buffer 时,读者应该等待,直到写者不再使用该buffer 。

● 当有其他读者在占用buffer 时,读者可对buffer 进行读取操作。

● 当buffer 中有数据时,则从其中读取一个数据,并显示然后退出。

● 当buffer 中没有数据时,应等待,直到buffer 中有数据可读。

3、定义一个写者函数● 当有读者在占用buffer 时,写者应该等待,直到所有的读者都退出为止。

● 当有其他写者占用buffer 时,该写者应该等待,直到占用buffer 的写者退出为止。

● 当buffer 有空闲时,写者应该在buffer 中写入一个数据并退出。

● 当buffer 满时,写者应该等待,直到buffer 有空闲为止。

4、定义主函数,在其中可以任意创建读者与写者。

● 可根据用户输入创建读者或写者进程(线程)。

5、用户界面2. 写者: 开始读出的内容:1. 读者: 开始结束 21读者队列等待结束写出的内容: Hello world ! 结束实验当堂所要完成事情列表:1.调试程序使其在读者优先模式下可以运行并且能实现基本的功能得出正确的结果:能够实现读写互斥,写写互斥,读读不互斥,一个进程结束能够唤醒等待队列中的进程(先读者队列后写着队列)2.根据实验要求完善功能:由用户决定写者向缓冲区中写入的内容,读者能够读出并显示出来;当缓冲区中没有数据时,读者要等待,直到缓冲区中有数据才能读3.根据“读者优先”加以改变,增加一个“写者优先”模式,并且由用户来选择模式源代码:#include<stdio.h>#include<stdlib.h>int rcount=0;//正在读的读者数量int wcount=0;//写者队列中等待写操作的写者数量int read_id=0;//读进程号int write_id=0;//写进程号int w=1;//读写互斥信号量char temp[300] = {'\0'};int choice; //用户选择读者优先OR写者优先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 first(){ //初始化int i;rq.index = 0;wq.index = 0;for(i = 0;i<20;i++){rq.readers[i] = 0;wq.writers[i] = 0;}}*///*******************************************读进程读操作void read(){int i = 0;read_id++;if(rcount == 0){//当前没有读进程在读可能有写进程在写可能CPU空闲if(w==1) {//如果CPU空闲,读者拿到CPUw--;// 相当于一个P操作rcount++;if(temp[0] == '\0'){sign = 0;if(choice == 1){rq.readers[rq.index++]=read_id;//将读者进程加入等待队列RFwakeup();return;}else{rq.readers[rq.index++]=read_id;//将读者进程加入等待队列WFwakeup();return;}}//ifprintf("读者%d正在读\n",read_id);for(i = 0;i < 300;i++){//读取temp内容即写者写的内容if(temp[i] == '\0'){printf("\n");return;}//ifprintf("%c",temp[i]);}//for}//ifelse{//写者线程正在执行printf("!有写者在写不能读!\n");rq.readers[rq.index++]=read_id;//将读者进程加入等待队列}//else}//ifelse{//rcount !=1 则知道当前已经有读者在读,读读不互斥,则这个读者可以直接进来了读printf("读者%d正在读\n",read_id);for(i = 0;i < 300;i++){if(temp[i] == '\0'){printf("\n");return;}printf("%c",temp[i]);}//for}//else}//***************************写进程写操作void write(){write_id++;if(w == 0){if(rcount != 0 ){//有读者进程在执行printf("!有读者在读不能写!\n");wq.writers[wq.index++]=write_id;//将写者进程加入等待队列wcount++;return;}if(rcount == 0 ){//rcount == 0则当前无读者,但w = 0,所以有写者在写printf("!有写者在写不能写!\n");wq.writers[wq.index++]=write_id;//将写者进程加入等待队列wcount++;return;}}if(w == 1){w--;printf("写者%d正在写\n请输入要写的内容",write_id);scanf("%s",temp);//while}//if}//************************读者优先时唤醒进程void RFwakeup(){int i = 0;int j = 0;int m,n;m = rq.index;// n = wq.index;if(rcount == 0){//当前无读进程,是写者在写 --》停止运行写进程bool reader_wait=false;w=1;printf("写者已经写完\n");sign = 1;//temp中已经有内容要置1for(i=0;i<=m;i++){// i ndex为当前读者队列中的等待进程数if(rq.readers[i]!=0){reader_wait=true; //确实有读者在等待printf("等待的读者%d正在读\n",rq.readers[i]);w = 0;for(j = 0;j < 300;j++){if(temp[j] == '\0'){printf("\n");break;}//ifprintf("%c",temp[j]);}//forrq.readers[i]=0;rcount++;rq.index--;}//if}//forif(!reader_wait){//没有读者等待,看是否有写者等待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}//if// return;}//ifelse{//rcount != 0读者正在读,stop读此时若有等待必为写者rcount=0;w = 1;if(sign == 0){printf("缓冲区空等待写者\n");return;}else{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}}//else}//******************************************写者优先唤醒void WFwakeup(){int i = 0;int j = 0;int m,n;m = rq.index;//n = wq.index;if(rcount == 0){//当前无读进程,是写者在写 --》停止运行写进程bool writer_wait=false;w=1;printf("写者已经写完\n");sign = 1;//temp中已经有内容要置1for(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){//没有xie者等待,看是否有du者等待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;}//ifprintf("%c",temp[j]);}//forrq.readers[i]=0;rcount++;}//if}//for}//if// return;}//ifelse{//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 menu1(){char i;printf(" 1-创建读者进程\n 2-创建写者进程\n 3-结束当前执行的进程\n 4-退出程序\n");printf("*******************************************\n");do{printf("当前队列中有读者: %d个写者: %d个\n",rq.index,wcount);printf("*******************************************\n");printf(" ----->");scanf("%s",&i);switch(i){case '1':read();break;case '2':write();break;case '3':RFwakeup();break;case '4':exit(0);default:printf("输入错误请重新输入\n");}}while(true);}void menu2(){char i;printf(" 1-创建读者进程\n 2-创建写者进程\n 3-结束当前执行的进程\n 4-退出程序\n");printf("*******************************************\n");do{printf("当前队列中有读者: %d个写者: %d个\n",rq.index,wcount);printf("*******************************************\n");printf(" ----->");scanf("%s",&i);switch(i){case '1':read();break;case '2':write();break;case '3':WFwakeup();break;case '4':exit(0);default:printf("输入错误请重新输入\n");}}while(true);}void main(){printf("*************************************************** ***********************\n");printf(" 20092104实验一\n 1.读者优先\n 2.写者优先\n");scanf("%d",&choice);while(1){if(choice == 1)menu1();if(choice == 2)menu2();if(choice != 1 && choice != 2){printf("输入错误请重新输入\n");scanf("%d",&choice);}}}实验流程图:核心部分设计思路:分别用两个队列来存放等待的读者进程和写者进程,一个进程结束后就要将因他阻塞的进程唤醒,如果是读者优先,则先检查读者进程,如果发现读者进程不为空,就进行读操作,直到读者进程为空,才进行写操作;同理,如果是写者优先,则先检查写进程,如果发现写者进程不为空,就进行写操作,直到写者进程为空,才进行读操作。

读者写者问题实验报告

读者写者问题实验报告

读者写者问题实验报告1.实验目的:掌握读者写者问题的基本概念和操作实现方法。

2.实验原理:(1)读者写者问题:1.读者优先:若读者进程正在读文件,写者进程需等待。

2.写者优先:若写者进程正在写文件,读者进程需等待。

3.公平竞争:读写者进程均有机会访问文件。

(2)进程同步:1.信号量:能够同步进程的执行,性能较好。

2.互斥量:能够同步进程的执行,提供了更细粒度的控制。

3.条件变量:让进程能够进行相互之间的协作。

3.实验内容:(1)依照读者写者问题的操作实现方法,采用信号量机制,编写读者进程和写者进程。

(2)测试不同读者写者优先级下程序的执行情况。

4.实验步骤:(1)设计程序架构:1.使用信号量实现读者写者访问文件的同步操作;2.设计Readers和Writers两个类分别实现读者和写者进程的操作。

(2)实现程序:1.编写读者进程,在进程对文件进行读操作之前使用信号量P操作,读取完成后使用信号量V操作;2.编写写者进程,在进程对文件进行写操作之前使用信号量P操作,写入完成后使用信号量V操作;3.设计信号量的初始值,以实现不同读者写者优先级下程序的执行情况。

(3)测试程序:在有多个读者进程和多个写者进程的情况下,测试不同读者写者优先级下程序的执行情况。

5.实验结果:(1)读者优先:读者优先的情况下,不管读者进程和写者进程的数量如何设置,读者总是有后进先出的机会访问文件。

(2)写者优先:写者优先的情况下,不管读者进程和写者进程的数量如何设置,写者总是有先进先出的机会访问文件。

(3)公平竞争:公平竞争的情况下,读者或写者进程均有机会访问文件。

6.实验结论:(1)在实现读者写者问题的过程中,需要采用进程同步技术来确保进程之间的正确协作。

(2)信号量提供了一种较为有效的进程同步机制,能够满足读者写者问题的操作需求。

(3)采用不同的优先级设置,可以使读者写者进程之间实现不同的访问策略,进而实现不同的访问效果。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验二读者写者问题实
验报告
HEN system office room 【HEN16H-HENS2AHENS8Q8-HENH1688】
实验二读者写者问题实验报告
一、实验目的
Windows2000/XP提供了互斥量(mutex)、信号量(semapore)、事件(event)等三种同步对象和相应的系统调用,用于线程的互斥与同步。

通过对读者写者问题的调试,了解Windows2000/XP中的同步机制。

二、实验内容及实验步骤
利用Windows2000/XP信号量机制,实现读者写者问题。

在Windows 2000环境下,创建一个控制台进程,此进程包含n个线程。

用这n 个线程来表示n个读者或写者。

每个线程按相应测试数据文件(后面有介绍)的要求进行读写操作。

用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的读写操作限制(包括读者优先和写者优先):
写-写互斥,即不能有两个写者同时进行写操作。

读-写互斥,即不能同时有一个线程在读,而另一个线程在写。

读-读允许,即可以有一个或多个读者在读。

读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。

写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态才能开始读操作。

运行结果显示要求:要求在每个线程创建、发出读写操作申请、开始读写操作和结果读写操作时分别显示一行提示信息,以确定所有处理都遵守相应的读写操作限制。

三、实验结果及分析
图选择界面
第一字段为一个正整数,表示线程序号。

第二字段表示相应线程角色,R 表示读者是,W 表示写者。

第三字段为一个正数,表示读写操作的开始时间。

线程创建后,延时相应时间(单位为秒)后发出对共享资源的读写申请。

第四字段为一个正数,表示读写操作的持续时间。

当线程读写申请成功后,开始对共享资源的读写操作,该操作持续相应时间后结束,并释放共享资源。

下面是一个测试数据文件的例子:
1 R 3 5
2 W 4 5
3 R 5 2
4 R 6 5
5 W 3
测试结果如下:
图读者优先运行结果
图写者优先运行结果
分析如下:
将所有的读者和所有的写者分别放进两个等待队列中,当读允许时就让读者队列释放一个或多个读者,当写允许时,释放第一个写者操作。

读者优先:
如果没有写者正在操作,则读者不需要等待,用一个整型变量readcount记录
当前的读者数目,用于确定是否释放写者线程,(当readcout=0 时,说明所有的
读者都已经读完,释放一个写者线程),每个读者开始读之前都要修改readcount,为了互斥的实现对readcount 的修改,需要一个互斥对象Mutex来实现互斥。

另外,为了实现写-写互斥,需要一个临界区对象 write,当写者发出写的请求时,必须先得到临界区对象的所有权。

通过这种方法,可以实现读写互斥,当readcount=1 时,(即第一个读者的到来时,),读者线程也必须申请临界区对象的所有权.
当读者拥有临界区的所有权,写者都阻塞在临界区对象write上。

当写者拥有临界区对象所有权时,第一个判断完readcount==1 后,其余的读者由于等待对readcount的判断,阻塞在Mutex上!
写者优先:
写者优先和读者优先有相同之处,不同的地方在:一旦有一个写者到来时,应该尽快让写者进行写,如果有一个写者在等待,则新到的读者操作不能读操作,为此添加一个整型变量writecount,记录写者的数目,当writecount=0时才可以释放读者进行读操作!
为了实现对全局变量writecount的互斥访问,设置了一个互斥对象Mutex3。

为了实现写者优先,设置一个临界区对象read,当有写者在写或等待时,读者
必须阻塞在临界区对象read上。

读者除了要一个全局变量readcount实现操作上的互斥外,还需要一个互斥对象对阻塞在read这一个过程实现互斥,这两个互斥对象分别为mutex1和mutex2。

附:
源代码如下:
#include ""
#include <>
#include <>
#include <>
#include <>
#include <>
#include <>
#define READER 'R' n",m_serial);
n",m_serial);
Sleep(m_persist);
n",m_serial);
n",m_serial);
n",m_serial);
Sleep(m_persist);
n",m_serial);
erial;
inFile>>thread_info[n_thread].entity;
inFile>>thread_info[n_thread].delay;
inFile>>thread_info[n_thread++].persist;
( );
}
for(int i=0;i< (int)(n_thread);i++)
{
if(thread_info[i].entity==READER || thread_info[i].entity=='R')
{
h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(RP_ReaderThread),&thread_info[i],0,&thre ad_ID); n");
}
n",m_serial);
wait_for_mutex1= WaitForSingleObject(h_Mutex1,-1);
n",m_serial);
Sleep(m_persist);
n",m_serial);
n",m_serial);
n",m_serial);
Sleep(m_persist);
n",m_serial);
erial;
inFile>>thread_info[n_thread].entity;
inFile>>thread_info[n_thread].delay;
inFile>>thread_info[n_thread++].persist;
( );
}
for(int i=0;i< (int)(n_thread);i++)
{
if (thread_info[i].entity==READER || thread_info[i].entity=='R')
{
n");
}
///////////////////////////////////////////////////////////////////////////////
//主函数
int main(int argc,char* argv[])
{
char ch;
while (true)
{
//打印提示信息
printf("************************************************\n");
printf(" 1:Reader Priority\n");
printf(" 2:Writer Priority\n");
printf(" 3:Exit Priority\n");
printf("************************************************\n");
printf("Enter your choice(1,2 or 3): ");
//如果输入信息不正确,继续输入
do{
ch=(char)_getch( );
}while(ch != '1' &&ch != '2' && ch != '3');
system("cls");
//选择3,返回
if(ch=='3')
return 0;
//选择1,读者优先
else if(ch=='1')
ReaderPriority("");
//选择2,写者优先
else
WriterPriority("");
//结束
printf("\nPress Any Key To Continue: "); _getch( );
system("cls");
}
return 0;
}。

相关文档
最新文档