操作系统银行家算法

洛阳理工学院实验报告

学院计信学院班级学号姓名

课程名称操作系统实验日期10.17

实验名称实验二银行家算法成绩

实验目的：

1.了解进程产生死锁的原因，了解为什么要进行死锁的避免。

2.掌握银行家算法的数据结构，了解算法的执行过程，加深对银行家算法

的理解。

实验原理：

n个并发进程共享m个系统资源的系统，进程可动态申请资源和释放资源。

系统按各进程的申请动态的分配资源，先对用户提出的请求进行合法性检查，

再进行预分配，利用安全性检测算法进行安全性检测，如果系统分配资源，系

统进入安全状态，则预分配就是正式分配，如果系统分配资源，系统进入不安

全状态，则撤销预分配。

实验内容：

4include<stdio.h>

与include<stdlib.h>

「defineTRUE1

4defineFALSE0

inti,j,k,1；

intflag;

charc;

typedefstructBanker{

int"Available;〃可利用资源向量

int**Max;〃最大需求矩阵

int**A1location;〃分配矩阵

int**Need;〃需求矩阵

int**Rcqust;〃申请各类资源数量

int*Work;〃工作向量

int*Finish：〃结束向量

(Process;

intBank(Process"process,intm,intn);

intSafe(Process*process,intm,intn);

voidMax(Process*process,intm,intn);

voidNeed(Process"process,intm,intn);

voidAllocation(Process*process,intm,intn);

voidAvailable(Process^process,intn);

intRcqust(Process*process,intm,intn);

intBank(Process*process,intm,intn)

(

do〃资源请求失败或者系统不安全时flag=0,并重新输入。

(

if((flag=Requst(process,m,n))==1)

{

printf("请求并试分配成功。\n〃)；

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

(

(proccss->Available)[j]_=(proccss->Requst)[1][j];

(process->A11ocation)[1][j]+=(process->Requst)[1][j];

(process->Need)[1][j]-=(process->Requst)[1][j];

)

)

if(flag==l&&(flag=Safe(process,m,n))==0)//系统不安全,撤销资源

试分配

{

prinif("撤销资源试分配。\n〃)；

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

(process->Available)[j]+=(proccss->Rcqust)[1][j];

(process->Allocation)[1][j]-=(process->Requst)[1][j];

(process->Need)[1][j]+=(process->Requst)[1][j];

)

}

}while(flag==0);

if(flag==l)

(

printf("分配成功。\n");

printf(〃是否继续请求资源分配？输入Y继续，输入y结束：\n〃)；

getchar();

c=getchar();

if(c==，Y')return1;

if(c==，y')return0:

)

(

intSafe(Process"process,intm,intn)

(

(process->Work)=(int*)mal1oc(sizeof(int)*n);

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

(process->Work)[j]=(process->Available)[j];//系统可提供给进程

继续运行所需的各类资源数目

(process->Finish)=(int*)nicilloc(sizeof(int)*m);

for(i=0;i<m;i++)

(process->Finish)[i]:FALSE;

k=m;

intflagl;//当有不符合条件的资源时标记为0

intflag2;〃当所有进程不都分配成功时标记为0

int*s=(int*)malloc(sizeof(int)*m);〃记录安全序列

do

for(i=0;i<m;i++)//一轮分配

if((process->Finish)[i]二二FALSE)

(

flagl=l;

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

if((process->Need)[i][j]>(process->Work)[j])

flagl=0;//有不符合条件的资源

if(flagl==l)

(

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

*((process->Work)+j)+=*((process->Allocation)[i]+j);

(process->Finish)[i]=TRUE;

*s=i;

s++;

)

}

k--;〃每完成一次进程分配时k减1,以便跳出循环和防止死循环

}while(k>0);

flag2=l;

for(i=Oi〈叫i++)〃判断是否所有进程都完成

(

if((process->Finish)[i]—FALSE)

{

flag2=0;

break;

)

)

if(flag2==0)

printf(〃当前状态不安全！\n");

return0;

)

else

(

printf("当前状态安全!\n");

for(i=0;i<m;i++)s-;

printf("安全序列为：”);

for(i=0;i<m;i++)

printf(*P%d

printf(〃\n〃)；

free(s);

return1;

)

(

voidMax(Process*process,intm,intn)

(

process->Max=(int**)malloc(sizcof(int〃分配m个指针，用来

指向数组的首地址

for(i=0;i<m;i++)

(process->Max)[i]=(int*)malloc(sizeof(int)*n);//为每个数组分

配n个指针元素

printf(“输入各进程对各类资源的最大需求量：\n〃)；

for(i=0;i<m;i++)

(

printfC'P%d:\n",i);

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

scanf("%d”,((process->Max)[i]+j));

)

}

(

voidNeed(Process*process,intm,intn)

process->Need=(int**)malloc(sizeof(int

for(i=0;i<m;i++)

(process->Need)[i]=(int*)malloc(sizeof(int)*n);

printf(〃输入各进程对各类资源的需求量：\n〃)；

for(i=0;i<m;i++)

(

printf("P%d:\n”,i);

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

{

scanf(*%dz，,((process->Need)[i]+j));

)

(

(

voidAllocation(Process*process,intm,intn)

(

process->Allocation=(intloc(sizeof(int

for(i=0;i<m;i++)

(process->Allocation)[i]=(int*)malloc(sizeof(int)*n);

for(i=0;i<m;i++)

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

*((process->Allocation)[i]+j)=(*((process->Max)[i]+j))-(*((proces

s->Need)[i]+j));

}

voidAvai1able(Processxprocess,inrn)

process->Avai1able=(int*)malloc(sizeof(int)*n);

printf(〃输入系统可用资源数：\n〃)；

for(i=0;i<n;i++)

scanf&(process->Available)[i]);

intRequst(Process*process,intm,intn)

(

process->Requst=(int**)malloc(sizeof(int

for(i=0;i<m;i++)

(process->Requst)[i]=(int*)malloc(sizeof(int)*n);

printf("输入进程名及其资源请求量：\n〃)；

scanf&i);

l=i；

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

scanf("%d〃，(process->Requst)[i]+j);

intfla弁1=1;〃申请量大于需求量时标记为0

intflag2=l;〃申请量大于可利用资源量时标记为0

for(j=0;j〈n;j++)〃检查申请量是否小于等于需求量

if((process->Requst)[i][j]>(process->Need)[i][j])

flagl=0;

if(flagl==0)

(

printf(〃不允许申请量大于需求量！请重新输入。\n〃)；

return0;

)

if(flagl==l)

(

for(产O;j<n;j++)〃检查申请量是否小于等于系统中的可利用资源量

if((process->Requst)[i][j]>(process->Available)[j])

flag2=0;

if(flag2==0)

printf（〃不允许申请量大于可利用资源量！请重新输入。\n〃）；

return0;

)

elsereturn1;

}

}

intmain()

(

Processprocess;

intm,n;

printf(“请输入进程数：”)；

scanf&m);

printf("请输入资源种类数：〃)；

scanf("%d",&n);

Max(&process,m,n);

Need(&process,m,n);

Allocation(&process,m,n);

Available(&process,n);

Safe(&process,m,n);

while(Bank(&process,m,n));

return0;

}

实验结果：

请输入替源种黑l：3

修入各进程对各类资源的最大需求员:安全序列为：PlP3P4P0P2

输入进程名及其资源请求后：

p3

3122002

请求并试分配成功。

g62当前状态安全！

安全序列为：

1322