操作系统 读者与写者 课程设计报告
- 格式:doc
- 大小:219.50 KB
- 文档页数:12
操作系统课程设计课题:读者写者问题姓名:赫前进班级: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 个读者或写者。
每个线程按相应测试数据文件(格式见下)的要求进行读写操作。
操作系统课程设计课题:读者写者问题******班级: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 个读者或写者。
每个线程按相应测试数据文件(格式见下)的要求进行读写操作。
读者与写者的课程设计一、课程目标知识目标:1. 学生能够理解并掌握阅读与写作的基本概念和技巧。
2. 学生能够识别并分析不同文体的特点,如记叙文、说明文和议论文。
3. 学生能够运用所学知识评价和欣赏文本,理解作者的观点和意图。
技能目标:1. 学生能够运用各种阅读策略,提高阅读理解能力和速度。
2. 学生能够运用写作技巧,进行有逻辑、有结构的文章创作。
3. 学生能够通过小组讨论、同伴互评等方式,提高表达和沟通能力。
情感态度价值观目标:1. 培养学生对阅读和写作的兴趣,激发创作潜能。
2. 培养学生合作、探究的学习态度,敢于表达自己的观点和感受。
3. 培养学生尊重他人观点,学会倾听和包容,形成良好的审美观。
课程性质:本课程旨在帮助学生掌握阅读与写作的基本技能,提高语文素养,培养良好的学习习惯和情感态度。
学生特点:六年级学生具有一定的阅读和写作基础,好奇心强,求知欲旺盛,但学习方法、技巧有待提高。
教学要求:结合学生特点,注重启发式教学,以学生为主体,关注个体差异,提高学生的实践能力和创新能力。
通过本课程的学习,使学生具备以下具体学习成果:1. 能够独立阅读并分析不同文体的文章。
2. 能够运用所学技巧进行创意写作,并具备一定的审美能力。
3. 形成主动阅读、乐于分享的学习习惯,具备良好的沟通能力和团队协作精神。
二、教学内容本课程教学内容主要包括以下三个方面:1. 阅读理解:- 教材章节:第三单元“阅读与理解”- 内容列举:文章结构分析、作者观点理解、文章主旨归纳、阅读策略运用等。
2. 写作技巧:- 教材章节:第四单元“写作与表达”- 内容列举:记叙文写作技巧、说明文写作技巧、议论文写作技巧、文章构思与布局等。
3. 语文实践:- 教材章节:第五单元“语文实践活动”- 内容列举:小组讨论、同伴互评、创意写作、阅读分享等。
教学安排和进度:第一周:阅读理解(文章结构分析、阅读策略运用)第二周:阅读理解(作者观点理解、文章主旨归纳)第三周:写作技巧(记叙文写作技巧、文章构思与布局)第四周:写作技巧(说明文写作技巧、议论文写作技巧)第五周:语文实践(小组讨论、同伴互评、创意写作)第六周:语文实践(阅读分享、成果展示)教学内容科学系统,注重培养学生的阅读与写作能力,同时结合实践环节,提高学生的实际操作和创新能力。
兰州交通大学操作系统课程设计课程:计算机操作系统题目:进程同步(读者--写者)班级:姓名:学号:指导教师:日期: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设计功能利用模拟用信号量机制实现读者和写者问题:通过用户控制读进程和写进程,反应读者和写者问题中所涉及的进程的同步与互斥。
《计算机操作系统》实验报告题目读者写者问题学院(部)信息学院专业计算机科学与技术班级、学生姓名学号指导教师(签字)一、《二、问题描述一个数据文件或者记录,可以被多个进程共享,我们把只要求读该文件的进程称为“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.更加深入的了解读者写者问题的算法;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上。
操作系统课程设计报告一、操作系统课程设计任务书读者-写者问题实现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()释放指定临界区对象的所有权文件系统的设计通过对文件系统的设计,加深理解文件系统的内部功能及内部实现。
青岛理工大学操作系统课程设计报告院(系):计算机工程学院专业:计算机科学与技术专业学生姓名:__杨晓玉班级:__计算093__学号: 200907195 题目:采用“读写平等”策略演示“读者-写者”问题起迄日期:2012-7-2 至2012-7-13___设计地点:网络中心计算机学院机房指导教师:王金龙2011—2012年度第 2 学期完成日期: 2012 年 7 月 13日一、课程设计目的进行操作系统课程设计主要是在学习操作系统课程的基础上,在完成操作系统各部分实验的基础上,对操作系统的整体进行一个模拟,通过实践加深对各个部分的管理功能的认识,还能进一步分析各个部分之间的联系,最后达到对完整系统的理解。
同时,可以提高运用操作系统知识解决实际问题的能力;锻炼实际的编程能力、创新能力及团队组织、协作开发软件的能力;还能提高调查研究、查阅技术文献、资料以及编写软件设计文档的能力。
此次实验我选择的是经典的读者写者问题。
读写者问题的传统解决方案采用读优先策略,可能会造成后续的写者被随后而来的读者插队而长时间等待,直到全部读者进程运行完毕后,才可进行写操作。
为此,选择采用“读写平等策略”解决读写者问题,希望通过此次课程设计实现读写者的公平竞争,加深对线程、进程及同步概念的理解。
通过研究经典的进程同步问题,实现对读者-写者问题的并发控制,掌握运用信号量解决“同类进程多次访问,而不同类的进程必须互斥访问资源”的控制问题。
此次实验我选择用比较大众的jAVA语言编写,通过自学JAVA语言实现读者写者问题,还提供了我进一步学习编程语言的机会。
二、课程设计内容与要求1、设计内容:通过研究经典的进程同步问题,实现对读者-写者问题的并发控制。
2、说明:阅览室一次最多可以容纳20个人。
3、设计要求:1)读者与写者至少包括ID、进入内存时间、读写时间三项内容,可在界面上进行输入。
2)读者与写者均有二个以上,可在程序运行期间动态增加读者与写者。
读者写者问题实验报告引言读者写者问题是计算机科学中经典的同步问题之一,它涉及多线程编程中的资源竞争与同步机制。
通过对读者写者问题的研究,我们可以深入理解线程同步的重要性,并掌握解决并发编程中可能出现的竞争条件和死锁等问题的方法。
在本实验中,我们将设计并实现一个简单的读者写者问题的解决方案,并通过模拟多个读者和写者的并发访问来验证方案的正确性和效果。
问题描述读者写者问题可描述为:有一共享资源(如文件、数据库等),读者可同时访问共享资源进行读取操作,但写者在进行写入操作时,不可同时被其他任何读者或写者访问。
读者和写者的并发访问需要由线程同步机制来保证共享资源的一致性和完整性。
实验设计与实现为了解决读者写者问题,我们需要考虑以下几个关键点:1. 共享资源的访问控制我们可以使用互斥量(Mutex)来实现对共享资源的访问控制。
当一个线程访问共享资源时,它需要先获得互斥量的锁,如果锁已被其他线程占用,则线程进入等待状态,直到锁可用。
一旦线程完成对共享资源的访问,它将释放锁,以便其他线程继续访问。
2. 读者与写者的优先级在读者写者问题中,我们往往需要设定某个优先级规则,以确定读者和写者之间的调度顺序。
一种常见的策略是给予写者优先级,即当一个写者在等待访问共享资源时,其他读者都必须等待。
这样做是为了避免写者长时间等待,以免造成饥饿问题。
3. 记录读者和写者的数量为了控制读者和写者的并发访问,我们需要记录当前同时访问共享资源的读者和写者的数量。
我们可以使用整数变量来记录读者和写者的数量,并通过信号量来保证对这些计数变量的互斥访问。
4. 同步机制的设计在实现读者写者问题的解决方案时,我们需要考虑如何合理地使用互斥量和信号量,并结合优先级规则来实现读者和写者的同步。
这需要通过仔细的设计和调试来确保解决方案的正确性。
实验结果与分析我们基于上述设计实现了一个读者写者问题的解决方案,并进行了多次仿真实验。
实验环境•操作系统:Windows 10•编程语言:C++•编译器:GCC实验步骤1.编写读者和写者线程的代码,其中涉及到对共享资源的读取和写入操作,以及对计数变量和互斥量的访问操作。
操作系统课程设计报告课程设计题目:读者与写者问题学生姓名:汪杰专业:信息安全方向班级:1232102学号:201230210205指导教师:周跃文小组成员:汪杰、聂庆添、刘洋2014年6月10日目录一设计概述……………………………………………………错误!未定义书签。
二设计目的与内容 (4)三设计分析 (5)四程序实现 (6)五程序调试 (7)六结果分析和讨论 (7)七心得体会 (8)八源代码 (8)一设计概述所谓读者写者问题,是指保证一个writer进程必须与其他进程互斥地访问共享对象的同步问题。
读者写者问题可以这样的描述,有一群写者和一群读者,写者在写同一本书,读者也在读这本书,多个读者可以同时读这本书,但是,只能有一个写者在写书,并且,读者必写者优先,也就是说,读者和写者同时提出请求时,读者优先。
当读者提出请求时需要有一个互斥操作,另外,需要有一个信号量S来当前是否可操作。
信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制,而读者写者问题则是这一机制的一个经典范例。
与记录型信号量解决读者—写者问题不同,信号量机制它增加了一个限制,即最多允许RN个读者同时读。
为此,又引入了一个信号量L,并赋予初值为RN,通过执行wait(L,1,1)操作,来控制读者的数目,每当有一个读者进入时,就要执行wait(L,1,1)操作,使L的值减1。
当有RN个读者进入读后,L便减为0,第RN+1 个读者要进入读时,必然会因wait (L,1,1)操作失败而堵塞。
对利用信号量来解决读者—写者问题的描述如下:Var RN integer;L,mx:semaphore: =RN,1;BeginParbeginReader :beginRepeatSwait(L,1,1);Swait(mx,1,0);.Perform reader operation;Ssignal(L,1);Until false;EndWriter :beginRepeatSwait(mx ,1,1,l,RN,0);Perform writer operation;Ssignal(mx,1);Until false;EndParendEnd其中,Swait(mx,1,0)语句起着开关作用,只要无Writer进程进入些,mx=1,reader 进程就都可以进入读。
但是要一旦有Writer进程进入写时,其MX=0,则任何reader进程就都无法进入读。
Swait(mx ,1,1,l,RN,0)语句表示仅当既无Write进程在写(mx=1),又无reader 进程在读(L=RN)时,writer进程才能进入临界区写。
本设计方案就是通过利用记录型信号量对读者写者问题的解决过程进行模拟演示,形象地阐述记录型信号量机制的工作原理。
二设计目的与内容一实验目的l. 用信号量来实现读者写者问题。
2. 理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。
二、二实验内容读者写者问题的定义如下:有一个许多进程共享的数据区,这个数据区可以是一个文件或者主存的一块空间;有一些只读取这个数据区的进程(Reader)和一些只往数据区写数据的进程(Writer),此外还需要满足以下条件:(1)任意多个读进程可以同时读这个文件;(2)一次只有一个写进程可以往文件中写;(3)如果一个写进程正在进行操作,禁止任何读进程度文件。
我们需要分两种情况实现该问题:读优先:要求指一个读者试图进行读操作时,如果这时正有其他读者在进行操作,他可直接开始读操作,而不需要等待。
写优先:一个读者试图进行读操作时,如果有其他写者在等待进行写操作或正在进行写操作,他要等待该写者完成写操作后才开始读操作。
三设计分析在Windows 7 环境下,创建一个包含n 个线程的控制台进程。
用这n 个线程来表示n 个读者或写者。
每个线程按相应测试数据文件的要求,进行读写操作。
请用信号量机制分别实现读者优先和写者优先的读者-写者问题。
读者-写者问题的读写操作限制:读者-写者的读写限制(包括读者优先和写者优先)1)写-写互斥,即不能有两个写者同时进行写操作2)读-写互斥,即不能同时有一个读者在读,同时却有一个写者在写3)读读允许,即可以有2个以上的读者同时读将所有的读者和所有的写者分别放进两个等待队列中,当读允许时就让读者队列释放一个或多个读者,当写允许时,释放第一个写者操作。
读者写者问题的定义如下:有一个许多进程共享的数据区,这个数据区可以是一个文件或者主存的一块空间;有一些只读取这个数据区的进程(Reader)和一些只往数据区写数据的进程(Writer),此外还需要满足以下条件:1)任意多个读进程可以同时读这个文件;2) 一次只有一个写进程可以往文件中写;3)如果一个写进程正在进行操作,禁止任何读进程度文件。
我们需要分两种情况实现该问题:读优先:要求指一个读者试图进行读操作时,如果这时正有其他读者在进行操作,他可直接开始读操作,而不需要等待。
写优先:一个读者试图进行读操作时,如果有其他写者在等待进行写操作或正在进行写操作,他要等待该写者完成写操作后才开始读操作。
这个项目设计是由我们这小组三人共同完成的,每个人都负责一些功能模块。
我是这组的组长,我负责的是整体的一个框架,以及主函数的实现。
然后将改组成员做出的功能模块添加到程序中。
四程序实现程序由两部分组成:1。
读者-写者模块:包括系统调用接口,读者-写者活动描述主程序。
系统接口主要功能是通过管道向父进程发送系统调用命令,并读取父进程送来的返回值。
读者-写者活动程序根据临界资源的共享,互斥原则编制,具体见源程序。
2。
主控模块:主控模块实现系统初始化系统调用命令接收与解释执行,系统调用功能的实现(包括信号量机制),及读者-写者活动过程记录与显示。
初始化系统环境建立通信管道启动读者-写者进程接收系统调用命令解释执行系统初始化模块管道建立模块进程启动模块命令解释模块Wait()Signal()Wakeup()Block()五程序调试测试数据文件格式:测试数据文件包括n 行测试数据,分别描述创建的n 个线程是读者还是写者,以及读写操作的开始时间和持续时间。
每行测试数据包括四个字段,各字段间用空格分隔。
第一字段为一个正整数,表示线程序号。
第二字段表示相应线程角色,R 表示读者是,W 表示写者。
第三字段为一个正数,表示读写操作的开始时间。
线程创建后,延时相应时间(单位为秒)后发出对共享资源的读写申请。
第四字段为一个正数,表示读写操作的持续时间。
当线程读写申请成功后,开始对共享资源的读写操作,该操作持续相应时间后结束,并释放共享资源。
六结果分析和讨论在读者写者同时在队列中等待申请资时,读者优先调用资源。
而且如果一个读者申请进行读操作时已有另一读者正在进行读操作,则该读者可直接开始读操作,即读读允许。
进程1是R操作,在时间3时进入队列,运行时间是5,在它进入时没有进程占用资源,它既占用资源;知道它释放资源,等候的进程有3,4,5;进程2是W操作,在时间16时进入队列,运行时间是5,在它进入时进程4占用资源,它等待资源,当4释放时占用资源;进程3是R操作,在时间5时进入队列,运行时间是2,在它进入时进程1占用资源,它等待资源,当进程1释放资源后,由于读者优先,进程3,5同时调运资源;进程4是R操作,在时间6时进入队列,运行时间是5,在它进入时进程1占用资源,它等待资源,当进程1释放资源后,由于读者优先,进程3,5占用资源,它依然等待,直到进程3,5都结束;进程5是W操作,在时间4时进入队列,运行时间是3, 在它进入时进程1占用资源,它等待资源,当进程1释放资源后,由于读者优先,进程3,5同时调运资源;七心得体会这一次课程设计,让我体会很深刻。
读者-写者问题经典的线程同步问题的一个模型。
经过读者写者问题的编写,我对同步机构应用有了深入的了解。
懂得了运用信号量实现进程间的互斥。
实现了不让共享资源同时修改。
用信号量上的原语操作使临界段问题的解决比较简单明了了。
读者写者问题的编写,花的时间很多,也学到很多东西。
了解支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的信号量机制。
几天的试验,虽然难度有点大,但只要自己花时间去学习,还是会攻克困难的。
总之,每一次课程设计不仅是我们学习的好机会,而且是我们锻炼实际动手能力的平台,虽然有难度的东西总会让人很抵触,比如在课设过程中有很多郁闷的时候,一个小小的错误一不小心就花去了自己一上午的时间,所以在这个过程中能够磨练人的意志与耐心,最后感谢老师的指导与监督。
八源代码#include <windows.h>#include <ctype.h>#include <stdio.h>#include <string.h>#include <stdlib.h>#include <malloc.h>#define MAX_PERSON 100#define READER 0 //读者#define WRITER 1 //写者#define END -1#define R READER#define W WRITERtypedef struct _Person{HANDLE m_hThread; //定义处理线程的句柄int m_nType; //进程类型(读写)int m_nStartTime; //开始时间int m_nWorkTime; //运行时间int m_nID; //进程号}Person;Person g_Persons[MAX_PERSON];int g_NumPerson = 0;long g_CurrentTime= 0; //基本时间片数int g_PersonLists[] = { //进程队列1, R, 3, 5, 2, W, 4, 5, 3, R, 5, 2,4, R, 6, 5, 5, W, 5.1, 3, END,};int g_NumOfReading = 0;int g_NumOfWriteRequest = 0; //申请写进程的个数HANDLE g_hReadSemaphore; //读者信号HANDLE g_hWriteSemaphore; //写者信号bool finished = false; //所有的读完成//bool wfinished = false; //所有的写完成void CreatePersonList(int *pPersonList);bool CreateReader(int StartTime,int WorkTime,int ID);bool CreateWriter(int StartTime,int WorkTime,int ID);DWORD WINAPI ReaderProc(LPVOID lpParam);DWORD WINAPI WriterProc(LPVOID lpParam);int main(){g_hReadSemaphore = CreateSemaphore(NULL,1,100,NULL); //创建信号灯,当前可用的资源数为1,最大为100g_hWriteSemaphore = CreateSemaphore(NULL,1,100,NULL); //创建信号灯,当前可用的资源数为1,最大为100CreatePersonList(g_PersonLists); // Create All the reader and writersprintf("Created all the reader and writer\n...\n");g_CurrentTime = 0;while(true){g_CurrentTime++;Sleep(300); // 300 msprintf("CurrentTime = %d\n",g_CurrentTime); //显示时间片数if(finished) //读者完成时结束return 0;} // return 0;}//创建所有读者与写者void CreatePersonList(int *pPersonLists){int i=0;int *pList = pPersonLists;bool Ret;while(pList[0] != END){switch(pList[1]){case R:Ret = CreateReader(pList[2],pList[3],pList[0]);//351,w452,523,654break;case W:Ret = CreateWriter(pList[2],pList[3],pList[0]);break;}if(!Ret)printf("Create Person %d is wrong\n",pList[0]);pList += 4; // move to next person list}}//读过程DWORD WINAPI ReaderProc(LPVOID lpParam){Person *pPerson = (Person*)lpParam;// wait for the start timewhile(g_CurrentTime != pPerson->m_nStartTime){}printf("Reader %d is Requesting ...\n",pPerson->m_nID);printf("\n\n************************************************\n");// wait for the write requestWaitForSingleObject(g_hReadSemaphore,INFINITE);if(g_NumOfReading ==0){WaitForSingleObject(g_hWriteSemaphore,INFINITE);}g_NumOfReading++;ReleaseSemaphore(g_hReadSemaphore,1,NULL);pPerson->m_nStartTime = g_CurrentTime;printf("Reader %d is Reading the Shared Buffer...\n",pPerson->m_nID);printf("\n\n************************************************\n");while(g_CurrentTime <= pPerson->m_nStartTime + pPerson->m_nWorkTime) {}printf("Reader %d is Exit...\n",pPerson->m_nID);printf("\n\n************************************************\n");WaitForSingleObject(g_hReadSemaphore,INFINITE);g_NumOfReading--;if(g_NumOfReading == 0){ReleaseSemaphore(g_hWriteSemaphore,1,NULL); //此时没有读者,可以写}ReleaseSemaphore(g_hReadSemaphore,1,NULL);if(pPerson->m_nID == 4)finished = true; //所有的读写完成ExitThread(0);return 0;}//写过程DWORD WINAPI WriterProc(LPVOID lpParam){Person *pPerson = (Person*)lpParam;// wait for the start timewhile(g_CurrentTime != pPerson->m_nStartTime){}printf("Writer %d is Requesting ...\n",pPerson->m_nID);printf("\n\n************************************************\n");WaitForSingleObject(g_hWriteSemaphore,INFINITE);// modify the writer's real start timepPerson->m_nStartTime = g_CurrentTime;printf("Writer %d is Writting the Shared Buffer...\n",pPerson->m_nID);while(g_CurrentTime <= pPerson->m_nStartTime + pPerson->m_nWorkTime){}printf("Writer %d is Exit...\n",pPerson->m_nID);printf("\n\n************************************************\n");//g_NumOfWriteRequest--;ReleaseSemaphore(g_hWriteSemaphore,1,NULL);if(pPerson->m_nID == 4)finished = true; //所有的读写完成ExitThread(0);return 0;}//创建读者bool CreateReader(int StartTime,int WorkTime,int ID){DWORD dwThreadID;if(g_NumPerson >= MAX_PERSON)return false;Person *pPerson = &g_Persons[g_NumPerson];pPerson->m_nID = ID;pPerson->m_nStartTime = StartTime;pPerson->m_nWorkTime = WorkTime;pPerson->m_nType = READER;g_NumPerson++;// Create an New ThreadpPerson->m_hThread=CreateThread(NULL,0,ReaderProc,(LPVOID)pPerson,0,&dwThreadID);if(pPerson->m_hThread == NULL)return false;return true;}//创建写者bool CreateWriter(int StartTime,int WorkTime,int ID){DWORD dwThreadID;if(g_NumPerson >= MAX_PERSON)return false;Person *pPerson = &g_Persons[g_NumPerson];pPerson->m_nID = ID;pPerson->m_nStartTime = StartTime;pPerson->m_nWorkTime = WorkTime;pPerson->m_nType = WRITER;g_NumPerson++;// Create an New ThreadpPerson->m_hThread=CreateThread(NULL,0,WriterProc,(LPVOID)pPerson,0,&dwThreadID);if(pPerson->m_hThread == NULL)return false;return true;}。