操作系统课程设计报告苹果问题.docx
《操作系统课程设计报告苹果问题.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计报告苹果问题.docx（24页珍藏版）》请在冰点文库上搜索。
操作系统课程设计报告苹果问题
《操作系统》课程设计报告
专业：
计算机科学与技术
班级：
12计本（3）班
学号
姓名
成绩
2012020305
魏永祥
题目名称：
苹果问题
完成日期：
2014年6月
目录
目录1
1．设计题目与要求2
1.1设计目的2
1.2设计要求2
2．总体设计思想2
2.1总体设计思想2
3．功能设计3
3.1数据结构设计3
3.2模块说明3
3.3各模块的算法流程图4
3.4P、V原语的描述7
4.开发平台及程序清单的主要部分8
4.1开发平台8
5.运行结果与运行情况分析9
5.1运行结果9
6.自我评价与总结10
7.参考资料11
附录12
1、分工说明：
12
2、程序源代码：
12
1．设计题目与要求
1.1设计目的
通过实现吃水果问题的同步,深入了解和掌握进程同步的原理。
1.2设计要求
吃水果问题的描述:
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。
爸爸专门向盘子中放苹果（apple），妈妈专门向盘子中放橘子（orange），两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
2．总体设计思想
2.1总体设计思想
这是进程同步与互斥问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。
通过编程实践时，实际是随机的调用一个进程的操作，而这些进程的操作相当于程序中的函数调用。
而计算机在执行时每一个时刻只能执行一个操作，这就是互斥的表现。
同步的模拟可以类似于函数调用时的前提关系即先决条件。
这样进程同步模拟就完全可以通过函数的调用来实现。
具体的每一个操作的对应的函数的关系：
爸爸向盘子中放一个苹果：
Father（）
妈妈向盘子中放一个橘子：
Mother（）
儿子1从盘子取一个橘子：
Son1（）
儿子2从盘子取一个橘子：
Son2（）
女儿1从盘子取一个橘子：
Daugther1（）
女儿2从盘子取一个橘子：
Daugther2（）
3．功能设计
3.1数据结构设计
（1）用一个整型变量Plate_Size表示盘子里的水果数量，初始值为0，当放水果时Plate_Size加1，取水果时Plate_Size减1。
变量Plate_Size的最大值为2，当为2时表示盘子已经满，此时若进行放水果操作，放水果将处于等待状态；为0时表示盘子为空，此时若进行取水果操作，取水果操作将处于等待状态，Plate_Size是爸爸和妈妈进行放水果的私有信号量。
（2）整型变量orange和apple分别表示盘子中的橘子和苹果数目，初始都为0，其中orange是儿子的私有变量，apple是女儿的私有变量，盘子中的总水果数是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个整数，分别对应六个进程的调用。
3.2模块说明
3.2.1主函数
用一个随机的函数产生0—5的6个整数，即i=rand（）%6，分别对应六个进程的调用，调用的次数可以通过修改K值来实现，for（k=0;k<10;k++），本程序共产生了10次随机的调用进程。
3.2.26个进程函数
爸爸向盘子中放一个苹果操作：
Father（）
妈妈向盘子中放一个橘子操作：
Mother（）
儿子1从盘子取一个橘子操作：
Son1（）
儿子2从盘子取一个橘子操作：
Son2（）
女儿1从盘子取一个橘子操作：
Daugther1（）
女儿2从盘子取一个橘子操作：
Daugther2（）
3.2.3Print函数
用于输出盘子中苹果和橘子的个数，水果总个数及哪些进程处于等待状态。
3.3各模块的算法流程图
3．3．1放水果操作
A、爸爸放苹果进程的操作流程图：
B、妈妈放橘子进程的操作流程图
3．3．2取水果操作
儿子1取橘子的操作流程图
女儿i取苹果的操作流程图
3.4P、V原语的描述
SemaphorePlate_Siz
Semaphoreapple
Semaphoreorange
Father（）
{
While（ture）
{
P（Plate_Siz）
P（mutex）
父亲向盘子中放进一个苹果
V（apple）
V（mutex）
}
}
Mother（）
{
While（ture）
{
P（Plate_Siz）
P（mutex）
母亲向盘子中放进一个桔子
V（orange）
V（mutex）
}
}
Son（i）
{
While（ture）
{
P（Plate_Siz）
P（mutex）
P（apple）
儿子从盘子中走一个桔子
V（orange）
V（mutex）
}
}
Daugther（i）
{
While（ture）
{
P（Plate_Siz）
P（mutex）
女儿从盘子中走一个苹果
V（apple）
V（mutex）
}
}
4.开发平台及程序清单的主要部分
4.1开发平台
（1）使用系统：
ＷindowsXP
（2）使用语言：
C++
（3）开发工具：
VisualC++6.0
5.运行结果与运行情况分析
5.1运行结果
第一次运行结果为：
第二次运行结果为：
6.自我评价与总结
此次试验是完全在小组合作下完成的，首先在分析问题并把问题转化为编程问题，对进程同步理解的比较透彻；其次我用了个随机函数来调用相应的进程函数，这对进程间的同步和等待状态有很好的说明和十分的全面；再次我们设了六个bool型的变量来表示各进程时候处于等待状态，还设置了相应的整型变量来解决等待进程在适当的条件下自动调用的先后问题。
任有不足之处，由于各进程调用是随机的，在某个处于等待状态时，可以还能被调用，事实上这不是很合理。
因为处于等待状态的进程就不可能在被分配调用。
再有就是程序有些代码部分有重的，可以把这些重复执行的代码写成函数，需要用时直接调用代码函数。
这次自己的收获还是不小，首先使我们提高了分析问题，并根据需求转化成相应的程序结构的能力；其次也丰富了自己编写程序，调试程序的经验，这使得我编程时可能出现的错误的认识，并如何去避免产生了新的认识。
对于此题我觉得除了可以用随机函数来产生随机数来调用相应的进程函数，也可以用人输入的方式来选择调用相应的进程函数，这样可以会麻烦些，不过对进程同步的模拟可能会更加透彻。
总的来说这次试验比较成功，加深我了进程的理解，同时也提高了自己的编程的能力。
编程是个长久的过程，平时要多去动手实践，去提高自己分析问题、发现问题、解决问题的能力。
7.参考资料
[1]宗大华，宗涛，陈吉人著操作系统北京：
人民邮电出版社，2009
[2]李爱华，程磊著面相对象程序设计（C++语言）北京:
清华大学出版社，2010
[3]宋晓宇，windows操作系统核心编程实验教程中国铁道出版社
[4]张丽芬刘利雄王金玉编著操作系统实验教程清华大学出版社
附录
1、分工说明：
***
定义信号量的描述，完成P、V原语，画出流程图，写子女进程（Son和Daugther）
***
查找用到的系统调用，,写父母进程（Father和Mother）和main函数
2、程序源代码：
#include//用到了time函数，所以要有这个头文件
#include//用到了srand函数，所以要有这个头文件
#include
intPlate_Size=0;//表示盘子中当前有几个水果
intorange=0,apple=0;//表示盘子中orange和apple的个数
boolFather_lag,Mother_lag,Son1_lag,Son2_lag,Daughter1_lag,Daughter2_lag;//六个进程处于等待时，变量值为true
voidmain（）//main（）函数，实现其他功能函数的调用
{voidPrint（）;//函数声明
voidFather（）;
voidMother（）;
voidSon1（）;
voidSon2（）;
voidDaughter1（）;
voidDaughter2（）;
intk;
srand（（unsigned）time（NULL））;//srand（）函数产生一个以当前时间开始的随机种子
for（k=0;k<10;k++）
{cout<<"第"<"<\n",k+1）;
inti=rand（）%6;//随进生成6以内的整数，即0-5的6个整数
Plate_Size=apple+orange;
intMonFa_c,Daughter_b,Son_a;//for语句的局部变量，控制进程等待的优先次序,MonFa_c=2,Mather（）执行，MonFa_c=1，Father（）执行
switch（i）//0为Father（）调用，1为Mother（）调用，2、3为Son1（）、Son2（）调，4、5为Daughteri（）调用
{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等待取消
Daughter1（）;//处于等待的Daughter1自动调用
Daughter_b=2;//优先级让给Daughter2
}
else
{
Daughter2_lag=false;//Daughter2等待取消
Daughter2（）;//处于等待的Daughter2（）自动调用
Daughter_b=1;//优先级让给Daughter1
}
}
else
{
if（Daughter1_lag==true）
{
Daughter1_lag=false;//Daughter1等待取消
Daughter1（）;//处于等待的Daughter1（）自动调用
Daughter_b=0;//没有等待的Dauther进程
}
elseif（Daughter2_lag==true）
{
Daughter2_lag=false;//Daughter2等待取消
Daughter2（）;//处于等待的Daughter2（）自动调用
Daughter_b=0;
}
}
}
break;
case1:
cout<<"Mother调用."<if（Plate_Size==2）
{
Mother_lag=true;//Mother（）等待
Print（）;
if（Father_lag==false）
MonFa_c=2;
}
else
{
Mother（）;
if（（Son1_lag==true）&&（Son2_lag==true））//Son1和Son2都等待
{
if（Son_a==1）//Son1执行
{
Son1_lag=false;//Son1等待取消
Son1（）;//处于等待的Son1（）自动调用
Son_a=2;//优先级让给Son2
}
else
{
Son2_lag=false;//Son2等待取消
Son2（）;//处于等待的Son2（）自动调用
Son_a=1;//优先级让给Son1
}
}
else
{
if（Son1_lag==true）
{
Son1_lag=false;//Son1等待取消
Son1（）;//处于等待的Son1（）自动调用
Son_a=0;
}
elseif（Son2_lag==true）
{
Son2_lag=false;//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;
Father（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
Mother（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{
Mother_lag=false;
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;
Father（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
Mother（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用Father
{
Father_lag=false;
Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用Mother
{
Mother_lag=false;
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;
Father（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
Mother（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{
Mother_lag=false;
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;
Father（）;
MonFa_c=2;
}
else//Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
Mother（）;
MonFa_c=1;
}
}
else
{
if（Father_lag==true）//只有Father处于等待，调用
{
Father_lag=false;
Father（）;
MonFa_c=0;
}
elseif（Mother_lag==true）//只有Mother处于等待，调用
{
Mother_lag=false;
Mother（）;
MonFa_c=0;
}
}
}
break;
}//switch语句结束
}//for语句结束
}//main函数结束
voidPrint（）//Print函数（打印盘子剩余水果及各进程等待状态）
{
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（）;
}
升级会员 