银行家算法
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了银行家算法相关的知识，希望对你有一定的参考价值。
最大资源数 A B C D F
5 3 8 2 10
进程名
P1 3 3 5 0 5
P2 5 3 8 1 2
P3 2 1 2 0 4
P4 4 0 7 0 5
P5 1 2 3 2 5
P6 3 2 6 2 9
3、采用时间片轮转法调度进程。
4、进程执行时提出资源请求（可利用随机数给出或从键盘输入）。
5、判断资源是否可以安全分配，要求进程每提出一个资源请求，都要进行安全判断并给出安全序列，否则给出提示。
三、实验报告
1、程序中使用的数据结构及符号说明。
2、给出主要算法的流程图。(可以不写)
3、给出程序清单并附上注释。
4、给出测试数据和运行结果。
#include "stdlib.h"
#define M 5
#define N 3
int max[M][N]=7,5,3,3,2,2,9,0,2,2,2,2,4,3,3;
int need[M][N]=7,4,3,1,2,2,6,0,0,0,1,1,4,3,1;
int allocation[M][N]=0,1,0,2,0,0,3,0,2,2,1,1,0,0,2;
int request[N]=0;
int finish[M]=0;
int available[N]=3,3,2;
int work[N]=3,3,2;
int safe[M]=0;
int n=1,m=1;
void showdata()
int i,j;
printf("系统可用的资源数为:\n");
for (j=0;j<N;j++)
printf("资源%c: %d \n",j+65, work[j]);
printf("\n");
printf("进程还需要的资源量: \n");
printf(" A B C\n" );
for(i=0;i<M;i++)
printf("进程p%d:",i);
for(j=0;j<N;j++)
printf(" %d ", need[i][j]);
printf("\n");
printf("进程已经得到的资源量:\n");
printf(" A B C\n" );
for(i=0;i<M;i++)
printf("进程%d:",i);
for(j=0;j<N;j++)
printf(" %d ",allocation[i][j]);
printf("\n");
void fp(int i)
for(int j=0;j<N;j++)
work[j]=work[j]+allocation[i][j];
finish[i]=1;
void secure()
showdata();
int y=0,flag=6,h,i,j;
while(flag)
for(i=0;i<M;i++)
for(j=0;j<N;j++)
if((finish[i]==0)&&(need[i][j]<=work[j]))
continue;
else
j=15;
if(j==N)
fp(i);
safe[y++]=i;
i=15;
else
continue;
flag--;
for( h=0;h<M;h++)
if(finish[h]==1)
continue;
else
h=M+1;
if(h==M)
printf("该状态安全！安全序列是:\n");
for(int l=0;l<M;l++)
if(l==M-1)
printf("p%d",safe[l]);
else
printf("p%d-->",safe[l]);
n=1;
else
n=0;
printf("该状态不安全！！");
void sfp(int k)
for(int i=0;i<N;i++)
work[i]=work[i]-request[i];
allocation[k][i]+=request[i];
need[k][i]-=request[i];
secure();
if(n==1)
printf("给与分配！\n");
else if(n==0)
printf("不给与分配！\n");
int choice(int k)
int e=1;
printf("输入选择的量:\n");
while(e)
for(int i=0;i<N;i++)
printf("资源%c:",65+i);
scanf("%d",&request[i]);
for(int j=0;j<N;j++)
if((request[j]<=need[k][j])&&(request[j]<=work[j]))
continue;
else
printf("资源%c申请超量！不与分配!",65+j);
return 0;
e=0;
if(j==N)
printf("可以试申请！\n");
return 1;
e=0;
void recover(int k)
for(int i=0;i<N;i++)
work[i]=available[i];
need[k][i]+=request[i];
allocation[k][i]-=request[i];
void main()
int p=1,k=1,i=0,c,f;
while(k)
printf("请选择：1:显示进程情况；2:判断此时状态是否安全；3:选择进程进行申请资源；4：结束程序！");
scanf("%d",&c);
switch(c)
case 1:showdata();break;
case 2:secure();work[0]=3;for(i=0;i<N;i++) work[i]=available[i];
break;
case 3: for(i=0;i<M;i++)
finish[i]=0;
printf("请选择进程（0--4）:\n");
scanf("%d",&f);
if(choice(f))
sfp(f);
recover(f);
else
printf("不与分配");
break;
case 4:k=0;
break;
default:k=0;break;
printf("\n");
参考技术B #include<stdio.h>
#include<stdlib.h>
struct type
int a;
int b;
int c;
;
struct allocation
struct type value;
struct allocation *next;
;
struct max
struct type value;
struct max *next;
;
struct available
struct type value;
struct available *next;
;
struct need
struct type value;
struct need *next;
;
struct path
int value;
struct path *next;
;
struct finish
int value;
struct finish *next;
;
void main()
int p,status=0,i,j,temp,flag=0;
struct allocation *allochead,*alloc1,*alloc2,*alloctemp;
struct max *maxhead,*max1,*max2,*maxtemp;
struct available *availablehead,*workhead,*worktemp;
struct need *needhead,*need1,*need2,*needtemp;
struct path *pathhead,*path1,*path2,*pathtemp;
struct finish *finishhead,*finish1,*finish2,*finishtemp;
printf("请输入进程的数目\n");
scanf("%d",&p);
for(i=0;i<p;i++)
printf("\n输入进程p%d已经分配的资源\n",i+1);
if(flag==0)
allochead=alloc1=alloc2=(struct allocation*)malloc(sizeof(struct allocation));
printf("\t当前资源类型是 %c\t",'a');
scanf("%d",&alloc1->value.a);
printf("\t当前资源类型是 %c\t",'b');
scanf("%d",&alloc1->value.b);
printf("\t当前资源类型是 %c\t",'c');
scanf("%d",&alloc1->value.c);
flag++;
allochead=alloc1;
else
alloc2=(struct allocation*)malloc(sizeof(struct allocation));
printf("\t当前资源类型是 %c\t",'a');
scanf("%d",&alloc2->value.a);
printf("\t当前资源类型是 %c\t",'b');
scanf("%d",&alloc2->value.b);
printf("\t当前资源类型是 %c\t",'c');
scanf("%d",&alloc2->value.c);
alloc1->next=alloc2;
alloc1=alloc2;
flag++;
alloc2->next=NULL;
flag=0;
for(i=0;i<p;i++)
printf("\n输入进程p%d要求的最大数目\n",i+1);
if(flag==0)
maxhead=max1=max2=(struct max*)malloc(sizeof(struct max));
printf("\t当前资源类型是 %c\t",'a');
scanf("%d",&max1->value.a);
printf("\t当前资源类型是 %c\t",'b');
scanf("%d",&max1->value.b);
printf("\t当前资源类型是 %c\t",'c');
scanf("%d",&max1->value.c);
maxhead=max1;
flag++;
else
max2=(struct max*)malloc(sizeof(struct max));
printf("\t当前资源类型是 %c\t",'a');
scanf("%d",&max2->value.a);
printf("\t当前资源类型是 %c\t",'b');
scanf("%d",&max2->value.b);
printf("\t当前资源类型是 s %c\t",'c');
scanf("%d",&max2->value.c);
max1->next=max2;
max1=max2;
flag++;
max2->next=NULL;
flag=0;
printf("\n请输入可以利用是资源数目\n");
availablehead=workhead=(struct available*)malloc(sizeof(struct available));
printf("\n");
printf("\t当前资源类型是 %c\t",'a');
scanf("%d",&availablehead->value.a);
printf("\t当前资源类型是 %c\t",'b');
scanf("%d",&availablehead->value.b);
printf("\t当前资源类型是 %c\t",'c');
scanf("%d",&availablehead->value.c);
workhead=availablehead;
workhead->value=availablehead->value;
flag=0;
alloctemp=allochead;
maxtemp=maxhead;
for(i=0;i<p;i++)
if(flag==0)
needhead=need1=need2=(struct need*)malloc(sizeof(struct need));
need1->next=need2->next=NULL;
need1->value.a=(maxtemp->value.a)-(alloctemp->value.a);
need1->value.b=(maxtemp->value.b)-(alloctemp->value.b);
need1->value.c=(maxtemp->value.c)-(alloctemp->value.c);
needhead=need1;
flag++;
else
need2=(struct need*)malloc(sizeof(struct need));
need2->value.a=(maxtemp->value.a)-(alloctemp->value.a);
need2->value.b=(maxtemp->value.b)-(alloctemp->value.b);
need2->value.c=(maxtemp->value.c)-(alloctemp->value.c);
need1->next=need2;
need1=need2;
flag++;
maxtemp=maxtemp->next;
alloctemp=alloctemp->next;
need2->next=NULL;
flag=0;
for(i=0;i<p;i++)
if(flag==0)
finishhead=finish1=finish2=(struct finish*)malloc(sizeof(struct finish));
finish1->next=finish2->next=NULL;
finish1->value=0;
finishhead=finish1;
flag++;
else
finish2=(struct finish*)malloc(sizeof(struct finish));
finish2->value=0;
finish1->next=finish2;
finish1=finish2;
flag++;
finish2->next=NULL;
flag=0;
for(temp=0;temp<p;temp++)
alloctemp=allochead;
needtemp=needhead;
finishtemp=finishhead;
worktemp=workhead;
for(j=0;j<p;j++)
if(finishtemp->value==0)
if((needtemp->value.a<=worktemp->value.a)&&(needtemp->value.b<=worktemp->value.b)&&(needtemp->value.c<=worktemp->value.c))
worktemp->value.a+=alloctemp->value.a;
worktemp->value.b+=alloctemp->value.b;
worktemp->value.c+=alloctemp->value.c;
finishtemp->value=1;
if(flag==0)
pathhead=path1=path2=(struct path*)malloc(sizeof(struct path));
path1->next=path2->next=NULL;
path1->value=j+1;
pathhead=path1;
flag++;
else
path2=(struct path*)malloc(sizeof(struct path));
path2->value=j+1;
path1->next=path2;
path1=path2;
flag++;
finishtemp=finishtemp->next;
alloctemp=alloctemp->next;
needtemp=needtemp->next;
else
finishtemp=finishtemp->next;
alloctemp=alloctemp->next;
needtemp=needtemp->next;
else
finishtemp=finishtemp->next;
alloctemp=alloctemp->next;
needtemp=needtemp->next;
path2->next=NULL;
finishtemp=finishhead;
pathtemp=pathhead;
for(temp=0;temp<p;temp++)
if(finishtemp->value==0)
printf("\n警告!当前系统是不安全的\n");
exit(0);
finishtemp=finishtemp->next;
printf("\n当前系统是安全的!\n");
printf("\n安全序列为: \n");
for(i=0;i<p;i++)
printf("p%d\t",pathhead->value);
pathhead=pathhead->next;
本回答被提问者采纳
银行家算法超清晰代码
一、实验目的
- 理解死锁的概念，了解导致死锁的原因。
- 掌握死锁的避免方法，理解安全状态和不安全状态的概念。
- 理解银行家算法，并应用银行家算法避免死锁。
二、实验原理
银行家算法的基本思想：分配资源之前，判断系统是否处于安全状态，若处于安全状态则分配资源，否则不进行分配。该算法是典型的避免死锁算法。
银行家算法的基本结构如下：
假设Requesti是进程 Pi 的资源请求向量， 如果Requesti [j] = k，表示进程 Pi 需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查。
（1）如果Requesti[j]£ Need[I, j]，则转向步骤（2），否则认为出错，因为进程所申请的资源数已经超过所需要的最大数。
（2）如果Requesti[j]£ Available, 则转向步骤（3）， 否则表示尚无足够的资源，Pi 必须等待。
（3）系统试探着将资源分配给进程Pi，并修改下面数据结构中的数值。
Available[j]:= Available[j]–Requesti[j] ;
Allocation[I, j]:= Allocation[I, j] + Requesti[j];
Need[I, j]:= Need[I, j]–Requesti[j]；
（4）系统在安全状态下执行，每次资源分配前都检查此次资源分配后系统是否处于安全状态。若处于安全状态，则将该资源分配给进程Pi；否则，此次试探分配行为取消，恢复原来的资源分配状态，让进程Pi等待。
银行家算法的数据结构：
Available: 长度为 m的向量。如果available[j]=k，那么资源Rj有k个实例有效；
Max: n x m 矩阵。 如果Max[i,j]=k，那么进程Pi可以最多请求资源Rj的k个实例；
Allocation: n x m 矩阵。如果Allocation[i,j]=k，那么进程Pj当前分配了k个资源Rj的实例；
Need: n x m 矩阵。如果Need[i,j]=k，那么进程Pj还需要k个资源Rj的实例；
Need [i,j] = Max[i,j] – Allocation [i,j].
银行家算法具体示例如下：
（1）5个进程P0、P1、P2 、P3、P4；3个资源类型A(10个实例），B（5个实例），C（7个实例）
（2）时刻T0的快照：
Allocation Max Available
A B C A B C A B C
P0 0 1 0 7 5 3 3 3 2
P1 2 0 0 3 2 2
P2 3 0 2 9 0 2
P3 2 1 1 2 2 2
P4 0 0 2 4 3 3
（3）矩阵的内容。Need被定义为Max– Allocation
（4）系统处在安全的状态，因为序列P1, P3, P4, P2, P0 满足安全标准
银行家算法