读者-写者问题说明书

合集下载

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

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

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

《计算机操作系统》实验报告题目读者写者问题学院（部）信息学院专业计算机科学与技术班级、学生姓名学号指导教师（签字）一、《二、问题描述一个数据文件或者记录，可以被多个进程共享，我们把只要求读该文件的进程称为“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、执行结果读者优先在读者优先中先两个读者申请，再一个写者申请，再有两个读者申请。

读者-写者问题的实现

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

操作系统读者写者问题报告

操作系统读者写者问题报告
读者写者问题是一种典型的操作系统同步问题，其描述如下：有多个读者和写者同时访问共享资源，读者可以同时访问共享资源，但写者必须独占式的访问共享资源，即任何时刻只能有一个写者访问共享资源，且在写者访问共享资源的期间，任何读者都不得访问共享资源。

此外，读者在访问共享资源时不会修改共享资源，而写者则会对共享资源进行修改。

如何实现读者写者问题呢？简单来说，可以使用信号量机制来解决这个问题。

具体来说，可以使用两个信号量RdMutex和WrMutex，RdMutex用于锁定读者，在读者访问共享资源时，需要申请RdMutex信号量，如果有写者在访问共享资源，则RdMutex会阻止读者访问共享资源；而当最后一个读者结束访问共享资源时，需要释放RdMutex信号量，以便让其他等待的读者访问共享资源。

类似地，WrMutex用于锁定写者，在写者访问共享资源时，需要申请WrMutex信号量，如果有其他读者或者写者在访问共享资源，则WrMutex会阻止写者访问共享
资源；而当写者访问共享资源结束时，需要释放WrMutex信号量，以便让其他等待的写者访问共享资源。

除了信号量机制之外，还可以使用其他同步机制来解决读者写者问题，比如互斥量、条件变量等。

同时，操作系统还可以采用优化策略，比如写优先、读写优先等，来提高读写效率。

总之，读者写者问题是操作系统同步问题中的一个经典问题，其实现方式需要考虑多方面的因素，包括并发访问、同步机制、优化策略等，需要经过深入思考和有效实践才能得到较好的解决方案。

实验一读者写者问题

实习一:读者写者问题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实习分析可以将所有读者和所有写者分别存于一个读者等待队列和一个写者等待队列中，每当读允许时，就从读者队列中释放一个或多个读者线程进行读操作;每当写允许时，就从写者队列中释放一个写者进行写操作。

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

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，算法如下：}}现在回到【写者优先】优先问题【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。

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

经典同步问题读者-写者问题

经典同步问题读者-写者问题读者-写者问题在读者-写者问题中，只对共享数据进⾏读取的进程为读者进程，修改共享数据的进程称为写者进程。

多个读者可同时读取共享数据⽽不会导致出现错误，但是任何时刻多个写者进程不能同时修改数据，写者进程和读者进程也不能同时访问共享数据。

读者-写者问题的解决策略有不同的倾向。

读者优先需要⽤到的共享变量：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);写者优先有可能导致读者进程产⽣饥饿现象，当系统中不断出现写者进程时，读者进程始终⽆法进⼊临界区。

读者和写者问题

学号：课程设计课程名称操作系统学院计算机科学与技术学院专业软件工程专业班级姓名指导教师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 设计目的通过实验模拟读者和写者之间的关系，了解并掌握他们之间的关系及其原理。

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

收稿日期: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卷。

操作系统之读者与写者问题(C++)

ReleaseMutex(s);//释放互斥信号量
printf("第%d位读者正在读。。。\n", myid);
Sleep(2000);//模拟读操作
printf("第%d位读者已完成\n", myid);
WaitForSingleObject(rc_mutex, INFINITE);//对rc互斥访问
ReleaseMutex函数的功能是释放互斥对象的控制权，可以理解为使一个特定的内核对象变为已通知状态。
4.测试及实验结果
4.1 实验结果
图4-1 第一次运行结果图
图4-2 第二次运行结果图
4.2 结果分析
根据图4-1的运行结果来分析，当第二位读者和第二位写者同时存在时，先运行的是写者进程，只有当写者进程完成操作后才能进行读者进程，根据图4-2的运行结果来分析，第一位读者进入后需等第四位写者完成写操作后才能开始读操作。总得来看，该程序得读者与写者得优先级其实是一样的，谁先创建的就谁先运行，但必须等上一个进程完成后才能运行下一个进程。
6.参考文献
[1]张玉生、刘炎、张亚红. C语言程序设计[M].上海交通大学出版社，2004
[2]陆丽娜.计算机操作系统[M].高等教育出版社. 2015.8
[3]李春葆.数据结构教程[M].清华大学出版社，2004
[4].陈向群，向勇等. Windows操作系统原理(第二版) [M]. 机械工业出版社，2004
rc -= 1;//读者数减1
if (rc == 0)
ReleaseMutex(w);//释放写互斥信号量
ReleaseMutex(rc_mutex);//释放互斥信号量rc_mutex
return 1;

操作系统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为等待的对象，也就是实现同步或者互斥的对象。

操作系统——读者写者问题

操作系统——读者写者问题⼀、问题描述要求：1、允许多个读者可以同时对⽂件执⾏读操作。

2、只允许⼀个写者往⽂件中写信息。

3、任⼀写者在完成写操作之前不允许其他读者或写者⼯作。

4、写者执⾏写操作前，应让已有的读者和写者全部退出。

⼆、问题分析读者写者问题最核⼼的问题是如何处理多个读者可以同时对⽂件的读操作。

三、如何实现semaphore rw = 1; //实现对⽂件的互斥访问int count = 0;semaphore mutex = 1;//实现对count变量的互斥访问int i = 0;writer(){while(1){P(rw); //写之前“加锁”写⽂件V(rw); //写之后“解锁”}}reader (){while(1){P(mutex); //各读进程互斥访问countif(count==0) //第⼀个读进程负责“加锁”{P(rw);}count++; //访问⽂件的进程数+1V(mutex);读⽂件P(mutex); //各读进程互斥访问countcount--; //访问⽂件的进程数-1if(count==0) //最后⼀个读进程负责“解锁”{V(rw);}V(mutex);}}只要有源源不断的读进程存在，写进程就要⼀直阻塞等待，可能会造成“饿死”，在上述的算法中，读进程是优先的，那么应该怎么样来改造呢？新加⼊⼀个锁变量w，⽤于实现“写优先”！这⾥我们来分析⼀下读者1->写者1->读者2这种情况。

第⼀个读者1在进⾏到读⽂件操作的时候，有⼀个写者1操作，由于第⼀个读者1执⾏了V(w)，所以写者1不会阻塞在P(w)，但由于第⼀个读者1执⾏了P(rw)但没有执⾏V(rw)，写者1将会被阻塞在P(rw)上，这时候再有⼀个读者2，由于前⾯的写者1进程执⾏了P(w)但没有执⾏V(w)，所以读者2将会被阻塞在P(w)上，这样写者1和读者2都将阻塞，只有当读者1结束时执⾏V(rw)，此时写者1才能够继续执⾏直到执⾏V(w)，读者2也将能够执⾏下去。

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

读者写者问题-写者优先参考答案【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。

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

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

所以对共享资源的读写操作的限制条件是：⏹允许任意多的读进程同时读；⏹一次只允许一个写进程进行写操作；如果有一个写进程正在进行写操作，禁止⋯⋯;P(Rmutex);Rcount = Rcount - 1;if (Rcount == 0) V(wmutex);V(Rmutex);}}void writer() /*写者进程*/{while (true){P(Wmutex);⋯⋯;write; /* 执行写操作 */⋯⋯;P(Wmutex);}}现在回到【写者优先】优先问题【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。

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

【解题思路】在上面的读者写者问题基础上，做以下修改：⏹增加授权标志authFlag，当写者到来，发现有读者在读，则取消授权，然后等待缓冲区；⏹增加“等待授权计数器waitAuthCount”，写者离开时，如果waitAuthCount大于0，则迭代唤醒等待授权的读者；⏹读者到来，首先看授权标志，如果有授权标志，则继续，否则等待授权，即写者取消授权后，新来的读者不能申请缓冲区。

读者-写者问题说明书

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

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

读者-写者问题的实现

读者写者问题描述

读者写者问题

读者-写者问题解答

操作系统读者写者问题报告

实验一 读者写者问题

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

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

经典同步问题读者-写者问题

读者和写者问题

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

操作系统之读者与写者问题(C++)

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

操作系统——读者写者问题

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

实验一读者写者问题