进程同步模拟吃水果操作系统课程设计.docx
《进程同步模拟吃水果操作系统课程设计.docx》由会员分享，可在线阅读，更多相关《进程同步模拟吃水果操作系统课程设计.docx（25页珍藏版）》请在冰点文库上搜索。
进程同步模拟吃水果操作系统课程设计
某某大学
课程设计报告
课程名称：
操作系统课程设计
设计题目：
进程同步模拟吃水果问题
系别：
计算机系
专业：
计算机科学与技术
组别：
学生姓名:
学号:
起止日期:
指导教师:
指导教师评语：
指导教师签名：
年月日
成绩评定
项目
权重
成绩
1、设计过程中出勤、学习态度等方面
0.1
2、设计技术水平
0.4
3、安全程度及可操作程度
0.2
4、设计报告书写及图纸规范程度
0.3
总成绩
教研室审核意见：
教研室主任签字：
年月日
教学院（系）审核意见：
主任签字：
年月日
目录
第一章需求分析1
1.1问题概述1
1.2任务分析1
1.3设计思路1
1.4运行环境1
第二章概要设计2
2.1数据结构2
2.2模块说明2
2.2.1主函数2
2.2.26个进程函数2
2.3操作的流程图3
第三章详细设计4
3.1定义类4
3.2定义各个过程5
3.3定义Print（）函数5
3.4主函数6
第四章调式和操作说明13
4.1测试用例13
4.2运行结果14
第五章总结和体会15
参考文献：
15
致谢：
15
第一章需求分析
1.1问题概述
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
1.2任务分析
1．模拟吃水果的同步模型：
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
2．设计报告内容要求：
模拟吃水果问题，实现进程的同步操作；
给出实现方案（包括数据结构和模块说明等）；画出程序的基本结构框图和流程图；分析说明每一部分程序的的设计思路；实现源代码；
按期提交完整的程序代码和可执行程序；根据要求完成课程设计报告。
1.3设计思路
这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。
通过编程实践时，实际是随机的调用人一个进程的操作，而这些进程的操作相当于程序中的函数调用。
而计算机在执行时每一个时刻只能执行一个操作，这就默认了互斥。
同步的模拟可以类似于函数调用时的前提关系即先决条件。
这样进程同步模拟就完全可以通过函数的调用来实现。
具体的每一个操作的对应的函数的关系：
爸爸向盘子中放一个苹果：
Father（）
妈妈向盘子中放一个橘子：
Mother（）
儿子1从盘子取一个橘子：
Son1（）
儿子2从盘子取一个橘子：
Son2（）
女儿1从盘子取一个橘子：
Daugther1（）
儿子1从盘子取一个橘子：
Daugther2（）
1.4运行环境
（1）：
硬件配置
个人计算机：
PⅢ500MHz以上/128M内存/10G硬盘
（2）：
软件配置
操作系统：
WindowsXP
开发软件:
VisualC++6.0
第二章概要设计
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.2.1主函数
用一个随机的函数产生0—5的6个整数，分别对应六个进程的调用，调用的次数可以自己输入，本程序共产生了10次随机的调用进程。
2.2.26个进程函数
爸爸向盘子中放一个苹果操作：
Father（）
妈妈向盘子中放一个橘子操作：
Mother（）
儿子1从盘子取一个橘子操作：
Son1（）
儿子2从盘子取一个橘子操作：
Son2（）
女儿1从盘子取一个橘子操作：
Daugther1（）
女儿2从盘子取一个橘子操作：
Daugther2（）
2.2.3Print函数
用于输出盘子中苹果和橘子的个数，水果总个数及有哪些进程处于等待状态。
2.3操作的流程图
图一放水果操作（放水果时父亲和母亲是随即进行）
图二吃水果的流程图（假如儿子1先）
第三章详细设计
3.1定义类
*//*classA
{
private:
intapple=0;
intorange=0;
public:
voidFather（）;
voidMother（）;
voidSon1（）;
voidSon2（）;
voidDaughter1（）;
voidDaughter2（）;
voidprint（）;
}
3.2定义各个过程
voidFather（）//Father进程
{
apple++;
Print（）;
}
voidMother（）//Mother进程
{
orange++;
//Print（）;
}
voidSon1（）//Son1进程
{
orange--;
//Print（）;
}
voidSon2（）//Son2进程
{
orange--;
//Print（）;
}
voidDaughter1（）//Daughter1进程
{
apple--;
//Print（）;
}
voidDaughter2（）//Daughter2进程
{
apple--;
//Print（）;
}
3.3定义Print（）函数
voidPrint（）
{
cout<<"现在盘子里有"<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<}
3.4主函数
intmain（）
{
intk;
srand（（unsigned）time（NULL））;//srand（）函数产生一个以当前时间开始的随机种子
for（k=0;k<10;k++）
{inti;
cout<<"第"<"<i=rand（）%6;//随进生成1-5.
Plate_Size=apple+orange;
switch（i）
{case0:
cout<<"Father调用."<if（Plate_Size==2）
{Father_lag=true;//Father（）等待
Print（）;
if（Mother_lag==false）
MonFa_c=1;
}
else
{
Father（）;
Print（）;
if（（Daughter1_lag==true）&&（Daughter2_lag==true））
{
if（Daughter_b==1）
{
Daughter1_lag=false;//Daughter1等待取消
cout<<"处于等待的Daughter1自动被调用"<Daughter1（）;//处于等待的Daughter1自动调用
Print（）;
Daughter_b=2;
}
else
{
Daughter2_lag=false;//Daughter2等待取消
cout<<"处于等待的Daughter2自动被调用"<Daughter2（）;//处于等待的Daughter2（）自动调用
Print（）;
Daughter_b=1;
}
}
else
{
if（Daughter1_lag==true）
{
Daughter1_lag=false;//Daughter1等待取消
cout<<"处于等待的Daughter1自动被调用"<Daughter1（）;//处于等待的Daughter1（）自动调用
Print（）;
Daughter_b=0;
}
elseif（Daughter2_lag==true）
{
Daughter2_lag=false;//Daughter2等待取消
cout<<"处于等待的Daughter1自动被调用"<Daughter2（）;//处于等待的Daughter2（）自动调用
Daughter_b=0;
}
}
}
break;
case1:
cout<<"Mother调用."<if（Plate_Size==2）
{
Mother_lag=true;//等待
Print（）;
if（Father_lag==false）
MonFa_c=2;
}
else
{
Mother（）;
Print（）;
if（（Son1_lag==true）&&（Son2_lag==true））
{
if（Son_a==1）
{
Son1_lag=false;//Son1等待取消
cout<<"处于等待的Son1自动被调用"<Son1（）;//处于等待的Son1（）自动调用
Print（）;
Son_a=2;
}
else
{
Son2_lag=false;//Son2等待取消
cout<<"处于等待的Son2自动被调用"<Son2（）;//处于等待的Son2（）自动调用
Print（）;
Son_a=1;
}
}
else
{
if（Son1_lag==true）
{
Son1_lag=false;//Son1等待取消
cout<<"处于等待的Son1自动被调用"<Son1（）;//处于等待的Son1（）自动调用
Print（）;
Son_a=0;
}
elseif（Son2_lag==true）
{
Son2_lag=false;//Son2等待取消
cout<<"处于等待的Son2自动被调用"<Son2（）;//处于等待的Son2（）自动调用
Print（）;
Son_a=0;
}
}
}
break;
case2:
cout<<"Son1调用."<if（orange==0）
{
Son1_lag=true;//Son1处于等待
Print（）;
if（Son2_lag==false）
Son_a=1;//用于判断Son1和Son2等待的先后性
}
else
{
Son1（）;
Print（）;
if（（Father_lag==true）&&（Mother_lag==true））
{
if（MonFa_c==1）//Father和Mother同时处于等待，但Father先等待，因此先调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
Print（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
Print（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
Print（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mothe处于等待，调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
Print（）;
MonFa_c=0;
}
}
}
break;
case3:
cout<<"Son2调用."<if（orange==0）
{
Son2_lag=true;//Son2处于等待
Print（）;
if（Son1_lag==false）
Son_a=2;
}
else
{
Son2（）;
Print（）;
if（（Father_lag==true）&&（Mother_lag==true））
{
if（MonFa_c==1）//Father和Mother同时处于等待，但Father先等待，因此先调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
Print（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
Print（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
Print（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
Print（）;
MonFa_c=0;
}
}
}
break;
case4:
cout<<"Daughter1调用."<if（apple==0）
{
Daughter1_lag=true;//Daughter1
Print（）;
if（Daughter2_lag==false）
Daughter_b=1;
}
{
Daughter1（）;
Print（）;
if（（Father_lag==true）&&（Mother_lag==true））
{
if（MonFa_c==1）//Father和Mother同时处于等待，但Father先
{//等待，因此先调用
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
Print（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
Print（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
Print（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
Print（）;
MonFa_c=0;
}
}
break;case5:
cout<<"Daughter2调用."<if（apple==0）
{
Daughter2_lag=true;//Daughter2等待
Print（）;
if（Daughter1_lag==false）
Daughter_b=2;
}
else
{
Daughter2（）;
Print（）;
if（（Father_lag==true）&&（Mother_lag==true））
{
if（MonFa_c==1）//Father和Mother同时处于等待，但Father先等待，因此先调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
Print（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
Print（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
Print（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
Print（）;
MonFa_c=0;
}
}
}
break;
}
}
return0;
}
第四章调式和操作说明
4.1测试用例
由于程序是模拟产生10次随机的操作，执行相应的函数来模拟进程同步。
可以将程序运行两次将会得到不同的结果。
4.2运行结果
随即运行的结果
第五章总结和体会
这次自己的收获还是不小，首先使我提高了分析问题，并根据需求
化成相应的程序结构的能力；其次也丰富了自己编写程序，调试程序的经
这使得我编程时可能出现的错误的认识，并如何去避免产生了新的认识。
不足之处，由于各进程调用是随机的，在某个处于等待状态时，可以还能被调用，事实上这不是很合理。
因为处于等待状态的进程就不可能在被分配调用。
再有就是程序有些代码部分有重的，可以把这些重复执行的代码写成函数，需要用时直接调用代码函数。
通过这次课程设计增进了同学友谊，也学会了将理论用于实践的重要性。
非常感谢陕粉丽老师的辛勤指导！
参考文献：
操作系统教程第四版主编：
孙钟秀高等教育出版社
实用VISUALC++6.0教程作者：
[美]JonBates,TimTompkins 清华大学出版社
致谢：
感谢陕老师对我们的辛勤指导，我们从这次课程设计从学到了很多东西。
使我们更加了解实践的重要性。
升级会员 