进程同步模拟设计--吃水果问题
吃水果问题
实习一进程同步
一、实习内容
模拟进程同步。
二、实习目的
本实习要求学生理解进程同步的概念和进程同步技术——信号量机制。
三、实习题目
编写一个程序，模拟“吃水果问题”。
问题描述：桌上有一个盘子，每次只能放一个水果，爸爸专向盘中放苹果，妈妈专向盘中放橘子，儿子专等吃盘里的橘子，女儿专等吃盘里的苹果。
只要盘子空，爸爸妈妈可向盘中放水果，仅当盘中有自己需要的水果时，儿子或女儿可从中取出，请用信号量及PV操作模拟四人的同步关系。
提示：
（1）信号量和P、V(semwait&semsignal)操作原语自己定义，在保证该对原语原有意义的基础上，也可添加新内容（模拟的需要，结合提示（5）思考）；
（2）4人分别是4个进程，每个进程的程序可由一个函数模拟；
其中，
进程名——作为进程的标识，自己定义。
状态——有两种状态，“就绪”和“阻塞”，初始状态都为“就绪”，用“R”表示。
当一个进程阻塞后，它的状态为“阻塞”，用“B”表示。
（3）当前执行哪个进程可由随机函数决定，若该进程当前是阻塞的，则打印“该进程阻塞”提示；否则，执行该进程程序；
（4）取、放水果的操作可用打印语句的方式替代；
（5）当一个阻塞态进程被唤醒成为就绪态，然后，再次被选中执行时，应从P原语的下一个语句开始执行。
这该怎么控制？想办法解决（结合提示（1）思考）。
注意：
信号量的设置和初值；
程序应有提示，界面友好!
用循环队列存阻塞队列和就绪队列。
操作系统课程设计吃水果问题完整
1
1.1
进程同步模拟设计:吃水果问题
1.2
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
1.3
将问题转换为信号量上的资源分配类型问题:
这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。通过编程实践时，实际是随机的调用人一个进程的操作，而这些进程的操作相当于程序中的函数调用。而计算机在执行时每一个时刻只能执行一个操作，这就默认了互斥。同步的模拟可以类似于函数调用时的前提关系即先决条件。这样进程同步模拟就完全可以通过函数的调用来实现。
int MonFa_c;//用于爸爸妈妈等待次序的区别
int Son_a;//用于两个儿子等待次序的区别
int daughter_b;//用于两个女儿等待次序的区别
int k;//产生进程调用的数量
srand((unsigned)time(NULL));//srand()函数产生一个以当前时间开始的随机种子
Son2(); //处于等待的Son2()自动调用
Son_a=1;
}
}
else
{
if(Son1_lag==true)
{
Son1_lag=false; //Son1等待取消
cout<<"处于等待的Son1自动被调用"<<endl;
Son1(); //处于等待的Son源自()自动调用Son_a=0;
}
else if(Son2_lag==true)
{
orange--;
进程同步模型系统的设计—吃水果
课程设计课程设计任务书学生： Miss屠专业班级： 08计科指导教师：王海英工作单位：计算机科学与技术学院题目: 进程同步模型系统的设计——吃水果问题初始条件：1．预备容：阅读操作系统的进程管理章节容，对进程的同步和互斥，以及信号量机制度有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．为下面吃水果的问题创建进程并利用通信API实现进程之间的同步模型。
能够处理以下的情形：桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
2．设计报告容应说明：⑴课程设计目的与功能；⑵需求分析，数据结构或模块说明(功能与框图)；⑶源程序的主要部分；⑷运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他的其他方法（如果有，简要说明该方法）；时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：撰写课程设计报告。
指导教师签名：年月日系主任（或责任教师）签名：年月日进程同步模型系统的设计——吃水果问题1、课程设计目的与功能1.1、目的为下面吃水果的问题创建进程并利用通信API实现进程之间的同步模型。
能够处理以下的情形：桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
1.2、实现的功能本程序共创建了4个在windows系统环境下实现的线程，即Fahter、Mother、Son和Daughter等4个线程，以及putapple、putorange、getapple和getorange 等4个函数，其中4个线程是用于实现爸爸、妈妈、儿子和女儿分别放水果和取水果的线程操作的，并分别调用这4个函数，来实现真正的操作。
2.9 经典的进程的同步互斥问题3
1.m-n 2.C
课后思考1 理发师问题
假设后街有家理发店，店里有一个理发师、一把理发椅和n把
等候理发的顾客椅子。 ① 如果没有顾客则理发师便在理发椅上看报纸； ② 当有一个顾客到达时，首先查看理发师在干什么，如果在看报 纸则告诉理发师理发，然后坐到理发椅上开始理发；如果理发
师正在理发，则查看是否有空的椅子可坐，如果有，他就坐下
随堂练习1
程序填空：超市购物问题
问题描述：某小型超级市场，可容纳50个人同时购物。入口处备有篮子，每个购物
者可拿一只篮子入内购物。出口处结帐，并归还篮子（出、入口禁止多 人同时通过）。试用P、V操作写出购物者的同步算法。
struct semaphore s,mutex=
,
;
cobegin void comsumeri(void) (i=1,2,…,k) { while(TRUE) { ;
semaphore s=1; semaphore sp=0; semaphore so=0;
void father (void) { while(TRUE) { have an apple; P(s); put an apple; V(sp); } } void son (void) { while(TRUE) { P(so); get an orange; V(s); eat an orange; } } void mother (void) { while(TRUE) { have an orange; P(s); put an orange; V(so); } } void daught (void) { while(TRUE) { P(sp); get an apple; V(s); eat an apple; } }
操作系统-吃水果问题
操作系统-吃水果问题操作系统-吃水果问题1、引言本文档描述了一个操作系统的模拟问题-吃水果问题。
该问题涉及到多个进程同时对有限数量的水果资源进行访问的情况。
我们将介绍该问题的背景、目标和关键概念。
2、背景吃水果问题模拟了现实生活中多个进程同时访问共享资源的情况。
在该问题中，不同的进程可以同时访问一定数量的水果资源。
然而，由于水果资源有限，进程必须遵守特定的规则以确保公平访问。
3、目标该问题的目标是设计一种算法，使得不同的进程能够共享有限的水果资源。
我们的目标是确保进程之间的公平访问，并通过合适的同步机制来避免产生竞争条件和死锁。
4、关键概念4.1 进程(Process)进程是计算机中正在运行的程序的实例。
在吃水果问题中，每个进程代表一个人，这些人需要同时访问共享的水果资源。
4.2 共享资源(Shared Resource)共享资源是多个进程可能同时访问的资源。
在吃水果问题中，水果资源是共享资源，被多个进程同时竞争。
4.3 同步机制(Synchronization Mechanism)同步机制用于控制多个进程对共享资源的访问。
在吃水果问题中，我们需要设计一种同步机制来确保进程之间的公平访问和避免竞争条件。
5、解决方案5.1 问题分析首先，我们需要确定问题的规模和要求。
包括进程数量、水果资源数量以及对公平访问的要求等。
5.2 同步机制设计我们可以采用多种同步机制来解决吃水果问题，例如互斥锁、条件变量等。
在设计同步机制时，需要考虑到公平性、死锁避免和性能等方面的因素。
5.3 算法实现根据设计的同步机制，我们需要实现相应的算法来解决吃水果问题。
这个算法应该能够正确地控制进程对资源的访问，并满足公平访问和避免死锁的要求。
6、测试与调试在实现算法之后，我们需要进行测试和调试来确保算法的正确性和性能。
包括编写测试用例、模拟并发情况和调整参数等。
7、结论通过本文档，我们介绍了操作系统中的吃水果问题，并提供了解决该问题的解决方案。
进程同步模拟设计--吃水果问题
附件1：学号：012课程设计题目进程同步模拟设计--吃水果问题学院计算机科学与技术学院专业计算机科学与技术专业班级计算机姓名指导教师2011 年01 月19 日课程设计任务书学生：专业班级：指导教师：作单位：计算机科学与技术学院题目: 进程同步模拟设计——吃水果问题初始条件：1．预备容：阅读操作系统的进程管理章节容，对进程的同步和互斥，以及信号量机制度有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟吃水果的同步模型：桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
2．设计报告容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；v）对实验题的评价和改进意见，请你推荐设计题目。
时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，一律按0分记）指导教师签名：年月日系主任（或责任教师）签名：年月日进程同步模拟设计——吃水果问题1需求分析1.1吃水果问题的描述桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
1.2问题的转换这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。
2.9 经典的进程的同步互斥问题3
经典的进程同步互斥问题
例6：吃水果问题
问题描述：桌上有一只盘子，每次只能放一个水果，爸爸专向盘中放苹果，妈妈专
向盘中放桔子，儿子专等吃盘里的桔子，女儿专等吃盘里的苹果。只要
盘子空，则爸爸或妈妈可向盘中放水果，仅当盘中有自己需要的水果时， 儿子或女儿可从中取出，请给出四人之间的同步关系，并用PV操作实 现四人正确活动的程序。
1.m-n 2.C
课后思考1 理发师问题
假设后街有家理发店，店里有一个理发师、一把理发椅和n把
等候理发的顾客椅子。 ① 如果没有顾客则理发师便在理发椅上看报纸； ② 当有一个顾客到达时，首先查看理发师在干什么，如果在看报 纸则告诉理发师理发，然后坐到理发椅上开始理发；如果理发
师正在理发，则查看是否有空的椅子可坐，如果有，他就坐下
问题分析：该问题可以看做是两个生产着和两个消费者共享一个仅能存放一件产品
的缓冲池 ，生产者各自生产不同的产品，消费者各自取自己需要的产 品。爸爸妈妈存放水果时必须互斥。爸爸往盘子里放苹果后，应该将消 息发给女儿；妈妈往盘子里放桔子后，应该将消息发给儿子；儿子或者 女儿从盘子里取走水果后，应该不定向的得将“盘子里没有水果的”的 消息发给爸爸或者妈妈。爸爸妈妈竞争资源（盘子）。
等待，如果没有，则离开； ③ 理发师为一位顾客理完发后，查看是否有人等待，如有则唤醒 一位为其理发，如没有则在理发椅上看报纸； ④ 顾客不分优先级
课后思考1 理发师问题
问题分析 当理发师看报时顾客近来需要唤醒理发师为其理发，当有顾 客时理发师为其理发，没有的时候理发师看报，因此理发师和
顾客之间是同步的关系；由于每次理发师只能为一个人理发，
等待；站席区满时，只能在入口外等待。
java与操作系统同步问题（三）————父亲儿子女儿水果问题
java与操作系统同步问题（三）————⽗亲⼉⼦⼥⼉⽔果问题问题描述：⽗亲每次都会放⼀个⽔果在桌⼦上，⼥⼉喜欢吃⾹蕉（只吃⾹蕉），⼉⼦喜欢吃苹果（只吃苹果）。
⽗亲每次只会随机往桌⼦上放⼀个⽔果（苹果或⾹蕉），⼉⼦，⼥⼉会来取。
使⽤p、v操作来完成⽗亲、⼉⼦、⼥⼉的同步⾏为模拟。
问题分析：由上述描述我们可以知道，桌⼦就是⼀个缓冲区（单缓冲），同⼀时刻，只能有⼀个⼈对它进⾏放和取得操作。
所以桌⼦就是⼀个互斥信号量。
⽽桌⼦上有苹果，且⽗亲没有放，⼉⼦才能取，⼥⼉也是同理。
所以应该还有两个资源信号量：1 苹果 2 ⾹蕉在由题意分析可知，三个信号量的初始值应该为 1 0 0 因为桌⼦只能放⼀个⽔果。
⽽在开始的时候，桌⼦上是空的（所以可以进⾏放的操作），所以苹果、⾹蕉初始资源量都为空。
代码实现：1.信号量设定如下：/*** 缓冲区是否满信号量*/Semaphore empty;/*** 苹果信号量*/Semaphore apple;/*** ⾹蕉信号量*/Semaphore banana;empty = new Semaphore(1);apple = new Semaphore(0);banana = new Semaphore(0);2.⽗亲的放的线程，只有在桌⼦互斥资源量可以⽤的时候才能进⾏放的操作。
所以要先p⼀下桌⼦信号量。
Thread fatherThread = new Thread(new Runnable() {String className = "father";@Overridepublic void run() {// TODO Auto-generated method stubwhile(true) {Semaphore.Wait(empty, className);if (randomAB()) {System.out.println(className + "往盘⼦⾥放了⼀个苹果");Semaphore.Signal(apple, className);} else {System.out.println(className + "往盘⼦⾥放了⼀个⾹蕉");Semaphore.Signal(banana, className);}System.out.println(className + "完成了⼀次放的操作");//随机⽣成休眠时间，代表放⼊产品的操作时间long millis = (long) (Math.random() * 1000);try {Thread.sleep(millis);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}});3.⼉⼦的实现，要判断是否有苹果，没有的话就等待Thread sonThread = new Thread(new Runnable() {String className = "son";@Overridepublic void run() {// TODO Auto-generated method stubwhile(true) {Semaphore.Wait(apple, className);System.out.println(className + "从盘⼦⾥取了⼀个苹果");//随机⽣成休眠时间，代表放⼊产品的操作时间long millis = (long) (Math.random() * 1000);try {Thread.sleep(millis);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println(className + "吃了⼀个苹果");Semaphore.Signal(empty, className);System.out.println(className + "完成了⼀次取吃的操作"); }}});4.⼥⼉的代码实现：原理跟⼉⼦的类似Thread daughterThread = new Thread(new Runnable() {String className = "daughter";@Overridepublic void run() {// TODO Auto-generated method stubwhile(true) {Semaphore.Wait(banana, className);System.out.println(className + "从盘⼦⾥取了⼀个⾹蕉");//随机⽣成休眠时间，代表放⼊产品的操作时间long millis = (long) (Math.random() * 1000);try {Thread.sleep(millis);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println(className + "吃了⼀个⾹蕉");Semaphore.Signal(empty, className);System.out.println(className + "完成了⼀次取吃的操作"); }}});运⾏结果如下：daughter被阻塞son被阻塞father往盘⼦⾥放了⼀个⾹蕉father资源量⾜够，唤醒⼀个father完成了⼀次放的操作daughter从盘⼦⾥取了⼀个⾹蕉daughter吃了⼀个⾹蕉daughter完成了⼀次取吃的操作daughter被阻塞father往盘⼦⾥放了⼀个⾹蕉father资源量⾜够，唤醒⼀个father完成了⼀次放的操作daughter从盘⼦⾥取了⼀个⾹蕉father被阻塞daughter吃了⼀个⾹蕉daughter资源量⾜够，唤醒⼀个daughter完成了⼀次取吃的操作....。
进程吃水果
西华大学上机实践报告课程名称：Windows系统编程年级：2011上机实践成绩：指导教师：陈克力姓名：徐千上机实践名称：吃水果问题学号：312011*********上机实践日期：12_04上机实践编号：实验10组号：1上机实践时间：18:30--20:30一、目的1. 掌握多进程间消息通信方式；2. 掌握定时器应用，随即函数的应用；3. 提高项目系统分析与设计方法；二、内容与设计思想吃水果问题介绍：吃水果问题是操作系统中典型的进程间通信问题。
桌上有一个空盘，允许存放20个水果，父母可向盘内随机个数的水果，如果盘子放满了，则等待；孩子等着吃盘内的水果，如果盘子空了，则等着父母放水果。
设计三个基于对话框的进程分别模拟盘子、父母、孩子的行为。
可以实现：（1）盘子进程动态显示盘子里面的水果数量；（2）父母进程中点击开始按钮，每隔5 秒随机往盘子里面放不大于10 个水果；并显示真正放入的水果数；（3）孩子进程中点击开始按钮，每隔2 秒随机从盘子里面取不多于5 个水果；并显示真正取到的水果数量。
实验思想：1. 采用基于对话框的MFC 应用程序；2. 利用自定义消息来实现多个进程间通信：（1）父母放水果时发送一个自定义消息（WM_MSG1），通过消息参数WParam的值（如规定为100 表示放），lParam 的值表示具体放入的水果数量；（2）孩子取水果时发送一个自定义消息消息（WM_MSG2），通过消息参数WParam 的值（如规定为200 表示取），lParam 的值表示具体想取得的水果数量；（3）盘子进程随时响应父母进程或孩子进程的消息，并进行判断处理：父母放时要判断盘子是否满，并发送一条自定义消息（WM_MSG3）给父母表明实际放入的水果数；孩子取时要判断盘子是否为空，并发送一条自定义消息（WM_MSG4）给孩子表明实际取得的水果数；（4）父母或孩子把盘子返回的消息显示在各自的对话框中；3. 父母或孩子的行为可以用定时器消息来完成。
操作系统课程设计---吃水果问题
}
void Father() //Father进程
{
apple++;
Print();
}
void Mother() //Mother进程
{
orange++;
Print();
}
void Son1() //Son1进程
{
orange--;
Print();
}
void Son2() //Son2进程
(4)两个放水果进程进程同时处于等待状态时，若有取水果的操作将自动执行等待的放水果进程，执行按等待的先后顺序；两个取苹果或橘子进程同时候处于等待状态，若有放苹果或橘子的操作将自动执行等待的取进程，进行按等待的先后顺序。
(5)用一个随机的函数产生0—5的6个整数，分别对应六个进程的调用。
放水果操作流程图设计(以Father为例,Mother类似):
具体的每一个操作的对应的函数的关系：
爸爸向盘子中放一个苹果：Father()
妈妈向盘子中放一个橘子：Mother()
儿子1从盘子取一个橘子：Son1()
儿子2从盘子取一个橘子：Son2()
女儿1从盘子取一个苹果：Daugther1()
儿子1从盘子取一个苹果：Daugther2()
具体实现方案:
(1)用一个整型变量Plate_Size表示盘子，初始值为0，当放水果时Plate_Size加1，取水果时Plate_Size减1。变量Plate_Size的最大值为2，当为2时表示盘子已经满，此时若进行放水果操作，放水果将处于等待状态；为0时表示盘子为空，此时若进行取水果操作，取水果操作将处于等待状态。
Plate_Size=apple+orange;
进程同步模拟设计
进程同步模拟设计——吃水果问题1、课程设计目的与功能1.1、目的为下面吃水果的问题创建进程并利用通信API实现进程之间的同步模型。
能够处理以下的情形：桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
1.2、实现的功能本程序共创建了6个在W indows系统环境下实现的线程，即Father、Mother、Son1、Son2、Daughter1和Daughter2等6个线程，以及Put_Apple、Put_Orange、Get_Apple1、Get_Apple2、Get_Orange1和Get_Orange2等6个函数，其中4个线程是用于实现爸爸、妈妈、儿子和女儿分别放水果和取水果的线程操作的，并分别调用这4个函数，来实现真正的操作。
在本程序中还设置了mutex互斥信号，empty、apple和orange等信号量，用于各线程之间获取资源和放弃资源等的线程之间的操作控制，并且设置了盘子容量上限量content。
其主要功能是用于实现爸爸和妈妈这2个互斥线程对于资源的使用操作以及爸爸和女儿、妈妈和儿子这2组同步线程对于资源的操作。
2、需求分析当计算机中两个或者多个进程在执行时需要使用公用缓冲区，并且对该缓冲区采取了互斥措施，这时如果并发执行这些进程的时候就会造成CPU时间的极大浪费，这是操作系统设计要求不允许的。
而这种现象在操作系统和用户进程中大量存在。
因此为了解决这一问题，提出了同步的概念，即把异部环境下的一组并发进程，因直接制约而互相发送消息而进行互相合作、互相等待，使得各进程按一定的速度执行的过程称为进程间的同步。
在本系统中，爸爸与妈妈、儿子与女儿的线程操作是互斥的，但是爸爸与女儿、妈妈与儿子线程之间的操作是同步的。
因此要利用进程同步的方法来实现这几者之间的操作，当然其中也包含着互斥进程，因为盘子每次只能放入或者取出一个水果。
同步和互斥实验-吃水果问题、消费者问题
实验3 报告源程序1/**作者：wwj时间：2012/4/12功能：实现吃水果问题**题目内容：桌子有一只盘子，只允许放一个水果，父亲专向盘子放苹果，母亲专向盘子放桔子儿子专等吃盘子的桔子，女儿专等吃盘子的苹果。
只要盘子为空，父亲或母亲就可以向盘子放水果，仅当盘子有自己需要的水果时，儿子和女儿可从盘子取出。
请给出四个人之间的同步关系，并用pv操作实现四个人的正确活动的问题。
****题目分析：父亲和女儿是相互制约的，父亲进程执行完即往盘中放入苹果后，女儿进程才能执行即吃苹果，是同步关系；母亲和儿子是相互制约的，母亲进程执行完即往盘中放入桔子，儿子进程才能执行即吃桔子，也是同步关系而父亲和母亲这两个进程不能同时进行，是互斥关系；****/#include<windows.h>#include<iostream>using namespace std;//声明句柄HANDLE EmptyPlate;HANDLE Apple;HANDLE orange;HANDLE fatherThread;HANDLE motherThread;HANDLE sonThread;HANDLE daughterThread;//线程函数声明DWORD WINAPI father(LPVOID IpParameter);DWORD WINAPI mother(LPVOID IpParameter);DWORD WINAPI daughter(LPVOID IpParameter);DWORD WINAPI son(LPVOID IpParameter);int main(){//创建信号量EmptyPlate = CreateSemaphore(NULL,1,1,NULL); //盘子Apple = CreateSemaphore(NULL,0,1,NULL); //苹果orange = CreateSemaphore(NULL,0,1,NULL); //桔子//创建线程fatherThread = CreateThread(NULL,0,father,NULL,0,NULL);motherThread = CreateThread(NULL,0,mother,NULL,0,NULL);daughterThread = CreateThread(NULL,0,daughter,NULL,0,NULL);sonThread = CreateThread(NULL,0,son,NULL,0,NULL);//等线程的结束WaitForSingleObject(fatherThread,INFINITE);WaitForSingleObject(motherThread,INFINITE);WaitForSingleObject(daughterThread,INFINITE);WaitForSingleObject(sonThread,INFINITE);//关闭线程句柄CloseHandle(fatherThread);CloseHandle(motherThread);CloseHandle(daughterThread);CloseHandle(sonThread);//关闭信号量句柄CloseHandle(EmptyPlate);CloseHandle(Apple);CloseHandle(orange);return 0;}//父亲线程函数DWORD WINAPI father(LPVOID IpParameter){for(int i = 0; i < 5; ++i){WaitForSingleObject(EmptyPlate, INFINITE); // P操作// 开始临界区cout << "\nFather往盘中放一个水果\n";// 结束临界区ReleaseSemaphore(Apple, 1, NULL); // V操作}return 0;}//母亲线程函数DWORD WINAPI mother(LPVOID IpParmeter){for(int i = 0; i < 5; ++i){WaitForSingleObject(EmptyPlate, INFINITE); // P操作// 开始临界区cout << "\nMother往盘中放一个桔子\n";// 结束临界区ReleaseSemaphore(orange, 1, NULL); // V操作}return 0;}//女儿线程函数DWORD WINAPI daughter(LPVOID IpParameter){while(1){WaitForSingleObject(Apple,INFINITE); //p操作cout<<"女儿吃苹果"<<endl;ReleaseSemaphore(EmptyPlate,1,NULL); //v操作}return 0;}//儿子线程函数DWORD WINAPI son(LPVOID IpParameter){while(1){WaitForSingleObject(orange,INFINITE); //p操作cout<<"儿子吃苹果"<<endl;ReleaseSemaphore(EmptyPlate,1,NULL); //v操作}return 0;}程序运行结果截图：运行结果分析：从运行结果可知父进程执行完后，女儿进程立即执行，这说明父进程跟女儿进程有时序关系，只有当父进程执行之后，女儿进程才会执行，女儿进程是父进程的子线程，他们具有同步关系，同理；母亲进程跟儿子进程，也是同步关系。
进程同步例题
例1：医生进程Doctor，化验进程Lab共同完成病人的诊治工作，医生开化验单，化验进程进行化验，医生根据化验结果进行诊断。
请用记录型信号量和P、V 操作实现两进程的同步。
例2 吃水果问题
例3、某集装箱仓库共有100个仓位，用同一辆吊车负责集装箱的吊进和吊出。
现有一批集装箱运来进仓，另有货主不断前来提货（按仓位顺序进出），设进仓用过程PUTIN表示，出仓用过程GETOUT表示，请用P、V操作协调上述工作。
例4、有一独木桥，每次只允许一人过桥，现在桥的南北两端随时有人要过桥（PASS），为保证安全，请用P、V操作解决如下问题：
1)只要桥上无人则允许任一方的一人过桥，桥上有人则等待。
2)两边的人交替过桥。
即某一方一人过桥后要让另一方的一个人过桥，桥上
有人则等待。
例5、有三个进程PA、PB、PC合作解决文件打印问题：PA将文件记录从磁盘读入主存的缓冲区1，每执行一次读一个记录；PB将缓冲区1的内容复制到缓冲区2，每执行一次复制一个记录；PC将缓冲区2的内容打印出来，每执行一次打印一个记录。
缓冲区的大小等于一个记录的大小。
请用P、V操作协调三个进程的工作。
例6 少林寺问题。
操作系统中经典的水果问题
操作系统中经典的水果问题首先写下P、V操作实例分析Eg.1、桌上有一空盘，允许存放一只水果。
爸爸可向盘中存放苹果，也可向盘中存放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。
规定当盘空时一次只能放一只水果供吃者取用，请用P、V原语实现爸爸、儿子、女儿三个并发进程的同步。
答:根据题目知本题中需设置4个信号量，其中empty_number表示还可以向盘中放几个水果，其初值为1；;apple对应已放入盘中的苹果，orange 对应已放入盘中的桔子，它们的初值均为0; mutex 用来实现对盘子的互斥访问(包括放和取)，其初值为1。
相应的进程可描述为:Eg.2、桌上有一个盘子，最多可以容纳两个水果，每次只能放入或取出一个水果。
爸爸专向盘子中放入苹果(apple) ，妈妈专向盘子中放入桔子(orange)，两个儿子专等吃盘中的桔子，两个女儿专等吃盘子中的苹果。
请用P、V操作来实现爸爸、妈妈、儿子、女儿之间的同步互斥关系。
答:本题中需设置4个信号量，其中empty_number表示还可以向盘中放几个水果，其初值为2；apple对应已放入盘中的苹果，orange 对应已放入盘中的桔子，它们的初值均为0; mutex 用来实现对盘子的互斥访问(包括放和取)，其初值为1。
相应的进程可描述为:Eg.3、桌上有一个盘子，可以存放一个水果，爸爸专向盘子中放入苹果，妈妈专向盘子中放入香蕉，一个儿子专等吃盘中的香蕉，一个女儿专等吃盘子中的苹果。
请用那P、V操作来实现爸爸、妈妈、儿子、女儿之间的同步互斥关系。
答:由题可知，盘子为互斥资源，因为可以放一个水果，所以empty_number初值为1；信号量mutex控制对盘子的互斥访问，初值为1；apple 和orange 分别表示盘中苹果和橘子的个数，初值为0。
新版进程同步典型例题(操作系统)
进程同步练习题1.在公共汽车上，司机和售票员的工作流程如图所示。
为保证乘客的安全，司机和售票员应密切配合协调工作。
请用信号量来实现司机与售票员之间的同步。
司机售票员图司机和售票员工作流程图2.桌子上有一只盘子，盘子中只能放一只水果。
爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，一个儿子专等吃盘子中的橘子，一个女儿专等吃盘子中的苹果。
用PV操作实现他们之间的同步机制。
3.a，b两点之间是一段东西向的单行车道，现要设计一个自动管理系统，管理规则如下：（1）当ab之间有车辆在行驶时同方向的车可以同时驶入ab段，但另一方向的车必须在ab 段外等待；（2）当ab之间无车辆在行驶时，到达a点（或b点）的车辆可以进入ab段，但不能从a 点和b点同时驶入；（3）当某方向在ab段行驶的车辆驶出了ab段且暂无车辆进入ab段时，应让另一方向等待的车辆进入ab段行驶。
请用信号量为工具，对ab段实现正确管理以保证行驶安全。
4．将只读数据的进程称为“读者”进程，而写或修改数据的进程称为“写者”进程。
允许多个“读者”同时读数据，但不允许“写者”与其他“读者”或“写者”同时访问数据。
另外，要保证：一旦有“写者”等待时，新到达的“读者”必须等待，直到该“写者”完成数据访问为止。
试用P、V操作正确实现“读者”与“写者”的同步。
（第二类读者写者问题，信号量解决方法）5．一条河上架设了由若干个桥墩组成的一座桥。
若一个桥墩只能站一个人，过河的人只能沿着桥向前走而不能向后退。
过河时，只要对岸无人过，就可以过。
但不允许河对岸的两个人同时过，以防止出现死锁。
请给出两个方向的人顺利过河的同步算法。
6．有一个仓库，可以存放A和B两种产品，但要求：（1）每次只能存入一种产品（A或B）；（2）-N＜A产品数量－B产品数量＜M。
其中，N和M是正整数。
试用同步算法描述产品A与产品B的入库过程。
1、在公共汽车上，司机和售票员的工作流程如图所示。
为保证乘客的安全，司机和售票员应密切配合协调工作。
武汉理工大学进程同步模拟设计-——吃水果问题
武汉理⼯⼤学进程同步模拟设计-——吃⽔果问题进程同步模拟设计——吃⽔果问题1需求分析1.1吃⽔果问题的描述桌⼦上有⼀只盘⼦，最多可容纳两个⽔果，每次只能放⼊或者取出⼀个⽔果。
爸爸专门向盘⼦中放苹果，妈妈专门向盘⼦中放橘⼦，两个⼉⼦专门等待吃盘⼦中的橘⼦，两个⼥⼉专门等吃盘⼦中的苹果。
1.2问题的转换这是进程同步问题的模拟，可以把向盘⼦放或取⽔果的每⼀个过程可以转为⼀个进程的操作，这些进程是互斥的，同时也存在⼀定的同步关系。
通过编程实践时，实际是随机的调⽤⼈⼀个进程的操作，⽽这些进程的操作相当于程序中的函数调⽤。
⽽计算机在执⾏时每⼀个时刻只能执⾏⼀个操作，这就默认了互斥。
同步的模拟可以类似于函数调⽤时的前提关系即先决条件。
这样进程同步模拟就完全可以通过函数的调⽤来实现。
具体的每⼀个操作的对应的函数的关系：爸爸向盘⼦中放⼀个苹果：Father()妈妈向盘⼦中放⼀个橘⼦：Mother()⼉⼦1从盘⼦取⼀个橘⼦：Son1()⼉⼦2从盘⼦取⼀个橘⼦：Son2()⼥⼉1从盘⼦取⼀个苹果：Daugther1()⼉⼦1从盘⼦取⼀个苹果：Daugther2()2功能设计2.1 数据结构(1)⽤⼀个整型变量Plate_Size表⽰盘⼦，初始值为0，当放⽔果时Plate_Size 加1，取⽔果时Plate_Size减1。
变量Plate_Size 的最⼤值为2，当为2时表⽰盘⼦已经满，此时若进⾏放⽔果操作，放⽔果将处于等待状态；为0时表⽰盘⼦为空，此时若进⾏取⽔果操作，取⽔果操作将处于等待状态。
(2)整型变量orange和apple分别表⽰盘⼦中的橘⼦和苹果数⽬，初始都为0，Plate_Size=apple+orange。
(3)⽤6个bool型的变量Father_lag，Mother_lag，Son1_lag，Son2_lag，Daughter1_lag，Daughter2_lag表⽰六个进程是否处于等待状态。
处于等待时，变量值为true。
C++11实现信号量（吃水果问题）
C++11实现信号量（吃⽔果问题）c++11中有互斥和条件变量但是并没有信号量，但是利⽤互斥和条件变量很容易就能实现信号量。
1.信号量 信号量是⼀个整数 count，提供两个原⼦(atom，不可分割)操作：P 操作和 V 操作，或是说 wait 和 signal 操作。
P操作 (wait操作)：count 减1；如果 count < 0 那么挂起执⾏线程；V操作 (signal操作)：count 加1；如果 count <= 0 那么唤醒⼀个执⾏线程；2.信号量的实现 吃⽔果问题：桌⼦有⼀只盘⼦，只允许放⼀个⽔果，⽗亲专向盘⼦放苹果，母亲专向盘⼦放桔⼦⼉⼦专等吃盘⼦的桔⼦，⼥⼉专等吃盘⼦的苹果。
只要盘⼦为空，⽗亲或母亲就可以向盘⼦放⽔果，仅当盘⼦有⾃⼰需要的⽔果时，⼉⼦和⼥⼉可从盘⼦取出。
请给出四个⼈之间的同步关系，并⽤ pv操作实现四个⼈的正确活动的问题。
#include <iostream>#include <thread>#include <mutex>#include <condition_variable>using namespace std;class semaphore{public://初始化信号个数semaphore(int value = 1) :count(value) {}void P()//相当于信号P操作，申请⼀个信号{unique_lock<mutex> lck(mtk);if (--count < 0)//资源不⾜挂起线程cv.wait(lck);}void V()//相当于V操作，释放⼀个信号{unique_lock<mutex> lck(mtk);if (++count <= 0)//有线程挂起，唤醒⼀个cv.notify_one();}private:int count;mutex mtk;condition_variable cv;};//有苹果、橙⼦、盘⼦三种信号semaphore plate(1), apple(0), orange(0);void father(){while (true){//可⽤盘⼦减⼀plate.P();cout << "往盘中放⼀个苹果" << endl;//苹果加⼀apple.V();}}void mother(){while (true){//盘⼦减⼀plate.P();cout << "往盘中放⼀个橘⼦" << endl;//橙⼦加⼀orange.V();}}void son(){while (true){//苹果减⼀apple.P();cout << "⼉⼦吃苹果" << endl;//盘⼦加⼀plate.V();}}void daughter(){while (true){//橙⼦减⼀orange.P();cout << "⼥⼉吃橘⼦" << endl;//盘⼦加⼀plate.V();}}int main(){thread f(father), m(mother), s(son), d(daughter);f.join();m.join();s.join();d.join();system("pause");return0;}。
第3章 进程同步与通信_2
吃水果问题2 吃水果问题
题目：桌上有一只盘子，允许存放一个水果， 题目：桌上有一只盘子，允许存放一个水果，父亲 专向盘中放苹果，母亲专向盘中放桔子， 专向盘中放苹果，母亲专向盘中放桔子，儿子专等 吃盘里的桔子，女儿专等吃盘里的苹果。 吃盘里的桔子，女儿专等吃盘里的苹果。只要盘子 则父亲或母亲可向盘中放水果， 空，则父亲或母亲可向盘中放水果，仅当盘中有自 己需要的水果时，儿子或女儿可从中取出。 己需要的水果时，儿子或女儿可从中取出。 请给出四人之间的同步关系，并用 操作实现四人 请给出四人之间的同步关系，并用PV操作实现四人 正确活动的程序。 正确活动的程序。
用信号量解决“生产者 消费者 生产者-消费者 用信号量 生产者 消费者”问 题
semaphore mutex =1; semaphore empty = n; semaphore full = 0; int i,j; ITEM buffer[n]; ITEM data_p, data_c;
void producer() //生产者进程 void consumer()//消费者进程 生产者进程 消费者进程 {while (true) {while (true) {produce an item in data_p; { P(full); P(empty); P(mutex); P(mutex); data_c = buffer[j]; buffer[i] = data_p; j = (j + 1) % n; i = (i + 1) % n; V(mutex); V(mutex); V(empty); V(full);} consume the item in data_c;} } }
进程同步问题实例
P(Sa);
从plate中取苹果;
V(S); 吃苹果；
18
16
5 吃水果问题
桌上有一空盘，允许存放一只水果。爸爸向盘中放苹 果，妈妈向盘中放桔子，儿子专等吃盘中的桔子，女 儿专等吃盘中的苹果。规定当盘空时一次只能放一只 水果供吃者取用，请用P、V原语实现爸爸、妈妈、儿 子、女儿三个并发进程的同步。
爸爸 儿子
plate
妈妈 女儿
17
5 吃水果问题
应设置三个信号量S、So、Sa，信号量S表示盘子是否为空，其初值 为1；信号量So表示盘中是否有桔子，其初值为0；信号量Sa表示盘 中是否有苹果，其初值为0。同步描述如下：
} while (1);
do { wait(full); wait(mutex); … remove an item from buffer to nextc … signal(mutex); signal(empty); … consume the item in nextc …
} while (1);
Semaphor S=1, So=Sa=0;
Process father: Process mother: Process son:
Process daughter:
P(S);
把苹果放入plate;
V(So);
P(S);
把橘子放入plate;
V(Sa);
P(So);
从plate中取橘子;
V(S); 吃橘子；
8
2 缓冲区问题(生产者-消费者问题)
三个进程P1、P2、P3 互斥使用一个包含N(N>0)个单 元的缓冲区。P1 每次用produce()生成一个正整数并 用put()送入缓冲区某一个空单元中；P2 每次用 getodd()从该缓冲区中取出一个奇数并用countodd() 统计奇数个数；P3 每次用geteven()从该缓冲区中取 出一个偶数并用counteven()统计偶数个数。请用信号 量机制实现这三个进程的同步与互斥活动，并说明所 定义的信号量的含义。要求用伪代码描述。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
附件1：学号：012课程设计题目进程同步模拟设计--吃水果问题学院计算机科学与技术学院专业计算机科学与技术专业班级计算机姓名指导教师2011 年01 月19 日课程设计任务书学生：专业班级：指导教师：作单位：计算机科学与技术学院题目: 进程同步模拟设计——吃水果问题初始条件：1．预备容：阅读操作系统的进程管理章节容，对进程的同步和互斥，以及信号量机制度有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟吃水果的同步模型：桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
2．设计报告容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；v）对实验题的评价和改进意见，请你推荐设计题目。
时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，一律按0分记）指导教师签名：年月日系主任（或责任教师）签名：年月日进程同步模拟设计——吃水果问题1需求分析1.1吃水果问题的描述桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
1.2问题的转换这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。
通过编程实践时，实际是随机的调用人一个进程的操作，而这些进程的操作相当于程序中的函数调用。
而计算机在执行时每一个时刻只能执行一个操作，这就默认了互斥。
同步的模拟可以类似于函数调用时的前提关系即先决条件。
这样进程同步模拟就完全可以通过函数的调用来实现。
具体的每一个操作的对应的函数的关系：爸爸向盘子中放一个苹果：Father()妈妈向盘子中放一个橘子：Mother()儿子1从盘子取一个橘子：Son1()儿子2从盘子取一个橘子：Son2()女儿1从盘子取一个橘子：Daugther1()儿子1从盘子取一个橘子：Daugther2()2功能设计2.1 数据结构(1)用一个整型变量Plate_Size表示盘子，初始值为0，当放水果时Plate_Size加1，取水果时Plate_Size减1。
变量Plate_Size的最大值为2，当为2时表示盘子已经满，此时若进行放水果操作，放水果将处于等待状态；为0时表示盘子为空，此时若进行取水果操作，取水果操作将处于等待状态。
(2)整型变量orange和apple分别表示盘子中的橘子和苹果数目，初始都为0，Plate_Size=apple+orange。
(3)用6个bool型的变量Father_lag，Mother_lag，Son1_lag，Son2_lag，Daughter1_lag，Daughter2_lag表示六个进程是否处于等待状态。
处于等待时，变量值为true。
(4)两个放水果进程进程同时处于等待状态时，若有取水果的操作将自动执行等待的放水果进程，执行按等待的先后顺序；两个取苹果或橘子进程同时候处于等待状态，若有放苹果或橘子的操作将自动执行等待的取进程，进行按等待的先后顺序。
(5)用一个随机的函数产生0—5的6个整数，分别对应六个进程的调用。
2.2模块说明2.1.1 主函数用一个随机的函数产生0—5的6个整数，分别对应六个进程的调用，调用的次数可以自己输入，本程序共产生了10次随机的调用进程。
2.1.2 6个进程函数爸爸向盘子中放一个苹果操作：Father()妈妈向盘子中放一个橘子操作：Mother()儿子1从盘子取一个橘子操作：Son1()儿子2从盘子取一个橘子操作：Son2()女儿1从盘子取一个橘子操作：Daugther1()女儿2从盘子取一个橘子操作：Daugther2()2.1.3 Print函数用于输出盘子中苹果和橘子的个数，水果总个数及有哪些进程处于等待状态。
2.3 操作的流程图2．3．1放水果操作爸爸放苹果进程的操作流程图：2．3．2取水果操作儿子1取橘子的操作流程图3开发平台及源程序的主要部分3.1开发平台（1）使用系统：Ｗindows XP（2）使用语言：C++（3）开发工具：Visual C++ 6.03.2源程序3.2.1各进程调用的函数void Father() //Father进程{apple++;Print();}void Mother() //Mother进程{orange++;Print();}void Son1() //Son1进程{orange--;Print();}void Son2() //Son2进程{orange--;Print();}void Daughter1() //Daughter1进程{apple--;Print();}void Daughter2() //Daughter2进程{apple--;Print();}3.2.2 Print函数（打印盘子剩余水果及各进程等待状态）void Print(){cout<<"现在盘子里有"<<apple<<"个苹果,"<<orange<<"个橘子,"<<"共有"<<apple+orange<<"个水果."<<endl;if(Father_lag==true)cout<<"Father进程处于等待状态,";if(Mother_lag==true)cout<<"Mother进程处于等待状态,";if(Son1_lag==true)cout<<"Son1进程处于等待状态,";if(Son2_lag==true)cout<<"Son2进程处于等待状态, ";if(Daughter1_lag==true)cout<<"Daughter1进程处于等待状态,";if(Daughter2_lag==true)cout<<"Daughter2进程处于等待状态,";if(((Father_lag==false)&&(Mother_lag==false)&&(Son1_lag==false)&&(Son2_ lag==false)&&(Daughter1_lag==false)&&(Daughter2_lag==false))!=true) cout<<endl;}3.2.3主函数int k;srand((unsigned)time(NULL));//srand()函数产生一个以当前时间开始的随机种子for(k=0;k<10;k++){cout<<"第"<<k+1<<"次操作:"<<endl;i=rand()%6; //随进生成1—5.Plate_Size=apple+orange;switch(i){case 0:cout<<"Father调用."<<endl;if(Plate_Size==2){Father_lag=true;//Father()等待Print();if(Mother_lag==false)MonFa_c=1;}else{Father();if((Daughter1_lag==true)&&(Daughter2_lag==true)){if(Daughter_b==1){Daughter1_lag=false;//Daughter1等待取消cout<<"处于等待的Daughter1自动被调用"<<endl;Daughter1(); //处于等待的Daughter1自动调用Daughter_b=2;}else{Daughter2_lag=false;//Daughter2等待取消cout<<"处于等待的Daughter2自动被调用"<<endl;Daughter2(); //处于等待的Daughter2()自动调用Daughter_b=1;}}else{if(Daughter1_lag==true){Daughter1_lag=false;//Daughter1等待取消cout<<"处于等待的Daughter1自动被调用"<<endl;Daughter1(); //处于等待的Daughter1()自动调用Daughter_b=0;}else if(Daughter2_lag==true){Daughter2_lag=false;//Daughter2等待取消cout<<"处于等待的Daughter1自动被调用"<<endl;Daughter2(); //处于等待的Daughter2()自动调用Daughter_b=0;}}}break;case 1:cout<<"Mother调用."<<endl;if(Plate_Size==2){Mother_lag=true; //等待Print();if(Father_lag==false)MonFa_c=2;}else{Mother();if((Son1_lag==true)&&(Son2_lag==true)){if(Son_a==1){Son1_lag=false;//Son1等待取消cout<<"处于等待的Son1自动被调用"<<endl;Son1(); //处于等待的Son1()自动调用Son_a=2;}else{Son2_lag=false;//Son2等待取消cout<<"处于等待的Son2自动被调用"<<endl;Son2(); //处于等待的Son2()自动调用Son_a=1;}}else{if(Son1_lag==true){Son1_lag=false; //Son1等待取消cout<<"处于等待的Son1自动被调用"<<endl;Son1(); //处于等待的Son1()自动调用Son_a=0;}else if(Son2_lag==true){Son2_lag=false; //Son2等待取消cout<<"处于等待的Son2自动被调用"<<endl;Son2(); //处于等待的Son2()自动调用Son_a=0;}}}break;case 2:cout<<"Son1调用."<<endl;if(orange==0){Son1_lag=true; //Son1处于等待Print();if(Son2_lag==false)Son_a=1; //用于判断Son1和Son2等待的先后性}else{Son1();if((Father_lag==true)&&(Mother_lag==true)){if(MonFa_c==1) //Father和Mother同时处于等待，但Father先等待，因此先调用{Father_lag=false;cout<<"处于等待的Father自动被调用"<<endl;Father();MonFa_c=2;}Else //Father和Mother同时处于等待，但Mother先等待，因此先调用{Mother_lag=false;cout<<"处于等待的Mother自动被调用"<<endl;Mother();MonFa_c=1;}}else{if(Father_lag==true) //只有Father处于等待，调用{Father_lag=false;cout<<"处于等待的Father自动被调用"<<endl;Father();MonFa_c=0;}else if(Mother_lag==true)//只有Mother处于等待，调用{Mother_lag=false;cout<<"处于等待的Mother自动被调用"<<endl;Mother();MonFa_c=0;}}}break;case 3:cout<<"Son2调用."<<endl;i f(orange==0){Son2_lag=true; //Son2处于等待Print();if(Son1_lag==false)Son_a=2;}else{Son2();if((Father_lag==true)&&(Mother_lag==true)){if(MonFa_c==1)//Father和Mother同时处于等待，但Father先等待，因此先调用{Father_lag=false;cout<<"处于等待的Father自动被调用"<<endl;Father();MonFa_c=2;}else //Father和Mother同时处于等待，但Mother先等待，因此先调用{Mother_lag=false;cout<<"处于等待的Mother自动被调用"<<endl;Mother();MonFa_c=1;}else{if(Father_lag==true) //只有Father处于等待，调用{Father_lag=false;cout<<"处于等待的Father自动被调用"<<endl;Father();MonFa_c=0;}else if(Mother_lag==true) //只有Mother处于等待，调用{Mother_lag=false;cout<<"处于等待的Mother自动被调用"<<endl;Mother();MonFa_c=0;}}}break;case 4:cout<<"Daughter1调用."<<endl;if(apple==0){Daughter1_lag=true; //Daughter1等待Print();if(Daughter2_lag==false)Daughter_b=1;}{Daughter1();if((Father_lag==true)&&(Mother_lag==true)){if(MonFa_c==1) //Father和Mother同时处于等待，但Father先{ //等待，因此先调用Father_lag=false;cout<<"处于等待的Father自动被调用"<<endl;Father();MonFa_c=2;}else //Father和Mother同时处于等待，但Mother先等待，因此先调用{Mother_lag=false;cout<<"处于等待的Mother自动被调用"<<endl;Mother();MonFa_c=1;}}else{if(Father_lag==true) //只有Father处于等待，调用{Father_lag=false;cout<<"处于等待的Father自动被调用"<<endl;Father();MonFa_c=0;}else if(Mother_lag==true) //只有Mother处于等待，调用{Mother_lag=false;cout<<"处于等待的Mother自动被调用"<<endl;Mother();MonFa_c=0;}}}break;case 5:cout<<"Daughter2调用."<<endl;if(apple==0){Daughter2_lag=true; //Daughter2等待Print();if(Daughter1_lag==false)Daughter_b=2;}else{Daughter2();if((Father_lag==true)&&(Mother_lag==true)){if(MonFa_c==1) //Father和Mother同时处于等待，但Father先等待，因此先调用{Father_lag=false;cout<<"处于等待的Father自动被调用"<<endl;Father();MonFa_c=2;}else //Father和Mother同时处于等待，但Mother先等待，因此先调用{ Mother_lag=false;cout<<"处于等待的Mother自动被调用"<<endl;Mother();MonFa_c=1;}}else{if(Father_lag==true) //只有Father处于等待，调用{ Father_lag=false;cout<<"处于等待的Father自动被调用"<<endl;Father();MonFa_c=0;}else if(Mother_lag==true) //只有Mother处于等待，调用{ Mother_lag=false;cout<<"处于等待的Mother自动被调用"<<endl;Mother();MonFa_c=0;}}}break;}4测试用例，运行结果与运行情况分析4.1测试用例由于程序是模拟产生10次随机的操作，执行相应的函数来模拟进程同步。