银行家算法的目标是为了避免死锁：
死锁的定义：一组相互竞争系统资源或进行通信的进程间的“永久”阻塞。（直白点，就是我占用你准备用的，你占用我准备用的，两者（或多者）互不相让，也不争抢，一直等待对方放手。）
死锁的条件：
- 互斥：一次只有一个进程可以使用一个资源。其他进程不能访问已分配给其他进程的资源。
- 占有且等待：当一个进程等待其他进程时，继续占有已分配的资源。
- 不可抢占：不能强行抢占进程已占有的资源。
- 循环等待：存在一个闭合的进程链，每个进程至少占有此链中下一个进程所需的一个资源。
处理死锁的三种方法：
采用某种策略消除死锁条件中的某个条件的出现（一般不会选择破坏互斥条件），来预防死锁
基于资源分配的当前状态做动态选择的避免死锁
试图检测死锁的存在并从死锁中恢复
银行家算法中涉及的数据结构：
1、可利用资源向量Available:表示含有m个元素的数组，其中每一个元素表示一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目。
最大需求矩阵Max。这是一个nm的矩阵，他定义了系统中n个进程中的每一个进程对m类资源的最大需求。
2、分配矩阵Allocation。这时一个nm的矩阵，定义了系统中每一类资源当前已分配给每一进程的资源数。
3、需求矩阵Need。这是一个n*m的矩阵，表示每一个进程尚需的各类资源数。
银行家算法步骤：
设Request_i是进程Pi的请求向量，如果Request_i[j]=K，表示进程Pi需要K个Rj类资源。当Pi发出资源请求后，系统按照下面的步骤进行检查：
如果Request_i[j]<=Need[i,j],便转向步骤2；否则认为出错，因为它所需要的资源数已超过了它所宣布的最大值。
如果Request_i[j]<=Available[j]，便转向步骤3；否则，表示尚无足够资源，Pi需等待。
系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
Available[j] = Available[j] - Request_i[j];
Allocation[i,j] = Allocation[i,j] + Request_i[j];
Need[i,j] = Need[i,j] - Request_i[j];
系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式的将资源分配给进程Pi，以完成此次分配；否则，将本次的试探分配作废，恢复原来的资源分配，让进程Pi等待。
安全性算法：
1.设置两个向量：1）工作向量Work，表示可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work=Available；2）Finish：表示系统是否有足够的资源分配给进程，使之运行完成。开始先做Finishp[i]=false;当有足够资源分配给进程时，在令Finish[i]=true。
2.从进程集合中找到一个能满足下述条件的进程：
1）Finish[i]=false;
2)Need[i,j]<=Work[j]
若找到，执行步骤3）；否则，执行步骤4).
3）当进程Pi获得资源后，可顺利执行，直到完成，并释放出分配给他的资源你，故应执行：
Work[[j] = Work[j] + Allocation[i,j];
Finish[i]=true;
go to step2 ;
4）如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。
完整代码：
#include<stdio.h>
#define res_Num 3
#define pro_Num 5
int available[res_Num]={3,3,2};//系统可用资源
int maxRequest[pro_Num][res_Num]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//进程的最大需求
int allocation[pro_Num][res_Num]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//进程已经分配资源
int need[pro_Num][res_Num]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//进程还需要资源
bool Finish[pro_Num];//是否有足够资源分配
int safeSeries[pro_Num]={0,0,0,0,0};//安全序列号
int request[res_Num];//进程请求资源量
int num;//资源数量计数
//打印输出系统信息
void Info()
{
printf("\n------------------------------------------------------------------------------------\n");
printf("当前系统各类资源剩余：\n\tres1\tres2\tres3\n");
for(int j = 0; j < res_Num; j++)
{
printf("\t%d",available[j]);
}
printf("\n\n当前系统资源情况：\n");
printf("进程\t 最大需求资源\t已分配资源\t 还需要资源\n");
for(int i = 0; i < pro_Num; i++)
{
printf(" P%d\t",i);
for(int j = 0; j < res_Num; j++)
{
printf("%2d",maxRequest[i][j]);
}
printf("\t\t");
for(j = 0; j < res_Num; j++)
{
printf("%2d",allocation[i][j]);
}
printf("\t\t");
for(j = 0; j < res_Num; j++)
{
printf("%2d",need[i][j]);
}
printf("\n");
}
}
//判断一个进程的资源是否全为零
bool isAllZero(int kang)
{
num = 0;
for(int i = 0; i < res_Num; i++ )
{
if(need[kang][i] == 0)
{
num ++;
}
}
if(num == res_Num)
{
return true;
}
else
{
return false;
}
}
//安全检查
bool check_Safe()
{
//int resourceNumFinish = 0;
int safeIndex = 0;
int allFinish = 0;
int work[res_Num] = {0};
int r = 0;
int temp = 0;
int pNum = 0;
//预分配为了保护available[]
for(int i = 0; i < res_Num; i++)
{
work[i] = available[i];
}
//把未完成进程置为false
for(i = 0; i < pro_Num; i++)
{
bool result = isAllZero(i);
if(result == true)
{
Finish[i] = true;
allFinish++;
}
else
{
Finish[i] = false;
}
}
//预分配开始
while(allFinish != pro_Num)
{
num = 0;
for(i = 0; i < res_Num; i++)
{
if(need[r][i] <= work[i] && Finish[r] == false)
{
num ++;
}
}
if(num == res_Num)
{
for(i = 0; i < res_Num; i++ )
{
work[i] = work[i] + allocation[r][i];
}
allFinish ++;
safeSeries[safeIndex] = r;
safeIndex ++;
Finish[r] = true;
}
r ++;
if(r >= pro_Num)
{
r = r % pro_Num;
if(temp == allFinish)
{
break;
}
temp = allFinish;
}
pNum = allFinish;
}
//判断系统是否安全
for(i = 0; i < pro_Num; i++)
{
if(Finish[i] == false)
{
printf("\n当前系统不安全！\n\n");
return false;
}
}
return true;
}
//主函数
void main()
{
int cur_Pro = 0;
int a = -1;
Info();
bool isStart = check_Safe();
while(isStart)
{
do
{
if(cur_Pro >= pro_Num || a == 0)
{
printf("\n请不要输入超出进程数量的值或者其他字符：\n");
while(getchar() != '\n'){};//清空缓冲区
a = -1;
}
printf("\n------------------------------------------------------------------------------------\n");
printf("\n输入要分配的进程：");
a = scanf("%d",&cur_Pro);
printf("\n");
}while(cur_Pro >= pro_Num || a == 0);
//限制用户输入，此处只接受数字，以防用户输入其他字符（乱输是不允许的）
for(int i = 0; i < res_Num; i++)
{
do
{
if(a == 0)
{
printf("\n请不要输入除数字以外的其他字符，请重新输入：\n");
while(getchar() != '\n'){};//清空缓冲区
a = -1;
}
printf("请输入要分配给进程 P%d 的第 %d 类资源：",cur_Pro,i+1);
a = scanf("%d", &request[i]);
}while( a == 0);
}
//判断用户输入的分配是否合理，如果合理，开始进行预分配
num = 0;
for(i = 0; i < res_Num; i++)
{
if(request[i] <= need[cur_Pro][i] && request[i] <= available[i])
{
num ++;
}
else
{
printf("\n进程资源分配发生错误！可能原因如下：\n(1)请求分配的资源可能大于该进程的某些资源的最大需要！\n(2)系统所剩的资源不足！\n");
break;
}
}
if(num == res_Num)
{
num = 0;
for(int j = 0; j < res_Num; j++)
{
//分配资源
available[j] = available[j] - request[j];
allocation[cur_Pro][j] = allocation[cur_Pro][j] + request[j];
need[cur_Pro][j] = need[cur_Pro][j] - request[j];
//记录分配以后，是否该进程需要值为0了
if(need[cur_Pro][j] == 0)
{
num ++;
}
}
//如果分配以后出现该进程对所有资源的需求为0了，即刻释放该进程占用资源（视为完成）
if(num == res_Num)
{
//释放已完成资源
for(int i = 0; i < res_Num; i++ )
{
available[i] = available[i] + allocation[cur_Pro][i];
}
printf("\n\n本次分配进程 P%d 完成,该进程占用资源全部释放完毕！\n",cur_Pro);
}
else
{
//资源分配可以不用一次性满足进程需求
printf("\n\n本次分配进程 P%d 未全部完成！\n",cur_Pro);
}
Info();
printf("\n当前系统安全!\n");
//预分配完成以后，判断该系统是否安全，若安全，则可继续进行分配，若不安全，将已经分配的资源换回来
if(!check_Safe())
{
for(int j = 0; j < res_Num; j++)
{
available[j] = available[j] + request[j];
allocation[cur_Pro][j] = allocation[cur_Pro][j] - request[j];
need[cur_Pro][j] = need[cur_Pro][j] +request[j];
}
printf("资源不足，等待中...\n\n分配失败！\n");
}
}
}
}
扫一扫
643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
