武汉理工大学进程同步模拟设计吃水果问题.docx
《武汉理工大学进程同步模拟设计吃水果问题.docx》由会员分享，可在线阅读，更多相关《武汉理工大学进程同步模拟设计吃水果问题.docx（21页珍藏版）》请在冰豆网上搜索。
武汉理工大学进程同步模拟设计吃水果问题
]
进程同步模拟设计
——吃水果问题
1需求分析
吃水果问题的描述
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
问题的转换
这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。
通过编程实践时，实际是随机的调用人一个进程的操作，而这些进程的操作相当于程序中的函数调用。
而计算机在执行时每一个时刻只能执行一个操作，这就默认了互斥。
同步的模拟可以类似于函数调用时的前提关系即先决条件。
这样进程同步模拟就完全可以通过函数的调用来实现。
具体的每一个操作的对应的函数的关系：
》
爸爸向盘子中放一个苹果：
Father（）
妈妈向盘子中放一个橘子：
Mother（）
儿子1从盘子取一个橘子：
Son1（）
儿子2从盘子取一个橘子：
Son2（）
女儿1从盘子取一个苹果：
Daugther1（）
儿子1从盘子取一个苹果：
Daugther2（）
2功能设计
·
数据结构
（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个整数，分别对应六个进程的调用。
模块说明
（1）main函数:
用一个随机的函数产生0—5的6个整数，分别对应六个进程的调用，调用的次数可以自己输入，本程序共产生了10次随机的调用进程。
#
（2）6个进程函数:
爸爸向盘子中放一个苹果操作：
Father（）；妈妈向盘子中放一个橘子操作：
Mother（）；儿子1从盘子取一个橘子操作：
Son1（）；儿子2从盘子取一个橘子操作：
Son2（）；女儿1从盘子取一个橘子操作：
Daugther1（）；女儿2从盘子取一个橘子操作：
Daugther2（）。
（3）Print函数：
用于输出盘子中苹果和橘子的个数，水果总个数及有哪些进程处于等待状态。
操作的流程图
（1）放水果操作
爸爸放苹果进程的操作流程图：
/
^
（2）取水果操作
儿子1取橘子的操作流程图
—
3开发平台及源程序的主要部分
{
开发平台
（1）使用系统：
windows7
（2）使用语言：
C++
（3）开发工具：
MicrosoftVisualC++2012Express
源程序主要部分
（1）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<}
（2）各进程调用的函数
voidFather（）{
）
apple++;
Print（）;
}
voidMother（）{
orange++;
Print（）;
}
voidSon1（）{
，
orange--;
Print（）;
}
voidSon2（）{
orange--;
Print（）;
}
voidDaughter1（）{
;
apple--;
Print（）;
}
voidDaughter2（）{
apple--;
Print（）;
}
（3）主函数
【
voidmain（）
{
intk;
inti;
intPlate_Size;
intMonFa_c;
intSon_a;
srand（（unsigned）time（NULL））;
;
for（k=0;k<10;k++）
{
cout<<"***********************************"<<"第"<i=rand（）%6;
Plate_Size=apple+orange;
switch（i）
{
case0:
；
cout<<"Father调用."<if（Plate_Size==2）
{
Father_lag=true;
Print（）;
if（Mother_lag==false）
MonFa_c=1;
}
/
else
{
Father（）;
if（（Daughter1_lag==true）&&（Daughter2_lag==true））
{
if（Daughter_b==1）
{
Daughter1_lag=false;
]
cout<<"处于等待的Daughter1自动被调用"<Daughter1（）;
Daughter_b=2;
}
else
{
Daughter2_lag=false;
cout<<"处于等待的Daughter2自动被调用"<》
Daughter2（）;
Daughter_b=1;
}
}
else
{
if（Daughter1_lag==true）
{
【
Daughter1_lag=false;
cout<<"处于等待的Daughter1自动被调用"<Daughter1（）;
Daughter_b=0;
}
elseif（Daughter2_lag==true）
{
Daughter2_lag=false；
`
cout<<"处于等待的Daughter1自动被调用"<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;
;
cout<<"处于等待的Son1自动被调用"<Son1（）;
Son_a=2;
}
else
{
Son2_lag=false；
cout<<"处于等待的Son2自动被调用"<、
Son2（）;
Son_a=1;
}
}
else
{
if（Son1_lag==true）
{
;
Son1_lag=false;
cout<<"处于等待的Son1自动被调用"<Son1（）;
Son_a=0;
}
elseif（Son2_lag==true）
{
Son2_lag=false;
%
cout<<"处于等待的Son2自动被调用"<Son2（）;
Son_a=0;
}
}
}
break;
case2:
…
cout<<"Son1调用."<if（orange==0）
{
Son1_lag=true;
Print（）;
if（Son2_lag==false）
Son_a=1;
}
】
else
{
Son1（）;
if（（Father_lag==true）&&（Mother_lag==true））
{
if（MonFa_c==1）{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<'
Father（）;
MonFa_c=2;
}
else
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
，
MonFa_c=1;
}
}
else
{
if（Father_lag==true）
{
Father_lag=false;
（
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<、
Mother（）;
MonFa_c=0;
}
}
}
break;
case3:
cout<<"Son2调用."<<
if（orange==0）
{
Son2_lag=true;
Print（）;
if（Son1_lag==false）
Son_a=2;
}
else
）
{
Son2（）;
if（（Father_lag==true）&&（Mother_lag==true））
{
if（MonFa_c==1）{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
&
MonFa_c=2;
}
else{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=1;
}
%
}
else
{
if（Father_lag==true）
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
{
MonFa_c=0;
}
elseif（Mother_lag==true）{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=0;
}
}
}
}
break;
case4:
cout<<"Daughter1调用."<if（apple==0）
{
Daughter1_lag=true;
，
Print（）;
if（Daughter2_lag==false）
Daughter_b=1;
}
else
{
Daughter1（）;
if（（Father_lag==true）&&（Mother_lag==true））
|
{
if（MonFa_c==1）{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=2;
}
else{
…
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=1;
}
}
else{
if（Father_lag==true）{
】
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<'
Mother（）;
MonFa_c=0;
}}
}
break;
case5:
cout<<"Daughter2调用."<if（apple==0）
]
{
Daughter2_lag=true;Print（）;
if（Daughter1_lag==false）
Daughter_b=2;
}
else{
Daughter2（）;
if（（Father_lag==true）&&（Mother_lag==true））
?
{
if（MonFa_c==1）{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=2;
}
else
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=1;
}}
else{
if（Father_lag==true）{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<Mother（）;
MonFa_c=0;
}}
}
break;
}}
}
4测试用例，运行结果与运行情况分析
测试用例
由于程序是模拟产生10次随机的操作，执行相应的函数来模拟进程同步。
即每次运行会有10种不同的结果。
运行结果
第一次运行结果为：
第二次运行结果为：
5自我评价与总结
在这次课程设计的过程中，我也遇到了很多难题。
在种种的困难中，我明白了在编写程序时要有耐心。
如果你没有耐心，即使再好的思路也不会得到很好的表达，特别是在调试的过程中，对于各种各样的错误，要特别的有耐心去自习分析原因，特别是一些基本的语法错误，不能一看到错误很多就乱了阵脚，更不能轻易的放弃，半途而废。
通过此次课程设计，再次对操作系统原理的基础知识和一些实际操作只是有了一定的了解，对操作系统的进程同步的过程有了一定的了解。
用了个随机函数来调用相应的进程函数，这对进程间的同步和等待状态有很好的说明，和十分的全面；再次我设了六个bool型的变量来表示各进程时候处于等待状态。
这次自己的收获很大，使我提高了分析问题，根据需求转化成相应的程序结构的能力，自己动手编写程序，能够很好地使自己认识到自己编程的不足之处即代码的组织能力。
对于此题我觉得除了可以用随机函数来产生随机数来调用相应的进程函数，也可以用人输入的方式来选择调用相应的进程函数，这样可以会麻烦些，不过对进程同步的模拟可能会更加透彻，且更容易理解进程调用。
对于这次课程设计的不足，主要是功能还不够完善，只能按等待的先后顺序进行进程调用，未能设计几种不同的进程调用方法。
这方面还有待完善。
升级会员 