操作系统课程设计吃水果问题完整版.docx
《操作系统课程设计吃水果问题完整版.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计吃水果问题完整版.docx（24页珍藏版）》请在冰豆网上搜索。
操作系统课程设计吃水果问题完整版
目 录
1题目内容及要求
1.1题目名称
进程同步模拟设计:
吃水果问题
1.2题目描述
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
1.3解题思路
将问题转换为信号量上的资源分配类型问题:
这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。
通过编程实践时，实际是随机的调用人一个进程的操作，而这些进程的操作相当于程序中的函数调用。
而计算机在执行时每一个时刻只能执行一个操作，这就默认了互斥。
同步的模拟可以类似于函数调用时的前提关系即先决条件。
这样进程同步模拟就完全可以通过函数的调用来实现。
具体的每一个操作的对应的函数的关系：
爸爸向盘子中放一个苹果：
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时表示盘子为空，此时若进行取水果操作，取水果操作将处于等待状态。
（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个整数，分别对应六个进程的调用。
放水果操作流程图设计（以Father为例,Mother类似）:
图1Father放水果操作流程图
取水果操作流程图设计（以Son为例,Daughter类似）:
图2Son取水果（橘子）操作流程图
1.4程序清单
#include
#include
#include
#include
intapple=0;
intorange=0;
boolFather_lag;
boolMother_lag;
boolSon1_lag;
boolSon2_lag;
intson_a;
intDaughter_b;
boolDaughter1_lag;
boolDaughter2_lag;
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<}
voidFather（）//Father进程
{
apple++;
Print（）;
}
voidMother（）//Mother进程
{
orange++;
Print（）;
}
voidSon1（）//Son1进程
{
orange--;
Print（）;
}
voidSon2（）//Son2进程
{
orange--;
Print（）;
}
voidDaughter1（）//Daughter1进程
{
apple--;
Print（）;
}
voidDaughter2（）//Daughter2进程
{
apple--;
Print（）;
}
voidmain（）
{
inti;
intPlate_Size;//水果数量
intMonFa_c;//用于爸爸妈妈等待次序的区别
intSon_a;//用于两个儿子等待次序的区别
intdaughter_b;//用于两个女儿等待次序的区别
intk;//产生进程调用的数量
srand（（unsigned）time（NULL））;//srand（）函数产生一个以当前时间开始的随机种子
for（k=0;k<10;k++）
{
cout<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（）;
if（（Daughter1_lag==true）&&（Daughter2_lag==true））
{
if（Daughter_b==1）
{
Daughter1_lag=false;//Daughter1等待取消
cout<<"处于等待的Daughter1自动被调用"<Daughter1（）;//处于等待的Daughter1自动调用
Daughter_b=2;
}
else
{
Daughter2_lag=false;//Daughter2等待取消
cout<<"处于等待的Daughter2自动被调用"<Daughter2（）;//处于等待的Daughter2（）自动调用
Daughter_b=1;
}
}
else
{
if（Daughter1_lag==true）
{
Daughter1_lag=false;//Daughter1等待取消
cout<<"处于等待的Daughter1自动被调用"<Daughter1（）;//处于等待的Daughter1（）自动调用
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（）;
if（（Son1_lag==true）&&（Son2_lag==true））
{
if（Son_a==1）
{
Son1_lag=false;//Son1等待取消
cout<<"处于等待的Son1自动被调用"<Son1（）;//处于等待的Son1（）自动调用
Son_a=2;
}
else
{
Son2_lag=false;//Son2等待取消
cout<<"处于等待的Son2自动被调用"<Son2（）;//处于等待的Son2（）自动调用
Son_a=1;
}
}
else
{
if（Son1_lag==true）
{
Son1_lag=false;//Son1等待取消
cout<<"处于等待的Son1自动被调用"<Son1（）;//处于等待的Son1（）自动调用
Son_a=0;
}
elseif（Son2_lag==true）
{
Son2_lag=false;//Son2等待取消
cout<<"处于等待的Son2自动被调用"<Son2（）;//处于等待的Son2（）自动调用
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（）;
if（（Father_lag==true）&&（Mother_lag==true））
{
if（MonFa_c==1）//Father和Mother同时处于等待，但Father先等待，因此先调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=0;
}
}
}
break;
case3:
cout<<"Son2调用."<if（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自动被调用"<Father（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=0;
}
}
}
break;
case4:
cout<<"Daughter1调用."<if（apple==0）
{
Daughter1_lag=true;//Daughter1等待
Print（）;
if（Daughter2_lag==false）
Daughter_b=1;
}
else
{
Daughter1（）;
if（（Father_lag==true）&&（Mother_lag==true））
{
if（MonFa_c==1）//Father和Mother同时处于等待，但Father先
{//等待，因此先调用
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=0;
}
}
}
break;
case5:
cout<<"Daughter2调用."<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自动被调用"<Father（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=0;
}
}
}
break;
}
}
}
1.5提交结果框图
由于程序是模拟产生10次随机的操作，执行相应的函数来模拟进程同步。
可以将程序运行两次将会得到不同的结果。
第一次产生结果如下:
图3第一次随机操作结果
图4第一次随机操作结果
图5第二次随机操作结果
图6第二次随机操作结果
2总结
此次试验是完全在自己独立完成的，首先在分析问题并把问题转化为编程问题，我觉得个人把握的很好，对进程同步模拟理解的比较透彻；其次我用了个随机函数来调用相应的进程函数，这对进程间的同步和等待状态有很好的说明，和十分的全面；再次我设了六个bool型的变量来表示各进程时候处于等待状态，还设置了相应的整型变量来解决等待进程在适当的条件下自动调用的先后问题。
这些我个人认为我设计的比较出色。
这次自己的收获还是不小，首先使我提高了分析问题，并根据需求转化成相应的程序结构的能力；其次也丰富了自己编写程序，调试程序的经验，这使得我编程时可能出现的错误的认识，并如何去避免产生了新的认识。
对于此题我觉得除了可以用随机函数来产生随机数来调用相应的进程函数，也可以用人输入的方式来选择调用相应的进程函数，这样可以会麻烦些，不过对进程同步的模拟可能会更加透彻。
总的来说这次试验比较成功，加深我了进程的理解，同时也提高了自己的编程的能力。
编程是个长久的过程，平时要多去动手实践，去提高自己分析问题、发现问题、解决问题的能力。
3参考文献
[1]宗大华主编操作系统人民邮电出版社
[2]孟庆昌主编操作系统原理中央广播电视大学出版社
[3]贾德博尔著操作系统清华大学出版社
[4]邹恒明计算机的心智操作系统之哲学原理上海交大出版社
升级会员 