操作系统课程设计吃水果问题完整

cout<<"处于等待的Father自动被调用"<<endl;
Father();
MonFa_c=2;
}
else //Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<<endl;
Mother();
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;
{
orange--;
Print();
}
void Daughter1() //Daughter1进程
{
apple--;
Print();
}
void Daughter2() //Daughter2进程
{
apple--;
Print();
}
void main()
{
int i;
int Plate_Size;//水果数量
图1 Father放水果操作流程图
取水果操作流程图设计(以Son为例,Daughter类似):
图2 Son取水果(橘子)操作流程图
1.4
#include <iostream.h>
#include <ctime>
#include <cstdlib>
#include <cmath>
int apple=0;
Daughter_b=1;
}
}
else
{
if(Daughter1_lag==true)
{
Daughter1_lag=false;//Daughter1等待取消
cout<<"处于等待的Daughter1自动被调用"<<endl;
Daughter1(); //处于等待的Daughter1()自动调用
Daughter_b=0;
具体的每一个操作的对应的函数的关系：
爸爸向盘子中放一个苹果：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时表示盘子为空，此时若进行取水果操作，取水果操作将处于等待状态。
break;
case 1:
cout<<" Mother调用."<<endl;
if(Plate_Size==2)
{
Mother_lag=true; //等待
Print();
if(Father_lag==false)
MonFa_c=2;
}
else
{
Mother();
if((Son1_lag==true)&&(Son2_lag==true))
int MonFa_c;//用于爸爸妈妈等待次序的区别
int Son_a;//用于两个儿子等待次序的区别
int daughter_b;//用于两个女儿等待次序的区别
int k;//产生进程调用的数量
srand((unsigned)time(NULL));//srand()函数产生一个以当前时间开始的随机种子
(2)整型变量orange和apple分别表示盘子中的橘子和苹果数目，初始都为0，Plate_Size=apple+orange。
(3)用6个bool型的变量Father_lag，Mother_lag，Son1_lag，Son2_lag，Daughter1_lag，Daughter2_lag表示六个进程是否处于等待状态。处于等待时，变量值为true。
}
else
{
Father();
if((Daughter1_lag==true)&&(Daughter2_lag==true))
{
if(Daughter_b==1)
{
Daughter1_lag=false;//Daughter1等待取消
cout<<"处于等待的Daughter1自动被调用"<<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处于等待，调用
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==பைடு நூலகம்rue)
Plate_Size=apple+orange;
switch(i)
{
case 0:
cout<<" Father调用."<<endl;
if(Plate_Size==2)
{
Father_lag=true;//Father()等待
Print();
if(Mother_lag==false)
MonFa_c=1;
{
Mother_lag=false;
目录
1
1.1
进程同步模拟设计:吃水果问题
1.2
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
1.3
将问题转换为信号量上的资源分配类型问题:
这是进程同步问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。通过编程实践时，实际是随机的调用人一个进程的操作，而这些进程的操作相当于程序中的函数调用。而计算机在执行时每一个时刻只能执行一个操作，这就默认了互斥。同步的模拟可以类似于函数调用时的前提关系即先决条件。这样进程同步模拟就完全可以通过函数的调用来实现。
(4)两个放水果进程进程同时处于等待状态时，若有取水果的操作将自动执行等待的放水果进程，执行按等待的先后顺序；两个取苹果或橘子进程同时候处于等待状态，若有放苹果或橘子的操作将自动执行等待的取进程，进行按等待的先后顺序。
(5)用一个随机的函数产生0—5的6个整数，分别对应六个进程的调用。
放水果操作流程图设计(以Father为例,Mother类似):
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先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<<endl;
Mother();
MonFa_c=0;
}
}
}
break;
case 3:
cout<<" Son2调用."<<endl;
if(orange==0)
{
Son2_lag=true; //Son2处于等待
Print();
}
else if(Daughter2_lag==true)
{
Daughter2_lag=false;//Daughter2等待取消
cout<<"处于等待的Daughter1自动被调用"<<endl;
Daughter2(); //处于等待的Daughter2()自动调用
Daughter_b=0;
}
}
}
cout<<" Son2进程处于等待状态, "<<endl;
if(Daughter1_lag==true)
cout<<" Daughter1进程处于等待状态,"<<endl;
if(Daughter2_lag==true)
cout<<" Daughter2进程处于等待状态,"<<endl;
if(((Father_lag==false)&&(Mother_lag==false)&&(Son1_lag==false)&&(Son2_lag==false)&&(Daughter1_lag==false)&&(Daughter2_lag==false))!=true)
int orange=0;
bool Father_lag;
bool Mother_lag;
bool Son1_lag;
bool Son2_lag;
int son_a;
int Daughter_b;
bool Daughter1_lag;
bool Daughter2_lag;
void Print()
{
cout<<"现在盘子里有"<<apple<<"个苹果,"<<orange<<"个橘子,"<<"共有"<<apple+orange<<"个水果."<<endl;
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处于等待，调用
for(k=0;k<10;k++)
{
cout<<endl;
cout<<"***********************************"<<"第"<<k+1<<"次操作"<<"***********************************"<<endl;
i=rand()%6; //随进生成1-5.
{
if(Son_a==1)
{
Son1_lag=false;//Son1等待取消
cout<<"处于等待的Son1自动被调用"<<endl;
Son1(); //处于等待的Son1()自动调用
Son_a=2;
}
else
{
Son2_lag=false;//Son2等待取消
cout<<"处于等待的Son2自动被调用"<<endl;
Son2(); //处于等待的Son2()自动调用
Son_a=1;
}
}
else
{
if(Son1_lag==true)
{
Son1_lag=false; //Son1等待取消
cout<<"处于等待的Son1自动被调用"<<endl;
Son1(); //处于等待的Son1()自动调用
Son_a=0;
}
else if(Son2_lag==true)
{
Father_lag=false;
cout<<"处于等待的Father自动被调用"<<endl;
Father();
MonFa_c=2;
}
else //Father和Mother同时处于等待，但Mother先等待，因此先调用
{
Mother_lag=false;
cout<<"处于等待的Mother自动被调用"<<endl;
{
Son2_lag=false; //Son2等待取消
cout<<"处于等待的Son2自动被调用"<<endl;
Son2(); //处于等待的Son2()自动调用
Son_a=0;
}
}
}
break;
case 2:
cout<<" Son1调用."<<endl;
if(orange==0)
{
Son1_lag=true; //Son1处于等待
cout<<endl;
}
void Father() //Father进程
{
apple++;
Print();
}
void Mother() //Mother进程
{
orange++;
Print();
}
void Son1() //Son1进程
{
orange--;
Print();
}
void Son2() //Son2进程