信号量读者写者问题

合集下载

经典IPC问题

经典IPC问题

经典IPC问题(使用信号量的生产者-消费者问题、哲学家就餐问题、读者-写者问题)①使用信号量的生产者-消费者问题#define N 100typedef int semaphore;semaphore mutex = 1;semaphore empty = N;semaphore full = 0;void producer (void){int item;while(TRUE){item=produce_item();down(&empty);down(&mutex);insert_item(item);up(&mutex);up(&full);}}void consumer(void){int item;while(TRUE){down(&full);down(&mutex);item=remove_item();up(&mutex);up(&empty);consume_item(item);}}②哲学家就餐问题#define N 5#define LEFT (i+N-1)%N #define RIGHT (i+1)%N #define THINKING 0#define HUNGER 1#define EATING 2typedef int semaphore; int sate [N];void philosopher(int i){ while(TRUE){}}void take_forks(int i){down(&mutex);state[i]=HUNGER;test(i);up(&mutex);down(&s[i]);}void put_forks(i){down(&mutex);state[i]=THINKING;test(LEFT);test(RINGHT);up(&mutex);}void test(i){if(state[i]==HUNGER && state[LEFT]!=EATING && state[RIGHT]!=EATING){ state[i]=EATING;up(&s[i]);}}③读者-写者问题typedef int semaphore;semaphore mutex = 1;semaphore db = 1;int rc = 0;void reader(void){while(TRUE){down(&mutex);rc=rc+1;if(rc==1){down(&db);}up(&mutex);read_data_base();down(&mutex);rc=rc-1;if(rc==0){up(&db);}up(&mutex);use_data_read();}}void writer(void){while(TRUE){think_up_data();down(&db);write_data_base();up(&db);}}。

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

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

本科实验报告实验名称:操作系统原理实验(读者写者问题)课程名称:操作系统原理实验时间: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、信号量信号量机制:概念:其实就是⼀个变量,可以⽤⼀个信号量来表⽰系统中某种资源的数量、⽤户进程通过使⽤操作系统提供的⼀对原语来对信号量进⾏操作,从⽽⽅便的实现了进程互斥。

这⾥的⼀对原语是指wait(S)和signal(S),也简写为P(S)和V(S),即申请和释放资源。

P、V操作必须成对出现。

整数型信号量:⽤⼀个整数作为信号量,数值表⽰某种资源数。

对信号量的操作只有三种:初始化、P操作、V操作。

不满⾜让权等待原则。

记录型信号量:S.value表⽰某种资源数,S.L指向等待该资源的队列。

P操作中,先S.value++,之后可能执⾏block阻塞原语。

V操作中,先S.value--,之后可能执⾏wakeup唤醒原语。

可以⽤记录型信号量实现系统资源的申请和释放,申请S.value--,然后如果S.value<0说明资源分配完了,就阻塞;释放S.value++,然后如果S.value<=0说明还有进程在等待队列中等待,就唤醒。

记录型信号量可以实现进程互斥、进程同步。

实现进程互斥:划定临界区。

设置互斥信号量mytex,初值为1。

在临界区之前执⾏P(mutex),在临界区之后执⾏V(mutex)。

实现进程同步:分析那些地⽅是必须保证⼀前⼀后执⾏的两个操作。

设置同步信号量S,初始值为0。

在“前操作”之后执⾏V(S)。

在“后操作”之前执⾏P(S)。

实现前驱关系:每⼀对前驱关系都是⼀个进程同步问题。

为每⼀对前驱关系设置⼀个同步变量,初始值为0。

在“前操作”之后执⾏V操作。

在“后操作”之前执⾏P操作。

⽣产者消费者问题:⽣产者每次⽣产⼀个产品放⼊缓冲区,消费者每次从缓冲区取出⼀个产品使⽤。

缓冲区满⽣产者必须等待(同步关系1),缓冲区空消费者必须等待(同步关系2)。

缓冲区是临界资源,必须被互斥访问(互斥关系)。

问题中的P、V操作:⽣产者每次P⼀个缓冲区,V⼀个产品。

消费者每次V⼀个缓冲区,P⼀个产品。

进程同步模拟设计——读者和写者问题

进程同步模拟设计——读者和写者问题

附件1:学号:012081034课程设计进程同步模拟设计——读者和题目写者问题学院计算机科学与技术学院专业计算机科学与技术班级计算机科学与技术姓名指导教师2011 年 1 月19 日目录目录 (1)1 设计概述 (4)1.1问题描述: (4)1.1.1规则: (4)1.1.2读者和写者的相互关系: (4)1.2采用信号量机制 (4)1.3 C++语言程序模拟用信号量机制实现生产者和消费者问题 (5)2课程设计目的及功能 (5)2.1 设计目的 (5)2.2 设计功能: (5)3 需求分析,数据结构或模块说明(功能与框图) (5)3.1数据结构 (5)3.2模块说明 (6)3.3开发平台及源程序的主要部分 (6)3.3.1写操作的设计: (6)3.3.2读操作的设计: (7)3.3.3主函数的设计: (9)3.4 功能流程图 (12)4测试用例,运行结果与运行情况分析 (12)4.1测试用例 (12)4.2运行结果 (13)4.3运行情况分析 (14)5自我评价与总结 (15)6 参考文献 (16)课程设计任务书学生姓名:专业班级:计算机科学与技术指导教师:工作单位:计算机科学与技术学院题目: 进程同步模拟设计——读者和写者问题初始条件:1.预备内容:阅读操作系统的进程管理章节内容,对进程的同步和互斥,以及信号量机制度有深入的理解。

2.实践准备:掌握一种计算机高级语言的使用。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟用信号量机制实现读者和写者问题。

2.设计报告内容应说明:⑴课程设计目的与功能;⑵需求分析,数据结构或模块说明(功能与框图);⑶源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他的其他方法(如果有,简要说明该方法);v)对实验题的评价和改进意见,请你推荐设计题目。

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

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

《计算机操作系统》实验报告题目读者写者问题学院(部)信息学院专业计算机科学与技术班级、学生姓名学号指导教师(签字)一、《二、问题描述一个数据文件或者记录,可以被多个进程共享,我们把只要求读该文件的进程称为“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<iostream>#include<>using namespace std;CRITICAL_SECTION rmutex,wmutex;int wr;$int readernum;DWORD WINAPI reader(LPVOID IpParamter){cout<<"读者申请\n";wr++;EnterCriticalSection(&rmutex);if(readernum==0)EnterCriticalSection(&wmutex);readernum++;cout<<"读者进入成功正在读取\n";LeaveCriticalSection(&rmutex);Sleep(2000);—EnterCriticalSection(&rmutex);readernum--;cout<<"读者退出\n";wr--;if(readernum==0)LeaveCriticalSection(&wmutex);LeaveCriticalSection(&rmutex);return 0;}DWORD WINAPI writer(LPVOID PM){cout<<"写者申请\n";&while(wr!=0){}EnterCriticalSection(&wmutex);cout<<"写者已进入正在写入\n";Sleep(500);cout<<"写者退出\n";LeaveCriticalSection(&wmutex);return 0;}int main(){readernum=0;#wr=0;InitializeCriticalSection(&rmutex);InitializeCriticalSection(&wmutex);HANDLE hr[5];//定义读者线程HANDLE hw[5];//定义写者线程//int thnum;int drn=0; //输入的读者个数int dwn=0; //输入的写者个数cout<<"输入读者写者线程 1代表读者 2代表写者 0代表结束"<<endl;int th[10];int num=0;^cin>>th[num];while(th[num]){if(th[num]==1){drn++;}if(th[num]==2){dwn++;}num++;cin>>th[num];}&int hr1=0,hw1=0;for(int j=0;j!=num;j++){if(th[j]==1){hr[hr1]=CreateThread(NULL,0,reader,NULL,0,NULL);hr1++;}if(th[j]==2){hw[hw1]=CreateThread(NULL,0,writer,NULL,0,NULL);hw1++;}}>WaitForMultipleObjects(drn, hr, TRUE, INFINITE);WaitForMultipleObjects(dwn, hw, TRUE, INFINITE);for(int i=0;i!=drn;i++){CloseHandle(hr[i]);}for(int i=0;i!=dwn;i++){CloseHandle(hw[i]);}DeleteCriticalSection(&rmutex);DeleteCriticalSection(&wmutex);return 0;(}2、写者优先#include<iostream>#include<>using namespace std;CRITICAL_SECTION rmutex,wmutex;int ww;int readernum;DWORD WINAPI reader(LPVOID IpParamter){cout<<"读者申请\n";!while(ww!=0){}EnterCriticalSection(&rmutex);if(readernum==0){EnterCriticalSection(&wmutex);}cout<<"读者进入成功正在读取\n";readernum++;LeaveCriticalSection(&rmutex);Sleep(2000);EnterCriticalSection(&rmutex);-readernum--;if(readernum==0)LeaveCriticalSection(&wmutex);cout<<"读者退出\n";LeaveCriticalSection(&rmutex);return 0;}DWORD WINAPI writer(LPVOID PM){ww++;cout<<"写者申请\n";EnterCriticalSection(&wmutex);{cout<<"写者已进入正在写入\n";Sleep(1000);cout<<"写者退出\n";ww--;LeaveCriticalSection(&wmutex);return 0;}int main(){readernum=0;ww=0;InitializeCriticalSection(&rmutex);|InitializeCriticalSection(&wmutex);HANDLE hr[5];//定义读者线程HANDLE hw[5];//定义写者线程int drn=0; //输入的读者个数int dwn=0; //输入的写者个数cout<<"输入读者写者线程 1代表读者 2代表写者 0代表结束"<<endl;int th[10];int num=0;cin>>th[num];while(th[num]){if(th[num]==1){、drn++;}if(th[num]==2){dwn++;}num++;cin>>th[num];}int hr1=0,hw1=0;for(int j=0;j!=num;j++){if(th[j]==1){》hr[hr1]=CreateThread(NULL,0,reader,NULL,0,NULL);Sleep(10);hr1++;}if(th[j]==2){hw[hw1]=CreateThread(NULL,0,writer,NULL,0,NULL);Sleep(10);hw1++;}}WaitForMultipleObjects(drn, hr, TRUE, INFINITE);*WaitForMultipleObjects(dwn, hw, TRUE, INFINITE);for(int i=0;i!=drn;i++){CloseHandle(hr[i]);}for(int i=0;i!=dwn;i++){CloseHandle(hw[i]);}DeleteCriticalSection(&rmutex);DeleteCriticalSection(&wmutex);return 0;}3、执行结果读者优先在读者优先中先两个读者申请,再一个写者申请,再有两个读者申请。

读者-写者问题说明书

读者-写者问题说明书

《操作系统原理》课程设计任务书题目:读者-写者问题的实现学生姓名:李志旭学号: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 陈映霞”,内容包括任务书、设计文档。

读者写者问题

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

实验一 读者写者问题

实验一 读者写者问题

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

下面是一个测试数据文件的例子:2 W 4 53 R 5 24 R 6 55 W 5.1 3注意在创建数据文件时,由于涉及到文件格式问题,最好在记事本中手工逐个键入数据,而不要拷贝粘贴数据,否则,本示例程序运行时可能会出现不可预知的错误。

3实习分析可以将所有读者和所有写者分别存于一个读者等待队列和一个写者等待队列中,每当读允许时,就从读者队列中释放一个或多个读者线程进行读操作;每当写允许时,就从写者队列中释放一个写者进行写操作。

信号量读者写者问题

信号量读者写者问题

成绩:实验报告课程名称: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个以上的读者同时读将所有的读者和所有的写者分别放进两个等待队列中,当读允许时就让读者队列释放一个或多个读者,当写允许时,释放第一个写者操作。

4.9 经典进程同步问题:读者-写者问题

4.9 经典进程同步问题:读者-写者问题

4.9 经典进程同步问题:读者-写者问题(the readers-writers problem)
问题描述:对共享资源的读写操作,任一时刻“写者”最多只允许一个,而“读者”则允许多个,要求:
●“读-写” 互斥
●“写-写” 互斥
●“读-读” 允许
设置如下信号量:
Wmutex表示“允许写”,初值是1;
Rmutex表示对Rcount的互斥操作,初值是1。

公共变量Rcount表示“正在读”的进程数,初值是0。

由问题描述,我们可以分析出:
只要一个reader进程在读,便不允许writer进程去写;
仅当Rcount=0,reader进程才需要执行P(Wmutex)操作;
仅当reader进程执行了Rcount减1操作后,其值为0时,才须执行V(Wmutex)操作。

用信号量和P、V原语解决读者-写者问题如下:。

读者写者问题_写者优先参考答案

读者写者问题_写者优先参考答案
V(Rmutex);
}
}
void writer() /*写者进程*/
{
if(Rcount>0)
authFlag=0;
P(Wmutex);
......;
write; /* 执行写操作 */
......;
P(Wmutex);
P(Amutex)
while(waitAuthCount>0){
v(mutexAuth);
waitAuthCou
【vc++代码】
// testsemaphore.cpp : Defines the entry point for the console application.
// by西南大学计算机科学系周竹荣
//
#include"stdafx.h"
#include"windows.h"
Rmutex=CreateSemaphore(NULL,1,1,NULL);
Authmutex=CreateSemaphore(NULL,1,1,NULL);
Amutex=CreateSemaphore(NULL,1,1,NULL);
while(1){
Sleep(100);
srand((unsigned)time(NULL));
允许任意多的读进程同时读;
一次只允许一个写进程进行写操作;
如果有一个写进程正在进行写操作,禁止任何读进程进行读操作。
为了解决该问题,我们只需解决“写者与写者”和“写者与第一个读者”的互斥问题即
可,为此我们引入一个互斥信号量Wmutex,为了记录谁是第一个读者,我们用一个共享整
型变量Rcount 作一个计数器。而在解决问题的过程中,由于我们使用了共享变量Rcount,

读者写者问题写者优先参考答案完整版

读者写者问题写者优先参考答案完整版

读者写者问题写者优先参考答案HUA system office room 【HUA16H-TTMS2A-HUAS8Q8-HUAH1688】【写者优先】在读者、写者问题中,如果总有读者进程进行读操作,会造成写者进程永远都不能进行写操作(读者优先),即所谓的写者饿死现象。

给出读者、写者问题的另一个解决方案:即保证当有一个写者进程想写时,不允许读者进程再进入,直到写者写完为止,即写者优先。

让我们先回顾读者写者问题[1]:一个数据对象若被多个并发进程所共享,且其中一些进程只要求读该数据对象的内容,而另一些进程则要求写操作,对此,我们把只想读的进程称为“读者”,而把要求写的进程称为“写者”。

在读者、写者问题中,任何时刻要求“写者”最多只允许有一个执行,而“读者”则允许有多个同时执行。

因为多个“读者”的行为互不干扰,他们只是读数据,而不会改变数据对象的内容,而“写者”则不同,他们要改变数据对象的内容,如果他们同时操作,则数据对象的内容将会变得不可知。

所以对共享资源的读写操作的限制条件是:允许任意多的读进程同时读;一次只允许一个写进程进行写操作;如果有一个写进程正在进行写操作,禁止任何读进程进行读操作。

为了解决该问题,我们只需解决“写者与写者”和“写者与第一个读者”的互斥问题即可,为此我们引入一个互斥信号量Wmutex,为了记录谁是第一个读者,我们用一个共享整型变量Rcount 作一个计数器。

而在解决问题的过程中,由于我们使用了共享变量Rcount,该变量又是一个临界资源,对于它的访问仍需要互斥进行,所以需要一个互斥信号量Rmutex,算法如下:}}现在回到【写者优先】优先问题【写者优先】在读者、写者问题中,如果总有读者进程进行读操作,会造成写者进程永远都不能进行写操作(读者优先),即所谓的写者饿死现象。

给出读者、写者问题的另一个解决方案:即保证当有一个写者进程想写时,不允许读者进程再进入,直到写者写完为止,即写者优先。

记录型信号量解决读者写者问题的探究

记录型信号量解决读者写者问题的探究
2 0 1 3年 第 2 O 期
ห้องสมุดไป่ตู้
电子 技 术 论 坛
记 已 录 型 求 信 号 量 解 决读者写者 问题 的探 究
■林德 丽 臧香伟
摘 要 :在 多道程序环境 下,进程 同步 问题十分 重要 , 操 作系统引 八 进程后 ,进程 的异步性在 多个进程争用临界 资源时会给 系统造成 混 乱, 进程 同步的主要 任务就是使并发执 行的各 个进程之 间能有 效地共 享 各种 资源, 相 互合作 , 是程序的执行具有可再现性。其中读 者写者问题 尤其具有 代表性 ,而记 录型信 号量是 一个很好的解决方法 。 关键词 :信 号量 记 录式信 号量 同步
w a i t ( S ) : w h i l e S ≤0 d o n o o p
S :- S ~ 1
:=
0:
R e a d e r : b e g i n
repeat
读 者 进 程 /
w a i t ( r m u t e x ) : i f r e a d c o u n t - O t h e n w a i t ( w m u t e x ) : / 第 申请 互 斥 信 号量 w m u t e x /
态。 二 、记 录 型 信 号 量 的 描 述
s i g n a l ( r m u t e x ) :
w a i t ( r m u t e x ) :
r e a d c o u nt : = r e ad c ou nt — l:
为 了解决 “ 忙等 ” 现象 的问题 , 提 出 了记录型信号量机制 , 采用 “ 让 权等待 ” ,但在采取 了 “ 让权等待 ”的策略后 ,又会 出现 多个进程等待 访问同 一临界资源 的情况 。为此 ,存信 号量机制中,除了需要 一个用于 代 表 资 源 数 目的整 型 变 最 v a l u e外 ,还 应 增 加 一 个 进 程 链 表 L ,用 于链 按j 述 的所有等待进程 。 记录 型信 号鼍 足由于它采用 了记录型 的数据结 构 丽得名的 。它所包含 的上述两个数据项可描述为: t y p e s e m a p h o r e = r e c 0 r d / 定 义 类 型 为 记 录 型 /

读者_写者问题的写者优先算法_符广全

读者_写者问题的写者优先算法_符广全

收稿日期:2003-03-13作者简介:符广全(1966)),男,山东费县人,临沂师范学院讲师.读者-写者问题的写者优先算法符广全(临沂师范学院计算机与信息科学系,山东临沂276005)摘 要:分析了操作系统中读者-写者这个经典进程同步问题,对读者优先的算法加以改进,探讨了用信号量实现的写者优先的算法.关键词:信号量;互斥;同步;算法中图分类号:TP316 文献标识码:A 文章编号:1009-6051(2003)06-0135-02并发是现代操作系统的重要特征,进程的并发大大提高了系统效率,但也带来了不确定因素.因此,并发系统中处理好进程的互斥与同步至关重要.信号量机制是解决进程互斥与同步问题的重要工具,其应用很多而又复杂、常易出错,是操作系统原理学习中的重点与难点之一.信号量(semaphore)是荷兰计算机科学家Dijkstra 在1965年提出的一个同步机制,对信号量只能进行Wai t(S)、Signal(S)两个原语操作.信号量及Wait(S)、Si gnal(S)原语描述如下:type Semaphore=recordvalue:integer; L:pointer to PCB; end Wai t(S):S.value:=S.value-1; if S.value<0then beginInsert(C ALLER,S.L); Block(CALLER); endSignal(S):S.value:=S.value+1;if S.value<=0 then beginRemove(S.L,id); Wakeup(id); end其中Insert 、Block 、Remove 、Wakeup 均是系统提供的过程.读者-写者问题是一个用信号量实现的经典进程同步问题.在系统中,一个数据集(如文件或记录)被几个并发进程共享,其中有些进程要求读数据集,而另一些进程要求写或修改数据集.我们把只要求读的进程称为/读者0,其他进程称为/写者0,把此类问题称为/读者-写者0问题(Reader -Writers Problem).在这类问题中,我们允许多个读者同时读此数据集,但绝不允许一个写者和其他进程(读者或写者)同时访问此数据集,因为这将违反Bernstein 条件,破坏数据的完整性、正确性.解决此问题的最简单的方法是:当没有写进程正在访问共享数据集时,读进程可以进入访问,否则必须等待.操作系统的教材中一般都给出了不考虑写者优先的共享算法.在这种算法中,只要有读者不断到来,写者就要持久地等待,直到所有的读者都读完且没有新的读者到来时写者才能写数据集,是一种读者优先的算法.在此我们要对此算法改进,探讨一种实现写者优先的算法.在这个算法中,我们要实现的目标是:首先,要让读者与写者之间以及写者与写者之间要互斥地访问数据集,其次,在无写进程到来时各读者可同时访问数据集;在读者和写者都等待时访问时写者优先.我们将用两个不同的互斥信号量分别实现读者与写者间的互斥及各写者进程间的互斥:以互斥信号量Wmutex 实现各写者间的互斥,用互斥信号量Rmutex 实现各读者与写者间的互斥;设置两个整型变量Wcount 和Rcount 分别记录等待的写者数和正在读的读者数,因Wcount 、Rcount 都是共享变量,因此还要设置两个互斥信号量Mut1和Mut2以实现进程对这两个变量的互斥访问.用信号量机制实现的写者优先的算法如下:Var Mut1,Mut2,Wmu tex ,Rmutex:Semaphore;Rcount,Wcount:integer;第25卷 第6期临沂师范学院学报2003年12月Vol.25No.6Journal of Linyi Teachers .College Dec.2003Mut1:=Mut2:=Wmu tex:=Rmutex:=1; Rcount:=Wcount:=0;beginparbeginwriteri:beginWai t(Mut1);Wcount:=Wcount+1;If Wcount=1then Wait(Rmutex);Signal(Mut1);Wai t(Wmutex);写数据集;Wai t(Mut1);Wcount:=Wcount-1;If Wcount=0then Si gnal(Rmutex);Signal(Wmutex);Signal(Mut1);end Readeri:beginWait(Mu t1);Signal(Mut1);Wait(Mu t2);Rcount:=Rcount+1;If Rcount=1then Wait(Rmutex);Signal(Mut2);读数据集;Wait(Mu t2);Rcount:=Rcount-1;If Rcount=0then Signal(Rmutex);Signal(Mut2);endcoendend正访问者等待者(a)W1R1R2W2W3R3(b)R1W1R2R3W2W3图1正访问者与等待者次序算法分析:假设有诸多读者R1、R2、R3,及诸多写者W1、W2、W3,都要访问数据集,对以下几种情况下的优先、互斥情况分析如下:(1)当写者先到达进入数据集访问,其后到达的次序如图1(a)所示.因第1个写者W1访问数据集前要执行Wait(Rmutex),第1个读者R1等待在信号量Rmutex上,其他的读者等待在信号量Mut2上;第2、第3写者W2、W3等待在信号量Wmutex上,Wcount=3.W1写完后唤醒写者W2、W3,写者得以先于读者访问;最后的写者访问完成后唤醒第1个读者R1,R1唤醒R2后去访问数据集,随后R3被唤醒,R2、R3可与R1同时访问数据集.(2)当读者正访问数据集,又有诸多读者到来而无写者到来时诸读者可共同读数据集.(3)当读者正访问数据集,又有诸多读者和写者到来时(如图1(b)所示),写者能优先于诸读者访问数据集.此时,第1个写者W1等待在信号量Rmutex上,这时的第二、第三读者R2、R3不能进入临界区与R1共同访问数据集,而是等待在信号量Mut1上,第2、第3写者W2、W3也等待在信号量Mut1上;一旦R1完成后,唤醒第1个写者W1去访问数据集,W1访问数据集之前它将唤醒R2,继而R3、W2、W3会被唤醒,R2会重新被阻塞在信号量Rmutex上,R3被阻塞在信号量Mut2上,W2、W3会重新被阻塞在信号量Wmutex上;第1个写者W1访问完后,先唤醒写者W2、W3,最后一个写者完成后才唤醒读者R2、R3,因此,写者W2、W3会优先于读者R2、R3去访问数据集.需要说明的是,进程并发是系统中常见而且复杂的问题,信号量在进程的互斥、同步等方面有广泛的应用,但实现的方法也并不仅限于信号量机制.用信号量解决读者-写者问题,实现写者优先的算法不止一种,在此仅作抛砖引玉,与读者共商榷.参考文献:[1]汤子瀛,杨成忠,哲凤屏.计算机操作系统[M].西安:电子科技大学出版社,1996.[2]屠祁,屠立德.操作系统基础.北京:清华大学出版社,2000.Writer Priority Calculation of the Reader-Writer ProblemFU Guang-quan(Department of Computer and Information Science,Linyi Teachers.College,Linyi Shandong276005,China)Abstract:Not only the classic process synchronization)))Reader-Writer Problem is analyzed,but also the method to improve Reader Priority calcula tion is provided in this article.At the sa me time,the realization of Writer Priority calculation by using semaphore is also discussed.Key words:semaphore;mutual repellency;synchronization;calculation136临沂师范学院学报第25卷。

操作系统OS报告读者与写者问题(进程同步问题)

操作系统OS报告读者与写者问题(进程同步问题)

目录一、课程设计目的及要求 (1)二、相关知识 (1)三、题目分析 (2)四、概要设计 (4)五、代码及流程 (5)六、运行结果 (11)七、设计心得 (12)八、参考文献 (12)一、课程设计目的及要求读者与写者问题(进程同步问题)用n 个线程来表示n个读者或写者。

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

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

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

二、相关知识Windows API:在本实验中涉及的API 有:1线程控制:CreateThread 完成线程创建,在调用进程的地址空间上创建一个线程,以执行指定的函数;它的返回值为所创建线程的句柄。

HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, // SDDWORD dwStackSize, // initial stack sizeLPTHREAD_START_ROUTINE lpStartAddress, // threadfunctionLPVOID lpParameter, // thread argumentDWORD dwCreationFlags, // creation optionLPDWORD 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 objectDWORD dwMilliseconds // time-out interval);hHandle为等待的对象,也就是实现同步或者互斥的对象。

实验3--读者-写者问题与进程同步

实验3--读者-写者问题与进程同步

实验3 读者/写者问题与进程同步3.1 实验目的理解临界区和进程互斥的概念,掌握用信号量和PV操作实现进程互斥的方法。

3.2 实验要求在linux环境下编写一个控制台应用程序,该程序运行时能创建N个线程〔或者进程〕,其中既有读者线程又有写者线程,它们按照事先设计好的测试数据进行读写操作。

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

读者/写者问题的描述如下:有一个被许多进程共享的数据区,这个数据区可以是一个文件,或者主存的一块空间〔比方一个数组或一个变量〕,甚至可以是一组处理器寄存器。

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

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

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

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

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

对于读者-写者问题,有三种解决方法:1、读者优先除了上述四个规则外,还增加读者优先的规定,当有读者在读文件时,对随后到达的读者和写者,要首先满足读者,阻塞写者。

这说明只要有一个读者活跃,那么随后而来的读者都将被允许访问文件,从而导致写者长时间等待,甚至有可能出现写者被饿死的情况。

2、写者优先除了上述四个规则外,还增加写者优先的规定,即当有读者和写者同时等待时,首先满足写者。

当一个写者声明想写文件时,不允许新的读者再访问文件。

3、无优先除了上述四个规则外,不再规定读写的优先权,谁先等待谁就先使用文件。

实验步骤算法分析有同学认为,可以将文件视为临界资源,使用临界资源的代码就构成临界区,为了对临界区进行管理,只需设置一个互斥信号量r_w_w,读或者写之前执行P(r_w_w),之后执行V(r_w_w)即可,从而得到图3-1所示的算法描述。

读者-写者问题代码解释

读者-写者问题代码解释

读者-写者问题有同学反映“读者-写者问题”的代码比较难理解。

主要是因为Windows提供了一种互斥机制称为“Critical Section”,中文翻译为“临界区”,这个名字具有迷惑性,因为,它容易与我们课本上讲的“临界区”的概念混淆。

课本上临界区指“对临界资源进行访问的代码”;而这种称为“Critical Section”互斥机制,并不是这个意思,而是访问临界区之前的一种加锁机制,与Mutex 信号量的作用类似,只是“Critical Section”互斥机制只能在同一进程内部各个线程间使用,而Mutex互斥机制是可以跨进程使用的。

为帮助大家更容易理解读者-写者的代码,下面的代码用Mutex互斥机制替换了“Critical Section”互斥机制,并添加了部分注释,并用蓝色标注,其原理都是一样的。

#include "windows.h"#include "process.h"#include <conio.h>#include <stdlib.h>#include <fstream.h>#include <io.h>#include <string.h>#include <stdio.h>#define READER 'R' // 读者#define WRITER 'W' // 写者#define INTE_PER_SEC 1000 // 每秒时钟中断数目#define MAX_THREAD_NUM 64 // 最大线程数目#define MAX_FILE_NUM 32 // 最大数据文件数目#define MAX_STR_LEN 32 // 字符串长度volatile int readcount = 0; // 读者数目HANDLE RP_Write;struct ThreadInfo // 定义线程数据结构{int serial; // 线程序号char entity; // 线程类别(判断是读者线程还是写者线程)double delay; // 线程延迟double persist; // 线程读写操作持续时间};/////////////////////////////////////////////////////////////////////////// 读者优先——读者线程/// p:读者线程信息unsigned int __stdcall RP_ReaderThread(void *p){// 互斥变量HANDLE h_Mutex;h_Mutex = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount");DWORD wait_for_mutex; //等待互斥变量所有权DWORD m_delay; //延迟时间DWORD m_persist; //读文件持续时间int m_serial; //线程序号//从参数中获得信息m_serial = ((ThreadInfo *)(p))->serial;m_delay = (DWORD)(((ThreadInfo *)(p))->delay*INTE_PER_SEC);m_persist = (DWORD)(((ThreadInfo*)(p))->persist*INTE_PER_SEC);Sleep (m_delay) ; //延迟等待printf("Reader thread %d sents the reading require......\n",m_serial);//等待互斥信号,保证对readcount的访问、修改互斥wait_for_mutex = WaitForSingleObject(h_Mutex,-1);// 读者数目增加readcount++;if(readcount ==1){//这是第一个读者,第二个读者到来时,readcount为2,if的条件不满足,不会进入if语句内部执行//这是第一个读者,如果此刻没有写者正在写,则RP_Write信号量状态为可用(未占用),那它就必须先占用(锁定)RP_Write信号量,这就实现了读-写互斥//如果此刻有写者正在写,则RP_Write信号量被写者占用(锁定),读者想对RP_Write加锁就会阻塞在此,等待RP_Write信号量释放后,才能继续运行WaitForSingleObject(RP_Write, INFINITE);}ReleaseMutex(h_Mutex) ; //释放互斥信号// 读文件printf("Reader thread %d begins to read file.\n",m_serial);Sleep(m_persist) ;// 退出线程printf("Reader thread %d finished reading file.\n",m_serial);//等待互斥信号,保证对readcount的访问、修改互斥wait_for_mutex = WaitForSingleObject(h_Mutex,-1) ;//读者数目减少readcount-- ;if(readcount == 0){//如果所有读者读完,则释放RP_Write信号量;此刻若有写者正在等待(处于阻塞状态),将(自动)唤醒写者ReleaseMutex(RP_Write);}ReleaseMutex(h_Mutex) ; //释放互斥信号return 0;}////////////////////////////////////////////////////////////////////////// 读者优先——写者线程// p:写者线程信息unsigned int __stdcall RP_WriterThread(void* p){DWORD m_delay; //延迟时间DWORD m_persist; //写文件持续时间int m_serial; //线程序号//从参数中获得信息m_serial = ((ThreadInfo *)(p))->serial;m_delay = (DWORD)(((ThreadInfo *)(p))->delay*INTE_PER_SEC) ;m_persist = (DWORD)(((ThreadInfo *)(p))->persist*INTE_PER_SEC) ;Sleep (m_delay); //延迟等待printf("Writer thread %d sents the writing require.\n",m_serial);// 写者在进行写数据之前,必须确定没有其它写者正在写,也没有其它读者在读,// 通过RP_Write互斥量实现,若有其它写者正在写或其它读者在读,则该写者调用“WaitForSingleObject(RP_Write, INFINITE);”后将阻塞在此// 等待RP_Write信号量释放后,才能够继续向下执行。

进程同步通信经典问题—读者写者问题的算法分析与设计

进程同步通信经典问题—读者写者问题的算法分析与设计
2021.12
理论算法
进程同步通信经典问题一读者写者问题的算法分析与设计
曾思源,徐艳 (四川大学锦城学院计算机与软件学院,四川成都,611731)
摘要:本篇文章就读者-写者这一经典问题,利用信号量和count计数器,提出了其多种实现算法和思考解决问题的过 程。同时,本文也通过模拟验证了这些算法,发现其利弊,进而来对其进行了部分的优化。在文章的最后提出了实际生活 中该经典问题的应用场景。本文的讨论有利于让读者对该经典问题有更深刻的认识。 关键字:读者和写者;同步通信;PV操作算法
Classical problem of process synchronization Communication Algorithm analysis and design of reader and writer problem
Zeng Siyuan, Xu Yan (School of Computer and Software, Jincheng College, Sichuan University, Chengdu Sichuan, 611731)
Abstract: This paper uses semaphore to realize a variety of algorithms and problem solving processes for a classical problemnamed aReader -Writer” . At the same time, this paper finds out the advantages and disadvantages and optimizes it by Simulating the actual situation. At the end of the paper, the practical application scenario of the algorithm is presented. The discussion in this article is helpful for readers to have a deeper understanding of this. Keywords; Reader - Writer; Synchronous; Communicationalgorithms
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
printf("*************************************\n");
switch(choose){
case 1:show();break;
case 2:reader();break;
case 3:writer();break;
case 4:flag=0;printf("程序已退出\n");break;
printf(" * 2.增加一位读者\n");
printf(" * 3.增加一位写者('#'结束)\n");
printf(" * 4.退出程序\n");
printf("*************************************\n");
printf("请输入相应数字:");
scanf("%d",&choose);
2.写者模块:包括系统调用接口,写者活动描述主程序,写入内容并且使用互斥锁。
读者-写者活动程序根据临界资源的共享,互斥原则编制。
初始化系统环境
建立信号量
启动信号量的PV原语
读取或写入数据
提示当前读取或写入情况
五、系统实现
1.多个进程同时读取
2.多个进程读取,写进程不能执行
3.一个写进程,其他进程不能写也不能读
实验报告
课程名称:
Unix下C
实验项目:
读者写者问题
姓名:
专业:
网络工程
班级:
网络
学号:
指导老师:
计算机科学与技术学院
实验教学中心
2013年12月22
一、课程设计目的及意义
l.用信号量来实现读者写者问题。
2.理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。
3.通过研究Linux的线程机制和信号量实现读者写者(Reader-Writer)问题并发控制。
printf("添加一个读者\n");
show();
sleep(50);
semop(semid,&sb[1],1);
printf("减少一个读者\n");
}
else
{
show();
printf("写者数不为0,不能读!\n");
}
}
void writer()
{
if(semctl(semid,0,GETVAL)==0 & semctl(semid,1,GETVAL)==0)
#include<sys/>
#include<>
#include<sys/>
int main()
{
FILE *fp;
int semid;
int choose;
char ch;
struct sembuf sb[4];
unsigned short array[]={0,0};
semid=semget(0x1234,2,0666|IPC_CREAT);
有一个被许多进程共享的数据区,这个数据区可以是一个文件,或者主存的一块空间,甚至可以是一组处理器寄存器。有一些只读取这个数据区的进程(reader)和一些只往数据区中写数据的进程(writer)。以下假设共享数据区是文件。这些读者和写者对数据区的操作必须满足以下条件:读—读允许;读—写互斥;写—写互斥。这些条件具体来说就是:
semctl(semid,0,SETALL,array);
sb[0].sem_num=0;
sb[0].sem_op=1;
sb[1].sem_num=0;
sb[1].sem_op=-1;
sb[2].sem_num=1;
sb[2].sem_op=1;
sb[3].sem_num=1;
sb[3].sem_op=-1;
void show()
{
printf("当前的读者数为%d\n",semctl(semid,0,GETVAL));
printf("当前的写者数为%d\n",semctl(semid,1,GETVAL));
}
void reader()
{
if(semctl(semid,1,GETVAL)==0)
{
semop(semid,&sb[0],1);
(1)任意多的读进程可以同时读这个文件;
(2)一次只允许一个写进程往文件中写;
(3)如果一个写进程正在往文件中写,禁止任何读进程或写进程访问文件;
(4)写进程执行写操作前,应让已有的写者或读者全部退出。这说明当有读者在读文件时不允许写者写文件。
程序由二部分组成:
1.读者模块:包括系统调用接口,读者活动描述主程序。系统接口主要功能是读取内容并且使用共享锁
六、总结
这一次课程设计,让我体会很深刻。读者-写者问题经典的线程同步问题的一个模型。经过读者写者问题的编写,我对同步机构应用有了深入的了解。懂得了运用信号量实现进程间的互斥。实现了不让共享资源同时修改。用信号量上的原语操作使临界段问题的解决比较简单明了了。读者写者问题的编写,花的时间很多,也学到很多东西。了解支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的信号量机制。几天的试验,虽然难度有点大,但只要自己花时间去学习,还是会攻克困难的。
二、课程设计内容
在windows或者linux环境下编写一个控制台应用程序,本次课程设计在操作系统:Linux下,使用的编程语言为C语言。该程序运行时能创建N个线程,其中既有读者线程又有写者线程,它们按照事先设计好的测试数据进行读写操作。用信号量和PV操作实现读者/写者问题。
三、总体设计
读者/写者问题的描述如下:
default:printf("输入错误,请从新输入\n");
}
}while(flag);
}
2)读-写互斥,即不能同时有一个读者在读,同时却有一个写者在写
3)读读允许,即可以有2个以上的读者同时读
将所有的读者和所有的写者分别放进两个等待队列中,当读允许时就让读者队列释放一个或多个读者,当写允许时,释放第一个写者操作。读者写者问题的定义如下:有一个许多进程共享的数据区,这个数据区可以是一个文件或者主存的一块空间;有一些只读取这个数据区的进程(Reader)和一些只往数据区写数据的进程(Writer),此外还需要满足以下条件:
{
semop(semid,&sb[2],1);
printf("添加一个写者\n");
show();
if((fp=fopen("/root/","w"))==NULL)
{
printf("cannot open file \n");
exit(0);
}
printf("输入内容:");
ch=getchar();
(1)任意多的读进程可以同时读这个文件;
(2)一次只允许一个写进程往文件中写;
(3)如果一个写进程正在往文件中写,禁止任何读进程或写进程访问文件;
(4)写进程执行写操作前,应让已有的写者或读者全部退出。这说明当有读者在读文件时不允许写者写文件。
四、详细设计
读者-写者的读写限制
1)写-写互斥,即不能有两个写者同时进行写操作
}
}
int flag=1;
do{
printf("\n****************利用信号量机制解决读者写者问题***************\n");
printf("****************主菜单***************\n");
printf(" * 1.查看读者、写者人数\n");
总之,每一次课程设计不仅是我们学习的好机会,而且是我们锻炼实际动手能力的平台,虽然有难度的东西总会让人很抵触,比如在课设过程中有很多郁闷的时候,一个小小的错误一不小心就花去了自己一上午的时间,所以在这个过程中能够磨练人的意志与耐心,最后感谢老师的指导与监督。
附录A:代码
#include<sys/>
#include<sys/>while(cຫໍສະໝຸດ !='#'){
fputc(ch,fp);
putchar(ch);
ch=getchar();
}
putchar(10);
fclose(fp);
sleep(1);
semop(semid,&sb[3],1);
printf("写者写入结束\n");
}
else
{
show();
printf("读者或写者数不为0,不能写!\n");
相关文档
最新文档