一、银行家算法
1.主要内容
银行家算法最初级为银行系统设计，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况。在OS设计中，用它来避免死锁。 为实现银行家算法，每个新进程在进入系统时它必须申明在运行过程中，可能需要的每种资源类型的最大单元数目，其数目不应超过系统所拥有的资源总量。当某一进程请求时，系统会自动判断请求量是否小于进程最大所需，同时判断请求量是否小于当前系统资源剩余量。若两项均满足，则系统试分配资源并执行安全性检查算法。
2.算法原理
以下四个数据结构用来描述系统中可利用的资源、所有进程对资源的最大需 求、系统中的资源分配以及所有进程还需多少资源的情况
1. 可利用资源向量 Available，其中每一个元素代表一类可利用的资源数 目，初始值是系统中所配置的该类全部可用资源数目，其数值随该类资源的分配 和回收而动态的改变。
2. 最大需求矩阵 Max，定义系统中 n 个进程对 m 类资源的最大需求。
3. 分配矩阵 Allocation，定义系统中每一类资源当前已分配给每一进程的 资源数。
4. 需求矩阵 Need，用来表示每一进程尚需的各类资源数。 上述三矩阵存在以下关系： Need[i, j] = Max[i, j]- Allocation[i, j] 设R i equest 是进程Pi 的请求向量，如果R i equest [j]=K,表示进程Pi 需要 K 个 R j 类型的资源。当Pi 发出资源请求后，系统按照以下步骤进行检查：
（1）.如果R i equest [j]<= Need[i, j] ,便转向步骤（2）；否则认为出错，因 为他所需的资源数已超过他所宣布的最大值。
（2）如果R i equest [i]<= Available[ j],便转向步骤（3）；否则表示尚无足 够资源，Pi 必须等待。 （3）系统试探着把资源分配给进程Pi ，并修改下面数据结构中的数值： Available[ j]= Available[ j]-R i equest [i]； Allocation[i, j] Allocation[i, j] Re quest [ j] i ； Need[i, j] Need[i, j] Re quest [ j] i ；
（4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安 全，才正式将资源分配给进程Pi ，以完成本次分配；否则，将本次的试探分配作 废，恢复原来的资源分配状态，让进程Pi 等待。
3.算法实现
#include<stdio.h>
#include<stdlib.h>
#include<string>
#define False 0
#define True 1
/********主要数据结构********/
char NAME[100]={0};//资源的名称
int Max[100][100]={0};//最大需求矩阵
int Allocation[100][100]={0};//系统已分配矩阵
int Need[100][100]={0};//还需要资源矩阵
int Available[100]={0};//可用资源矩阵
int Request[100]={0};//请求资源向量
int Work[100]={0};//存放系统可提供资源量
int Finish[100]={0}; //标记系统是否有足够的资源分配给各个进程
int Security[100]={0};//存放安全序列
int M=100;//进程的最大数
int N=100;//资源的最大数
/********初始化数据：输入进程数量、资源种类、各种资源可利用数量、
各进程对资源最大需求量、各进程的资源已分配数量等。********/
void init()
{
/* m为进程个数，即矩阵行数，n为资源种类，即矩阵列数。*/
int i,j,m,n;
int number,flag;
char name;//输入资源名称
int temp[100]={0};//统计已经分配的资源
//输入系统资源数目及各资源初试个数
printf("系统可用资源种类为:");
scanf("%d",&n);
N=n;
for(i=0;i<n;i++)
{
printf("资源%d的名称:",i);
fflush(stdin); //清空输入流缓冲区的字符，注意必须引入#include<stdlib.h>头文件
scanf("%c",&name);
NAME[i]=name;
printf("资源%c的初始个数为:",name);
scanf("%d",&number);
Available[i]=number;
}
//输入进程数及各进程的最大需求矩阵
printf("\n请输入进程的数量:");
scanf("%d",&m);
M=m;
printf("请输入各进程的最大需求矩阵的值[Max]:\n");
do{
flag = False;
for(i=0;i<M;i++)
for(j=0;j<N;j++)
{
scanf("%d",&Max[i][j]);
if(Max[i][j]>Available[j])
flag = True;
}
if(flag)
printf("资源最大需求量大于系统中资源最大量，请重新输入!\n");
} while(flag);
//输入各进程已经分配的资源量，并求得还需要的资源量
do{
flag=False;
printf("请输入各进程已经分配的资源量[Allocation]:\n");
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
scanf("%d",&Allocation[i][j]);
if(Allocation[i][j]>Max[i][j])
flag=True;
Need[i][j]=Max[i][j]-Allocation[i][j];
temp[j]+=Allocation[i][j];//统计已经分配给进程的资源数目
}
}
if(flag)
printf("分配的资源大于最大量，请重新输入!\n");
}while(flag);
//求得系统中可利用的资源量
for(j=0;j<N;j++)
Available[j]=Available[j]-temp[j];
}
void show_original_data()
{
int i,j;
printf("*************************************************************\n");
printf("系统目前可用的资源[Available]:\n");
for(i=0;i<N;i++)
printf("%c ",NAME[i]);
printf("\n");
for(j=0;j<N;j++)
printf("%d ",Available[j]);
printf("\n");
printf("系统当前的资源分配情况如下：\n");
printf(" Max Allocation Need\n");
printf("进程名 ");
//输出与进程名同行的资源名，Max、Allocation、Need下分别对应
for(j=0;j<3;j++){
for(i=0;i<N;i++)
printf("%c ",NAME[i]);
printf(" ");
}
printf("\n");
//输出每个进程的Max、Allocation、Need
for(i=0;i<M;i++){
printf(" P%d ",i);
for(j=0;j<N;j++)
printf("%d ",Max[i][j]);
printf(" ");
for(j=0;j<N;j++)
printf("%d ",Allocation[i][j]);
printf(" ");
for(j=0;j<N;j++)
printf("%d ",Need[i][j]);
printf("\n");
}
}
void showdata()
{
int i, j, k;
printf("*************************************************************\n");
printf("系统目前可用的资源[Available]:\n");
for (i = 0; i < N; i++)
printf("%c ", NAME[i]);
printf("\n");
for (i = 0; i < N; i++)
printf("%d ", Available[i]);
printf("\n");
printf("系统当前的资源分配情况如下：\n");
printf(" Work Need Allocation Work+Allocation\n");
printf("进程名 ");
// 输出与进程名同行的资源名，Max、Allocation、Need下分别对应
for (j = 0; j < 4; j++) {
for (i = 0; i < N; i++)
printf("%c ", NAME[i]);
printf(" ");
}
printf("\n");
// 初始化Work数组为Available
for (i = 0; i < N; i++)
Work[i] = Available[i];
// 按照安全序列输出每个进程的Max、Allocation、Need
for (k = 0; k < M; k++) {
i = Security[k]; // 根据安全序列获取当前进程号
printf(" P%d ", i);
for (j = 0; j < N; j++) {
printf("%d ", Work[j]); // 显示当前进程的Work
}
printf(" ");
for (j = 0; j < N; j++)
printf("%d ", Need[i][j]);
printf(" ");
for (j = 0; j < N; j++)
printf("%d ", Allocation[i][j]);
printf(" ");
for (j = 0; j < N; j++) {
printf("%d ", Work[j] + Allocation[i][j]);
}
printf("\n");
// 更新Work为下一个进程的Work
for (j = 0; j < N; j++)
Work[j] += Allocation[i][j];
}
}
/********尝试分配资源********/
int test(int i) //试探性的将资源分配给第i个进程
{
for(int j=0;j<N;j++)
{
Available[j]=Available[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
}
return True;
}
/********试探性分配资源作废********/
int Retest(int i) //与test操作相反
{
for(int j=0; j<N; j++)
{
Available[j] = Available[j] + Request[j];
Allocation[i][j] = Allocation[i][j] - Request[j];
Need[i][j] = Need[i][j] + Request[j];
}
return True;
}
/********安全性算法********/
int safe()
{
int i,j,k=0,m,apply;
//初始化work
for(j=0;j<N;j++)
Work[j] = Available[j];
//初始化Finish
for(i=0;i<M;i++)
Finish[i] = False;
//求安全序列
for(i=0;i<M;i++){
apply=0;
for(j=0;j<N;j++){
if(Finish[i]==False && Need[i][j]<=Work[j])
{
apply++;
//直到每类资源尚需数都小于系统可利用资源数才可分配
if(apply==N)
{
for(m=0;m<N;m++)
Work[m]=Work[m]+Allocation[i][m];//更改当前可分配资源
Finish[i]=True;
Security[k++]=i;
i=-1; //保证每次查询均从第一个进程开始
}
}
}
}
for(i=0;i<M;i++){
if(Finish[i]==False){
printf("系统不安全\n");//不成功系统不安全
return False;
}
}
printf("系统是安全的!\n");//如果安全，输出成功
printf("存在一个安全序列:");
for(i=0;i<M;i++){//输出运行进程数组
printf("P%d",Security[i]);
if(i<M-1)
printf("->");
}
printf("\n");
return True;
}
/********利用银行家算法对申请资源进行试分********/
int bank()
{
int flag = True;//标志变量，判断能否进入银行家算法的下一步
int i,j;
printf("请输入请求分配资源的进程号(0-%d):",M-1);
scanf("%d",&i);//输入须申请资源的进程号
printf("请输入进程P%d要申请的资源个数:\n",i);
for(j=0;j<N;j++)
{
printf("%c:",NAME[j]);
scanf("%d",&Request[j]);//输入需要申请的资源
}
//判断银行家算法的前两条件是否成立
for (j=0;j<N;j++)
{
if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错
{
printf("进程P%d申请的资源大于它需要的资源",i);
printf("分配不合理，不予分配！\n");
flag = False;
break;
}
else
{
if(Request[j]>Available[j])//判断申请是否大于当前可分配资源，若大于则出错
{
printf("进程%d申请的资源大于系统现在可利用的资源",i);
printf("\n");
printf("系统尚无足够资源，不予分配!\n");
flag = False;
break;
}
}
}
//前两个条件成立，试分配资源，寻找安全序列
if(flag) {
test(i); //根据进程需求量,试分配资源
showdata(); //根据进程需求量，显示试分配后的资源量
if(!safe()) //寻找安全序列
{
Retest(i);
showdata();
}
}
}
int main()//主函数
{
char choice;
init();//初始化数据
show_original_data();//显示各种资源
//用银行家算法判定系统当前时刻是否安全，不安全就不再继续分配资源
if(!safe()) exit(0);
do{
printf("*************************************************************\n");
printf("\n");
printf("\n");
printf("\t-------------------银行家算法演示------------------\n");
printf(" R(r):请求分配 \n");
printf(" E(e):退出 \n");
printf("\t---------------------------------------------------\n");
printf("请选择：");
fflush(stdin); //清空输入流缓冲区的字符，注意必须引入#include<stdlib.h>头文件
scanf("%c",&choice);
switch(choice)
{
case 'r':
case 'R':
bank();break;
case 'e':
case 'E':
exit(0);
default: printf("请正确选择!\n");break;
}
} while(choice);
}4.运行结果与结果分析
手动输入系统可用资源数、进程数、进程最大需求矩阵和已经分配的资源量 
输出刚输入信息后系统当前资源分配情况和系统目前可用的资源以及判断系统 是否是安全的，如果安全则输出一安全序列。如下图输出了一个安全序列 P0->P3->P0->P2->P4,下面分析这个序列是否是真的安全序列。
首先系统可用资 源 A、B、C 分别为 3、3、2，均大于等于 P1 所需，故可执行进程 P1，执行完 P1 后释放资源，A、B、C 更新后分别为 5、3、2，均大于进程 P3 所需资源数目，故 下一步可以执行进程 P3。执行完 P3 后释放资源，A、B、C 更新后分别为 7、4、 3，等于 P0 所需资源数，故下一步可执行进程 P0。执行完 P0 后释放资源，A、B、 C 更新后分别为 7、5、3，均大于进程 P2 所需资源数目，故下一步可以执行进程 P2。执行完 P2 后释放资源，A、B、C 更新后分别为 10、5、5，均大于进程 P4 所需资源数目，故下一步可以执行进程 P4。到此所有进程执行完毕，按照此序 列将资源分配给进程过程中并未发生死锁，故，是一个安全序列。 下面请求分配，选择给进程 P1 分配资源（1,0,2），均小于可用资源，故可以完 成分配，将申请的资源分配后，输出系统当前可用的资源以及当前各个进程资源 分配情况，如下图所示。
接着进程 P4 申请资源（3.3,0），其中资源 A 只有 2，故申请资源大于可用资源， 系统资源不足，故此时选择不予分配。
接着进程 P0 申请分配资源（0,2,0），系统各进程资源分配情况如下图所示，为 进程 P0 分配后系统剩余可用资源为（2,1,0），已不能满足任何进程的需要，故 系统进入不安全状态，此时系统不分配资源。
二、安全性检查算法
1.主要内容
安全性检查算法用于检查系统进行资源分配后是否安全，若安全系统才可以执行此次分配；若不安全，则系统不执行此次分配。 安全性检查算法原理为：在系统试分配资源后，算法从现有进程列表寻找出一个可执行的进程进行执行，执行完成后回收进程占用资源；进而寻找下一个可执行进程。当进程需求量大于系统可分配量时，进程无法执行。当所有进程均可执行，则产生一个安全执行序列，系统资源分配成功。若进程无法全部执行，即无法找到一条安全序列，则说明系统在分配资源后会不安全，所以此次分配失败。
2.算法原理
系统所执行的安全性算法课描述如下：
（1）设置两个向量：工作向量 Work，他表示系统可提供给进程继续运行所 需的各类资源数目，它含有 m 个元素，在执行安全算法开始时，Work=Available； Finish 向量，表示系统是否有足够资源分配给进程，使之运行完成。开始时先 做 Finish[i]=false；当有足够资源分配给进程时，再令 Finish[i]=true。
（2）从进程集合中找到一个能满足下述条件的进程： Finish[i]=false; Need[i,j]<=Work[j]; 若找到执行步骤（3），否则执行步骤（4），直至完成，并释放出分配给他 的资源，故应执行：Work[j]=Work[j]+Allocation[i,j]; Finish[i]=true; go to step 2;
（3）如果所有进程的 Finish[i]=true 都满足，则表示系统处于安全状态； 否则，系统处于不安全状态；
3.算法实现
安全性算法与上述的银行家算法已融合在一起实现死锁避免问题。
三、总结
本次实现了银行家算法和安全性算法的结合来防止系统进入不安全状 态，以免进入死锁状态。虽然并非所有不安全状态都必然会转化为死锁，但当系 统进入不安全状态后，就有可能会进入死锁状态，反之，只要系统处于安全状态， 系统便不会进入死锁状态，故避免死锁的实质就在于，系统进行资源分配时应使 系统不进入不安全状态。 银行家算法通过预分配资源的方式来避免死锁的发生，它确保在任何时候， 系统都能找到一个安全序列，使得每个进程都能获得所需的资源并完成执行。而 安全性算法用于检查系统是否处于安全状态。如果存在至少一个安全序列，系统 就被认为是安全的，这意味着没有进程会因为资源不足而永远阻塞。这两种算法 的结合能够很好的避免系统资源分配时容易遇到的死锁问题
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
