实验3__读者-写者问题与进程同步
实验三 进程同步
集美大学诚毅学院信息工程系实验报告课程名称计算机操作系统序号名称实验三进程同步姓名孙幸杰学号2011957032专业计算1191 日期13.11.22成绩教师洪联系评语：1.实验目的:掌握用Linux信号灯集机制实现两个进程间的同步问题2．实验环境Win7系统虚拟机下运行的Linux系统。
3.实验内容司机与售票员问题是两个进程的同步问题,司机要启动汽车前,要检查售票员车门是否已经关好;售票员要打开车门之前要等司机把车停稳.要求：需要的信号灯: System V信号灯实现用于控制司机是否可以启动车辆的的信号灯 S1=0用于控制售票员是否可以开门的信号灯 S2=04．实验程序（有详细注释）//---------------------------------------------------//这是一个公共汽车的驾驶员与售票员之间的同步问题//一个进程模拟驾驶员，一个进程模拟售票员;//驾驶员的动作:启动车辆--驾驶车辆--到站停车//售票员的动作:关门--售票--开门;//售票员把车门关好后，驾驶员才能启动汽车;//当驾驶员在一个站把车子停稳后，售票员方能打开车门;////本程序采用System V的信号灯集实现两者的同步// 2010.10.8//-----------------------------------------------------#include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>#include <stdio.h>#include <time.h>#include <stdlib.h>union semun{int val;//仅用于SETVAL命令struct semid_ds *buf;//用于IPC_SET等命令ushort *array;//用于SETALL等命令};//用于信号灯初始化//semid--信号灯的ID//val--欲设置的信号灯初值//sn--信号灯集的分量void seminit(int semid,int val,int sn) {union semun arg;arg.val=val;semctl(semid,sn,SETVAL,arg);};//实现信号灯的P操作//semid--信号灯的ID//sn--信号灯集的分量void semdown(int semid,int sn){/* define P operating*/struct sembuf op;op.sem_num=sn;op.sem_op=-1;//P操作为-1op.sem_flg=0;semop(semid,&op,1);}//实现信号灯的V操作//semid--信号灯的ID// sn--信号灯集的分量void semup(int semid, int sn){/*define V operating*/struct sembuf op;op.sem_num=sn;op.sem_op=1;//V操作为1op.sem_flg=0;semop(semid,&op,1);}main(){int i,j;key_t semkey;char *pathname="./driver.c";int semid;int rrand;srand((int)time(0));//用于产生随机延时 semkey=ftok(pathname,45);if(semkey==-1){printf("Error:create a key error!\n");exit(-1);}semid=semget(semkey,2,IPC_CREAT | 0666);if(semid==-1){printf("Error:create semaphore error!\n");exit(-1);}seminit(semid,0,0);//对信号灯集的0号分量进行初始化seminit(semid,0,1);//对信号灯集的1号分量进行初始化if(fork()==0) //Create a process{//子进程作为驾驶员进程for(i=1;i<10;i++){semdown(semid,0);//等待售票员关门printf("Driver(pid:%d): Start the bus.\n",getpid());printf("Driver(pid:%d): Traveling....\n",getpid());rrand=1+(int)(6.0*rand()/(RAND_MAX+1.0));//产生一个(1-6)的随机数表示车辆的行驶时间sleep(rrand);printf("Driver(pid:%d): Arrive at a station. stop!\n",getpid()); semup(semid,1);//唤醒售票员}}else{//父进程作为售票员进程for(j=1;j<10;j++){printf("Conductor(pid:%d):Close all doors.\n",getpid());semup(semid,0);//唤醒司机printf("Conductor(pid:%d):Ticketing...\n",getpid());semdown(semid,1); //等待汽车到站printf("Conductor(pid:%d):Open all doors.\n",getpid());sleep(1);}}}5．实验结果及其分析输入程序：程序：编译：运行结果：6．实验小结完成本实验后，我对基本的额进程间的通信有了初步的了解。
操作系统实验-读者写者问题
《计算机操作系统》实验报告题目读者写者问题学院（部）信息学院专业计算机科学与技术班级、学生姓名学号指导教师（签字）一、《二、问题描述一个数据文件或者记录，可以被多个进程共享，我们把只要求读该文件的进程称为“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、执行结果读者优先在读者优先中先两个读者申请，再一个写者申请，再有两个读者申请。
读者-写者问题解答计算机操作系统实验报告指导资料
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)读者优先的设计思想是读进程只要看到有其它读进程正在读，就可以继续进行读；写进程必须等待所有读进程都不读时才能写，即使写进程可能比一些读进程更早提出申请。
操作系统实验3进程同步报告
实验三进程同步一、实验目的：1.了解进程和线程的同步方法，学会运用进程和线程同步方法来解决实际问题；2.了解windows系统下Win32 API或Pthread信号量机制的使用方法；二、实验预备内容：1.对书上所说基于信号量的有限缓冲的生产者－消费者问题；2.对于信号量的概念有大概的了解，知道如何用信号量的wiat()和signal()函数如何取消应用程序进入临界区的忙等；三、实验环境说明：此实验在Win7(32位) CodeBlocks环境下实现，采用WinAPI的信号量机制。
四、实验内容：设计一个程序解决有限缓冲问题，其中的生产者与消费者进程如下图所示。
在Bounded-Buffer Problem（6.6.1节）中使用了三个信号量：empty （记录有多少空位）、full（记录有多少满位）以及mutex（二进制信号量或互斥信号量，以保护对缓冲区插入与删除的操作）。
对于本项目，empty和full将采用标准计数信号量，而mutex将采用二进制信号量。
生产者与消费者作为独立线程，在empty、full、mutex的同步前提下，对缓冲区进行插入与删除。
本项目可采用Pthread或Win32 API。
（本实验采用Win32 API）五、程序设计说明：1.全局变量：定义缓冲区数组及其环形队列表达方式，定义mutex、empty、full 三个信号量。
empty记录缓冲区有多少个空位；full记录缓冲区有多少个满位；mutex作为互斥信号量，保护对缓冲区插入或删除的操作。
具体定义如下：定义生产者、消费者线程结构和包含的信息：（由于题目中没有要求，因此只定义了编号一个变量）2.缓冲区：缓冲区是一个元数据类型为buffer_item（可通过typedef定义）的固定大小的数组，按环形队列处理。
buffer_item的定义及缓冲区大小可保存在头文件中：A.insert_item()：先判断缓冲区是否已满，不满则向缓冲区中插入元素；B.remove_item()先判断缓冲区是否为空，不空则从缓冲区中删除元素；3.生产者线程：生产者线程交替执行如下两个阶段：睡眠一段随机事件，向缓冲中插入一个随机数。
操作系统课程之“读者—写者”问题教学探讨
操作系统课程之“读者—写者”问题教学探讨操作系统课程之“读者—写者”问题教学探讨摘要：针对操作系统教学中概念多而繁杂、容易混淆，初学者存在畏难情绪等问题，文章提出采取类比、逐层解剖、层层深入、循序渐进的教学方法，并以操作系统中的进程同步互斥问题中“读者－写者”问题为例，对其概念、算法进行形象启发、分层解剖的阐述，并结合多种教学方法，说明使学生能更深刻地理解进程同步互斥问题的方法。
教学实践表明其效果良好。
关键词：操作系统；分层解剖；读者－写者问题；PV原语；教学实践操作系统是计算机专业的一门核心课程(图1)，其在计算机系统中的特殊地位，使得该课程的学习在整个计算机学科教育中显得尤为重要。
作为一门理论性和实践性并重的课程，它具有概念多、算法较抽象的特点，同时又涉及了程序设计语言、软件工程思想、算法设计、计算机系统结构、网络等相关知识。
枯燥的理论讲述往往使学生感到抽象、难懂，进而产生厌学的思想。
尽管近年来一些高校在加强理论教学的同时，引入对操作系统内核的分析，如Linux操作系统，在教学实践方面取得了一点的成效，但是对于初学者和教师而言，在一个学期内课时数不变的情况下，完成教与学的工作显得有点心有余而力不足。
为了在有限的教学时间内，提高教学效率，既让学生深入理解理论知识，又能借助PV操作原语来验证操作系统的算法思想，笔者根据以往教学经验，结合初学者学习的实际情况，以进程同步中“读者－写者”为例，探讨如何由浅入深、循序渐进地开展教学工作。
1 问题描述“读者—写者”问题是现代操作系统中经典的进程同步互斥问题，在以C/S模式为代表的多进(线)程通信系统都可以作为该模型的不同表现形式，有着广泛的应用[1]。
该问题描述如下：一个数据文件或记录可被多个进程所共享，我们将其中只要求读该文件的进程称为读者，即“Reader进程”，其他进程称为写者，即“Writer进程”。
多个Reader 进程和多个Writer进程在某个时间段内对该文件资源进行异步操作，也就是说允许多个进程同时读一个共享对象，但绝不允许一个Writer进程和其他Reader进程或Writer进程同时访问共享对象，因此，所谓“读者—写者问题”就是指必须保证一个Writer进程和其他进程(Writer进程和Reader进程)互斥地访问共享对象的同步问题[2]。
操作系统线程同步机制实验报告
操作系统线程同步机制实验报告一、实验目的本实验旨在通过对操作系统线程同步机制的实验，深入了解操作系统中线程的运行和同步原理，掌握线程同步机制的使用方法以及安全性问题。
二、实验背景在操作系统中，线程是实现多任务并发执行的基本单位。
为了确保线程的安全性，避免出现竞态条件等问题，需要采取合适的线程同步机制。
三、实验内容1.实现基本的线程同步操作通过使用互斥锁和条件变量，实现以下线程同步问题：（1）生产者/消费者问题：生产者线程生产一定数量的产品，消费者线程从缓冲区中取出产品并消费。
（2）读者/写者问题：多个读者线程可以同时读取共享资源，但是写者线程获取写权限后，其他线程无法读取或写入。
2.实验操作步骤（1）设计和实现多线程程序，包括生产者线程、消费者线程、读者线程和写者线程。
（2）使用互斥锁和条件变量对共享资源进行同步操作，保证线程的安全性。
（3）编译并运行程序，观察线程的执行顺序和结果是否符合预期。
四、实验结果与分析1.生产者/消费者问题通过设计合适的缓冲区和互斥锁，保证生产者线程和消费者线程的安全访问。
实验结果表明，生产者线程可以正确地生产产品，并将产品存储到缓冲区中。
消费者线程可以从缓冲区中取出产品并消费。
2.读者/写者问题通过使用互斥锁和条件变量，实现多个读者线程可以同时读取共享资源，但是写者线程获取写权限后，其他线程无法读取或写入。
实验结果表明，读者线程可以同时读取共享资源，而写者线程获取写权限后，其他线程无法读取或写入。
五、实验总结本实验通过对操作系统线程同步机制的实验，深入了解了操作系统中线程的运行和同步原理，掌握了线程同步机制的使用方法以及安全性问题。
实验结果表明，在设计合适的缓冲区和使用适当的同步机制的情况下，可以有效地保证线程的安全性和正确的并发执行。
六、实验心得通过本次实验，我深刻理解了线程同步机制在操作系统中的重要性。
线程同步机制可以保证多个线程正确地访问共享资源，避免竞态条件等问题的出现。
读者写者问题实验报告
北京电子科技学院（BESTI）实验报告课程：操作系统班级：0921 姓名：学号：成绩：指导教师：徐小青实验日期：2011.11.22 实验密级：/ 预习程度：代码实验时间：12:50-15:20 仪器组次：A04 必修/选修：必修实验序号：(一)实验名称：用信号量来实现读者-写者问题实验目的与要求：理解进程(或线程)及信号量的概念实验仪器：一、实验目的：理解进程(或线程)及信号量的概念二、实验内容：1、定义一个数据缓存buffer及用于实现同步互斥的信号量。
2、定义一个读者函数：●当有写者在占用buffer时，读者应该等待，直到写者不再使用该buffer。
●当有其他读者在占用buffer时，读者可对buffer进行读取操作。
●当buffer中有数据时，则从其中读取一个数据，并显示然后退出。
●当buffer中没有数据时，应等待，直到buffer中有数据可读。
3、定义一个写者函数●当有读者在占用buffer时，写者应该等待，直到所有的读者都退出为止。
●当有其他写者占用buffer时，该写者应该等待，直到占用buffer的写者退出为止。
●当buffer有空闲时，写者应该在buffer中写入一个数据并退出。
●当buffer满时，写者应该等待，直到buffer有空闲为止。
4、定义主函数，在其中可以任意创建读者与写者。
可根据用户输入创建读者或写者进程(线程)。
三、实验当堂完成内容：1，将设计好的思路以代码形式呈现，并调通。
2，将数据改变，看结果是否符合预期设想3，与同学交流，将代码完善。
四、设计思想：读进程：read(){P(Sr); 申请区域P(Scot); 锁定读者计数器first = first+1;if(first ==1)P(Sdoc);V(Scnt); 解锁读者计数器开始读；P(Scnt); 锁定读者计数器V(Sdoc);V(Scnt);V(Sr);}写进程：write(){P(sdoc);开始写;V(sdoc);}主函数设计思想：五、代码及具体解释：#include <stdlib.h>#include <windows.h>#include <stdio.h>#define P(S) WaitForSingleObject(S, INFINITE)// 这是Windows 下多线程工作的P 操作#define V(S) ReleaseSemaphore(S, 1, NULL)// 这是Windows 下多线程工作的V 操作const int RN = 5 ; // 所有读者总数（可以改变）const int WN = 3; // 所有写者总数（可以改变）HANDLE Sdoc; // 文档信号量——互斥量(临界区的信号量题目要求是1）HANDLE Sr; // 读者信号量——广义信号量（一次最多有多少个读者在读）HANDLE Scnt; // 保护g_cntReader 的互斥量（目前有多少读者正在读）int g_cntReader = 0; // 读者个数计数器// funcname : JustWait ( )// note: 显示一些信息，让后等待// ret val : void//// + Parameter :// [ int ] - nReader 读者（写者）编号，读者>0，写者<0// [ int ] - min 操作等待的最短时间// [ int ] - max 操作等待得最长时间，实际等待的时间介于两者之间// [ LPCSTR ] - info 要显示的信息void JustWait(int nReader, int min, int max, LPCSTR info);DWORD WINAPI Reader(LPVOID lpPara);DWORD WINAPI Writer(LPVOID lpPara);// 这是主函数void main(){Sdoc = CreateSemaphore(NULL, 1, 1, "Document");// 创建信号量初值，最大信号量值Sr = CreateSemaphore(NULL, 3, 3, "ReaderNumber"); // 一次最多允许3 个Scnt = CreateSemaphore(NULL, 1, 1, "ReaderCounterProtect");// 他也是一个互斥信号量，初值为 1HANDLE threads[RN+WN];for (int i=0; i<RN; i++) //不断创建读者线程threads[i] = CreateThread(0, 0, Reader, 0, 0, 0);for (int j=0; j<WN; j++)threads[j+RN] = CreateThread(0, 0, Writer, 0, 0, 0);WaitForMultipleObjects(RN+WN, threads, TRUE, INFINITE);}// 读者线程DWORD WINAPI Reader(LPVOID lpPara){// 注意是静态变量，可以使每来一个读者增加一static int reader_num = 1;int i = reader_num ++;int x=0;while (x<=5){JustWait(i, 1, 2, "我想读"); //1s的时候来，给2s的时间去读P(Sr); // 读者未满P(Scnt); // 锁定读者计数器printf("还有%d 个读者在读, 读者%d进入\n", g_cntReader, i);g_cntReader ++;if (g_cntReader == 1) // 如果是第一个读者{JustWait(i, 1, 2, "我是第一个!");P(Sdoc); // 锁定文档printf("读者%d说：有人在读，不可写文件\n", i);JustWait(i, 1, 2, "我可以读文件了！");V(Scnt); // 解锁读者计数器释放JustWait(i, 2, 5, "我在读");// 读ing…………JustWait(i, 1, 2, "我将要离开！");P(Scnt); // 锁定读者计数器g_cntReader --;if (g_cntReader == 0) // 如果是最后一个{JustWait(i, 1, 2, "我是最后一个!");printf("读者%d说：可以对文件操作了！~~~\n", i);V(Sdoc);// 解锁文档}printf("还有%d个读者在, 读者%d离开\n", g_cntReader, i);V(Scnt);// 解锁读者计数器V(Sr); // 离开JustWait(i, 5, 3, "结束");x++;printf("%d\n",x);}return 0;}DWORD WINAPI Writer(LPVOID lpPara){// 注意是静态变量，可以使每来一个写者减去一，注意初值是负值static int g_cnt = -1;int j = g_cnt --;while (1){JustWait(j, 2, 4, "我想写");// 锁定文档P(Sdoc);printf("\t写者%d说：文件正在修改不可操作\n", -j);JustWait(j, 4, 3, "写···"); // 写ing……JustWait(j, 1, 2, "写完了，离开");printf("写者%d说：可以对文件操作了\n", -j);V(Sdoc);// 解锁文档JustWait(j, 8, 4, "休息了");}return 0;}void JustWait(int nReader, int min, int max, LPCSTR info)//min为读者到来时间，max为读者离开时间{const int BASETIME = 1000;// 等待时间的基本量，以毫秒表示int wait_time = 0;// 实际等待得时间if (max==min) // 判断是为了避免%0错误，注意取随机值wait_time = min*BASETIME;//处理时间为0；elsechar s_out[128];// 最终显示的信息缓冲if (nReader > 0)// 读者大于0，写者小于0sprintf(s_out, "读者%d说: %s\n", nReader, info);elsesprintf(s_out, "\t写者%d说: %s\n", -nReader, info);printf(s_out);// 打印Sleep(wait_time);// 然后等待}//其设计思想是：读者在读，来了写着，创建写着线程，利用时间片区分他们。
“读写平等”策略的“读者--写者”问题实验报告
淮北师范大学程序设计课程设计采用“读写平等”策略的“读者--写者”问题学院计算机科学与技术专业计算机科学与技术(师范)学号 ***********学生姓名 ***指导教师姓名 ***2012年6月16 日一、设计目的与内容课程设计的目的：操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决问题的机会。
●进一步巩固和复习操作系统的基础知识。
●培养学生结构化程序、模块化程序设计的方法和能力。
●提高学生调试程序的技巧和软件设计的能力。
●提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。
设计内容：用高级语言编写和调试一个采用“读写平等”策略的“读者—写者”问题的模拟程序。
设计的要求：1.读者与写者至少包括ID、进入内存时间、读写时间三项内容，可在界面上进行输入。
2.读者与写者均有两个以上，可在程序运行期间进行动态增加读者与写者。
3.可读取样例数据（要求存放在外部文件中），进行读者/写者、进入内存时间、读写时间的初始化。
4.要求将运行过程用可视化界面动态显示，可随时暂停，查看阅览室中读者/写者数目、读者等待队列、读写时间、等待时间。
5.读写策略：读写互斥、写写互斥、读写平等（严格按照读者与写者到达的顺序进入阅览室，有写着到达，则阻塞后续到达的读者；有读者到达，则阻塞后续到达的写者）。
有一个被许多进程共享的数据区，这个数据区可以是一个文件，或者主存的一块空间，甚至可以是一组处理器寄存器。
有一些只读取这个数据区的进程（reader）和一些只往数据区中写数据的进程（writer）。
以下假设共享数据区是文件。
这些读者和写者对数据区的操作必须满足以下条件：读—读允许；读—写互斥；写—写互斥。
这些条件具体来说就是：（1）任意多的读进程可以同时读这个文件；（2）一次只允许一个写进程往文件中写；（3）如果一个写进程正在往文件中写，禁止任何读进程或写进程访问文件；（4）写进程执行写操作前，应让已有的写者或读者全部退出。
实验三 进程同步实验讲解
实验三进程同步机制一、实验内容:学习Windows有关进程/线程同步的背景知识和API，学习windows平台下常用的同步方式，并分析2个实验程序（利用信号量实现两个进程间的同步和利用互斥量实现读者写者问题），观察程序的运行情况并分析执行结果。
二、实验目的:在本实验中，通过对互斥量（Mutex）和信号量（Semaphore）对象的了解，来加深对Windows 进程、线程同步的理解。
(1) 了解互斥量和信号量对象。
(2) 通过分析实验程序，理解管理信号量对象的API。
(3) 理解在进程中如何使用信号量对象。
(4) 通过分析实验程序，理解在线程中如何使用互斥量对象。
(5) 理解父进程创建子进程的程序设计方法，理解在主线程中创建子线程的方法。
三、实验要求：(1) 理解Windows有关进程/线程同步的背景知识和API。
(2) 按要求运行2个程序，观察程序执行的结果，并给出要求的结果分析。
(3) 参照3-2程序，写出一个实现单个生产者—消费者问题的算法，可以使用单个缓冲区，也可以使用缓冲池，生产者随机产生任意形式的数据并放入缓冲区中，消费者则以随机的时间间隔从缓冲区中取数据，随机时间请使用随机数产生。
四、并发与同步的背景知识Windows开发人员可以使用同步对象来协调线程和进程的工作，以使其共享信息并执行任务。
此类对象包括互斥量Mutex、信号量Semaphore、事件Event等。
多进程、多线程编程中关键的一步是保护所有的共享资源，工具主要有互斥量Mutex 和信号量Semaphore等；另一个是协调线程使其完成应用程序的任务，为此，可利用内核中的信号量对象或事件对象。
互斥量是一个可命名且安全的内核对象，主要目的是引导对共享资源的访问。
拥有单一访问资源的线程创建互斥体，所有希望访问该资源的线程应该在实际执行操作之前获得互斥体，而在访问结束时立即释放互斥体，以允许下一个等待线程获得互斥体，然后接着进行下去。
经典同步问题读者-写者问题
经典同步问题读者-写者问题读者-写者问题在读者-写者问题中，只对共享数据进⾏读取的进程为读者进程，修改共享数据的进程称为写者进程。
多个读者可同时读取共享数据⽽不会导致出现错误，但是任何时刻多个写者进程不能同时修改数据，写者进程和读者进程也不能同时访问共享数据。
读者-写者问题的解决策略有不同的倾向。
读者优先需要⽤到的共享变量：semaphore rw_mutex = 1; // 读者与写者互斥访问共享数据的互斥信号量semaphore mutex = 1; // 多个读者进程互斥修改当前读者进程数量的信号量int read_count = 0; // 系统当前读者进程数量写者进程结构do {wait(rw_mutex);.../* 修改共享数据 */...signal(rw_mutex);}while(true);读者进程结构do {wait(mutex); // 获取修改读者进程数量的互斥信号量，该操作在请求rw_mutex之前，防⽌出现死锁read_count++;if(read_count == 1) // 判断当前是否为第⼀个读者进程wait(rw_mutex); // 如果是就需要请求访问共享数据的互斥信号量signal(mutex); // read_count修改后释放信号量.../* 读取数据 */...wait(mutex); // 获取修改读者进程数量的互斥信号量read_count--;if(read_count == 0) // 判断当前进程是否为最后⼀个读者进程signal(rw_mutex); // 如果是则释放共享数据的互斥信号量，以允许写者进程操作共享数据signal(mutex);}while(true);读者优先有可能导致写者进程产⽣饥饿现象，当系统中不断出现读者进程时，写者进程始终⽆法进⼊临界区。
写者优先需要⽤到的共享变量：semaphore rw_mutex = 1; // 读者与写者互斥访问共享数据的互斥信号量semaphore r_mutex = 1; // 互斥修改当前读取⽂件的进程数semaphore w_mutex = 1; // 互斥修改当前修改⽂件的进程数semaphore enter_mutex = 1; // 获取申请访问⽂件的权限int read_count = 0; // 系统当前读者进程数量int write_count = 0; // 系统当前写者进程数量写者进程结构do {wait(w_mutex); // 新的写者进程进⼊，获取修改写者进程数量的权限write_count++;if(write_count == 1) // 判断当前是否为第⼀个写者进程wait(enter_mutex); // 阻断后续到达的读者进程signal(w_mutex);wait(rw_mutex); // 获取访问⽂件的权限，⽂件可能被其它写者进程占⽤，或者等待最后⼀个读者进程释放.../* 修改数据 */...wait(rw_mutex);wait(w_mutex);write_count--;if(write_count == 0) // 当所有写者进程都放弃使⽤⽂件时，运⾏读者进程申请访问⽂件signal(enter_mutex);signal(mutex);}while(true);读者进程结构do {wait(enter_mutex); // 获取申请访问⽂件的权限wait(r_mutex);read_count++;if(read_count == 1) // 判断当前是否为第⼀个读者进程wait(rw_mutex); // 占⽤⽂件signal(r_mutex);signal(enter_mutex);.../* 读取数据 */...wait(r_mutex);read_count--;if(read_count == 0)signal(rw_mutex);signal(r_mutex);}while(true);写者优先有可能导致读者进程产⽣饥饿现象，当系统中不断出现写者进程时，读者进程始终⽆法进⼊临界区。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验3 读者/写者问题与进程同步3.1 实验目的理解临界区和进程互斥的概念，掌握用信号量和PV操作实现进程互斥的方法。
3.2 实验要求在windows或者linux环境下编写一个控制台应用程序，该程序运行时能创建N个线程，其中既有读者线程又有写者线程，它们按照事先设计好的测试数据进行读写操作。
请用信号量和PV操作实现读者/写者问题。
读者/写者问题的描述如下：有一个被许多进程共享的数据区，这个数据区可以是一个文件，或者主存的一块空间，甚至可以是一组处理器寄存器。
有一些只读取这个数据区的进程（reader）和一些只往数据区中写数据的进程（writer）。
以下假设共享数据区是文件。
这些读者和写者对数据区的操作必须满足以下条件：读—读允许；读—写互斥；写—写互斥。
这些条件具体来说就是：（1）任意多的读进程可以同时读这个文件；（2）一次只允许一个写进程往文件中写；（3）如果一个写进程正在往文件中写，禁止任何读进程或写进程访问文件；（4）写进程执行写操作前，应让已有的写者或读者全部退出。
这说明当有读者在读文件时不允许写者写文件。
对于读者-写者问题，有三种解决方法：1、读者优先除了上述四个规则外，还增加读者优先的规定，当有读者在读文件时，对随后到达的读者和写者，要首先满足读者，阻塞写者。
这说明只要有一个读者活跃，那么随后而来的读者都将被允许访问文件，从而导致写者长时间等待，甚至有可能出现写者被饿死的情况。
2、写者优先除了上述四个规则外，还增加写者优先的规定，即当有读者和写者同时等待时，首先满足写者。
当一个写者声明想写文件时，不允许新的读者再访问文件。
3、无优先除了上述四个规则外，不再规定读写的优先权，谁先等待谁就先使用文件。
3.3实验步骤3.3.1 算法分析有同学认为，可以将文件视为临界资源，使用临界资源的代码就构成临界区，为了对临界区进行管理，只需设置一个互斥信号量r_w_w，读或者写之前执行P(r_w_w)，之后执行V(r_w_w)即可，从而得到图3-1所示的算法描述。
该方法虽然能满足读—写互斥和写—写互斥，但是不满足读—读允许，只要有一个读者在读文件，其他的读者都被阻塞了。
可见，单纯使用互斥信号量不能解决读者/写者问题，还需要引入计数器对读者进行记数。
2、读者优先如何纠正上述解法中存在的错误呢？其实，对于相继到达的一批读者，并不是每个读者都需要执行P(r_w_w)和V(r_w_w)。
在这批读者中，只有最先到达的读者才需要执行P(r_w_w)，与写者竞争对文件的访问权，若执行P(r_w_w)成功则获得了文件的访问权，其他的读者可直接访问文件；同理，只有最后退出临界区的读者需要执行V(r_w_w)来归还文件访问权。
为了记录正在读文件的一批读者的数量，需要设置一个整型变量readercount，每一个读者到达时都要将readercount加1，退出时都要将readercount减1。
由于只要有一个读者在读文件，便不允许写者写文件，所以，仅当readercount=0时，即尚无读者在读文件时，读者才需要执行P(r_w_w)操作。
若P(r_w_w)操作成功，读者便可去读文件，相应地，readercount+1。
同理，仅当在执行了readercount减1操作后其值为0时，才需要执行V(r_w_w)操作，以便让写者写文件。
又因为readercount是一个可被多个读者访问的临界资源，所以应该为它设置一个互斥信号量readercount_mutex.。
每个读者在访问readercount之前执行P(readercount_mutex)，之后执行V(readercount_mutex)。
通过上述分析得到图3-2所示的算法描述，其中的数字表示语句对应的行号。
下面对该算法的调度效果进行分析。
假设最初没有进程在访问文件。
过了一会，就会有很多读者和写者到达。
对它们可能有两种调度情形。
情形1 最先调度写者写者执行P(r_w_w)操作成功，将r_w_w的值变为0，获得文件的访问权；其它的写者执行P(r_w_w)将r_w_w的值变为负数，从而阻塞在信号量r_w_w上；第一个读者执行P(readercount_mutex)成功，将信号量readercount_mutex的值变为0，然后判断readercount 是0，所以执行P(r_w_w)，将r_w_w的值减1后仍然为负数从而阻塞在信号量r_w_w上，其它的读者执行P(readercount_mutex)将信号量readercount_mutex的值变为负数，从而阻塞在信号量readercount_mutex上。
例如，对于请求序列w1,w2,r1,w3,r2,r3，我们用图表形象地刻画进程的活动，图表中包括读者计数器的值、信号量readercount_mutex 和r_w_w 的值和队列以及访问文件的进程。
①初始状态。
没有进程使用文件，计数器readercount 的值是0，信号量readercount_mutex 和r_w_w 的值都是1，队列都是空，参见图3-3；②w1请求写文件，所以执行语句17，将信号量r_w_w 的值减1后变成0，w1获得文件使用权，执行语句18，开始写文件，参见图3-4；③在w1尚未写完时，w2提出写请求，所以执行语句17，将信号量r_w_w 的值减1后变成负1，w2被阻塞在信号量r_w_w 上，参见图3-5；④同时r1提出读请求，所以执行语句5，将信号量readercount_mutex 的值减1后变成0，接着执行语句6，判断readercount 的值是0，所以执行P(r_w_w)，将信号量r_w_w 的值减1后变成-2，r1被阻塞在信号量r_w_w 上，参见图3-6；⑤同时w3提出写请求，所以执行语句17，将信号量r_w_w 的值减1后变成-3，w3被阻塞在信号量r_w_w 上，参见图3-7；⑥同时r2提出读请求，所以执行语句5，将信号量readercount_mutex 的值减1后变成-1，r2被阻塞在信号量readercount_mutex 上，参见图3-8；⑦同时r3提出读请求，所以执行语句5，将信号量readercount_mutex 的值减1后变成-2，r3被阻塞在信号量readercount_mutex 上，参见图3-9；⑧w1写完文件，执行语句19，将信号量r_w_w 的值加1后变成-2，并唤醒w2，w2接着执行语句18，开始写文件，参见图3-10；⑨w2写完文件，执行语句19，将信号量r_w_w 的值加1后变成-1，并唤醒r1，r1接着执行语句7，将readercount 的值加1后变成1，执行语句8，将信号量readercount_mutex 的值加1后变成-1，并唤醒r2，r1执行语句9，开始读文件；被唤醒的r2执行语句6，判断readercount 的值不是0，所以执行语句7，将readercount 的值加1后变成2，执行语句8，将信号量readercount_mutex 的值加1后变成0，并唤醒r3，r2执行语句9，开始读文件；被唤醒的r3执行语句6，判断readercount 的值不是0，所以执行语句7，将readercount 的值加1后变成3，执行语句8，将信号量readercount_mutex 的值加1后变成1，r3执行语句9，开始读文件。
这样三个读者同时读文件，参见图3-11；⑩当r1、r2和r3读完文件时，都执行语句10~14，并由最后一个执行语句10~14的读者执行V(r_w_w)，将信号量r_w_w的值加1后变成0，并唤醒w3，w3接着执行语句18，开始写文件，参见图3-12；当w3写完文件时，执行语句19，将信号量r_w_w的值加1后变成1，回到初始状态。
可见，对于请求序列w1,w2,r1,w3,r2,r3，实际访问文件的顺序是w1,w2,r1,r2,r3,w3。
虽然w3比r2、r3先提出请求，但是由于在此之前已经有r1在读文件，所以优先响应读者r2、r3，阻塞写者w3。
如果在w3之后不断有新的读者到达，则w3将一直被阻塞，直至被饿死。
情形2 最先调度读者第一个读者执行P(readercount_mutex)成功，将信号量readercount_mutex的值变为0，接着该读者判断readercount是0，所以执行P(r_w_w)操作成功，获得文件的访问权，将r_w_w 的值变为0，然后将readercount变成1，执行V(readercount_mutex)，之后开始读文件；随后的写者执行P(r_w_w)将r_w_w的值变为负数，从而阻塞在信号量r_w_w上；其它的读者执行P(readercount_mutex)成功，判断readercount不是0，所以直接将readercount的值再加1，执行V(readercount_mutex)，之后开始读文件。
可见多个读者可以同时读文件，并在读文件时阻塞写者。
3、写者优先通过增加信号量并修改上述程序可以得到写者优先算法。
为了实现写者优先算法，需要将写者和读者分开排队，并且第一个读者和其它读者也要分开排队。
这样就需要三个队列，一个是写者排队的地方，另一个是第一个读者排队的地方，第三个是其它读者排队的地方。
相应地需要设置三个信号量，r_w_w、first_reader_wait和reader_wait。
当一个写者声明想写文件时，可以让新的读者中的第一个到first_reader_wait上排队等待；当有读者阻塞在first_reader_wait上时，让其它读者阻塞在reader_wait上；当有一个写者在写文件时，其它写者到r_w_w上排队。
只要有活跃的写者或者写者队列不为空，则阻塞新到达的读者。
为了记录已经发出声明的写者数量，需要设置一个整数writercount，以表示声明要写文件的写者数目。
由于只要有一个写者到达，就不允许读者去读，因此仅当writercount=0，表示无写者声明写时，写者才需要执行P(first_reader_wait)操作，若操作成功，写者便可以执行P(r_w_w)去竞争写文件权利。
其它写者不需要再向读者声明，可以直接执行P(r_w_w)去竞争写文件权利。
同理仅当写者在执行writercount减1操作后其值为0时，才需要执行V(first_reader_wait)操作，以便唤醒第一个被阻塞的读者去读文件。
又因为writercount是一个可被多个写者访问的临界资源，所以，应该为它设置一个互斥信号量writer_mutex。
通过上述分析得到图3-13的算法描述。
下面对该算法的调度效果进行分析。
假设最初没有进程在访问文件。
过了一会，就会有很多读者和写者到达。
对它们可能有两种调度情形。