淮海工学院实验报告

淮海工学院计算机工程学院实验报告书

课程名：《操作系统原理》

题目：实验二：进程调度

学号： 2012130198

姓名：刘恒辉

一、实验目的

银行家算法是操作系统中避免死锁的典型算法，本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。

二、实验要求

用C语言编写一个简单的银行家算法模拟程序，用银行家算法实现资源分配。程序能模拟多个进程共享多种资源的情形。进程可动态地申请资源，系统按各进程的申请动态地分配资源。要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。

三、实验原理与步骤

实验中进程的数量、资源的种类以及每种资源的总量Total[j]最好允许动态指定。初始时每个进程运行过程中的最大资源需求量Max[i,j]和系统已分配给该进程的资源量Allocation[i,j]均为已知（这些数值可以在程序运行时动态输入），而算法中其他数据结构的值（包括Need[i,j]、Available[j]）则需要由程序根据已知量的值计算产生。

1．认真理解好课本中银行家算法的实例。

2．根据课本中银行家算法的描述，画出程序流程图。

3．按照程序流程图，用C语言编程并实现。

四、实验结果与分析

#include

#include

#define M 3 //资源的种类数

#define N 5 //进程的个数

void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]); //统一的输出格式

bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);

bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);

void main()

{

int i,j;

//当前可用每类资源的资源数

int iAvailable[M]={3,3,2};

//系统中N个进程中的每一个进程对M类资源的最大需求

int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};

//iNeed[N][M]每一个进程尚需的各类资源数

//iAllocation[N][M]为系统中每一类资源当前已分配给每一进程的资源数int iNeed[N][M],iAllocation[N][M]={{0,1,1},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};

//进程名

char cName[N]={'a','b','c','d','e'};

bool bExitFlag=true; //退出标记

char ch; //接收选择是否继续提出申请时传进来的值

bool bSafe; //存放安全与否的标志

//计算iNeed[N][M]的值

for(i=0;i

for(j=0;j

iNeed[i][j]=iMax[i][j]-iAllocation[i][j];

//输出初始值

output(iMax,iAllocation,iNeed,iAvailable,cName);

//判断当前状态是否安全

bSafe=safety(iAllocation,iNeed,iAvailable,cName);

//是否继续提出申请

while(bExitFlag)

{

cout<<"\n"<<"继续提出申请？\ny为是；n为否。\n";

cin>>ch;

switch(ch)

{

case 'y':

//cout<<"调用银行家算法";

bSafe=banker(iAllocation,iNeed,iAvailable,cName);

if (bSafe) //安全，则输出变化后的数据

output(iMax,iAllocation,iNeed,iAvailable,cName);

break;

case 'n':

cout<<"退出。\n";

bExitFlag=false;

break;

default:

cout<<"输入有误，请重新输入：\n";

}

}

}

//输出

void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])

{

int i,j;

cout<<"\n\t Max \tAllocation\t Need \t Available"<

cout<<"\tA B C\tA B C\tA B C\t A B C"<

for(i=0;i

{

cout<

for(j=0;j

cout<

cout<<"\t";

for(j=0;j

cout<

cout<<"\t";

for(j=0;j

cout<

cout<<"\t";

cout<<" ";

//Available只需要输出一次

if (i==0)

for(j=0;j

cout<

cout<

}

}

//安全性算法，进行安全性检查；安全返回true，并且输出安全序列，不安全返回false，并输出不安全的提示；

bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])

{

int i,j,flag,x=0;

char num[5];

int Work[M];

bool Finish[N]; //定义基本变量

for(j=0;j<3;j++)

Work[j]=iAvailable[j]; //将iAvailable的值赋给Work

for(i=0;i<5;i++) //将Finish全部置为False

Finish[i]=false;

while(true) //执行无限循环，满足条件时跳出

{

flag=0; //每次循环开始时将记录本次循环中是否有使有满足条件iAllocation的标志置为0，若为0表示不存在，若不为0表示存在for(i=0;i<5;i++) //执行循环，看有没有满足条件的iAllocation

{

if(Finish[i]==false&&Work[0]>=iNeed[i][0]&&Work[1]>=iNeed[i][1]&&Work[2]>=iNeed[i ][2])

{

for(j=0;j<3;j++)

{

Work[j]+= iAllocation[i][j] ; //Work[j]+= Work[j]+iAllocation[i][j] }

Finish[i]=true; //将Finish置true

flag++; //标志加1

num[x++]=cName[i]; //将该序列名赋给数组num[] }

}

if(flag==0)

{

cout<<"无安全序列"; //标志为0，证明已无满足条件iAllocation ，退出循环，返回false

return false;

}

if(Finish[0]==true&&Finish[1]==true&&Finish[2]==true&&Finish[3]==true&&Finish[4]== true) //若所有Finish置为true，输出安全数列，返回True {

cout<<"\n";

cout<<"安全序列为：";

for(x=0;x<5;x++)

cout<

cout<<"\n";

return true;

}

}

return true;

}

//安全返回true，不安全返回false

bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]) {

int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};

int t,i,Request[3],check_1[3];

char x; //定义变量

cout<<"请输入进程名："; //输入进程名

cin>>x;

if(x=='a')i=0;

if(x=='b')i=1;

if(x=='c')i=2;

if(x=='d')i=3;

if(x=='e')i=4;

cout<<"请输入各资源数量："; //输入变量名

for(t=0;t<3;t++)

cin>>Request[t];

for(t=0;t<3;t++) //检查数值{

check_1[t]=Request[t]+iAllocation[i][t];

}

for(t=0;t<3;t++)

{

if((iMax[i][t]-check_1[t])<0)

{

cout<<"\n资源申请超过最大需求量！！！\n";

return false;

}

}

for(t=0;t<3;t++) //检查数值

{

if((iAvailable[t]-Request[t])<0)

{

cout<<"\n不能满足进程！！！\n";

return false;

}

}

for(t=0;t<3;t++) //将该变量的iAvailable、iAllocation、iNeed重新赋值{

iAvailable[t]-=Request[t];

iAllocation[i][t]+=Request[t];

iNeed[i][t]-=Request[t];

}

safety(iAllocation,iNeed,iAvailable,cName); //执行安全数列算法

return true;

return true;

}

五、小结与思考

分析与思考

1．要找出某一状态下所有可能的安全序列，程序该如何实现？

答：要找出这个状态下的所有可能的安全序列，前提是要是使这个系统先处于安全状态，而

系统的状态可通过以下来描述：

进程剩余申请数=最大申请数-占有数；可分配资源数=总数-占有数之和；通过这个描述来算出系统是否安全，从而找出所有的安全序列。

2．银行家算法的局限性有哪些？

答：银行家算法是一种最有代表性的避免死锁的算法。银行家算法即把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也

要推迟分配。但任何一种算法都存在其缺点，对各进程的资源分配要求严格，经常使其处于不安全状态，银行家算法的主要局限是过于谨慎和检查各申请者对各类资源的最大需求量开销较大。

小结

通过本次实验，我知道了可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

银行家算法是避免死锁的主要方法，其思路在很多方面都非常值得我们来学习借鉴。