操作系统课程设计读者写者问题
操作系统课程设计报告——读者写者问题
操作系统课程设计课题：读者写者问题姓名：赫前进班级：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 个读者或写者。
每个线程按相应测试数据文件（格式见下）的要求进行读写操作。
读者-写者问题(Reader-Writer Problem)
学号：课程设计题目用多线程同步方法解决读者－写者问题(Reader-Writer Problem)学院计算机科学与技术学院专业软件工程班级姓名指导教师2010 年 6 月日目录目录 (1)课程设计任务书 (1)正文 (2)1.设计目的与要求 (2)1.1设计目的 (2)1.2设计要求 (2)2.设计思想及系统平台 (2)2.1设计思想 (2)2.2系统平台及使用语言 (3)3.详细算法描述 (3)4.源程序清单 (6)5.运行结果与运行情况 (9)6.调试过程 (11)7.总结 (12)本科生课程设计成绩评定表 (13)课程设计任务书学生姓名：专业班级：指导教师：工作单位：计算机科学与技术学院题目: 用多线程同步方法解决读者－写者问题(Reader-Writer Problem)初始条件：1．操作系统：Linux2．程序设计语言：C语言3．设有20个连续的存储单元，写入/读出的数据项按增序设定为1－20这20个字符。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．技术要求：1）为每个读者／写者产生一个线程，设计正确的同步算法2）每个读者/写者对该存储区进行操作后，即时显示该存储区的全部内容、当前指针位置和读者/写者线程的自定义标识符。
3）读者应有3个以上，写者应有有两个以上。
4）多个读者/写者之间须共享对存储区进行操作的函数代码。
2．设计说明书内容要求：1)设计题目与要求2)总的设计思想及系统平台、语言、工具等。
3）数据结构与模块说明（功能与流程图）4）给出用户名、源程序名、目标程序名和源程序及其运行结果。
（要注明存储各个程序及其运行结果的主机IP地址和目录。
）5）运行结果与运行情况（提示: (1)连续存储区可用数组实现。
(2)编译命令可用：cc -lpthread -o 目标文件名源文件名(3)多线程编程方法参见附件。
）3. 调试报告：1) 调试记录2)自我评析和总结上机时间安排：18周一~ 五08：0 －12：00指导教师签名：年月日系主任（或责任教师）签名：年月日正文1.设计目的与要求1.1设计目的通过研究Linux的线程机制和信号量实现读者写者问题(Reader-Writer Problem )的并发控制。
操作系统实验-读者写者问题
《计算机操作系统》实验报告题目读者写者问题学院（部）信息学院专业计算机科学与技术班级、学生姓名学号指导教师（签字）一、《二、问题描述一个数据文件或者记录，可以被多个进程共享，我们把只要求读该文件的进程称为“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、执行结果读者优先在读者优先中先两个读者申请，再一个写者申请，再有两个读者申请。
(完整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上。
读者-写者问题解答计算机操作系统实验报告指导资料
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)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。
读者-写者问题说明书
《操作系统原理》课程设计任务书题目：读者-写者问题的实现学生姓名：李志旭学号：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 陈映霞”，内容包括任务书、设计文档。
操作系统课程设计 (4)
设计1 题目进程同步（读者-写者问题）一、问题描述与分析一个数据文件或记录，可被多个进程共享，我们把只要求读该文件的进程称为“Reader”进程，其他进程则称为“Writer进程”允许多个进程同时读一个共享对象，因为读操作不会使数据文件混乱。
但不允许一个Writer进程和其他Reader进程或Writer进程同时访问将会引起混乱。
所谓读者写者问题，是指保证一个writer进程必须与其他进程互斥地访问共享对象的同步问题。
读者写者问题可以这样的描述，有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书，并且，读者必写者优先，也就是说，读者和写者同时提出请求时，读者优先。
当读者提出请求时需要有一个互斥操作，另外，需要有一个信号量S 来当前是否可操作。
二、设计要求和目的1.设计要求通过解决读者写者问题实现进程同步。
即（1）实现写-写互斥，（2）读-写互斥（3）读-读允许（4）写者优先2. 设计目的（l）.用信号量来实现读者写者问题，掌握进程同步机制及其实现机理。
（2）.理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。
三、背景知识1.参考操作系统课本中关于进程同步这方面的知识以及结合老师上课的讲解，仔细研究利用信号量实现读写者问题。
读者写者问题的定义如下：有一个许多进程共享的数据区，这个数据区可以是一个文件或者主存的一块空间；有一些只读取这个数据区的进程（Reader）和一些只往数据区写数据的进程(Writer)，此外还需要满足以下条件：（1）任意多个读进程可以同时读这个文件；（2）一次只有一个写进程可以往文件中写；（3）如果一个写进程正在进行操作，禁止任何读进程度文件。
我们需要分两种情况实现该问题：读优先：要求指一个读者试图进行读操作时，如果这时正有其他读者在进行操作，他可直接开始读操作，而不需要等待。
写优先：一个读者试图进行读操作时，如果有其他写者在等待进行写操作或正在进行写操作，他要等待该写者完成写操作后才开始读操作。
操作系统课程设计--读者-写者问题
操作系统课程设计报告一、操作系统课程设计任务书读者-写者问题实现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版)操作系统课程设计(采用读写平等策略的读者写者问题)完整版 内含代码(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) 读写策略：读写互斥、写写互斥、读写平等（严格按照读者与写者到达的顺序进入阅览室，有写着到达，则阻塞后续到达的读者；有读者到达，则阻塞后续到达的写者）。
读者写者问题
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)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。
读者写者问题写者优先参考答案完整版
读者写者问题写者优先参考答案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)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。
读者和写者问题
学号：课程设计课程名称操作系统学院计算机科学与技术学院专业软件工程专业班级姓名指导教师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 设计目的通过实验模拟读者和写者之间的关系，了解并掌握他们之间的关系及其原理。
操作系统-读者写入者问题
一、阅读者写入者问题描述有一个公用的数据集，有很多人需要访问，其中一些需要阅读其中的信息，一些需要修改其中的消息。
阅读者可以同时访问数据集，而写入者只能互斥的访问数据集，不能与任何的进程一起访问数据区。
二、程序运行说明1.本程序主要用于说明阅读者写入者问题中的资源互斥访问的调动策略，并模仿其访问的过程。
采用书上的伪码编制而成，实际上采用的是读优先策略。
2.在本程序中用于表现的图形界面说明：在程序编译运行后会出现中间一个大的圆圈表示公用的资源，上面一排五个矩形表示5个读者，下面的五个矩形表示五个写入者。
每个读者和写入者都有3种状态，休息，等待和操作（读入或者写入）分别用黑颜色，绿颜色，红颜色表示休息，等待和操作。
一旦操作者获得资源，可以进行读或者写，我们就划一条从操作者中心到资源中心的线，表示开始操作。
三、关于阅读者写入者问题的mfc程序分析：A. ReaderAndWriter.c函数说明：B．Mutex.c函数说明：1. DWORD WINAPI ReaderThread (LPVOID pVoid)读者进程：根据前面的资源分配策略，对于读进程，我们初始化设置都是处于休息状态，然后要是资源可读，根据进程到来的快慢，分配资源给读者，是其从休息，等待到读状态，最后释放资源进入休息状态，一直循环。
一旦有一个读者进入临界区，我们就封锁临界区，可以让所用的读者进入，而不让写入者进入，并用一个资源控制readercount，保证每次只有一个进程对变量进行操作。
这样，直到每一个读者都读完，没有一个读者的时候，开始释放临界区，这样写入者就可以进入与读者进行资源的争夺，决定是读还是写。
2. DWORD WINAPI WriterThread (LPVOID pVoid)写入者进程：与读者进程类似，从休息代等待，最后写入，一直循环。
其中只要一个写进程进入临界区，其他的进程就不能进入临界区了，直到写进程释放临界区。
操作系统——读者写者问题
操作系统——读者写者问题⼀、问题描述要求：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也将能够执⾏下去。
读者写者问题-写者优先参考答案
读者写者问题-写者优先参考答案【写者优先】在读者、写者问题中，如果总有读者进程进行读操作，会造成写者进程永远都不能进行写操作（读者优先），即所谓的写者饿死现象。
给出读者、写者问题的另一个解决方案：即保证当有一个写者进程想写时，不允许读者进程再进入，直到写者写完为止，即写者优先。
让我们先回顾读者写者问题[1]：一个数据对象若被多个并发进程所共享，且其中一些进程只要求读该数据对象的内容，而另一些进程则要求写操作，对此，我们把只想读的进程称为“读者”，而把要求写的进程称为“写者”。
在读者、写者问题中，任何时刻要求“写者”最多只允许有一个执行，而“读者”则允许有多个同时执行。
因为多个“读者”的行为互不干扰，他们只是读数据，而不会改变数据对象的内容，而“写者”则不同，他们要改变数据对象的内容，如果他们同时操作，则数据对象的内容将会变得不可知。
所以对共享资源的读写操作的限制条件是：⏹允许任意多的读进程同时读；⏹一次只允许一个写进程进行写操作；如果有一个写进程正在进行写操作，禁止⋯⋯;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，则迭代唤醒等待授权的读者；⏹读者到来，首先看授权标志，如果有授权标志，则继续，否则等待授权，即写者取消授权后，新来的读者不能申请缓冲区。
4--采用“写优先”策略的“读者-写者”问题
4--采用“写优先”策略的“读者-写者”问题《操作系统课程设计》任务书设计题目：采用“写优先”策略的“读者-写者”问题指导老师：赵娟课程设计的目的：操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
? 进一步巩固和复习操作系统的基础知识。
? 培养学生结构化程序、模块化程序设计的方法和能力。
? 提高学生调试程序的技巧和软件设计的能力。
? 提高学生分析问题、解决问题以及综合利用 C 语言进行程序设计的能力。
设计内容：用高级语言编写和调试一个采用“写优先”策略的“读者-写者”问题的模拟程序。
设计要求：1. 读者与写者至少包括ID、进入内存时间、读写时间三项内容，可在界面上进行输入 2. 读者与写者均有二个以上，可在程序运行期间动态增加读者与写者 3. 可读取样例数据（要求存放在外部文件中），进行读者/写者、进入内存时间、读写时间的初始化4. 要求将运行过程用可视化界面动态显示，可随时暂停，查看阅览室中读者/写者数目、读者等待队列、写者等待队列、读写时间、等待时间5. 读写策略为：读写互斥、写写互斥、写优先（只要写者到达，就阻塞后续的所有读者，一旦阅览室无人，写者能最快进入阅览室；在写者未出阅读室之前，又有新的读者与写者到达，仍然是写者排在前面）设计结束需提交下列资料：1、课程设计报告。
报告中至少应包括：相关操作系统的知识介绍，程序总的功能说明、程序各模块的功能说明、程序设计的流程图、源程序清单。
2、源程序和编译连接后的可执行程序文件。
时间安排：分析设计贮备阶段（1天）编程调试阶段（7天）写课程设计报告、考核（2天）感谢您的阅读，祝您生活愉快。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机与信息学院操作系统课程设计报告一、开题报告（一）该项课程设计的意义；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上。
（四）开发环境；VC++6.0（五）预期设计目标；读者-写者问题的读写操作限制（包括读者优先和写者优先）1.写-写互斥：不能有两个写者同时进行写操作2.读-写互斥：不能同时有一个线程在读，而另一个线程在写。
3.读-读允许：可以有一个或多个读者在读。
若读者的优先权比写者高,如果读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作.不必经过别的操件若读者的优先权比写者高,如果第一个写者已经占有了文件的时候.则别的读者必需等待该操作完成后.才能开始读操作.若写者的优先权比读者高,在一个写者提出要访问文件时，就必须使其尽可能的得到文件，而且不用调配。
完成课程设计的任务，实现读者写者问题的全部要求，同时可以实现“读者优先”和“写者优先”两种情况，有时间的话，争取实现可视化图形界面。
二、课程设计报告（一）课程设计任务、要求、目的；任务和要求：多进程/线程编程：读者-写者问题。
●设置两类进程/线程，一类为读者，一类为写者；●随机启动读者或写者；●显示读者或写者执行状态；●随着进程/线程的执行，更新显示；目的：1更加深入的了解读者写者问题的算法；2加深对线程，进程的理解；3加深对“线程同步”概念的理解，理解并应用“信号量机制”；4熟悉计算机对处理机的管理，了解临界资源的访问方式；5了解C++中线程的实现方式，研读API。
（二）原理及算法描述；写者优先原理图：读者优先原理图：算法描述：读者优先的附加限制：如果读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。
写者优先的附加限制：如果一个读者申请进行读操作时已有另一个写者在等待访问共享资源，则该读者必须等到没有写者处于等待状态后才能开始读操作。
（三）开发环境；VC++6.0（四）重要算法和设计思路描述；整体概况：该程序从大体上来分只有两个模块,即“读者优先”和“写者优先”模块.读者优先：如果没有写者正在操作，则读者不需要等待，用一个整型变量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上。
（五）程序实现---数据结构；相关WindowsAPI说明:CreateThread:创建一个在调用进程的地址空间中执行的线程。
ExitThreadSleep:对指定的时间间隔挂起当前的执行线程CreateMutex:创建有名或者无名的互斥对象ReleaseMutex:WaitForSingleObject:当发生(1)指定对象处于信号态(2)超时则该函数返回WaitForMultipleObject:任意一个或全部指定对象处于信号态或超时间隔已过时，返回CreateSemapore:创建一个有名或无名信号对象。
ReleaseSemapore:InitializeCriticalSection:初始化临界区对象EnterCriticalSection:等待指定临界区对象的所有权。
当调用线程被赋予所有权时，返回。
LeaveCriticalSection:该函数释放指定临界区对象的所有权。
（六）程序实现---程序清单；#include<windows.h>//#include<ctype.h>//#include<stdio.h>//#include<string.h>//#include<stdlib.h>//#include<malloc.h>#include<iostream>usingnamespacestd;#defineMAX_PERSON100//最多100人#defineREADER0//读者#defineWRITER1//写者#defineEND-1//结束//#defineRREADER//#defineWWRITERtypedefstruct{HANDLEm_hThread;//定义处理线程的句柄intType;//进程类型（读写）intStartTime;//开始时间intWorkTime;//运行时间intID;//进程号}Person;PersonPersons[MAX_PERSON]; intNumOfPerson=0;longCurrentTime=0;//基本时间片数intPersonLists[]={//进程队列1,WRITER,3,5,2,WRITER,16,5,3,READER,2,2,4,WRITER,6,5,5,READER,4,3,6,READER,17,7,END,};intNumOfReading=0;intNumOfWriteRequest=0;//申请写进程的个数HANDLEReadSemaphore;//读者信号HANDLEWriteSemaphore;//写者信号boolfinished=false;//所有的读完成//boolwfinished=false;//所有的写完成voidCreatePersonList(int*pPersonList); boolCreateReader(intStartTime,intWorkTime,intID); boolCreateWriter(intStartTime,intWorkTime,intID); DWORDWINAPIReaderProc(LPVOIDlpParam); DWORDWINAPIWriterProc(LPVOIDlpParam); intmain(){ReadSemaphore=CreateSemaphore(NULL,1,100,NULL);//创建信号量，当前可用的资源数为1，最大为100/*HANDLECreateSemaphore(LPSECURITY_ATTRIBUTESlpSemaphoreAttributes,//lpSemaphoreAttributes为安全属性LONGlInitialCount,//lInitialCount为Semaphore的初始值LONGlMaximumCount,//lMaximumCount为最大值LPCTSTRlpName//lpName为Semaphore对象的名字，NULL表示创建匿名Semaphore );*/WriteSemaphore=CreateSemaphore(NULL,1,100,NULL);//创建信号量，当前可用的资源数为1，最大为100CreatePersonList(PersonLists);//创建所有读者写者cout<<"创建所有的读者写者"<<"\n...\n";CurrentTime=0;while(true){CurrentTime++;Sleep(300);//300mscout<<"当前时间="<<CurrentTime<<endl;if(finished)return0;}//return0;}voidCreatePersonList(int*pPersonLists){inti=0;int*pList=pPersonLists;boolRet;while(pList[0]!=END){switch(pList[1]){caseREADER:Ret=CreateReader(pList[2],pList[3],pList[0]);break;caseWRITER:Ret=CreateWriter(pList[2],pList[3],pList[0]);break;}if(!Ret)printf("CreatePerson%diswrong\n",pList[0]);pList+=4;//寻找下一个读者或者写者}}boolCreateReader(intStartTime,intWorkTime,intID){DWORDdwThreadID;if(NumOfPerson>=MAX_PERSON)returnfalse;Person*pPerson=&Persons[NumOfPerson];pPerson->ID=ID;pPerson->StartTime=StartTime;pPerson->WorkTime=WorkTime;pPerson->Type=READER;NumOfPerson++;//新建进程pPerson->m_hThread=CreateThread(NULL,0,ReaderProc,(LPVOID)pPerson,0,&dwThreadID) ;/*HANDLECreateThread(LPSECURITY_ATTRIBUTESlpThreadAttributes,//pointertosecurityattributes安全属性DWORDdwStackSize,//initialthreadstacksize堆栈大小LPTHREAD_START_ROUTINElpStartAddress,//pointertothreadfunction函数指针LPVOIDlpParameter,//argumentfornewthreadDWORDdwCreationFlags,//creationflagsLPDWORDlpThreadId//pointertoreceivethreadID);*/if(pPerson->m_hThread==NULL)returnfalse;returntrue;}boolCreateWriter(intStartTime,intWorkTime,intID){DWORDdwThreadID;if(NumOfPerson>=MAX_PERSON)returnfalse;Person*pPerson=&Persons[NumOfPerson];pPerson->ID=ID;pPerson->StartTime=StartTime;pPerson->WorkTime=WorkTime;pPerson->Type=WRITER;NumOfPerson++;//新建进程pPerson->m_hThread=CreateThread(NULL,0,WriterProc,(LPVOID)pPerson,0,&dwThreadID);/*HANDLECreateThread(LPSECURITY_ATTRIBUTESlpThreadAttributes,//pointertosecurityattributes安全属性DWORDdwStackSize,//initialthreadstacksize堆栈大小LPTHREAD_START_ROUTINElpStartAddress,//pointertothreadfunction函数指针LPVOIDlpParameter,//argumentfornewthreadDWORDdwCreationFlags,//creationflagsLPDWORDlpThreadId//pointertoreceivethreadID);*/if(pPerson->m_hThread==NULL)returnfalse;returntrue;}DWORDWINAPIReaderProc(LPVOIDlpParam)//读过程{Person*pPerson=(Person*)lpParam;//等待启动时间while(CurrentTime!=pPerson->StartTime){//读操作还没有到达执行时间，则等待}printf("Reader%disRequesting...\n",pPerson->ID);printf("\n\n************************************************\n");//等待写者请求//该语句在写者优先的时候是认为写者优先级高于读者，在有写者的时候读者需要等候，而在读者优先的时候，不用判断是否存在写者，有读者时即开始读操作。