操作系统课程设计报告——读者写者问题
操作系统课程设计报告——读者写者问题
操作系统课程设计课题：读者写者问题姓名：赫前进班级：1020552学号102055211指导教师：叶瑶提交时间：2012/12/30（一）实验目的1.进一步理解“临界资源”的概念；2.把握在多个进程并发执行过程中对临界资源访问时的必要约束条件；3.理解操作系统原理中“互斥”和“同步”的涵义。
（二）实验内容利用程序设计语言编程，模拟并发执行进程的同步与互斥（要求：进程数目不少于3 个）。
（三）、程序分析读者写者问题的定义如下：有一个许多进程共享的数据区，这个数据区可以是一个文件或者主存的一块空间；有一些只读取这个数据区的进程（Reader）和一些只往数据区写数据的进程(Writer)，此外还需要满足以下条件：（1）任意多个读进程可以同时读这个文件；（2）一次只有一个写进程可以往文件中写；（3）如果一个写进程正在进行操作，禁止任何读进程度文件。
实验要求用信号量来实现读者写者问题的调度算法。
实验提供了signal类，该类通过P( )、V( )两个方法实现了P、V原语的功能。
实验的任务是修改Creat_Writer()添加写者进程，Creat_Reader()创建读者进程。
Reader_goon()读者进程运行函数。
读优先：要求指一个读者试图进行读操作时，如果这时正有其他读者在进行操作，他可直接开始读操作，而不需要等待。
读者优先的附加限制：如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作。
写优先：一个读者试图进行读操作时，如果有其他写者在等待进行写操作或正在进行写操作，他要等待该写者完成写操作后才开始读操作。
写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
在Windows 7 环境下，创建一个控制台进程，此进程包含n 个线程。
用这n 个线程来表示n 个读者或写者。
每个线程按相应测试数据文件（格式见下）的要求进行读写操作。
2011211320周俊霞-读者写者问题实验报告(word文档良心出品)
操作系统试验--读者-写者问题周俊霞20112113202011211307班进程同步一．实习要求：本课程实验内容引自《Windows 内核实验教程》(陈向群、林斌等编著，机械工业出版社2002.9)。
在Windows 环境下，创建一个包含n 个线程的控制进程。
用这n 个线程来表示n个读者或写者。
每个线程按相应测试数据文件的要求，进行读写操作。
请用信号量机制分别实现读者优先和写者优先的读者-写者问题。
1.读者-写者问题的读写操作限制：1）写-写互斥；2）读-写互斥；3）读-读允许；2.读者优先的附加限制：如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作。
写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确信所有处理都遵守相应的读写操作限制。
二．测试数据文件格式测试数据文件包括n 行测试数据，分别描述创建的n 个线程是读者还是写者，以及读写操作的开始时间和持续时间。
每行测试数据包括四个字段，各字段间用空格分隔。
第一字段为一个正整数，表示线程序号。
第一字段表示相应线程角色，R 表示读者是，W 表示写者。
第二字段为一个正数，表示读写操作的开始时间。
线程创建后，延时相应时间（单位为秒）后发出对共享资源的读写申请。
第三字段为一个正数，表示读写操作的持续时间。
当线程读写申请成功后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。
下面是一个测试数据文件的例子：1 R 3 52 W 4 53 R 5 24 R 6 55 W 5.1 3三、与实验相关的API 介绍在本实验中可能涉及的API 有：线程控制：CreateThread 完成线程创建，在调用进程的地址空间上创建一个线程，以执行指定的函数；它的返回值为所创建线程的句柄。
操作系统——读者-写者问题的解决方法
操作系统——读者-写者问题的解决⽅法问题描述不允许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);}有错误请指出！。
OS课程设计__读者写者
兰州交通大学操作系统课程设计课程：计算机操作系统题目：进程同步(读者--写者)班级：姓名：学号：指导教师：日期：2012年12月21日目录1题目 (1)2设计概述 (1)2.1问题描述 (1)2.2采用信号量机制 (1)3课程设计目的及功能 (1)3.1设计目的 (1)3.2设计功能 (1)4总体设计思想概述 (2)4.1功能流程图 (2)4.2开发平台及源程序的主要部分 (3)4.3数据结构 (3)4.4模块说明 (3)4.5源程序 (3)5测试用例，运行结果与运行情况分析 (12)5.1测试用例 (12)5.2运行结果 (12)5.3运行结果分析 (14)6总结与心得 (15)1题目进程同步模拟设计——读者和写者问题2设计概述2.1问题描述模拟用信号量机制实现读者和写者问题，即有两组并发进程:读者和写者,共享一组数据区，进行读写操作，要求任一时刻“写者”最多只允许一个，而“读者”则允许多个。
2.1.1要求允许多个读者同时执行读操作；不允许读者、写者同时操作；不允许多个写者同时操作。
2.1.2读者和写者的相互关系：2.2采用信号量机制1）Wmutex表示读写的互斥信号量，初值： Wmutex =1；2）公共变量Rcount表示“正在读”的进程数，初值：Rcount =0；3）Rmutex：表示对Rcount的互斥操作，初值：Rmutex=1。
3课程设计目的及功能3.1设计目的通过实验模拟读者和写者之间的关系，了解并掌握他们之间的关系及其原理。
由此增加对进程同步的问题的了解。
具体如下:1）掌握基本的同步互斥算法，理解读者和写者模型；2）了解windows中多线程（多进程）的并发执行机制，线程（进程）间的同步和互斥；3）学习使用windows中基本的同步对象，掌握相应的API。
3.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)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。
读写者问题
设计一读者写者问题实习环境：系统为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，算法如下：}}现在回到【写者优先】优先问题【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。
给出读者、写者问题的另一个解决方案：即保证当有一个写者进程想写时，不允许读者进程再进入，直到写者写完为止，即写者优先。
读者-写者问题解答
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、定义一个数据缓存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、需求分析 (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对读进程记数。
为了有效的解决读者写者问题，需要引进读者-写者锁，允许多名读者同时以只读的方式存取有锁保护的对象；或一位写者以写方式存取有锁保护的对象。
当一名或多名读者上锁后，此时形成读锁，写者将不能访问有锁保护的对象；当锁被请求者用于写操作时，形成写锁，其他进程的读写操作必须等待。
操作系统实验报告_读者写者问题
void WP_WriterThread(void * p) //---------------------------写者优先--写者线程
{
HANDLE h_Mutex1;//互斥变量
h_Mutex1 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutexl");
HANDLE h_Mutex2;
h_Mutex2 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex2");
DWORD wait_for_mutex1; //等待互斥变量所有权
};
void RP_ReaderThread(void * p) //---------------------------读者优先--读者线程
{
HANDLE h_Mutex;//互斥变量
//OpenMutex函数功能：为现有的一个已命名互斥体对象创建一个新句柄
h_Mutex = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount");
（附注释）
#include "stdafx.h"
#include"windows.h"
#include<conio.h>
#include<stdlib.h>
#include<fstream.h>
#include<io.h>
#include<string.h>
#include<stdio.h>
#define READER 'R' //读者
操作系统课程设计--读者-写者问题
操作系统课程设计报告一、操作系统课程设计任务书读者-写者问题实现1设计目的通过实现经典的读者写者问题，巩固对线程及其同步机制的学习效果，加深对相关基本概念的理解，并学习如何将基本原理和实际设计有机的结合。
2设计要求在Windows 2000/XP环境下，使用多线程和信号量机制实现经典的读者写者问题，每个线程代表一个读者或一个写者。
每个线程按相应测试数据文件的要求，进行读写操作。
请用信号量机制分别实现读者优先和写者优先的读者-写者问题。
读者-写者问题的读写操作限制：(1)写-写互斥，即不能有两个写者同时进行写操作(2)读-写互斥，即不能同时有一个读者在读，同时却有一个写者在写(3)读-读允许，即可以有二个以上的读者同时读读者优先的附加限制：如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作。
写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确信所有处理都遵守相应的读写操作限制。
3测试数据文件格式测试数据文件包括n行测试数据，分别描述创建的n个线程是读者还是写者，以及读写操作的开始时间和持续时间。
每行测试数据包括四个字段，各字段间用空格分隔。
第一字段为一个正整数，表示线程序号。
第二字段表示相应线程角色，R表示读者是，W表示写者。
第三字段为一个正数，表示读写操作的开始时间。
线程创建后，延时相应时间（单位为秒）后发出对共享资源的读写申请。
第四字段为一个正数，表示读写操作的持续时间。
当线程读写申请胜利后，开始对共享资源的读写操作，该操作持续相应时间后结束，并释放共享资源。
下面是一个测试数据文件的例子：1 r 3 52 w 4 53 r 5 24 r 6 55 w 5.1 34相关API函数CreateThread()在调用进程的地址空间上创建一个线程ExitThread()用于结束当前线程Sleep()可在指定的时间内挂起当前线程CreateMutex()创建一个互斥对象，返回对象句柄OpenMutex()打开并返回一个已存在的互斥对象句柄，用于后续访问ReleaseMutex()释放对互斥对象的占用，使之成为可用WaitForSingleObject()可在指定的时间内等待指定对象为可用状态InitializeCriticalSection()初始化临界区对象EnterCriticalSection()等待指定临界区对象的所有权LeaveCriticalSection()释放指定临界区对象的所有权文件系统的设计通过对文件系统的设计，加深理解文件系统的内部功能及内部实现。
(完整word版)操作系统课程设计-读者写者问题
操作系统课程设计报告一、开题报告（一）该项课程设计的意义；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上。
(完整word版)操作系统课程设计(采用读写平等策略的读者写者问题)完整版 内含代码(word文档良心出品)
淮北师范大学课程设计采用读写平等策略的读者写者问题学号：姓名：专业：指导教师：日期：目录第1部分课设简介 (3)1.1 课程设计题目 (3)1.2 课程设计目的................. 错误！未定义书签。
1.3 课程设计内容 (3)1.4 课程设计要求 (4)1.5 时间安排 (4)第2部分实验原理分析 (4)2.1问题描述 (4)2.2算法思想 (5)2.3主要功能模块流程图 (5)第3部分主要的功能模块 (6)3.1数据结构 (6)3.2测试用例及运行结果 (7)第4部分源代码 (7)第5部分总结及参考文献 (22)5.1 总结 (22)5.2 参考文献 (23)第1部分课设简介1.1 课程设计题目采用读写平等策略的读者写者问题1.2课程设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
1）进一步巩固和复习操作系统的基础知识。
2）培养学生结构化程序、模块化程序设计的方法和能力。
3）提高学生调试程序的技巧和软件设计的能力。
4）提高学生分析问题、解决问题以及综合利用C语言进行课程设计的能力。
1.3课程设计内容用高级语言编写和调试一个采用“读写平等”策略的“读者-- 写者”问题的模拟程序。
1.4课程设计要求1）读者与写者至少包括ID、进入内存时间、读写时间三项内容，可在界面上进行输入。
2) 读者与写者均有两个以上，可在程序运行期间进行动态增加读者与写者。
3)可读取样例数据（要求存放在外部文件中），进行读者/写者、进入内存时间、读写时间的初始化。
4) 要求将运行过程用可视化界面动态显示，可随时暂停，查看阅览室中读者/写者数目、读者等待队列、读写时间、等待时间。
5) 读写策略：读写互斥、写写互斥、读写平等（严格按照读者与写者到达的顺序进入阅览室，有写着到达，则阻塞后续到达的读者；有读者到达，则阻塞后续到达的写者）。
读者写者问题操作系统课程设计
某某大学课程设计报告课程名称：操作系统课程设计设计题目：读者写者问题系别：计算机系专业：计算机科学与技术组别：第四组学生姓名: 某某某学号:起止日期:指导教师:目录1、需求分析课程设计题目课程设计题目：读者写者问题课程任务及要求编写程序实现读者写者算法（读_写互斥,读_读允许,写写互斥）给出解决方案（包括说明设计实现(de)原理,采用(de)数据结构等）画出程序(de)基本结构框图和流程图分析说明每一部分程序(de)(de)设计思路实现源代码按期提交完整(de)程序代码和可执行程序根据要求完成课程设计报告总结课程设计思想读者-写者问题是一个经典(de)并发程序设计问题.有两组并发进程：读者和写者,共享文件F,要求：(1)允许多个读者同时对文件执行读操作；(2)只允许一个写者对文件执行写操作；(3)任何写者在完成写操作之前不允许其他读者或写者工作；(4)写者在执行写操作前,应让已有(de)写者和读者全部退出.单纯使用信号量不能解决此问题,必须引入计数器readcount对读进程记数.为了有效(de)解决读者写者问题,需要引进读者-写者锁,允许多名读者同时以只读(de)方式存取有锁保护(de)对象；或一位写者以写方式存取有锁保护(de)对象.当一名或多名读者上锁后,此时形成读锁,写者将不能访问有锁保护(de)对象；当锁被请求者用于写操作时,形成写锁,其他进程(de)读写操作必须等待.软硬件运行环境及开发工具本课程设计在windows操作系统下,使用java语言完成(de).2、概要设计程序流程图本系统主要有读者和写者两类对象,所以系统主要针对(de)是这两类对象(de)操作.读者类对象(de)流程图如下：图读者类对象写者类对象(de)流程图如下：图写者类对象所用原理并发原理进程(de)并发是指一组进程(de)执行在时间上重叠(de),所谓(de)时间重叠是指一个进程执行第一条指令是在另一个进程执行完最后一条指令之前开始(de).并发(de)实质是处理器在几个进程之间(de)多路复用,并发是对有限物理资源强制行使多用户共享,消除计算机部件之间(de)互等现象,提高系统资源(de)利用率.并发进程可能是无关(de),也可能是交互(de).进程(de)交互必须是有控制(de),否则会出现不正确(de)计算结果.互斥操作原理互斥是指若干进程因互相争夺独占型资源而产生(de)竞争制约关系.并发进程中与共享变量有关(de)程序段称为“临界区”,共享变量所代表(de)资源称为“临界资源”,临界区必须以一种相对于其他进程而言互相排斥(de)方式执行.如果能够保证一个进程在临界区执行时,不让另一个进程进入相同(de)临界区,即各进程对共享变量(de)访问是互斥(de),那么,就不会引发与时间有关(de)错误.而为了正确而有效地使用临界资源,共享变量(de)并发进程应遵守临界区调度(de)三个原则：一次至多有一个进程进入临界区内执行；如果已有进程在临界区中,试图进入临界区(de)其他进程应等待；进入临界区内进程应在有限时间内退出,以便让等待队列中(de)一个进程进入.总结起来有三句话：互斥使用,有空让进；忙则等待,有限等待；择一而入,算法可行.面向对象编程编程原理面向对象是一种新兴(de)程序设计方法,或者说它是一种新(de)程序设计范型,其基本思想是使用对象,类,继承,封装,消息等基本概念来进行程序设计.它是从现实世界中客观存在(de)事物（即对象）出发来构造软件系统,并在系统构造中尽可能运用人类(de)自然思维方式,强调直接以问题域（现实世界）中(de)事物为中心来思考问题,认识问题,并根据这些事物(de)本质特点,把他们抽象地表示为系统中(de)对象,作为系统(de)基本构成单位（而不是用一些与现实世界中(de)事物相关比较远,并且没有对应关系(de)其他概念来构造系统）.这可以使系统直接地映射问题域,保持问题域中事物及其相互关系(de)本来面貌.本课程设计中涉及了两个对象,因此用面向对象(de)语言来编程是适合(de).我们这次用到了Java语言.锁机制原理为了解决读者和写者之间(de)同步互斥问题,在本课程设计中要用到Java中(de)锁机制,这样会给编程带来很大(de)方便.多线程同步(de)实现最终依赖锁机制.我们可以想象某一共享资源是一间屋子,每个人都是一个线程.当A希望进入房间时,他必须获得门锁,一旦A获得门锁,他进去后就立刻将门锁上,于是B,C,D...就不得不在门外等待,直到A释放锁出来后,B,C,D...中(de)某一人抢到了该锁（具体抢法依赖于JVM(de)实现,可以先到先得,也可以随机挑选）,然后进屋又将门锁上.这样,任一时刻最多有一人在屋内（使用共享资源）. Java语言规范内置了对多线程(de)支持.对于Java程序来说,每一个对象实例都有一把“锁”,一旦某个线程获得了该锁,别(de)线程如果希望获得该锁,只能等待这个线程释放锁之后.获得锁(de)方法只有一个,就是synchronized关键字.1．用锁操作原语实现互斥为解决进程互斥进人临界区(de)问题,可为每类临界区设置一把锁,该锁有打开和关闭两种状态,进程执行临界区程序(de)操作按下列步骤进行：①关锁.先检查锁(de)状态,如为关闭状态,则等待其打开；如已打开了,则将其关闭,继续执行步骤②(de)操作.②执行临界区程序.③开锁.将锁打开,退出临界区.2．WAIT,NOTIFY,NOTIFYALL操作原语信号量(de)初值可以由系统根据资源情况和使用需要来确定.在初始条件下信号量(de)指针项可以置为0,表示队列为空.信号量在使用过程中它(de)值是可变(de),但只能由WAIT,SIGNAL操作来改变.设信号量为S,对S(de)WAIT操作记为WAIT（S）,对它(de)SIGNAL操作记为SIGNAL（S）.WAIT（S）：顺序执行以下两个动作：1）信号量(de)值减1,即S=S－1；2）如果S≥0,则该进程继续执行；如果 S＜0,则把该进程(de)状态置为阻塞态,把相应(de)WAITCB连人该信号量队列(de)末尾,并放弃处理机,进行等待（直至其它进程在S上执行SIGNAL操作,把它释放出来为止）.SIGNAL（S）：顺序执行以下两个动作线程(de)原理线程是进程中(de)实体,一个进程可以拥有多个线程,一个线程必须有一个父进程.线程不拥有系统资源,只有运行必须(de)一些数据结构；它与父进程(de)其它线程共享该进程所拥有(de)全部资源.线程可以创建和撤消线程,从而实现程序(de)并发执行.一般,线程具有就绪、阻塞和运行三种基本状态.读者写者问题(de)一般应用读者写者是典型(de)并发程序设计问题,它(de)方法可以普遍用于多线程(de)同步互斥问题,对于共享资源出现(de)问题做出了很好(de)解决,使得事物并发(de)效率更高,类似(de)问题还有生产者-消费者问题,理发师问题等等.3、详细设计本次课程设计采用(de)是java语言编写,所以要用到类,包括读者类和写者类,它们都是继承(de)线程Thread类,在主程序中创建类对象（读者对象和写者对象）,用线程来实现并发读者类对象和写者类对象(de)公共属性包括：private static final int NAP_TIME=5;private int readerCount;private int writerCount;private boolean dbReading;private boolean dbWriting;通过NAP_TIME调整线程随机休息时间通过readercount和writercount来记录读者和写者线程(de)个数通过dbreading和dbwriting来判断读者和写者(de)状态,其中读者是靠判断writercount>0来实现读写互斥(de),同时允许读读同步；而写者是靠判断dbreading=true||dbwriting=true来实现读写互斥和写写互斥(de).读写等待是随机(de),运用(de)是()函数程序代码如下：class Database{/读者写者公用(de)资源Database类/private static final int NAP_TIME=5;private int readerCount; /记录当前(de)读者个数/private int writerCount; /记录当前(de)写者个数/private boolean dbReading; /显示是否有读者在读/private boolean dbWriting; /显示是否有写者在写/public Database() {/构造函数/super();readerCount=0;writerCount=0;dbReading=false;dbWriting=false;Count="+readerCount);return readerCount;}public synchronized void startWriting(){++writerCount;while(dbReading==true||dbWriting==true){/如果有读者在读或者有写者在写,那么写者进行等待/ try{"Writer is waiting");wait();}catch(Exception e){}}dbWriting =true; /有写者在写,则设置写状态为true/}public synchronized void endWriting(){--writerCount;/由于每次只有一个写者在写,所以结束写操作后写者个数一定为0/ dbWriting=false; /没有写者写,则设置写状态为false/"one writer is done writing. Count="+writerCount);notifyAll(); /释放所有等待(de)线程/}}class Reader extends Thread{ /建立读者类/private Database server;private int readerNum;public Reader(int r,Database db) {super();readerNum=r;server=db;}public void run(){while(true){"reader "+readerNum+" is sleeping");();"reader "+readerNum+" wants to read");c=();"reader "+readerNum+" is reading. Count="+c);();c=();"It is reader "+readerNum+" who has done reading according to count="+c);}}}class Writer extends Thread{ /建立写者类/private Database server;private int writerNum;public Writer(int w,Database db) {writerNum=w;server=db;}public void run(){while(true){"Writer "+writerNum+" is sleeping");();"Writer "+writerNum+" wants to write");();"Writer "+writerNum+" is writing");();();"It is Writer "+writerNum+" who has done writing ."); }}}public class DatabaseServer {public DatabaseServer() {}public static void main(String[] args) { Database db=new Database();/建立四个读者对象和两个写者对象/Reader r1=new Reader(1,db);Reader r2=new Reader(2,db);Reader r3=new Reader(3,db);Reader r4=new Reader(4,db);Writer w1=new Writer(1,db);Writer w2=new Writer(2,db);();();();();();();}}4、调试与操作说明由于读写等待是随机(de)所以可能出现多中情况,读写(de)顺序可能会不一样,以下是几种不同(de)运行结果：图读者写者结果一上图中(de)结果说明：按照读者1、读者2、读者3、写者1、读者4、写者2……(de)顺序进入,最终(de)执行结果按写者1、写者2、读者2、4、3、1……(de)顺序进行.图读者写者结果二上图中(de)结果说明：按照读者1、读者3、读者2、写者1……(de)顺序进入,最终(de)执行结果按读者3、读者1、写者2……(de)顺序进行.5、课程设计总结与体会通过集体(de)努力,这次课程设计基本上可以完成功能了,读_写互斥,读_读允许,写写互斥能够实现了,但是还存在一些不足(de)地方,比如不能够实现读者优先或者写者优先,可能出现长时间等待(de)情况,在这次课程设计后,我们会继续努力将功能完善.这次我们(de)收获就是懂得了使用Java这样(de)面向对象(de)语言来实现线程同步互斥问题,知道了Java中(de)锁机制,这对以后(de)编程有很大(de)帮助,同时也进一步加深了对操作系统这类问题(de)理解.6、致谢感谢一学期来老师给我们(de)教导,让我们对操作系统有了整体(de)理解,这对我们以后(de)学习有很大(de)帮助,对于这次课程设计,老师也给了我们充分(de)支持和理解,是您对我们(de)指导帮助我们能够顺利(de)完成这次课程设计.7、参考文献[1]费翔林,骆斌. (第4版)[M]. 北京: 高等教育出版社, 2009.[2]李尊朝,苏军.Java语言程序设计(第二版)[M].中国铁道出版社,2008.。
操作系统读者写者实验报告
操作系统读者写者实验报告一、实验目的通过实验理解读者写者问题的实现原理，掌握相关的同步机制，实现读者写者问题的经典解法，并对比不同解法的优缺点。
二、实验原理1.读者写者问题读者写者问题是指在多个线程同时读写一个共享数据的情况下可能出现的问题。
其问题的核心在于多个读线程可以同时读，但只能有一个写线程能够写，并且在写操作过程中不能有任何的读操作。
2.互斥与同步为了解决读者写者问题，在多线程并发读写共享数据时，需要使用互斥与同步机制来保证数据的完整性和一致性。
-互斥：通过锁机制来保证只允许一个线程进入临界区，其他线程需要等待锁的释放。
-同步：通过信号量等机制来保证线程按照一定顺序执行。
三、实验步骤本次实验中将实现两个版本的读者写者问题解决方案：一是使用互斥锁和条件变量，二是使用信号量。
1.使用互斥锁和条件变量（1）定义全局变量和互斥锁：共享数据、读者数目、互斥锁、写者条件变量、读者条件变量。
（2）初始化互斥锁和条件变量。
（3）写者线程的实现：获取互斥锁，判断当前是否有读者或写者，如果有则等待条件变量，然后进行写操作，释放互斥锁。
（4）读者线程的实现：获取互斥锁，判断是否有写者，如果有则等待条件变量，否则增加读者数目并释放互斥锁，进行读操作。
（5）测试程序的运行并输出结果。
2.使用信号量（1）定义全局变量和信号量：共享数据、读者信号量、写者信号量、用于保护读者数目和写者数目的互斥信号量。
（2）初始化信号量和互斥信号量。
（3）写者线程的实现：首先获取写者互斥信号量，然后获取写者信号量，进行写操作，释放写者信号量和写者互斥信号量。
（4）读者线程的实现：首先获取读者互斥信号量，然后增加读者数目，如果是第一个读者则获取写者信号量，然后进行读操作，释放读者信号量和读者互斥信号量，如果是最后一个读者则释放写者信号量。
（5）测试程序的运行并输出结果。
四、实验结果与分析通过对比两种解决方案，可以得出以下结论：1.使用互斥锁和条件变量的解决方案相对较为简单，但可能存在饥饿问题，即可能会导致一些线程一直无法访问共享资源。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统课程设计课题：读者写者问题******班级：1020552学号*********指导教师：***提交时间：2012/12/30（一）实验目的1.进一步理解“临界资源”的概念；2.把握在多个进程并发执行过程中对临界资源访问时的必要约束条件；3.理解操作系统原理中“互斥”和“同步”的涵义。
（二）实验内容利用程序设计语言编程，模拟并发执行进程的同步与互斥（要求：进程数目不少于3 个）。
（三）、程序分析读者写者问题的定义如下：有一个许多进程共享的数据区，这个数据区可以是一个文件或者主存的一块空间；有一些只读取这个数据区的进程（Reader）和一些只往数据区写数据的进程(Writer)，此外还需要满足以下条件：（1）任意多个读进程可以同时读这个文件；（2）一次只有一个写进程可以往文件中写；（3）如果一个写进程正在进行操作，禁止任何读进程度文件。
实验要求用信号量来实现读者写者问题的调度算法。
实验提供了signal类，该类通过P( )、V( )两个方法实现了P、V原语的功能。
实验的任务是修改Creat_Writer()添加写者进程，Creat_Reader()创建读者进程。
Reader_goon()读者进程运行函数。
读优先：要求指一个读者试图进行读操作时，如果这时正有其他读者在进行操作，他可直接开始读操作，而不需要等待。
读者优先的附加限制：如果一个读者申请进行读操作时已有另一读者正在进行读操作，则该读者可直接开始读操作。
写优先：一个读者试图进行读操作时，如果有其他写者在等待进行写操作或正在进行写操作，他要等待该写者完成写操作后才开始读操作。
写者优先的附加限制：如果一个读者申请进行读操作时已有另一写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
在Windows 7 环境下，创建一个控制台进程，此进程包含n 个线程。
用这n 个线程来表示n 个读者或写者。
每个线程按相应测试数据文件（格式见下）的要求进行读写操作。
用信号量机制分别实现读者优先和写者优先的读者/写者问题。
运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作和结束读写操作时分别显示一行提示信息，以确定所有处理都遵守相应的读写操作限制。
测试数据文件包括n 行测试数据，分别描述创建的n 个线程是读者还是写者，以及读写操作的开始时间和持续时间。
每行测试数据包括4个字段，各个字段间用空格分隔。
Ø 第一个字段为一个正整数，表示线程序号Ø 第二个字段表示相应线程角色，R 表示读者，W 表示写者Ø 第三个字段为一个正数，表示读/写操作的开始时间：线程创建后，延迟相应时间（单位为秒）后发出对共享资源的读/写请求Ø 第四个字段为一正数，表示读/写操作的持续时间：线程读写请求成功后，开始对共享资源的读/写操作，该操作持续相应时间后结束，并释放共享资源例如：1 R 3 52 W 4 53 R 5 24 R 6 55 W 5.1 3读者写者问题是操作系统中经典的互斥问题：一块数据被多个读者和写者的访问，需要考虑读写互斥、写写互斥（可以同时由多个读者读取）。
具体的又可以分为读者优先和写者优先两类。
读者优先算法：当新的读者到来的时候，若当前正有读者在进行读操作，则该读者无需等待前面的写操作完成，直接进行读操作。
设置两个互斥信号量：rwmutex 用于写者与其他读者/写者互斥的访问共享数据rmutex 用于读者互斥的访问读者计数器readcountvar rwmutex, rmutex ：semaphore := 1,1 ；int readcount = 0;cobeginreaderi begin // i=1,2,….P(rmutex);Readcount++;If (readcount == 1) P(rwmutex);V(rmutex);读数据；P(rmutex);Readcount--;If (readcount == 0) V(rwmutex);V(rmutex);EndWriterj begin // j = 1,2,….P(rwmutex);写更新；V(rwmutex);EndCoend写者优先：条件：1）多个读者可以同时进行读2）写者必须互斥（只允许一个写者写，也不能读者写者同时进行）3）写者优先于读者（一旦有写者，则后续读者必须等待，唤醒时优先考虑写者）设置三个互斥信号量：rwmutex 用于写者与其他读者/写者互斥的访问共享数据rmutex 用于读者互斥的访问读者计数器readcountnrmutex 用于写者等待已进入读者退出，所有读者退出前互斥写操作var rwmutex, rmutex，nrmutex ：semaphore := 1，1，1 ；int readcount = 0;cobeginreaderi begin // i=1,2,….P(rwmutex);P(rmutex);Readcount++;If (readcount == 1) P(nrmutex); //有读者进入，互斥写操作V(rmutex);V(rwmutex); // 及时释放读写互斥信号量，允许其它读、写进程申请资源读数据；P(rmutex);Readcount--;If (readcount == 0) V(nrmutex); //所有读者退出，允许写更新V(rmutex);EndWriterj begin // j = 1,2,….P(rwmutex); // 互斥后续其它读者、写者P(nrmutex); //如有读者正在读，等待所有读者读完写更新；V(nrmutex); //允许后续新的第一个读者进入后互斥写操作V(rwmutex); //允许后续新读者及其它写者EndCoend/////////////////////////////////////////////////////////////////////////////////////////////////////////////////*---------函数声明---------*/void Creat_Writer(); //添加一个写者void Del_Writer(); //删除一个写者void Creat_Reader(); //添加一个读者void Reader_goon(); //读者进程运行函数void R_Wakeup(); //唤醒等待读者void Del_Reader(); //删除一个读者void Show(); //显示运行状态/*=============== class signal ===============*/class signal //信号量对象.{private:int value;int queue; //用int型数据模拟等待队列.public:signal();signal(int n);int P(); //检查临界资源int V(); //释放临界资源int Get_Value();int Get_Queue();};////////////////////////////////////////////////////////////////////#include<windows.h>#include<fstream>#include<cstdlib>#include<iostream>using namespace std;const int MaxThread=20;struct ThreadInfo{int num;char type;double start;double time;}thread_info[MaxThread];HANDLE hX;HANDLE hWsem;HANDLE thread[MaxThread];int readcount;double totaltime;void WRITEUNIT(int iProcess){printf("Thread %d begins to write.\n",iProcess);Sleep((DWORD)(thread_info[iProcess-1].time*1000));printf("End of thread %d for writing.\n",iProcess);}void READUNIT(int iProcess){printf("Thread %d begins to read.\n",iProcess);Sleep((DWORD)(thread_info[iProcess-1].time*1000));printf("End of thread %d for reading.\n",iProcess);}DWORD WINAPI reader(LPVOID lpVoid){int iProcess = *(int*)lpV oid;Sleep((DWORD)(thread_info[iProcess-1].start*1000));DWORD wait_for=WaitForSingleObject(hX,INFINITE);printf("Thread %d requres reading.\n",iProcess);readcount++;if(readcount==1)WaitForSingleObject(hWsem,INFINITE);ReleaseMutex(hX);READUNIT(iProcess);wait_for=WaitForSingleObject(hX,INFINITE);readcount--;if(readcount==0)ReleaseSemaphore(hWsem,1,0);ReleaseMutex(hX);return iProcess;}DWORD WINAPI writer(LPVOID lpV oid){int iProcess = *(int*)lpV oid;Sleep((DWORD)(thread_info[iProcess-1].start*1000));printf("Thread %d requres writing.\n",iProcess);DWORD wait_for=WaitForSingleObject(hWsem,INFINITE);WRITEUNIT(iProcess);ReleaseSemaphore(hWsem,1,0);return iProcess;}int main(){int threadNum;int threadcount;ifstream file;hX=CreateMutex(NULL, FALSE, NULL);hWsem=CreateSemaphore(NULL,1,1,NULL);//readcount=0;threadcount=0;totaltime=0;file.open("thread.dat",ios::in);if(file==0){printf("File Open Error.\n");return 0;}while(file>>threadNum){thread_info[threadNum-1].num=threadNum;file>>thread_info[threadNum-1].type;file>>thread_info[threadNum-1].start;file>>thread_info[threadNum-1].time;totaltime+=thread_info[threadNum-1].time;switch(thread_info[threadNum-1].type){case 'W':printf("Creating Thread %d for writing.\n",thread_info[threadNum-1].num);thread[threadNum-1] = CreateThread(NULL, 0,writer, &thread_info[threadNum-1].num,0,0);break;case 'R':printf("Creating Thread %d for reading.\n",thread_info[threadNum-1].num);thread[threadNum-1] = CreateThread(NULL, 0,reader, &thread_info[threadNum-1].num,0,0);break;}threadcount++;}file.close();Sleep((DWORD)(totaltime*1000));return 1;}//////////////////////////////////////////////////////////////////////////////////semaphore fmutex = 1 , rdcntmutex = 1 ;// fmutex --> access to file; rdcntmutex --> access to readcountint readcount = 0 ;void reader(){while ( 1 ){P(rdcntmutex);if ( readcount==0)P(fmutex);readcount = readcount + 1 ;V(rdcntmutex);// Do read operationP(rdcntmutex);readcount = readcount - 1 ;if ( readcount==0)V(fmutex);V(rdcntmutex);}}void writer(){while ( 1 ){P(fmutex);// Do write operationV(fmutex);}}/////////////////////////////////////////////////////////////////////////////////////// semaphore fmutex = 1 , rdcntmutex = 1 , wtcntmutex = 1 , queue = 1 ; // fmutex --> access to file; rdcntmutex --> access to readcount// wtcntmutex --> access to writecountint readcount = 0 ,writecount = 0 ;void reader(){while ( 1 ){P(queue);//申请队列信号P(rdcntmutex);//修改readcount，互斥if ( readcount==0)P(fmutex);//access to file 互斥readcount = readcount + 1 ;V(rdcntmutex);//释放V(queue);//释放// Do read operationP(rdcntmutex);readcount = readcount - 1 ;if ( readcount==0)V(fmutex);V(rdcntmutex);}}void writer(){while ( 1 ){P(wtcntmutex);if ( writecount==0)P(queue);writecount = writecount + 1 ;V(wtcntmutex);P(fmutex);// Do write operationV(fmutex);P(wtcntmutex);writecount = writecount - 1 ;if ( writecount==0)V(queue);V(wtcntmutex);}}。