操作系统课设: 实现读者写者(Reader-Writer Problem)问题

合集下载

操作系统课程设计报告——读者写者问题

操作系统课程设计报告——读者写者问题

操作系统课程设计课题:读者写者问题姓名:赫前进班级: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 个读者或写者。

每个线程按相应测试数据文件(格式见下)的要求进行读写操作。

(完整word版)操作系统课程设计-读者写者问题

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

4--采用“写优先”策略的“读者-写者”问题

4--采用“写优先”策略的“读者-写者”问题

4--采用“写优先”策略的“读者-写者”问题《操作系统课程设计》任务书设计题目:采用“写优先”策略的“读者-写者”问题指导老师:赵娟课程设计的目的:操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。

? 进一步巩固和复习操作系统的基础知识。

? 培养学生结构化程序、模块化程序设计的方法和能力。

? 提高学生调试程序的技巧和软件设计的能力。

? 提高学生分析问题、解决问题以及综合利用 C 语言进行程序设计的能力。

设计内容:用高级语言编写和调试一个采用“写优先”策略的“读者-写者”问题的模拟程序。

设计要求:1. 读者与写者至少包括ID、进入内存时间、读写时间三项内容,可在界面上进行输入 2. 读者与写者均有二个以上,可在程序运行期间动态增加读者与写者 3. 可读取样例数据(要求存放在外部文件中),进行读者/写者、进入内存时间、读写时间的初始化4. 要求将运行过程用可视化界面动态显示,可随时暂停,查看阅览室中读者/写者数目、读者等待队列、写者等待队列、读写时间、等待时间5. 读写策略为:读写互斥、写写互斥、写优先(只要写者到达,就阻塞后续的所有读者,一旦阅览室无人,写者能最快进入阅览室;在写者未出阅读室之前,又有新的读者与写者到达,仍然是写者排在前面)设计结束需提交下列资料:1、课程设计报告。

报告中至少应包括:相关操作系统的知识介绍,程序总的功能说明、程序各模块的功能说明、程序设计的流程图、源程序清单。

2、源程序和编译连接后的可执行程序文件。

时间安排:分析设计贮备阶段(1天)编程调试阶段(7天)写课程设计报告、考核(2天)感谢您的阅读,祝您生活愉快。

操作系统课程设计 (4)

操作系统课程设计 (4)

设计1 题目进程同步(读者-写者问题)一、问题描述与分析一个数据文件或记录,可被多个进程共享,我们把只要求读该文件的进程称为“Reader”进程,其他进程则称为“Writer进程”允许多个进程同时读一个共享对象,因为读操作不会使数据文件混乱。

但不允许一个Writer进程和其他Reader进程或Writer进程同时访问将会引起混乱。

所谓读者写者问题,是指保证一个writer进程必须与其他进程互斥地访问共享对象的同步问题。

读者写者问题可以这样的描述,有一群写者和一群读者,写者在写同一本书,读者也在读这本书,多个读者可以同时读这本书,但是,只能有一个写者在写书,并且,读者必写者优先,也就是说,读者和写者同时提出请求时,读者优先。

当读者提出请求时需要有一个互斥操作,另外,需要有一个信号量S 来当前是否可操作。

二、设计要求和目的1.设计要求通过解决读者写者问题实现进程同步。

即(1)实现写-写互斥,(2)读-写互斥(3)读-读允许(4)写者优先2. 设计目的(l).用信号量来实现读者写者问题,掌握进程同步机制及其实现机理。

(2).理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。

三、背景知识1.参考操作系统课本中关于进程同步这方面的知识以及结合老师上课的讲解,仔细研究利用信号量实现读写者问题。

读者写者问题的定义如下:有一个许多进程共享的数据区,这个数据区可以是一个文件或者主存的一块空间;有一些只读取这个数据区的进程(Reader)和一些只往数据区写数据的进程(Writer),此外还需要满足以下条件:(1)任意多个读进程可以同时读这个文件;(2)一次只有一个写进程可以往文件中写;(3)如果一个写进程正在进行操作,禁止任何读进程度文件。

我们需要分两种情况实现该问题:读优先:要求指一个读者试图进行读操作时,如果这时正有其他读者在进行操作,他可直接开始读操作,而不需要等待。

写优先:一个读者试图进行读操作时,如果有其他写者在等待进行写操作或正在进行写操作,他要等待该写者完成写操作后才开始读操作。

操作系统课程之“读者—写者”问题教学探讨

操作系统课程之“读者—写者”问题教学探讨

操作系统课程之“读者—写者”问题教学探讨操作系统课程之“读者—写者”问题教学探讨摘要:针对操作系统教学中概念多而繁杂、容易混淆,初学者存在畏难情绪等问题,文章提出采取类比、逐层解剖、层层深入、循序渐进的教学方法,并以操作系统中的进程同步互斥问题中“读者-写者”问题为例,对其概念、算法进行形象启发、分层解剖的阐述,并结合多种教学方法,说明使学生能更深刻地理解进程同步互斥问题的方法。

教学实践表明其效果良好。

关键词:操作系统;分层解剖;读者-写者问题;PV原语;教学实践操作系统是计算机专业的一门核心课程(图1),其在计算机系统中的特殊地位,使得该课程的学习在整个计算机学科教育中显得尤为重要。

作为一门理论性和实践性并重的课程,它具有概念多、算法较抽象的特点,同时又涉及了程序设计语言、软件工程思想、算法设计、计算机系统结构、网络等相关知识。

枯燥的理论讲述往往使学生感到抽象、难懂,进而产生厌学的思想。

尽管近年来一些高校在加强理论教学的同时,引入对操作系统内核的分析,如Linux操作系统,在教学实践方面取得了一点的成效,但是对于初学者和教师而言,在一个学期内课时数不变的情况下,完成教与学的工作显得有点心有余而力不足。

为了在有限的教学时间内,提高教学效率,既让学生深入理解理论知识,又能借助PV操作原语来验证操作系统的算法思想,笔者根据以往教学经验,结合初学者学习的实际情况,以进程同步中“读者-写者”为例,探讨如何由浅入深、循序渐进地开展教学工作。

1 问题描述“读者—写者”问题是现代操作系统中经典的进程同步互斥问题,在以C/S模式为代表的多进(线)程通信系统都可以作为该模型的不同表现形式,有着广泛的应用[1]。

该问题描述如下:一个数据文件或记录可被多个进程所共享,我们将其中只要求读该文件的进程称为读者,即“Reader进程”,其他进程称为写者,即“Writer进程”。

多个Reader 进程和多个Writer进程在某个时间段内对该文件资源进行异步操作,也就是说允许多个进程同时读一个共享对象,但绝不允许一个Writer进程和其他Reader进程或Writer进程同时访问共享对象,因此,所谓“读者—写者问题”就是指必须保证一个Writer进程和其他进程(Writer进程和Reader进程)互斥地访问共享对象的同步问题[2]。

操作系统课程设计--读者-写者问题

操作系统课程设计--读者-写者问题

操作系统课程设计报告一、操作系统课程设计任务书读者-写者问题实现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()释放指定临界区对象的所有权文件系统的设计通过对文件系统的设计,加深理解文件系统的内部功能及内部实现。

读者-写者问题解答

读者-写者问题解答

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

读者-写者问题解答

读者-写者问题解答

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 设计目的通过实验模拟读者和写者之间的关系,了解并掌握他们之间的关系及其原理。

操作系统原理课程设计读者-写者问题的实现

操作系统原理课程设计读者-写者问题的实现

*******************实践教学*******************计算机与通信学院2012年秋季学期操作系统原理课程设计题目:读者-写者问题的实现专业班级:姓名:学号:指导教师:成绩:目录摘要 (2)1.设计思想 (3)2.各模块的伪码算法 (4)3. 函数关系调用图 (6)4.程序测试结果 (7)设计总结 (10)参考文献 (11)致谢 (12)摘要本设计的读者写者问题,是指一些进程共享一个数据区。

数据区可以使一个文件、一块内存空间或者一组寄存器。

Reader进程只能读数据区中的数据,而writer进程必须与其他进程互斥地访问共享对象的同步问题。

读者写者问题可以这样的描述, 有一群写者和一群读者, 写者在写同一本书, 读者也在读这本书, 多个读者可以同时读这本书。

但是,只能有一个写者在写书, 并且,读者必写者优先,也就是说,读者和写者同时提出请求时,读者优先。

当读者提出请求时需要有一个互斥操作, 另外, 需要有一个信号量S来确定当前是否可操作。

本设计方案就是通过利用记录型信号量对读者写者问题的解决过程进行模拟演示,形象地阐述记录型信号量机制的工作原理。

关键词:共享对象,互斥,同步,信号量1.设计思想本设计借助C语言实现进程同步和互斥的经典问题--读者写者问题,用高级语言编写和调试一个进程同步程序,以加深对进程同步机制的理解。

通过用C 语言模拟进程同步实现,加深理解有关进程同步和互斥机制的概念及P、V操作的应用。

学生通过该题目的设计过程,掌握读者、写者问题的原理、软件开发方法并提高解决实际问题的能力。

在 Windows环境下,创建一个包含n个线程的控制台进程。

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

程来表示 n 个读者或写者。

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

将所有的读者和所有的写者分别放进两个等待队列中,当读允许时就让读者队列释放一个或多个读者,当写允许时,释放第一个写者操作。

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

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

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

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

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

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

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

HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, // SDDWORD dwStackSize, // initial stack sizeLPTHREAD_START_ROUTINE lpStartAddress, // threadfunctionLPVOID lpParameter, // thread argumentDWORD dwCreationFlags, // creation optionLPDWORD lpThreadId // thread identifier);2 ExitThread 用于结束当前线程。

VOID ExitThread(DWORD dwExitCode // exit code for this thread);3Sleep 可在指定的时间内挂起当前线程。

VOID Sleep(DWORD dwMilliseconds // sleep time);4信号量控制:WaitForSingleObject可在指定的时间内等待指定对象为可用状态;DWORD WaitForSingleObject(HANDLE hHandle, // handle to objectDWORD dwMilliseconds // time-out interval);hHandle为等待的对象,也就是实现同步或者互斥的对象。

读者写者问题课程设计

读者写者问题课程设计

读者写者问题课程设计一、课程目标知识目标:1. 理解“读者写者问题”的概念及其在计算机科学中的应用;2. 掌握解决“读者写者问题”的同步机制,如互斥锁、读写锁等;3. 了解“读者写者问题”在并发编程中的重要性。

技能目标:1. 能够运用所学知识编写简单的并发程序,解决“读者写者问题”;2. 能够通过实际案例分析,分析并优化程序性能;3. 学会使用调试工具检测并发程序中的潜在问题。

情感态度价值观目标:1. 培养学生对计算机科学的兴趣和热情,激发学生主动探索并发编程领域的欲望;2. 培养学生团队协作意识,学会在团队中共同解决问题;3. 培养学生严谨的学术态度,养成良好的编程习惯。

本课程针对高年级计算机科学专业学生设计,旨在帮助学生深入理解并发编程中的“读者写者问题”,掌握解决该问题的方法,并培养学生实际编程能力。

课程将结合实际案例,让学生在实践中掌握知识,提高技能,同时注重培养学生团队协作意识和严谨的学术态度。

通过本课程的学习,学生将能够独立解决并发编程中的实际问题,为未来从事计算机软件开发奠定基础。

二、教学内容1. 并发编程基本概念:复习进程、线程的基本概念,理解并发与并行的区别。

2. 读者写者问题引入:介绍读者写者问题的背景、定义及其在实际应用中的重要性。

3. 同步机制:- 互斥锁:讲解互斥锁的概念、用途及实现方式;- 读写锁:介绍读写锁的原理,比较其与互斥锁的优缺点。

4. 读者写者问题解决方案:- 经典算法:讲解Peterson解法、Rachlin解法等;- 现代并发库:介绍Java并发库、C++11标准库等在解决读者写者问题中的应用。

5. 实践环节:- 编写并发程序:指导学生编写简单的读者写者问题解决方案,并运用互斥锁、读写锁等同步机制;- 性能分析与优化:通过实际案例分析,讨论并发程序性能问题及优化方法。

6. 调试与测试:- 介绍调试工具:如GDB、Visual Studio等;- 演示测试方法:包括单元测试、集成测试等。

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

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

《计算机操作系统》实验报告题目读者写者问题学院(部)信息学院专业计算机科学与技术班级学生姓名学号指导教师(签字)一、问题描述一个数据文件或者记录,可以被多个进程共享,我们把只要求读该文件的进程称为“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<Windows.h>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<Windows.h>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、需求分析课程设计题目课程设计题目:读者写者问题课程任务及要求编写程序实现读者写者算法(读_写互斥,读_读允许,写写互斥)给出解决方案(包括说明设计实现(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.。

基于C++的读者与写者问题read—writeproblem的实现(一)

基于C++的读者与写者问题read—writeproblem的实现(一)

基于C++的读者与写者问题read—writeproblem的实现(一)基于C++的读者与写者问题的实现 11.设计题目与要求 12.总的设计思想及系统平台、语言、工具等 12.1设计思想 12.2系统平台,语言,工具 43.数据结构与模块说明(功能与流程图) 43.1功能实现 43.2流程图 64.源程序 74.1.ReaderAndWriter.CPP //具体的实现 74.2.thread.dat//辅助的文件,但是必不可以少 155.运行结果与运行情况 156.调试记录 177.自我评析和总结 18基于C++的读者与写者问题read—writeproblem的实现1.设计题目与要求读者写者问题(read—writeproblem)是一个经典的并发程序设计问题。

有两组并发进程:读者和写者,共享一个问题F,要求:(1)允许多个读者可同时对之执行读*作;(2)只允许一个写者往文件中写信息;(3)任一写者在完成写*作之前不允许其他读者或者写者工作;(4)写者执行写*作前,应让已有的写者和读者全部退出。

2.总的设计思想及系统平台、语言、工具等2.1设计思想根据题目要求,首先分析了以下4种可能发生的情况:第1种情况:读者的优先权比写者高,而且,不用调配。

所有读者的优先权都比写者的优先权高,而且,不用调配。

一个读者需要等待的唯一情况是,一个写者已经占用了文件。

一个写者可以取得文件的条件是,没有一个读者处在等待状态或正在读文件。

允许读者们结盟,以便能长期占用文件,而禁止写者的写。

第2种情况:在一个读者已经占有了文件的时候,全体读者的优先权才比写者高。

在没有任何一个读者在读文件时,读者的优先权和写者的优先权相同。

相反,如果有一个读者正在读文件,则其余的各读者都可以读文件,而不管有多少写者处在等待状态。

所有读者都有权结盟,以便垄断文件。

第3种情况:写者的优先权比读者的优先权高。

在一个写者提出要访问文件时,就必须使其尽可能的得到文件,而且不用调配。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

学号:课程设计课程名称操作系统学院计算机科学与技术学院专业软件工程班级姓名指导教师2014——2015学年第1学期1《操作系统原理》课程设计指导书课程编号:课程名称:操作系统/Operating System周数/学分:1周/1学分先修课程:高级语言程序设计、汇编语言、数据结构、计算机组成原理适用专业:计算机科学与技术、软件工程开课学院、系或教研室:计算机科学与技术学院一、课程设计的目的通过对操作系统内核实现代码的阅读、修改、设计,理解和掌握复杂的操作系统的工作原理。

二、课程设计的内容和要求1.系统调用学习在Linux中产生一个系统调用以及怎样通过往Linux内核中增加一个新函数从而在该内核空间中实现对用户空间的读写。

这个函数的功能是返回当前的系统时间。

实验条件要求:每人一台Linux主机且有超级用户权限。

2.内核定时器通过研究内核的时间管理算法学习内核源代码。

然后应用这些知识并且使用“信号”建立一种用户空间机制来测量一个多线程程序的执行时间。

实验条件要求:每人一台Linux主机且有超级用户权限。

3.实现生产者消费者(Bounded – Buffer Problem)问题通过研究Linux的线程机制和信号量实现生产者消费者(Bounded Buffer)问题的并发控制。

实验条件要求:每人一台与Linux主机联网的Windows主机,普通用户权限。

4.实现读者写者(Reader-Writer Problem)问题通过研究Linux的线程机制和信号量实现读者写者(Reader-Writer)问题并发控制。

实验条件要求:每人一台与Linux主机联网的Windows主机,普通用户权限。

三、课程设计进度安排四、课程设计说明书与图纸要求应包含如下内容:1.设计题目与要求2.总的设计思想及系统平台、语言、工具等。

3.数据结构与模块说明(功能与流程图)4.源程序5.运行结果与运行情况6.调试记录7.自我评析和总结五、课程设计评分标准注:优(90-100分)、良(80-89分)、中(70-79分)、及格(60-69分)、60分以下为不及格。

六、课程设计参考资料推荐教材:《Operating System Concepts(Sixth Edition)(操作系统概念)影印版》,主编:AbrahamSilberschatz出版社:高等教育出版社出版或修订时间:2003年10月参考书:《计算机操作系统教程(第三版)》主编:张尧学出版社:清华大学出版社出版或修订时间:2001年7月《操作系统原理(第三版)》,主编:庞丽萍出版社:华中科技大学出版社出版或修订时间:2000年12月执笔:杨铭熙审阅:陈天煌审定:徐东平课程设计任务书学生姓名:专业班级:软件工程指导教师:刘军工作单位:计算机科学与技术学院题目: 实现读者写者(Reader-Writer Problem)问题实验条件要求:通过研究Linux的线程机制和信号量实现读者写者(Reader-Writer)问题并发控制。

每人一台与Linux主机联网的Windows主机,普通用户权限。

课程设计进度安排2014年 12月 26日目录1 设计目的与要求 (1)1.1 课程设计目的 (1)1.2 课程设计要求 (1)2 总的设计思想及系统平台、语言、工具等 (1)2.1 设计思想 (1)2.2 系统平台及使用语言 (2)2.3 开发工具的选择 (2)3 数据结构和模块说明 (2)3.1 主函数 (2)3.2 写者线程函数 (3)3.3 读者线程函数 (3)4 源程序 (5)5 运行结果与运行情况 (13)6 调试记录 (30)7 自我评析和总结 (31)8 参考文献 (32)2设计目的与要求2.1课程设计目的通过研究Linux的线程机制和信号量实现读者写者(Reader-Writer)问题并发控制。

2.2课程设计要求1.每个读者/写者对该存储区进行操作后,即时显示该存储区的全部内容、当前指针位置和读者/写者线程的标识符;2.读者应有3个以上,写者应有有两个以上;3.多个读者/写者之间须共享对存储区进行操作的函数代码。

3总的设计思想及系统平台、语言、工具等3.1设计思想为实现reader与writer线程间在读或写时的互斥设置一个互斥信号量writer_mutex。

另外,再设置一个整形变量reader_counter表示正在读的线程数目。

由于只有一个reader线程在读,便不允许writer线程去写。

因此,仅当reader_counter=0,表示尚无reader线程在读时,reader线程才需要执行wait(writer_mutex)操作。

若wait(writer_mutex)操作成功,reader线程便可以去读,相应的,做reader_counter+1操作。

同理,仅当reader线程在执行reader_counter 减1操作后其值为0时,才必须执行signal(writer_mutex)操作,以便让writer线程写。

reader_counter是一个可被多个reader线程访问的临界资源,因此,也应该为它设置一个互斥信号量reader_mutex。

3.2系统平台及使用语言本课程设计在Linux操作系统下,使用C语言完成。

用到的工具主要有GCC 编译器和VI编辑器。

3.3开发工具的选择内存:1G工具:g++,vim,geany4数据结构和模块说明4.1主函数图3-1 主函数流程图4.2写者线程函数图3-2写者线程函数流程图4.3读者线程函数图3-3 读者线程函数流程图5源程序/*reader-writer Problemauther : zhengfei rj0315Modole:Shared datasemaphore mutex, wrt;Initiallymutex = 1, wrt = 1, readcount = 0writer process:begindo {wait(wrt);writing;signal(wrt);}while(1);endReader process:begindo {wait(mutex);readcount++;if (readcount == 1)wait(rt);signal(mutex);reading;wait(mutex);readcount--;if (readcount == 0)signal(wrt);signal(mutex);}while(1);end***/#include <iomanip>#include <unistd.h>#include <stdio.h>#include <pthread.h>#include <math.h>#include <time.h>#include <stdlib.h>#include <iostream>#include <fstream>#include <string>#include <semaphore.h>#define readerNum 5#define writerNum 7#define BUFFERSIZE 20using namespace std;int writeRoom[writerNum];//to store which buffer every writer are writing int readRoom[readerNum];//to store which buffer every reader are reading int buffer[BUFFERSIZE];//the bufferstring bufferOwn[BUFFERSIZE];//who use the buffer int readcount=0;int readp=0;int writerp=0;int content_id=0;//the content id of the buffersem_t mutex;sem_t wrt;time_t now;ofstream fout("out.txt");string int2str(int n){char temp[8];sprintf(temp,"%d",n);return (string)temp;}void showbuffer(){int width=4;for(int i=0;i<BUFFERSIZE;i++){bufferOwn[i]="";fout<<setw(width)<<buffer[i];cout<<setw(width)<<buffer[i];}fout<<endl;cout<<endl;for(int i=0;i<readerNum;i++){if(readRoom[i]!=-1)bufferOwn[readRoom[i]]+="r"+int2str(i);}for(int i=0;i<writerNum;i++){if(writeRoom[i]!=-1)bufferOwn[writeRoom[i]]+="w"+int2str(i);}for(int i=0;i<BUFFERSIZE;i++){fout<<setw(width)<<bufferOwn[i];cout<<setw(width)<<bufferOwn[i];}fout<<endl;cout<<endl;}string gettime(){time(&now);string t=ctime(&now);return t;}void writing(int n){writeRoom[n]=rand()%BUFFERSIZE;//set the write place randomlywriterp=writeRoom[n];//the current write placebuffer[writerp]=content_id++;//the writing content ,the content is recognise by a series of id which will increase as 1,2,3,4...fout<<"\nwriter "<<n<<" start to write buffer"<<writerp<<" on "<<gettime();cout<<"\nwriter "<<n<<" start to write buffer"<<writerp<<" on "<<gettime();showbuffer();sleep(rand()%2+1);fout<<"\nwriter "<<n<<" finish writing buffer"<<writerp<<" on "<<gettime();cout<<"\nwriter "<<n<<" finish writing buffer"<<writerp<<" on "<<gettime();writeRoom[n]=-1;showbuffer();}void reading(int n){sem_wait (&mutex);readRoom[n]=rand()%BUFFERSIZE;fout<<"\nreader "<<n<<" start to read buffer"<<readRoom[n]<<" on "<<gettime();cout<<"\nreader "<<n<<" start to read buffer"<<readRoom[n]<<" on "<<gettime();showbuffer();sem_post(&mutex);sleep(rand()%2+1);sem_wait (&mutex);fout<<"\nreader "<<n<<" finish reading buffer"<<readRoom[n]<<" on "<<gettime();cout<<"\nreader "<<n<<" finish reading buffer"<<readRoom[n]<<" on "<<gettime();fout<<"\nthere is "<<readcount-1<<" readers are still reading"<<endl;cout<<"\nthere is "<<readcount-1<<" readers are still reading"<<endl;readRoom[n]=-1;showbuffer();sem_post(&mutex);}void *writer_thread(void * wid){while(1){/*wait(wrt);*/sem_wait(&wrt);/*writing;*/writing((int)wid);/*signal(wrt);*/sem_post(&wrt);/*sleep a while and then write again*/sleep(rand()%5+1);}}void *reader_thread(void *rid){while(1){/*wait(mutex);*/sem_wait(&mutex);readcount++;if (readcount == 1)/*wait(wrt);*/sem_wait(&wrt);/* signal(mutex);*/sem_post(&mutex);/*add emptybottle to buffer;*/reading((int)rid);/*wait(mutex);*/sem_wait(&mutex);readcount--;if (readcount == 0)/*signal(wrt);*/sem_post(&wrt);/*signal(mutex); */sem_post(&mutex);/*sleep a while and then read again*/sleep(rand()%5+1);}}int main(int argc,char *argv[]){/* init */pthread_t reader[readerNum],writer[writerNum] ;sem_init(&wrt,0,1);sem_init(&mutex,0,1);for(int i=0;i<BUFFERSIZE;i++){buffer[i]=-1;bufferOwn[i]="";}for(int i=0;i<readerNum;i++){readRoom[i]=-1;}for(int i=0;i<writerNum;i++){writeRoom[i]=-1;}/*create threads*/for(int i=0;i<readerNum;i++){pthread_create(&reader[i], NULL, reader_thread, (void *)i);}for(int i=0;i<writerNum;i++){pthread_create(&writer[i], NULL, writer_thread, (void *)i);}sleep(40);fout.close();exit(0);return 0;}6运行结果与运行情况在本程序的实现过程中,使用了vim编辑器。

相关文档
最新文档