操作系统课程设计吃水果问题完整
吃水果问题
实习一进程同步
一、实习内容
模拟进程同步。
二、实习目的
本实习要求学生理解进程同步的概念和进程同步技术——信号量机制。
三、实习题目
编写一个程序，模拟“吃水果问题”。
问题描述：桌上有一个盘子，每次只能放一个水果，爸爸专向盘中放苹果，妈妈专向盘中放橘子，儿子专等吃盘里的橘子，女儿专等吃盘里的苹果。
只要盘子空，爸爸妈妈可向盘中放水果，仅当盘中有自己需要的水果时，儿子或女儿可从中取出，请用信号量及PV操作模拟四人的同步关系。
提示：
（1）信号量和P、V(semwait&semsignal)操作原语自己定义，在保证该对原语原有意义的基础上，也可添加新内容（模拟的需要，结合提示（5）思考）；
（2）4人分别是4个进程，每个进程的程序可由一个函数模拟；
其中，
进程名——作为进程的标识，自己定义。
状态——有两种状态，“就绪”和“阻塞”，初始状态都为“就绪”，用“R”表示。
当一个进程阻塞后，它的状态为“阻塞”，用“B”表示。
（3）当前执行哪个进程可由随机函数决定，若该进程当前是阻塞的，则打印“该进程阻塞”提示；否则，执行该进程程序；
（4）取、放水果的操作可用打印语句的方式替代；
（5）当一个阻塞态进程被唤醒成为就绪态，然后，再次被选中执行时，应从P原语的下一个语句开始执行。
这该怎么控制？想办法解决（结合提示（1）思考）。
注意：
信号量的设置和初值；
程序应有提示，界面友好!
用循环队列存阻塞队列和就绪队列。
进程同步模拟设计--吃水果问题
附件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问题的转换这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。
进程同步模型系统的设计—吃水果
课程设计课程设计任务书学生： 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个函数，来实现真正的操作。
技工院--苹果-桔子问题的实现
《操作系统》课程设计任务书题目：苹果-桔子问题的实现学生姓名：班级：物联网工程1班学号：指导教师：张清/贾娟娟一、设计目的学生通过该题目的设计过程，掌握进程同步问题的原理、软件开发方法并提高解决实际问题的能力。
二、设计内容1、了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序。
2、编写程序实现苹果-桔子问题。
桌上有一个空盘子，只允许放一个水果。
爸爸专向盘中放苹果，妈妈专向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。
规定当盘空时，一次只能放一个水果。
三、设计要求及工作量1、分析设计要求，给出解决方案（要说明设计实现所用的原理、采用的数据结构）。
2、设计合适的测试用例，对得到的运行结果要有分析。
3、设计中遇到的问题，设计的心得体会。
4、文档：课程设计打印文档每个学生一份，并装在统一的资料袋中。
5、光盘：每个学生的文档和程序资料建在一个以自己学号和姓名命名的文件夹下，刻录一张光盘，装入资料袋中。
四、要提交的成果1. 设计说明书一份，内容包括：1) 中文摘要100字；关键词3-5个；2) 设计思想；3）各模块的伪码算法；4）函数的调用关系图；5）测试结果；6）源程序（带注释）；7）设计总结；8) 参考文献、致谢等。
2. 刻制光盘一张。
五、设计进度计划及时间安排六、主要参考资料1.汤子瀛，哲凤屏.《计算机操作系统》.西安电子科技大学学出版社.2.王清，李光明.《计算机操作系统》.冶金工业出版社.3.孙钟秀等. 操作系统教程. 高等教育出版社4.曾明. Linux操作系统应用教程. 陕西科学技术出版社.5. 张丽芬，刘利雄.《操作系统实验教程》. 清华大学出版社.6. 孟静，操作系统教程－－原理和实例分析. 高等教育出版社7. 周长林，计算机操作系统教程. 高等教育出版社8. 张尧学，计算机操作系统教程，清华大学出版社9.任满杰，操作系统原理实用教程，电子工业出版社10.张坤.操作系统实验教程，清华大学出版社目录1.绪论 (1)1.1设计任务 (1)1.2设计思想 (1)1.3基础知识 (1)2.各模块伪码算法 (3)2.1父亲进程模块 (3)2.2母亲进程模块 (5)2.3儿子进程模块 (7)2.4女儿进程模块 (9)2.5Print函数 (11)3. 函数调用关系图 (14)3.1函数调用图........................................ 错误！未定义书签。
操作系统-吃水果问题
操作系统-吃水果问题操作系统-吃水果问题1、引言本文档描述了一个操作系统的模拟问题-吃水果问题。
该问题涉及到多个进程同时对有限数量的水果资源进行访问的情况。
我们将介绍该问题的背景、目标和关键概念。
2、背景吃水果问题模拟了现实生活中多个进程同时访问共享资源的情况。
在该问题中，不同的进程可以同时访问一定数量的水果资源。
然而，由于水果资源有限，进程必须遵守特定的规则以确保公平访问。
3、目标该问题的目标是设计一种算法，使得不同的进程能够共享有限的水果资源。
我们的目标是确保进程之间的公平访问，并通过合适的同步机制来避免产生竞争条件和死锁。
4、关键概念4.1 进程(Process)进程是计算机中正在运行的程序的实例。
在吃水果问题中，每个进程代表一个人，这些人需要同时访问共享的水果资源。
4.2 共享资源(Shared Resource)共享资源是多个进程可能同时访问的资源。
在吃水果问题中，水果资源是共享资源，被多个进程同时竞争。
4.3 同步机制(Synchronization Mechanism)同步机制用于控制多个进程对共享资源的访问。
在吃水果问题中，我们需要设计一种同步机制来确保进程之间的公平访问和避免竞争条件。
5、解决方案5.1 问题分析首先，我们需要确定问题的规模和要求。
包括进程数量、水果资源数量以及对公平访问的要求等。
5.2 同步机制设计我们可以采用多种同步机制来解决吃水果问题，例如互斥锁、条件变量等。
在设计同步机制时，需要考虑到公平性、死锁避免和性能等方面的因素。
5.3 算法实现根据设计的同步机制，我们需要实现相应的算法来解决吃水果问题。
这个算法应该能够正确地控制进程对资源的访问，并满足公平访问和避免死锁的要求。
6、测试与调试在实现算法之后，我们需要进行测试和调试来确保算法的正确性和性能。
包括编写测试用例、模拟并发情况和调整参数等。
7、结论通过本文档，我们介绍了操作系统中的吃水果问题，并提供了解决该问题的解决方案。
000操作系统课设报告(进程控制-吃苹果)
在计算机系统中每个进程都可产生某些资源或消耗一定的资源，当其产生资源的时候其就作为生产者，当其消耗资源的时候其就变为消费者。但是这些进程在执行的过程中只能互斥的访问临界区，否则就会产生一些错误。为了避免这种情况的发生，就必须引入一些信号量来控制程序有序的执行。
{
char *addr, end;
int shmid;
int semid_empty, semid_full1,semid_full2, semid_mutex;
struct sembuf sem_tmp;
/*开辟共享存储区*/
if ((shmid = shmget(SHMKEY, BUFF_LEN * PRODUCT_LEN+3, 0777|IPC_CREAT|IPC_EXCL)) == -1)
{
if (errno == EEXIST)
{
printf("The Buffer Has Existed!\n");
printf("Do You Want To Delete The Buffer(Y = yes)?\n====:");
scanf("%c", &end);
if(end == 'y' || end == 'Y')
小结：linux下的命令当然是非常多，以上列出的只是我在这次课程设计中所用到一些命令。此外，在我们在使用过程中遇到一些生僻的命令时，我们可以应用互联网来搜索相应的功能。在知道相关命令，但是忘记具体操作的时候我们还可以通过命令--help的方式来查看该命令的具体操作用法，非常实用。
苹果-桔子问题的实现
《操作系统》课程设计任务书题目：苹果-桔子问题的实现学生姓名：学号：班级：11计算机科学与技术题目类型：软件工程（R）指导教师：一、设计目的学生通过该题目的设计过程，掌握进程同步问题的原理、软件开发方法并提高解决实际问题的能力。
二、设计任务1、了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序。
2、编写程序实现苹果-桔子问题。
桌上有一个空盘子，只允许放一个水果。
爸爸专向盘中放苹果，妈妈专向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。
规定当盘空时，一次只能放一个水果。
三、设计要求1、分析设计要求，给出解决方案（要说明设计实现所用的原理、采用的数据结构）。
2、设计合适的测试用例，对得到的运行结果要有分析。
3、设计中遇到的问题，设计的心得体会。
4、文档：课程设计打印文档每个学生一份，并装在统一的资料袋中。
5、光盘：每个学生的文档和程序资料建在一个以自己学号和姓名命名的文件夹下，刻录一张光盘，装入资料袋中。
四、提交的成果1. 设计说明书一份，内容包括：1) 中文摘要100字；关键词3-5个；2) 设计思想；3）各模块的伪码算法；4）函数的调用关系图；5）测试结果；6）源程序（带注释）；7）设计总结；8) 参考文献、致谢等。
2. 刻制光盘一张。
五、主要参考文献1. 汤子瀛，哲凤屏.《计算机操作系统》.西安电子科技大学学出版社.2. 王清，李光明.《计算机操作系统》.冶金工业出版社.3.孙钟秀等. 操作系统教程. 高等教育出版社4.曾明. Linux操作系统应用教程. 陕西科学技术出版社.5. 张丽芬，刘利雄.《操作系统实验教程》. 清华大学出版社.6. 孟静，操作系统教程－－原理和实例分析. 高等教育出版社7. 周长林，计算机操作系统教程. 高等教育出版社8. 张尧学，计算机操作系统教程，清华大学出版社9.任满杰，操作系统原理实用教程，电子工业出版社10.张坤.操作系统实验教程，清华大学出版社六、各阶段时间安排（共2周）2013年12月9日。
水果盘问题
山西大学课程实验报告实验课程操作系统实验实验名称操作系统模拟程序设计（4）实验地点自动化与软件学院中心机房实验时间第七周第七节到第八节学生班级学生学号学生姓名指导教师2020 年 10 月 21 日实验题目：水果盘问题桌子上有一只盘子，只能容纳一个水果，每次只能放入或取出一个水果，爸爸专往盘子里放苹果。
妈妈专往盘子里放橘子，儿子专门等待吃盘子中的橘子，女儿专门等待吃盘子中的水果。
设计思路或流程图1.分析是否存在共享数据的问题？水果盘问题存在共享数据，在同一个时刻，只能有一个线程对水果盘中的水果进行操作，爸爸，妈妈放水果（爸爸放苹果，妈妈放橘子），儿子和女儿取水果（儿子取橘子，女儿取实验源程序加注释：package jihe;/*** @author moran* @create 2020-12-02-15:21*/import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/*水果盘问题*/class Plant{private int apple=0;private int orange=0;private int fruit=0;Lock lock = new ReentrantLock(); // 锁对象Condition fmther_lock = lock.newCondition();// 爸妈监视器Condition son_lock = lock.newCondition(); // 儿子监视器Condition daughter_lock = lock.newCondition(); // 女儿监视器public void FatherProcess() {lock.lock();while(fruit==1) {// System.out.println("爸爸线程阻塞");try {fmther_lock.await();} catch (InterruptedException e) {e.printStackTrace();}}while(fruit==0){fruit++;apple++;System.out.println(Thread.currentThread().getName()+":放苹果...");// lock.unlock();daughter_lock.signal();//System.out.println("女儿线程被唤醒....");}lock.unlock();}public void MotherProcess() {lock.lock();while (fruit == 1) {//System.out.println("妈妈线程阻塞");try {fmther_lock.await();//System.out.println("妈妈线程阻塞");} catch (InterruptedException e) {e.printStackTrace();}}while (fruit == 0) {fruit++;orange++;System.out.println(Thread.currentThread().getName() + ":放桔子...");//lock.unlock();son_lock.signal();//System.out.println("儿子线程被唤醒....");}lock.unlock();}public void SonProcess () {lock.lock();while (orange == 0) {// System.out.println("儿子线程阻塞");try {son_lock.await();} catch (InterruptedException e) {e.printStackTrace();}}while (orange==1) {System.out.println(Thread.currentThread().getName() + ":取桔子...");fruit--;orange--;// lock.unlock();fmther_lock.signal();//System.out.println("爸爸妈妈线程被唤醒....");}lock.unlock();}//创建女儿线程public void DaughterProcess() {lock.lock();while (apple == 0) {//当盘中没有苹果// System.out.println("女儿线程阻塞");try {daughter_lock.await();//唤醒女儿监视器，女儿进程阻塞// System.out.println("女儿线程阻塞");} catch (InterruptedException e) {e.printStackTrace();}}//当盘中有苹果while (apple == 1) {System.out.println(Thread.currentThread().getName() + ":取苹果...");fruit--;apple--;fmther_lock.signal();//System.out.println("爸爸妈妈线程被唤醒....");}lock.unlock();}}//用继承Thread的方法处理多线程问题class Father extends Thread{private Plant plant;public Father(Plant plant){this.plant=plant;}@Overridepublic void run() {while(true){//System.out.println(getName()+":开始放苹果");plant.FatherProcess();//调用爸爸线程}}}class Mother extends Thread{private Plant plant;public Mother(Plant plant){this.plant=plant;}@Overridepublic void run() {while(true){System.out.println(getName()+":开始放桔子");plant.MotherProcess();//调用妈妈线程}}}class Son extends Thread{private Plant plant;public Son(Plant plant){this.plant=plant;}public void run() {while(true){System.out.println(getName()+":开始取桔子");plant.SonProcess();//调用儿子线程}}}class Daughter extends Thread{private Plant plant;public Daughter(Plant plant){this.plant=plant;}public void run() {while(true){System.out.println(getName()+":开始取苹果");plant.DaughterProcess();//调用女儿线程}}}public class FruitTest {public static void main(String[] args) {Plant p=new Plant();Father f=new Father(p);Mother m=new Mother(p);Son s=new Son(p);Daughter d=new Daughter(p);f.setName("爸爸");//给线程命名m.setName("妈妈");s.setName("儿子");d.setName("女儿");f.start();//调用start函数开启线程m.start();s.start();d.start();}实验测试结果记录：1.测试结果一2.测试结果二实验成果总结：1.实现了本实验所要求的基本功能。
进程吃水果
西华大学上机实践报告课程名称：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. 父母或孩子的行为可以用定时器消息来完成。
苹果-桔子问题的实现（2）
*******************实践教学*******************兰州理工大学计算机与通信学院2013年秋季学期操作系统原理课程设计题目：苹果-桔子问题的实现专业班级：计算机科学与技术姓名：学号：指导教师：王旭阳成绩：_____________本设计实际上是生产者-消费者问题的一种变形。
这里，生产者（父亲和母亲）放入缓冲区（盘子）的产品有两类（苹果和桔子），消费者（女儿和儿子）也有两类，每类消费者只消费其中固定的一类产品。
生产者和消费者共享缓冲区，缓冲区中有空时，生产者可放入产品（不许放重），否则等待。
缓冲区中有产品时，消费者可取出产品（不许取重），否则等待。
关键词：进程同步；PV操作；互斥；信号量摘要 (I)第一章需求分析 (1)1.1吃水果问题的描述 (1)1.2问题的转换 (1)第二章功能设计 (1)2.1 数据结构 (1)2.2模块说明 (2)2.2.1 主函数 (2)2.2.2 4个调度进程函数 (2)2.3 操作的流程图 (3)2．3．1放水果操作 (3)2．3．2取水果操作 (5)2.4 P、V原语的描述 (5)第3章各模块的伪码算法 (7)3.1 算法设计 (7)3.1.1 父亲进程模块 (7)3.1.2 母亲进程模块 (7)3.1.3 儿子进程模块 (8)3.1.5 Print函数 (8)第4章开发平台及程序清单的主要部分 (9)4.1开发平台 (9)第5章运行结果与运行情况分析 (11)5.1运行结果 (11)课程设计总结 (13)参考文献 (14)附录：部分源程序代码 (15)第一章需求分析1.1吃水果问题的描述桌上有一个空盘子，只允许放一个水果。
爸爸专向盘中放苹果，妈妈专向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。
规定当盘空时，一次只能放一个水果。
1.2问题的转换这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。
进程同步模型系统的设计吃水果样本
课程设计课程设计任务书学生姓名： 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个函数，来实现真正操作。
猴子吃桃问题数据结构课程设计
一、设计题目猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
二、运行环境（软、硬件环境）VC++6.0 PC电脑一台三、算法的需求分析1) 采用数组数据结构实现上述求解2) 采用链数据结构实现上述求解3) 采用递归实现上述求解4) 如果采用4种方法者,适当加分//用户界面int Desk(int n){printf("**************************************************\n");printf("| 欢迎进入猴子吃桃子系统|\n");printf("| 1-数组法2-链表法3-递归法4-二叉树法5-退出|\n");printf("***************************************************\n");printf("请输入要选择的方法: ");scanf("%d",&n);getchar();system("cls"); //刷新屏幕while(n<1 || n>5){printf("***输入错误! 请重新输入***\n");scanf("%d",&n);}return n;}四、算法概要设计//采用链数据结构 (栈) 实现上述求解typedef struct{int *top;int *base;}stack;//初始化一个栈stack Init(stack *s){s->base=(int *)malloc(STACK_SIZE*sizeof(int));if(s->base == NULL){printf("Init failed !\n");exit(-1);}s->top = s->base;return *s;}//二叉树创建一个大小为DAYS(由用给出)的二叉树,二叉树的左孩子节点存放当天的桃子数，右节点存放数字1，即为多吃的一个桃子。
操作系统中经典的水果问题
操作系统中经典的水果问题首先写下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。
苹果-桔子问题
*******************实践教学*******************兰州理工大学计算机与通信学院2009年秋季学期操作系统原理课程设计题目：苹果-桔子问题的实现专业班级：计算机（2）班姓名：邢博文学号：07240214指导教师：王旭阳成绩：_______________摘要 (2)正文 (3)1．问题描述 (3)2．设计目的 (4)3．设计要求 (5)4．详细设计 (6)5．结果分析 (12)设计总结 (13)参考文献 (14)致谢 (15)附录：源程序代码 (16)本设计实际上是生产者-消费者问题的一种变形。
这里，生产者（父亲和母亲）放入缓冲区（盘子）的产品有两类（苹果和桔子），消费者（女儿和儿子）也有两类，每类消费者只消费其中固定的一类产品。
生产者和消费者共享缓冲区，缓冲区中有空时，生产者可放入产品（不许放重），否则等待。
缓冲区中有产品时，消费者可取出产品（不许取重），否则等待。
关键词：进程同步，PV操作，互斥，信号量1．问题描述桌上有一个空盘子，只允许放一个水果。
爸爸专向盘中放苹果，妈妈专向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。
规定当盘空时，一次只能放一个水果。
学生通过该题目的设计过程，可以掌握生产者与消费者问题、软件开发方法并提高解决实际问题的能力。
各进程在执行过程中为合作完成一个共同的任务，需要协调步伐，交换信息。
并发进程在一些关键点上可能需要互相等待与互通消息，这种相互制约的等待与互通消息，称为进程同步。
利用信号量和PV操作实现进程同步，PV操作是典型的同步机制之一。
用一个信号量与一个消息联系起来，当信号量的值为0时，表示期望的消息尚未产生；当信号量的值非0时，表示期望的消息已经存在。
用PV操作实现进程同步时，调用P操作测试消息是否到达，调用V操作发送消息。
本题实际上是生产者-消费者问题的一种变形。
这里，生产者放入缓冲区的产品有两类，消费者也有两类，每类消费者只消费其中固定的一类产品。
苹果橘子问题
*******************实践教学*******************兰州理工大学计算机与通信学院2013年秋季学期操作系统原理课程设计题目：苹果—桔子问题的实现专业班级：姓名：学号：指导教师：成绩：摘要 (2)正文 (3)1.问题描述 (3)2.设计目的 (3)3.设计要求 (4)4.详细设计 (4)4.1界面设计 (4)4.2算法设计 (5)4.2.1数据结构 (5)4.2.2模块声明 (6)4.2.3算法设计 (6)4.3流程图 (8)5.结果分析 (12)设计总结 (16)参考文献 (17)致谢 (18)附录：源程序代码 (19)本设计实际是生产者—消费者的变形，是典型的进程同步问题。
本问题利用C语言实现相应的P、V原语。
主要过程可用生产消费者来模拟，这里，生产者（父亲和母亲）放入缓冲区（盘子）的产品有两类（苹果和桔子），消费者（女儿和儿子）也有两类，每类消费者只消费其中固定的一类产品。
生产者和消费者共享缓冲区，缓冲区中有空时，生产者可放入产品（不许放重），否则等待。
缓冲区中有产品时，消费者可取出产品（不许取重），否则等待。
关键字：进程同步，P、V操作，信号量1.问题描述桌上有一个空盘子，只允许放一个水果。
爸爸专向盘中放苹果，妈妈专向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。
规定当盘空时，一次只能放一个水果。
这个问题实际上是两个生产者和两个消费者被连接到仅能放一个产品的缓冲器上。
生产者各自生产不同的产品，但就其本质而言，他们是同一类生产者。
而消费者则各自去需要的产品消费，但消费的方式不同。
解决此类问题利用记录型信号量机制和P、V操作来实现进程同步。
进程同步是指一个进程的执行依赖于另一个进程的信号或消息，当一个进程没有得到来自与另一个进程的信号或消息时则等待，直到信号或消息到达才被唤醒。
2.设计目的本实验是典型的进程同步问题。
某些进程为了完成同一任务分工合作，由于合作的每一个进程都是独立的不可预知的推进，这就需要相互合作的进程在某些合作点上协调各自的工作。
操作系统课程设计报告—多进程同步橘子苹果问题
操作系统课程设计报告院（系）：计算机工程学院专业：计算机科学与技术专业学生姓名:＿＿班级：＿＿学号:题目：用多进程同步方法演示“桔子-苹果”问题____起迄日期:＿2012.07.02＿--2012.07.13＿____设计地点:现代教育中心指导教师:熊晓芸2011—2012年度第 2 学期完成日期: 2012 年 7 月 13 日一、课程设计目的本次实验进行操作系统课程设计的主要任务是模拟生产者和消费者的一个衍生，即实现“橘子-苹果问题”。
这个问题中有两个生产者，分别生产苹果核橘子，有两个消费者，分别消费橘子和苹果。
同时，因为两个生产者和两个消费者对同一个缓冲区进行操作，所以应互斥的访问缓冲区以保证程序的正确性。
本次实验的目的就是加深各个进程正确有效的对资源的访问，即同步和互斥。
同时掌握信号量在互斥访问中的使用。
掌握生产者和消费者问题的流程和实现方法。
同时提高编程的能力、对问题的解决能力及查阅文档的能力。
二、课程设计内容与要求1、通过研究Linux的进程同步机制和信号量，实现特殊的生产者与消费者问题的并发控制。
2、说明：有两类生产者，一类负责生产桔子，一类负责生产苹果；有两类消费者，一类负责消费桔子，一类负责消费苹果；他们共享一个有20个存储单元的有界缓冲区，每个存储单元只能放入一种产品（桔子/苹果）。
3、设计要求：1)二类生产者与二类消费者数目均为20，即20个生产者负责生产桔子，20个生产者负责生产苹果；20个消费者负责消费桔子，20个消费者负责消费苹果2)二类生产者的生产速度与二类消费者的消费速度均可独立在程序界面调节，在运行中，该值调整后立即生效3)多个生产者或多个消费者之间必须有共享对缓冲区进行操作的函数代码，同时需要考虑算法的效率性4)每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容、当前生产者与消费者的指针位置，以及生产者和消费者线程标识符5)采用可视化界面，可在运行过程中随时暂停，查看当前生产者、消费者以及有界缓冲区的状态三、系统分析与设计1、系统分析1.此次任务是实现特殊生产者和消费者的演示程序，所需要处理的信息是生产者和消费者的个数，生产苹果、橘子和消费苹果、橘子的速度控制，缓冲区中橘子和苹果的个数和当前生产、消费指针的位置。
猴子吃桃子问题数据结构课程设计
目录1、需求分析 (1)2、概要设计 (1)2.1.用数组数据结构实现上述求解 (1)2.2.用链数据结构实现上述求解 (1)2.3 用栈数据结构实现求解 (1)2.4 用递归实现上述求解 (2)3、运行环境 (2)3.1 硬件环境 (2)3.2软件环境 (2)4、详细设计 (2)4.1系统流程图 (2)4.2用数组数据结构实现上述求解 (3)4.3用链数据结构实现上述求解 (4)4.4用栈数据结构实现求解 (5)4.5用递归实现上述求解 (6)5、调试分析 (7)6、运行结果 (7)课程设计总结 (8)参考文献 (9)附录： (9)1、需求分析1、猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
要求：1) 采用数组数据结构实现上述求解2) 采用链数据结构实现上述求解3) 采用栈实现上述求解4) 采用递归实现上述求解2、概要设计2.1.用数组数据结构实现上述求解在taozi函数中定义一个一维数组，分别存储每天的桃子个数，根据题目的内容找出各个数之间的关系，用数组元素表示出来，根据用户输入要计算哪一天的桃子，用for循环控制结束。
在main函数中让用户输入要计算的哪一天，调用taozi 函数，以便用户可查出任意一天的桃子个数，用switch语句判断用户要执行的功能，然后用while循环控制，直到用户输入0为止。
2.2.用链数据结构实现上述求解先写出预定义常量和类型，写出结点的类型定义，创建结点，初始化链表，定义变量并初始化，找出结点与其后继结点之间的联系，然后在主函数中控制。
2.3 用栈数据结构实现求解本部分包括预定义常量和类型，顺序栈的定义，InitStack函数，Push函数，和main函数，在InitStack函数构造一个空栈，在Push函数中调用该函数，并在其中编写控制栈顶指针和栈底指针移动的语句，找出指针所指向的数据之间的关系，在main函数中编写控制循环结束的语句，最后再用main函数去调用Push函数。
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完成了⼀次取吃的操作....。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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--;
Print();
}
void Daughter1() //Daughter1进程
{
apple--;
Print();
}
void Daughter2() //Daughter2进程
{
apple--;
Print();
}
void main()
{
int i;
int Plate_Size;//水果数量
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<<endl;
Mother();
MonFa_c=0;
}
}
}
break;
case 3:
cout<<" Son2调用."<<endl;
if(orange==0)
{
Son2_lag=true; //Son2处于等待
Print();
{
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处于等待，调用
具体的每一个操作的对应的函数的关系：
爸爸向盘子中放一个苹果：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时表示盘子为空，此时若进行取水果操作，取水果操作将处于等待状态。
for(k=0;k<10;k++)
{
cout<<endl;
cout<<"***********************************"<<"第"<<k+1<<"次操作"<<"***********************************"<<endl;
i=rand()%6; //随进生成1-5.
Daughter1(); //处于等待的Daughter1自动调用
Daughter_b=2;
}
else
{
Daughter2_lag=false;//Daughter2等待取消
cout<<"处于等待的Daughter2自动被调用"<<endl;
Daughter2(); //处于等待的Daughter2()自动调用
if(Father_lag==true)
cout<<" Father进程处于等待状态,"<<endl;
if(Mother_lag==true)
cout<<" Mother进程处于等待状态,"<<endl;
if(Son1_lag==true)
cout<<" Son1进程处于等待状态,"<<endl;
if(Son2_lag==true)
}
else
{
Father();
if((Daughter1_lag==true)&&(Daughter2_lag==true))
{
if(Daughter_b==1)
{
Daughter1_lag=false;//Daughter1等待取消
cout<<"处于等待的Daughter1自动被调用"<<endl;
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先等待，因此先调用
{
if(Son_a==1)
{
Son1_lag=false;//Son1等待取消
cout<<"处于等待的Son1自动被调用"<<endl;
Son1(); //处于等待的Son1()自动调用
Son_a=2;
}
else
{
Son2_lag=false;//Son2等待取消
cout<<"处于等待的Son2自动被调用"<<endl;
Daughter_b=1;
}
}
else
{
if(Daughter1_lag==true)
{
Daughter1_lag=false;//Daughter1等待取消
cout<<"处于等待的Daughter1自动被调用"<<endl;
Daughter1(); //处于等待的Daughter1()自动调用
Daughter_b=0;
{
Mother_lag=false;
}
else if(Daughter2_lag==true)
{
Daughter2_lag=false;//Daughter2等待取消
cout<<"处于等待的Daughter1自动被调用"<<endl;
Daughter2(); //处于等待的Daughter2()自动调用
Daughter_b=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。
{
Son2_lag=false; //Son2等待取消
cout<<"处于等待的Son2自动被调用"<<endl;
Son2(); //处于等待的Son2()自动调用
Son_a=0;
}
}
}
break;
case 2:
cout<<" Son1调用."<<endl;
if(orange==0)