本科毕业论文---信号量机制.doc

操作系统课程设计

学号：
姓名：
专业： 计算机科学与技术
课程： 操作系统
指导教师：
时间：
成绩：

目 录
目录 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
4. 设计心得 5
5. 参考资料 6
附录 7
程序源代码： 7

14

一．设计题目与要求
1.设计目的
了解信号量机制，了解并掌握进程同步和互斥机制，熟悉信号量的操作函数，利用信号量实现对资源共享的控制。
通过实现吃水果问题的同步,深入了解和掌握进程同步的原理。
2. 设计要求
编程模拟实现这一问题的程序控制，分析处理过程。
吃水果问题的描述:
桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。爸爸专门向盘中放苹果（apple），妈妈专门向盘子中放橘子（orange），两个儿子专门等待吃盘子中的橘子，两个女儿专门等吃盘子中的苹果。
二．总体设计思想
1.总体设计思想流程
这是进程同步与互斥问题的模拟，可以把向盘子放或取水果的每一个过程可以转为一个进程的操作，这些进程是互斥的，同时也存在一定的同步关系。通过编程实践时，实际是随机的调用一个进程的操作，而这些进程的操作相当于程序中的函数调用。而计算机在执行时每一个时刻只能执行一个操作，这就是互斥的表现。同步的模拟可以类似于函数调用时的前提关系即先决条件。这样进程同步模拟就完全可以通过函数的调用来实现。
具体的每一个操作的对应的函数的关系：
爸爸向盘子中放一个苹果：Father()妈妈向盘子中放一个橘子：Mother()
儿子1从盘子取一个橘子：Son1()儿子2从盘子取一个橘子：Son2()
女儿1从盘子取一个橘子：Daugther1()女儿2从盘子取一个橘子：Daugther2()
三．功能设计
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个整数，分别对应六个进程的调用。
2.程序清单
（1)主函数
用一个随机的函数产生0—5的6个整数，即 i=rand()%6，分别对应六个进程的调用，调用的次数可以通过修改K值来实现，for(k=0;k<10;k++)，本程序共产生了10次随机的调用进程。
(2)6个进程函数
爸爸向盘子中放一个苹果操作：Father()
妈妈向盘子中放一个橘子操作：Mother()
儿子1从盘子取一个橘子操作：Son1()
儿子2从盘子取一个橘子操作：Son2()
女儿1从盘子取一个橘子操作：Daugther1()
女儿2从盘子取一个橘子操作：Daugther2()
(3)Print函数
　　用于输出盘子中苹果和橘子的个数，水果总个数及哪些进程处于等待状态。

（4）P、V原语的描述
Semaphore Plate_Siz
Semaphore appl
Semaphore orange
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)
}
}
3. 运行结果

四．设计心得
完成本次课题首先在分析问题并把问题转化为编程问题，对进程同步理解的比较透彻；其次我用了个随机函数来调用相应的进程函数，这对进程间的同步和等待状态有很好的说明和十分的全面；再次我们设了六个bool型的变量来表示各进程时候处于等待状态，还设置了相应的整型变量来解决等待进程在适当的条件下自动调用的先后问题。
不足之处，由于各进程调用是随机的，在某个处于等待状态时，可以还能被调用，事实上这不是很合理。因为处于等待状态的进程就不可能在被分配调用。再有就是程序有些代码部分有重的，可以把这些重复执行的代码写成函数，需要用时直接调用代码函数。
这次自己的收获还是不小，首先使我们提高了分析问题，并根据需求转化成相应的程序结构的能力；其次也丰富了自己编写程序，调试程序的经验，这使得我编程时可能出现的错误的认识，并如何去避免产生了新的认识。
加深我了进程的理解，同时也提高了自己的编程的能力。编程是个长久的过程，平时要多去动手实践，去提高自己分析问题、发现问题、解决问题的能力。
五. 参考资料
[1]宗大华，宗涛，陈吉人著 操作系统 北京：人民邮电出版社，2009
[2]李爱华，程磊著 面相对象程序设计（C++语言） 北京: 清华大学出版社，2010
[3]宋晓宇 ， windows操作系统核心编程实验教程 中国铁道出版社
[4]张丽芬 刘利雄 王金玉编著 操作系统实验教程 清华大学出版社

附录：

程序源代码：
#include<time.h> //用到了time函数，所以要有这个头文件
#include<stdlib.h> //用到了srand函数，所以要有这个头文件
#include<iostream.h>
int Plate_Size=0; //表示盘子中当前有几个水果
int orange=0,apple=0; //表示盘子中orange和apple的个数
bool Father_lag,Mother_lag,Son1_lag,Son2_lag,Daughter1_lag,Daughter2_lag; //六个进程处于等待时，变量值为true
void main() //main()函数，实现其他功能函数的调用
{ void Print(); //函数声明
void Father();
void Mother();
void Son1();
void Son2();
void Daughter1();
void Daughter2();
int k;
srand((unsigned)time(NULL));//srand()函数产生一个以当前时间开始的随机种子
for(k=0;k<10;k++)
{ cout<<"第"<<k+1<<"次操作:"<<endl; //printf("第%d次操作:\n",k+1);
int i=rand()%6; //随进生成6以内的整数，即0-5的6个整数
Plate_Size=apple+orange;
int MonFa_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()调用
{ case 0:
cout<<"Father调用."<<endl;
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进程
}
else if(Daughter2_lag==true)
{
Daughter2_lag=false;//Daughter2等待取消
Daughter2(); //处于等待的Daughter2()自动调用
Daughter_b=0;
}
}
}
break;
case 1:
cout<<"Mother调用."<<endl;
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;
}
else if(Son2_lag==true)
{
Son2_lag=false; //Son2等待取消
Son2(); //处于等待的Son2()自动调用
Son_a=0;
}
}
}
break;
case 2:
cout<<"Son1调用."<<endl;
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;
}
else if(Mother_lag==true)//只有Mother处于等待，调用
{
Mother_lag=false;
Mother();
MonFa_c=0;
}
}
}
break;
case 3:
cout<<"Son2调用."<<endl;
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;
}
else if(Mother_lag==true) //只有Mother处于等待，调用Mother
{
Mother_lag=false;
Mother();
MonFa_c=0;
}
}
}
break;
case 4:
cout<<"Daughter1调用."<<endl;
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;
}
else if(Mother_lag==true) //只有Mother处于等待，调用
{
Mother_lag=false;
Mother();
MonFa_c=0;
}
}
}
break;
case 5:
cout<<"Daughter2调用."<<endl;
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;
}
else if(Mother_lag==true) //只有Mother处于等待，调用
{
Mother_lag=false;
Mother();
MonFa_c=0;
}
}
}
break;
} //switch语句结束
} //for语句结束
} //main函数结束
void Print() //Print函数（打印盘子剩余水果及各进程等待状态）
{
cout<<"现在盘子里有"<<apple<<"个苹果,"<<orange<<"个橘子,"<<"共有"<<apple+orange<<"个水果."<<endl;
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<<endl;
}
void Father() //Father进程
{ apple++;
Print();
}
void Mother() //Mother进程
{
orange++;
Print();
}
void Son1() //Son1进程
{ orange--;
Print();
}
void Son2() //Son2进程
{ orange--;
Print();
}
void Daughter1() //Daughter1进程
{ apple--;
Print();
}
void Daughter2() //Daughter2进程
{
apple--;
Print();
}