进程同步模拟实验
实验三 进程同步
集美大学诚毅学院信息工程系实验报告课程名称计算机操作系统序号名称实验三进程同步姓名孙幸杰学号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．实验小结完成本实验后，我对基本的额进程间的通信有了初步的了解。
进程的同步与互斥实验报告
进程的同步与互斥实验报告1.实验目的进程（线程）的同步与互斥是操作系统中非常重要的概念，本实验旨在通过实际操作，加深对这些概念的理解和掌握。
通过编写多个进程（线程），并在其间进行同步与互斥操作，验证同步与互斥的实际效果。
2.实验环境本实验在Linux系统下进行，使用C/C++语言编程。
3.实验内容3.1同步在实验中，我们编写了两个进程A和B，这两个进程需要按照特定的顺序执行。
为了实现同步，我们使用信号量机制来确保进程A和B按照正确的顺序执行。
3.2互斥在实验中，我们编写了多个进程C和D，这些进程需要同时对一个共享资源进行访问。
为了实现互斥，我们使用互斥锁机制来确保同一时刻只有一个进程访问共享资源。
4.实验过程4.1同步实验编写进程A和进程B的代码，使用信号量机制实现同步。
进程A先运行，然后通过信号量唤醒进程B，进程B再开始执行。
通过观察进程的运行顺序，验证同步机制是否起作用。
4.2互斥实验编写进程C和进程D的代码，使用互斥锁机制实现互斥。
进程C和进程D同时对一个共享资源进行访问，通过互斥锁来确保同一时刻只有一个进程访问共享资源。
观察进程的输出结果，验证互斥机制是否起作用。
5.实验结果5.1同步实验结果进程A开始执行进程A执行完毕进程B开始执行进程B执行完毕5.2互斥实验结果进程C开始执行进程C访问共享资源进程C执行完毕进程D开始执行进程D访问共享资源进程D执行完毕6.实验分析通过上述结果可以看出，同步实验中进程A和进程B按照正确的顺序执行，证明了同步机制的有效性。
互斥实验中进程C和进程D能够正确地交替访问共享资源，证明了互斥机制的有效性。
7.实验总结通过本次实验，我深刻理解了进程（线程）的同步与互斥，并通过实际操作加深了对这些概念的理解。
同步和互斥是操作系统中非常重要的概念，对于应对资源竞争和提高程序性能具有重要意义。
在实际开发中，我们应该合理使用同步和互斥机制，以确保程序的正确性和并发执行的效率。
操作系统实验一-进程同步
实验一进程同步一、实验目的：分析进程的同步与互斥现象，编程实现经典的进程同步问题——生产者与消费者问题的模拟，进一步加深对进程同步与互斥的理解。
二、实验内容：用C语言实现对生产者与消费者问题的模拟。
实验原理：生产者和消费者是经典的进程同步问题，在这个问题中，生产者不断的向缓冲区中写入数据，而消费者则从缓冲区中读取数据。
生产者进程和消费者对缓冲区的操作是互斥，即当前只能有一个进程对这个缓冲区进行操作，生产者进入操作缓冲区之前，先要看缓冲区是否已满，如果缓冲区已满，则它必须等待消费者进程将数据取出才能写入数据，同样的，消费者进程从缓冲区读取数据之前，也要判断缓冲区是否为空，如果为空，则必须等待生产者进程写入数据才能读取数据。
三、实验准备：1. 实现步骤：（1）分析计算机系统中对资源的分配与释放过程：计算机系统中的每个进程都可以消费或生产某类资源。
当系统中某一进程使用某一资源时，可以看作是消耗，且该进程称为消费者。
而当某个进程释放资源时，则它就相当一个生产者。
（2）定义生产者消费者问题中的各数据结构，并初始化信号量；（3）创建生产者与消费者进程，利用信号量实现生产者与消费者之间的同步与互斥；最后编程实现。
2. 相关函数：在实现的过程中需要用到以下API函数：（1）CreateThread（）//该函数创建一个在调用进程的地址空间中执行的线程。
若线程创建成功，将返回该线程的句柄。
函数原型：HANDLE CreateThread (LPSECURITY_ATTRIBUTES lpThreadAttributes, //描述安全性，用NULL表示使用缺省值DWORD dwStackSize, //新线程拥有自己的堆栈，0表示使用缺省值1MB，推荐LPTHREAD_START_ROUTINE lpStartAddress, //新线程的起始地址，放线程函数名称LPVOID lpParameter，//此值被传送到线程函数去作为参数DWORD dwCreationFlags,//允许产生一个暂时挂起的线程，默认是0立即开始执行LPDWORD lpThreadld );//新线程的ID被传到这用法举例：hHandle1 = CreateThread( (LPSECURITY_ATTRIBUTES) NULL,0,(LPTHREAD_START_ROUTINE) ThreadName1,(LPVOID) NULL,0, &dwThreadID1 );（2）CreateMutex（）函数可用来创建一个有名或无名的互斥量对象，函数返回值为互斥对象的句柄。
进程同步实验报告
一、实验目的1. 理解进程同步的概念和原理；2. 掌握进程同步的基本方法和机制；3. 学会使用信号量实现进程同步；4. 通过实验验证进程同步机制的有效性。
二、实验原理1. 进程同步：在多道程序设计中，进程的执行是并发的，但某些情况下需要保证多个进程按照一定的顺序执行，以避免出现数据不一致、死锁等问题。
进程同步是指通过某种机制，协调多个进程的执行顺序，保证它们能够正确、有效地共享资源。
2. 信号量：信号量是一种特殊的变量，用于实现进程同步。
信号量具有两个原子操作：P操作（wait）和V操作（signal）。
P操作用于申请资源，V操作用于释放资源。
3. 互斥锁：互斥锁是一种常见的进程同步机制，用于保证临界资源的互斥访问。
当一个进程进入临界区时，它会尝试获取互斥锁，如果锁已被其他进程获取，则该进程进入等待状态；当进程退出临界区时，它会释放互斥锁。
三、实验内容1. 实验环境：Linux操作系统，C语言编程环境。
2. 实验工具：gcc编译器、gdb调试器。
3. 实验步骤：（1）创建一个互斥锁，用于保护临界资源。
（2）编写两个进程，分别模拟对临界资源的访问。
（3）在进程访问临界资源前，使用P操作尝试获取互斥锁。
（4）在进程访问临界资源后，使用V操作释放互斥锁。
（5）编译并运行程序，观察进程执行情况。
四、实验结果与分析1. 实验结果：（1）在互斥锁的保护下，两个进程能够按照预期顺序访问临界资源。
（2）当其中一个进程正在访问临界资源时，另一个进程会进入等待状态。
（3）当进程访问临界资源完成后，它会释放互斥锁，允许其他进程访问。
2. 实验分析：（1）互斥锁能够有效地保护临界资源，避免数据不一致问题。
（2）信号量P操作和V操作保证了进程的同步，避免了死锁现象。
（3）通过实验验证了进程同步机制的有效性。
五、实验总结本次实验通过使用信号量和互斥锁，实现了进程同步。
实验结果表明，信号量和互斥锁能够有效地保证进程按照预期顺序执行，避免数据不一致和死锁等问题。
进程模拟实验报告
一、实验目的1. 理解进程的基本概念，包括进程的状态、生命周期、进程控制块（PCB）等。
2. 掌握进程调度算法的基本原理，包括先来先服务（FCFS）、时间片轮转（RR）、优先级调度等。
3. 通过模拟实验，加深对进程调度算法的理解，并评估其优缺点。
4. 提高编程能力，掌握C语言编程技巧。
二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio三、实验内容1. 定义进程控制块（PCB）结构体，包括进程ID、到达时间、运行时间、优先级、状态等信息。
2. 实现进程调度算法，包括FCFS、RR、优先级调度等。
3. 模拟进程创建、调度、运行、结束等过程。
4. 分析并比较不同调度算法的性能。
四、实验步骤1. 定义进程控制块（PCB）结构体：```ctypedef struct PCB {int pid; // 进程IDint arrivalTime; // 到达时间int runningTime; // 运行时间int priority; // 优先级int state; // 状态（就绪、运行、完成）} PCB;```2. 实现进程调度算法：```c// FCFS调度算法void FCFS(PCB processes, int n) {int currentTime = 0;for (int i = 0; i < n; i++) {if (processes[i].arrivalTime <= currentTime) { // 进程就绪processes[i].state = 1;// 执行进程currentTime += processes[i].runningTime; processes[i].state = 2; // 完成状态}}}// RR调度算法void RR(PCB processes, int n, int timeQuantum) {int currentTime = 0;for (int i = 0; i < n; i++) {if (processes[i].arrivalTime <= currentTime) {// 进程就绪processes[i].state = 1;// 执行进程currentTime += timeQuantum;if (currentTime > processes[i].runningTime) {currentTime -= processes[i].runningTime;processes[i].state = 2; // 完成状态} else {processes[i].state = 2; // 完成状态}}}}// 优先级调度算法void Priority(PCB processes, int n) {int currentTime = 0;for (int i = 0; i < n; i++) {if (processes[i].arrivalTime <= currentTime && processes[i].priority > 0) {// 进程就绪processes[i].state = 1;// 执行进程currentTime += processes[i].runningTime;processes[i].state = 2; // 完成状态processes[i].priority--; // 优先级降低 }}}```3. 模拟进程创建、调度、运行、结束等过程：```cint main() {int n = 5; // 进程数量PCB processes[n];// 初始化进程信息for (int i = 0; i < n; i++) {processes[i].pid = i + 1;processes[i].arrivalTime = i 2;processes[i].runningTime = 10;processes[i].priority = 10;processes[i].state = 0; // 初始化为就绪状态 }// FCFS调度算法FCFS(processes, n);// RR调度算法RR(processes, n, 3);// 优先级调度算法Priority(processes, n);// 打印进程调度结果for (int i = 0; i < n; i++) {printf("进程ID：%d，到达时间：%d，运行时间：%d，优先级：%d，状态：%d\n",processes[i].pid, processes[i].arrivalTime,processes[i].runningTime,processes[i].priority, processes[i].state);}return 0;}```4. 分析并比较不同调度算法的性能：- FCFS调度算法简单，但可能导致某些进程长时间得不到执行，产生“饥饿”现象。
进程同步实验报告
中北大学软件学院实验报告专 业： 软件工程方 向： 软件开发与测试课程名称： 操作系统班 级：学 号：姓 名：辅导教师：2017年9月制成绩：实验时间2017年11月5日8时至10时学时数22学时1.实验名称进程同步2.实验内容编程实现生产者-消费者问题的模拟。
3.基本要求1.生产者消费者对缓冲区进行互斥操作。
2. 缓冲区大小为10，缓冲区满则不允许生产者生产数据，缓冲区空则不允许消费者消费数据。
3. 生产者消费者各循环操作10次。
4. 实验原理或流程图生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。
在同一个进程地址空间内执行的两个线程。
生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品，然后释放缓冲区。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。
当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。
5.源程序#i n c l u d e<s t d i o.h>#i n c l u d e<p t h r e a d.h>#i n c l u d e<s e m a p h o r e.h>#i n c l u d e<u n i s t d.h>v o i d*p r o d u c t e r_f(v o i d*a r g);v o i d*c o n s u m e r_f(v o i d*a r g);s e m_t e m p t y;//信号量e m p t ys e m_t f u l l;//信号量f u l li n t r u n n i n g=1;i n t a p p l e_n u m=0;i n t m a i n(v o i d){p t h r e a d_t c o n s u m e r_t;//消费者p t h r e a d_t p r o d u c t e r_t;//生产者//p s h a r e d表示信号量共享类型， 为0时，表示只能在当前进程的//多个线程之间共享，不为0时，是可以和其他进程间共享该信号量//使用信号量，用来协作生产者和消费者的顺序，即实现同步效果s e m_i n i t(&e m p t y,0,1);//初始化e m p t y信号量s e m_i n i t(&f u l l,0,0);//初始化f u l l信号量p t h r e a d_c r e a t e(&c o n s u m e r_t,N U L L,c o n s u m e r_f,(v o i d*)&r u n n i n g); //创建消费者线程p t h r e a d_c r e a t e(&p r o d u c t e r_t,N U L L,p r o d u c t e r_f,(v o i d*)&r u n n i n g);//创建生产者线程//s l e e p(1);//睡眠3秒u s l e e p(1000);//睡眠10微秒r u n n i n g=0;p t h r e a d_j o i n(c o n s u m e r_t,N U L L);p t h r e a d_j o i n(p r o d u c t e r_t,N U L L);s e m_d e s t r o y(&e m p t y);s e m_d e s t r o y(&f u l l);r e t u r n0;}v o i d*p r o d u c t e r_f(v o i d*a r g){w h i l e(*(i n t*)a r g){s e m_w a i t(&e m p t y);a p p l e_n u m++;p r i n t f("p r o d u c t e r生产第%d个香蕉\n",a p p l e_n u m);s e m_p o s t(&f u l l);u s l e e p(1);}}v o i d*c o n s u m e r_f(v o i d*a r g){w h i l e(*(i n t*)a r g){s e m_w a i t(&f u l l);p r i n t f("c o n s u m e r消费第%d个香蕉\n",a p p l e_n u m);s e m_p o s t(&e m p t y);u s l e e p(1);}}6.运行截图7.实验心得本次实验学习了进程的同步问题，进程是计算机操作系统重要的一个功能，学好进程才能学好其他。
实验4 进程同步-生产者消费者实验
实验四生产者消费者实验：用信号量实现PV操作实验目的1、熟悉PV操作的实现原理。
2、了解进程间通信机制。
熟悉信号量机制。
使用信号量机制模拟实现PV操作，从而控制多个进程对共享资源的使用。
实验内容1、使用信号量机制来模拟实现PV操作。
2、编写一个简单的程序，使用该PV模拟操作控制多进程对共享资源的使用。
实验基础一、信号量基础1、进程间通信机制进程间通信机制包括共享内存(shared memory)、信号量(semaphores)和消息队列(Message Queue)等一系列进程通信方式。
System V IPC的进程间通信机制一个显著特点是：在内核中它的具体实例是以对象的形式出现的——被称之为IPC对象。
每个IPC对象在系统内核中都有一个惟一的标识符。
通过标识符内核可以正确地引用指定的IPC对象。
要注意的是，标识符的惟一性只在每一类的IPC对象内成立。
例如，一个消息队列和一个信号量的标识符可能相同，但是绝对不允许两个消息队列使用相同的标识符。
IPC对象在程序中通过关键字(key)来访问内核中的标识符。
与IPC对象标识符相同，关键字也是惟一的。
而且，如果要访问同一个IPC对象，客户和服务器就必须使用同一个关键字。
因此，建立IPC对象时要解决的首要的一个问题，就是如何构造新的关键字使之不与已有的关键字发生冲突，并能保证客户和服务器使用相同的关键字。
2、信号量信号量是一个计数器，用来控制多个进程对共享资源的使用。
进程为了获得共享资源，需要执行下列操作：(1) 测试控制该资源的信号量。
(2) 若此信号量的值为正，则进程可以使用该资源。
进程将信号量值减1，表示它使用了一个资源单位。
(3) 若此信号量的值为0，则进程进入睡眠状态，直至信号量值大于0。
若进程被唤醒后，它返回至(第(1)步)。
当进程不再使用由一个信息量控制的共享资源时，该信号量值增1。
如果有进程正在睡眠等待此信号量，则唤醒它们。
为了正确地实现信息量，信号量值的测试及减1操作应当是原子操作。
进程同步：实验报告
1．实验内容（进程的同步）(1)阅读理解示例程序。
(2)说明示例程序是否能适合解决N个生产者和1个消费者问题，并设计实验验证(3) 参照教材修改为N个生产者和1个消费者问题(4) 思考N个生产者和M个消费者问题的解决方案（不要求）(5) 利用信号量解决同步问题。
2．实验目的通过程序模拟及验证生产者消费者问题等经典问题，深入理解并发中的同步和互斥的概念3．实验原理（1）进程概念：（1.定义：程序的一次执行过程（2.三种基本状态:就绪状态，执行状态，阻塞状态（2）进程同步：（1.定义：并发进程在执行次序上的协调，以达到有效的资源共享和相互合作，使程序执行有可再现性。
（2.两种形式的制约关系：（一：资源共享关系：进程间接制约，需互斥地访问临界资源。
）、（二：相互合作关系：进程直接制约）（3.临界资源：一次仅允许一个进程访问的资源，引起不可再现性是因为临界资源没有互斥访问。
（3）信号量：定义一个用于表示资源数目的整型量S，它与一般的整型量不同，除初始化外，仅能通过两个标准的原子操作wait(S)和signal(S)来访问，俗称P,V操作。
通俗来讲就是用P来访问资源后减去一个单位资源，用V操作来释放一个单位资源就是现有资源上加一个单位资源。
4．实验内容一：说明示例程序是否能适合解决N个生产者和1个消费者问题，并设计实验验证答：示例程序不能解决多个生产者和消费者的问题，它是解决单个消费者和生产者的。
如果可以就要修改代码，如“二”所说。
二：多个消费者和生产者的问题如上图所示：如果要解决多个生产者和消费者的问题：第一步：分析上图得出了两种关系，分别是异步和同步的关系第二步：异步关系的是生产者和生产者之间的，因为同一时刻只能有一个生产者访问缓冲区，所以我们就可以设置临界资源.获得临界资源的生产者才能把产品放到缓冲区里第三步：同步关系有两个，首先是生产者和缓冲区之间，再是缓冲区和消费者之间。
他们都满足一前一后的关系，即当缓冲区空间未满时，生产者才可以放产品；缓冲区不为空的时候才可以让消费者取出产品消费。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
int w_wait[11]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
int r_wait[11]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
void write_p(int i);
{
Wmutex--;
if(Wmutex<0)
{
w_wait[-Wmutex-1]=10;
r_wait[0]=i;
}
else
radd_v(i);
}
void radd_v(int i)//模拟读者对Rmutex的V操作
{
Rmutex++;
if(Rmutex<=0)
{
int x,y;
y=r_wait[0];
rsub(i);
}
void rsub(int i)//Rcount减一
{
Rcount--;
if(Rcount==0)
read_v(i);
else
rsub_v(i);
}
void read_v(int i)//模拟读者对Rmutex的V操作
{
Wmutex++;
if(Wmutex<=0)
{
int x,y;
void write_v(int i);
void radd_p(int i);
void radd(int i);
void read_p(int i);
void radd_v(int i);
void read(int i);
void rsub_p(int i);
void rsub(int i);
void read_v(int i);
{
w[i]=4;
}
void write_v(int i)//模拟写者对Wmutex的V操作，同时也作为读者进程的入口
{
w[i]=0;
Wmutex++;
if(Wmutex<=0)
{
int x,y;
if((w_wait[0]>=0)&&(w_wait[0]<w_num))
{
y=w_wait[0];
for(x=0;x<w_num;x++)
for(x=0;x<r_num;x++)
r_wait[x]=r_wait[x+1];
radd_v(y);
}
}
rsub_v(i);
}
void rsub_v(int i)//模拟读之后对Rmutex的V操作
{
Rmutex--;
if(Rmutex<0)
{
r_wait[-Rmutex]=i;
}
else
radd(i);
}
void radd(int i)//Rcount加一
{
Rcount++;
if(Rcount==1)
read_p(i);
else
radd_v(i);
}
void read_p(int i)//模拟读者对Rmutex的P操作
二、实验内容
用高级语言编写和调试一个采用“读写平等”策略的“读者-写者”问题的模拟程序。利用模拟信号量机制实现读者和写者问题；通过用户控制读进程和写进程，反应读者和写者问题中涉及的进程的同步与互斥。
1.问题描述：模拟用信号量机制实现读者和写者问题，即有两组并发进程：读者和写者，共享一组数据区，进行读写操作，要求任一时刻“写者”最多只允许一个，而“读者”则允许多个。
一、实验目的
通过实验模拟读者和写者之间的关系，了解并掌握他们之间的关系及其原理。由此增加对进程同步的问题的了解。具体如下：
1)掌握基本的同步互斥算法，理解读者和写者模型；
2)了解windows中多线程（多进程）的并发执行机制，线程（进程）间的同步和互斥；
3)学习使用windows中基本的同步对象，掌握相应的API。
w_wait[x]=w_wait[x+1];
write(y);
}
else
{
y=r_wait[0];
for(x=0;x<w_num;x++)
w_wait[x]=w_wait[x+1];
for(x=0;x<r_num;x++)
r_wait[x]=r_wait[x+1];
radd_v(y);
}
}
}
void radd_p(int i)//模拟读之前对Rmutex的操作，同时也作为读者进程的入口
for(x=0;x<r_num;x++)
r_wait[x]=r_wait[x+1];
radd(y);
}
read(i);
}
void read(int i)//读操作
{
r[i]=1;
}
void rsub_p(int i)//模拟读之后对Rmutex的P操作，读操作完成时调用
{
r[i]=0;
Rmutex--;
2.规则说明：允许多个读者同时执行读操作；不允许读者写者同时操作；不允许多个写者同时操作。
三、实验源程序（或实验步骤）
#include <iostream.h>
int L;
int r_num;
int w_num;
int Wmutex=1;
int nt=0;
int Rmutex=1;
int r[10]={0,0,0,0,0,0,0,0,0,0};
void rsub_v(int i);
void write(int i);
void write_p(int i)//模拟写者对Wmutex的P操作，同时也作为写者进程的入口
{
Wmutex--;
if (Wmutex<0)
{
w_wait[-Wmutex-1]=i;
}
else
write(i);
}
void write(int i)
进程同步模拟实验
姓名
学号
实验日期
成绩
院别
班级
实验场地
实验课程名称
计算机操作系统
实验项目名称
进程同步模拟实验
对于每一个实验项目，实验报告（含预习）一般应包含以下内容：第一部分——预习后的书面汇报。其主要内容应包含：*1、实验目的；*2、实验内容。第二部分——实验结果的书面汇报。其主要内容应包含：*3、实验源代码；*4、实验结果及分析（含实验测试输入数据，试验运行结果截图，用简洁的语言总结实验，汇报是否达到实验目的）；*5、实验体会、问题讨论（谈体会或感想、提出建议或意见、讨论与实验有关的且自己感兴趣的问题、回答课后思考题）。
if((w_wait[0]>=0)&&(w_wait[0]<w_num))
{
y=w_wait[0];
for(x=0;x<w_num;x++)
w_wait[x]=w_wait[x+1];
write(y);
}
else
{
y=r_wait[0];
for(x=0;x<w_num;x++)
w_wait[x]=w_wait[x+1];