死锁的避免实验报告

信息科学与技术学院实验报告

课程名称: 操作系统实验项目: 死锁的避免

实验地点:指导教师: 日期:

实验类型:（验证性实验综合性实验设计性实验）

专业: 计算机服务外包班级: 14外3 姓名: 周鹏飞学号: 1414104033

一、实验目的及要求

了解死锁避免的概念，掌握避免死锁的算法

二、实验仪器、设备或软件

VC++6.0

三、实验内容及原理

银行家算法流程图：

银行家算法是死锁处理中较为经典的一种避免死锁的方法，它一般分为单资源银行家算法和多资源银行家算法，所谓单资源银行家算法是指只有一种可用资源，多银行家算法是指由多种可用资源，它主要是通过合理的分配资源使得系统不产生死锁的思想来完成。

1.Available是一个长度为m的向量，它表示每类资源可用的数量，Available【j】=k表

示rj类资源可用的数量为k。

2.Max是一个n*m矩阵，它表示每个进程对资源的最大需求，Max【i，j】=k，表示进程之

多可用申请k个rj类资源单位。

3，Allocation是一个n*m矩阵，它表示当前分给每个进程的资源数目。Allocation【i，j】=k，表示进程当前分到k个rj类资源。

4.Need是一个n*m矩阵，它表示每个进程还缺少多少资源。Need【i，j】=k，表示进程尚

需k个rj类资源才能完成其任务。显然Need【i，j】=Max【i，j】-Allocation【i，j】。

当输入进程数与资源数，以及各进程所需的资源和已分配资源之后，系统就会寻找安全序列，若能找到一个安全序列，则结果表明当前系统安全，若找不到则当前系统不安全。

假设进程P提出请求Request[i]，则银行家算法按如下步骤进行判断：

1)如果Request[i] <=Need[i]，则转向2）；否则出错。

2)如果Request[i] <=Available[i]，则转向3）；否则出错。

3)系统试探分配相关资源，修改相关数据：

Available[i]=Available[i]-Request[i];

Allocation[i]=Allocation[i]+Request[i];

Need[i]=Need[i]-Request[i];

4)系统执行安全性检查，如安全，则分配成立；否则试探性分配资源作废，系统恢复原状，

进程进入等待状态。

4.1.2安全检测函数（check）

1）设置两个向量work和finish：work = available，表示系统可提供给进程继续运行所需的各类资源数目；finish表示系统是否有足够的资源分配给进程，使之完成。开始时先做finish【i】：=false；当有足够资源分配给进程时，再令finish【i】：=true。

2）从进程集合中找到一个嫩满足下述条件的进程：

a：finish【i】=false；b：need【i】【j】<=work[j];若找到，执行（3），否则，执行（4）。

3）：当进程i获得资源后，可顺利执行，直到完成，并释放出分配给它的资源，故应执行：

Work【j】：=work【j】+allocation[i,j];

Finish[i]:=true;

A[v++]=I;

Go to step 2;

4）：如果所有进程的finish【i】=true都满足，则表示系统处于安全状态，输出安全

序列，否则系统处于不安全状态。

四、实验步骤（或过程）

#include

#include

#include

#define False 0

#define True 1

int Max[100][100]={0};//各进程所需各类资源的最大需求

int Avaliable[100]={0};//系统可用资源

char name[100]={0};//资源的名称

int Allocation[100][100]={0};//系统已分配资源

int Need[100][100]={0};//还需要资源

int Request[100]={0};//请求资源向量

int temp[100]={0};//存放安全序列

int Work[100]={0};//存放系统可提供资源

int M=100;//作业的最大数为100

int N=100;//资源的最大数为100

void showdata()//显示资源矩阵

{

int i,j;

cout<<"系统目前可用的资源[Avaliable]:"<

for(i=0;i

cout<

cout<

for (j=0;j

cout<

cout<

cout<<" Max Allocation Need"<

cout<<"进程名 ";

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

for(i=0;i

cout<

cout<<" ";

}

cout<

for(i=0;i

cout<<" "<

for(j=0;j

cout<

cout<<" ";

for(j=0;j

cout<

cout<<" ";

for(j=0;j

cout<

cout<

}

}

int changdata(int i)//进行资源分配

{

int j;

for (j=0;j

Avaliable[j]=Avaliable[j]-Request[j];

Allocation[i][j]=Allocation[i][j]+Request[j]; Need[i][j]=Need[i][j]-Request[j];

}

return 1;

}

int safe()//安全性算法

{

int i,k=0,m,apply,Finish[100]={0};

int j;

int flag=0;

Work[0]=Avaliable[0];

Work[1]=Avaliable[1];

Work[2]=Avaliable[2];

for(i=0;i

apply=0;

for(j=0;j

if (Finish[i]==False&&Need[i][j]<=Work[j]){ apply++;

if(apply==N){

for(m=0;m

Work[m]=Work[m]+Allocation[i][m];//变分配数

Finish[i]=True;

temp[k]=i;

i=-1;

k++;

flag++;

}

}

}

}

for(i=0;i

if(Finish[i]==False){

cout<<"系统不安全"<

return -1;

}

}

cout<<"系统是安全的!"<

cout<<"分配的序列:";

for(i=0;i

cout<

if(i";

}

cout<

return 0;

}

void share()//利用银行家算法对申请资源对进行判定

{

char ch;

int i=0,j=0;

ch='y';

cout<<"请输入要求分配的资源进程号(0-"<

cin>>i;//输入须申请的资源号

cout<<"请输入进程 "<

for(j=0;j

{

cout<

cin>>Request[j];//输入需要申请的资源

}

for (j=0;j

if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错

{

cout<<"进程 "<

cout<<" 分配不合理，不予分配！"<

ch='n';

break;

}

else {

if(Request[j]>Avaliable[j])//判断申请是否大于当前资源，若大于则 { //出错

cout<<"进程"<

cout<<" 分配出错，不予分配!"<

ch='n';

break;

}

}

}

if(ch=='y') {

changdata(i);//根据进程需求量变换资源

showdata();//根据进程需求量显示变换后的资源

safe();//根据进程需求量进行银行家算法判断

}

}

void addresources(){//添加资源

int n,flag;

cout<<"请输入需要添加资源种类的数量:";

cin>>n;

flag=N;

N=N+n;

for(int i=0;i

cout<<"名称:";

cin>>name[flag];

cout<<"数量:";

cin>>Avaliable[flag++];

}

showdata();

safe();

}

void delresources(){//删除资源

char ming;

int i,flag=1;

cout<<"请输入需要删除的资源名称：";

do{

cin>>ming;

for(i=0;i

if(ming==name[i]){

flag=0;

break;

}

if(i==N)

cout<<"该资源名称不存在，请重新输入：";

}

while(flag);

for(int j=i;j

{

name[j]=name[j+1];

Avaliable[j]=Avaliable[j+1];

}

N=N-1;

showdata();

safe();

}

void changeresources(){//修改资源函数

cout<<"系统目前可用的资源[Avaliable]:"<

cout<>Avaliable[0]>>Avaliable[1]>>Avaliable[2]; cout<<"经修改后的系统可用资源为"<

for (int k=0;k

cout<

safe();

}

void addprocess(){//添加作业

int flag=M;

M=M+1;

cout<<"请输入该作业的最打需求量[Max]"<

cout<

cin>>Max[flag][i];

Need[flag][i]=Max[flag][i]-Allocation[flag][i];

}

showdata();

safe();

}

int main()//主函数

{

int i,j,number,choice,m,n,flag;

char ming;

cout<<"*****************资源管理系统的设计与实现*****************"<

cin>>n;

N=n;

for(i=0;i

{

cout<<"资源"<

cin>>ming;

name[i]=ming;

cout<<"资源的数量:";

cin>>number;

Avaliable[i]=number;

}

cout<

cout<<"请输入作业的数量:";

cin>>m;

M=m;

cout<<"请输入各进程的最大需求量("<

for(i=0;i

for(j=0;j

cin>>Max[i][j];

do{

flag=0;

cout<<"请输入各进程已经申请的资源量("<

for(i=0;i

for(j=0;j

cin>>Allocation[i][j];

if(Allocation[i][j]>Max[i][j])

flag=1;

Need[i][j]=Max[i][j]-Allocation[i][j];

}

if(flag)

cout<<"申请的资源大于最大需求量，请重新输入!\n";

}

while(flag);

showdata();//显示各种资源

safe();//用银行家算法判定系统是否安全

while(choice)

{

cout<<"**************银行家算法演示***************"<

cout<<" 2:删除资源 "<

cout<<" 3:修改资源 "<

cout<<" 4:分配资源 "<

cout<<" 5:增加作业 "<

cout<<" 0:离开 "<

cout<<"*******************************************"<

cin>>choice;

switch(choice)

{

case 1: addresources();break;

case 2: delresources();break;

case 3: changeresources();break;

case 4: share();break;

case 5: addprocess();break;

case 0: choice=0;break;

default: cout<<"请正确选择功能号(0-5)!"<

}

}

return 1;

}

五、实验结论

1、实验结果

多资源银行家算法测试的结果如图所示：图1

图2

图1所示的是：系统中有3个可用的资源a b c，数量都是10，系统中有3个作业，他们最大需求量分别是1 2 3、1 2 3、1 2 3，而他们已经申请的资源是1 1 1、1 1 1、1 1 1，由于系统可用的资源a b c 都是10个，通过银行家算法可以使得任何一个作业完成释放自己得到的资源，从而使得整个系统正常运行，系统是安全。

图2所示的是：系统中有3个可用的资源a b c，数量都为0，系统中有3个作业，他们的最大需求量分别是1 1 1、1 1 1、1 1 1，而他们已经申请的资源是0 0 0、0 0 0、0 0 0，由于系统中可用资源都为0，通过银行家算法任何作业都无法完成释放自己的资源。从而使得整个系统不能正常运行，系统是不安全。

单资源银行家算法结果如下所示：

图3

图4

图3所示的是：系统中有一个可用的资源a，他的资源数量是10，系统中有2个作业，他们的最大需要量分别是8、9，他们已经申请的资源分别是2、3，而系统可用的资源为10，通过银行家算法可以使任何一个作业完成释放自己的资源，进而使得整个系统正常运行，系统是安全。

图4所示的是：系统中有一个可用的资源a，他的资源数量是10，系统中有2个作业，他们的最大需求量分别是12、12，他们已经申请的资源分别是1、1，而系统可用的资源为10，通过银行家算法不能使得任何一个作业都无法完成释放自己的资源，进而使得整个系统不能正常运行，系统是不安全的。

2、分析讨论

六、指导教师评语及成绩