银行家算法C语言代码

实验名称：

银行家算法

* 名： ***

学 号： **********

专业班级： 创新实验班111

指导老师： **

实验题目

银行家算法

实验目的

更深层的了解银行家算法是如何避免死锁的

设计思想

银行家算法是根据进程的请求，假设在已分配给该进程请求的资源后，进行安全性算法，如果都能满足其他进程的请求，则满足该进程的请求，否则挂起该进程的请求。假设在一个系统中，知道相应的进程的状态（最大需求、已占用的资源量、还需要的资源量和可利用的资源数），某个进程发出请求，在请求满足两大请求（小于还需要的资源并小于可利用资源数）时，分配给该进程相应的资源，再进行安全检测，在确认安全的情况下，才把资源真正分配给该进程，否则终止请求！

主要数据结构

根据算法的相应需求，需要定义int max[M][M];

int allocation[M][M];

int need[M][M];

int available[M];

int work[M]；

等数组

流程图

开始

结束 输入总进程数

输入资源数

输入Max矩阵

输入Allocation矩阵

是否添加进程请求

输入进程号和请求资源 否 是 运行结果

图（1）分配进程的相应状态

图（2）请求和请求完全部资源后释放资源

图（3）继续请求并释放其他进程

图（2）所有进程请求完成后系统资源还原

附录

原代码如下：

# include "stdio.h"

# define M 50

int max[M][M];

int allocation[M][M];

int need[M][M];

int available[M];

int i, j, n, m, anquan,x=0;

/*7 5 3 0 1 0 7 4 3 3 3 2

3 2 2 2 0 0 1 2 2

9 0 2 3 0 2 6 0 0

2 2 2 2 1 1 0 1 1

4 3 3 0 0 2 4 3 1*/

main()

{ void check();

int p,q,control;

int req[M],allocation1[M][M],need1[M][M],available1[M];

printf("输入进程总数:");

scanf("%d", &n);

printf("输入资源种类数量:");

scanf("%d", &m);

printf("输入需求矩阵Max:\n");

for(i=0;i

for(j=0;j

scanf("%2d",&max[i][j]);

printf("输入已分配矩阵Allocation:\n");

for(i=0;i

for(j=0;j

scanf("%d", &allocation[i][j]);

for (i=0;i

for(j=0;j

need[i][j]=max[i][j]-allocation[i][j];

printf("输入资源的系统初始值:\n");

for (j=0;j

scanf("%d", &available[j]);

for (j=0;j

for(i=0;i

check();

if (anquan==1) //如果已知的状态安全则执行以下代码

{

for(control=0;;control++)

{ p=0,q=0;

printf("输入请求的进程号: ");

scanf("%d", &i);

printf("输入该进程的请求资源数组:");

for(j=0;j

scanf("%d",&req[j]);

for(j=0;j

if(req[j]>need[i][j])

p=1;

if(p)

printf("请求资源大于该进程还需要的资源!\n");

else

{

for(j=0;j

if(req[j]>available[j])//判断请求是否大于可用资源

q=1;

if(q)

printf("可用资源不能满足请求!\n");

else

{

for(j=0;j

{

available1[j]=available[j]; //保持资源的当前

allocation1[i][j]=allocation[i][j];

need1[i][j]=need[i][j];

available[j]=available[j]-req[j]; //尝试把资源分配给进程

allocation[i][j]=allocation[i][j]+req[j];

need[i][j]=need[i][j]-req[j];

if(need[i][j]==0)

x=x+1; //当进程满足时释放资源

}

if(x==m)

for(j=0;j

{

available[j]=available[j]+allocation[i][j];

allocation[i][j]=0; available1[j]=available[j];

x--;

}

else x=0;

check();

if(anquan==0)

{for (j=0;j

{ available[j]=available1[j]; //还原分配前的状态

allocation[i][j]=allocation1[i][j];

need[i][j]=need1[i][j];

}

printf("执行该进程不安全！返回继续操作。\n");

}

}

}

printf("是否继续请求?\n");

}

}

}

void check() //安全性算法

{ int k, f, no=0;

int work[M],a[M];

char finish[M];

anquan=1;

for(i=0;i

finish[i]='F';

for(j=0;j

work[j]=available[j];

k=n;

do

{

for (i=0;i

{if (finish[i]=='F')

{ f=1;

for (j=0;j

if (need[i][j]>work[j])

f=0;

if (f==1) //找到还没完成的且需求数小于可提供进程继续运行的

{ finish[i]='T';

a[no++]=i; //记录安全序列号

for (j=0;j

work[j]=work[j]+allocation[i][j]; //释放该进程已分配的资源

available[j] =work[j];