操作系统linux：银行家算法（C语言实现）
大家好，又见面了，我是你们的朋友全栈君。
一、实验内容和要求 1、在Linux环境下编译运行程序； 2、按照教材的算法编写； 3、输入数据从文本文件中读出，不从键盘录入，数据文件格式见以下说明； 4、主要数据结构的变量名和教材中的一致，包括Available、Max、Allocation、Need、Request、Work、Finish。 5、程序可支持不同个数的进程和不同个数的资源； 6、验证教材中的“银行家算法示例”中的例子（包括可成功分配、不可分配）。
二、实验原理 1.资源分配算法 令Request i表示进程p i的申请向量。Request i[j]=k,表示进程p i需要申请k个r j类资源。当进程p i申请资源时，执行下列动作： ①若Request i>Need i，表示出错，因为进程对资源申请量大于它说明的最大值。 ②如果Request i>Available，则p i等待。 ③假设系统把申请的资源分给进程p i，则应对有关数据结构进行修改： Available:=Available-Request i Allocation i:=Allocation i+Rquest i Need i:=Need i-Request i ④系统执行安全性算法，查看此时系统状态是否安全。如果时安全的，就实际分配资源，满足进程p i的此次申请；否则，若新状态是不安全的，则p i等待，对申请的资源暂不予分配，并且把资源分配状态恢复成③之前的情况。 2.安全性算法 为了确定一个系统是否在安全状态，可采用下述算法： ①令Work和Finish分别表示长度为m和n的向量，最初，置Work:=Available，Finish[i]:=flase,i=1,2…,n。 ②搜索满足下列条件的i值：Finish[i]=false，且Need i<=Work。若没有找到，则转向④。 ③修改数据值：Work:=Work+Allocation i（p i释放所占的全部资源），Finish[i]:=true。转向②。 ④若Finish[i]=true对所有i都成立（任一进程都可能是p i），则系统处于安全状态；否则，系统处于不安全状态。
三、验证数据：建立在程序目录下建立data文件，文件内容是： 5 3 10 5 7 0 0 1 0 7 5 3 1 2 0 0 3 2 2 2 3 0 2 9 0 2 3 2 1 1 2 2 2 4 0 0 2 4 3 3 1 1 0 2 4 3 3 0 0 0 2 0 第一行：5个进程，3种资源。 第二行：每种资源系统拥有的最大数量。 3-7行：第一列是进程号（按顺序排），2-4列是Allocation（已有资源）向量，5-7列是Max（最大资源需求量）向量。 8-10行：第一列是进程号，2-4列是Request（资源请求）向量。 运行程序，通过命令行参数指定文件，如： ./banker ./data运行。
四、实现代码（banker.c文件）：
#include<stdio.h>
#include<stdlib.h>
int main()
{
int n ,m,t,w,flag1=1,flag2=1,flag4=1,flag5=1;
int*Available,*Request,*Finish;
int **Allocation,**Max,**Need,**Work;
FILE*fp;
fp=fopen("/home/student/data.txt","r"); //打开.txt文件
fscanf(fp,"%d",&n),fscanf(fp,"%d",&m); //赋值.txt文件的数值，n*m二维数组
Available = (int*)malloc(sizeof(int)*m); //开动态一维数组
for(int i=0;i<m;i++) //给一维数组赋值
fscanf(fp,"%d",&Available[i]);
Allocation= (int**)malloc(sizeof(int*)*n); //开动态二维数组
Max= (int**)malloc(sizeof(int*)*n);
Need= (int**)malloc(sizeof(int*)*n);
for (int i = 0; i < n; i++)
{
Allocation[i] = (int*)malloc(sizeof(int)*m);
Max[i] = (int*)malloc(sizeof(int)*m);
Need[i] = (int*)malloc(sizeof(int)*m);
}
for(int i=0;i<n;i++) //给二维数组赋值
{
fscanf(fp,"%d",&t); //t为进程编号
for(int j=0;j<m;j++)
fscanf(fp,"%d",&Allocation[t][j]);
for(int j=0;j<m;j++)
fscanf(fp,"%d",&Max[t][j]);
for(int j=0;j<m;j++)
Need[i][j]=Max[i][j]-Allocation[i][j];
}
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
Available[i]-=Allocation[j][i];
fscanf(fp,"%d",&w); //w为发出请求的进程的编号
Request = (int*)malloc(sizeof(int)*m);
for(int i=0;i<m;i++)
fscanf(fp,"%d",&Request[i]);
for(int i=0;i<m;i++)
if(Request[i]>Need[w][i])
flag1=0;
if(!flag1) //flag1用来判断Request是否小于等于Need
printf("Flase");
else {
for(int i=0;i<m;i++)
if(Request[i]>Available[i])
flag2=0;
if(!flag2) //flag2用来判断Request是否小于等于Available
printf("p %d 等待",w);
else {
for(int i=0;i<m;i++) //假设系统把申请的资源分给进程
{
Available[i]-=Request[i];
Allocation[w][i]+=Request[i];
Need[w][i]-=Request[i];
}
Work= (int**)malloc(sizeof(int*)*n);
for (int i = 0; i < n; i++)
Work[i] = (int*)malloc(sizeof(int)*m);
Finish = (int*)malloc(sizeof(int)*n);
for(int i=0;i<n;i++)
Finish[i]=0; //fnish[i]=0代表fnish[i]=flase，fnish[i]=1代表fnish[i]=true
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
Work[i][j]=Available[j];
while(flag5) //安全性算法，flag5用来判断系统是否已经完成安全性判断
{
for(int i=0;i<n;i++) //每次从0号进程开始搜索是否有满足条件的进程
{
int flag3=1; //flag3用来判断Need是否小于等于Work
for(int j=0;j<m;j++)
if(Need[i][j]>Work[i][j])
flag3=0;
if(!Finish[i]&&flag3) //找到满足Finish[i]=false且Need小于等于Work
{
Finish[i]=1; //置Finish[i]=true
for(int j=0;j<n;j++) //释放进程所占全部资源
for(int k=0;k<m;k++)
if(j!=i&&!Finish[j])
Work[j][k]=Work[i][k]+Allocation[i][k];
break;
}
else if(i==n-1) //没有找到满足条件的并且是最后一个进程
{
for(int j=0;j<n;j++)
if(!Finish[j])
flag4=0;
if(flag4) //flag4用来判断是否所有进程都是Finish[i]=true
{
printf("系统处于安全状态\n");
printf("Work:\n");
for(int j=0;j<n;j++) //输出安全状态下，系统把申请的资源分配给进程资源的情况
{
for(int k=0;k<m;k++)
printf("%4d",Work[j][k]);
printf("\n");
}
printf("Alllcation:\n");
for(int j=0;j<n;j++)
{
for(int k=0;k<m;k++)
printf("%4d",Allocation[j][k]);
printf("\n");
}
printf("Need:\n");
for(int j=0;j<n;j++)
{
for(int k=0;k<m;k++)
printf("%4d",Need[j][k]);
printf("\n");
}
printf("Available:\n");
for(int j=0;j<m;j++)
printf("%4d",Work[n-1][j]+Allocation[n-1][j]);
flag5=0;
}
else{
printf("系统处于不安全状态\n");
for(int j=0;j<m;j++) //系统不安全，还原资源分配给进程前的情况
{
Available[j]+=Request[j];
Allocation[w][j]-=Request[j];
Need[w][j]+=Request[j];
}
flag5=0;
}
}
}
}
}
}
}五、结果验证 1.验证第一个资源请求 //data.txt.文件 5 3 10 5 7 0 0 1 0 7 5 3 1 2 0 0 3 2 2 2 3 0 2 9 0 2 3 2 1 1 2 2 2 4 0 0 2 4 3 3 1 1 0 2
输出结果：
2.验证第二个资源请求 /data.txt文件/ 5 3 10 5 7 0 0 1 0 7 5 3 1 2 0 0 3 2 2 2 3 0 2 9 0 2 3 2 1 1 2 2 2 4 0 0 2 4 3 3 4 3 3 0
输出结果：
3.验证第三个资源请求 /data.txt文件/
5 3 10 5 7 0 0 1 0 7 5 3 1 2 0 0 3 2 2 2 3 0 2 9 0 2 3 2 1 1 2 2 2 4 0 0 2 4 3 3 0 0 2 0
输出结果：
4.验证资源请求出错（即Request i>Need i） /data.txt文件/ 5 3 10 5 7 0 0 1 0 7 5 3 1 2 0 0 3 2 2 2 3 0 2 9 0 2 3 2 1 1 2 2 2 4 0 0 2 4 3 3 3 0 2 1
输出结果：
5.验证进程资源请求等待（即Request i>Available） /data.txt文件/ 5 3 10 5 7 0 0 1 0 7 5 3 1 2 0 0 3 2 2 2 3 0 2 9 0 2 3 2 1 1 2 2 2 4 0 0 2 4 3 3 0 4 4 3
输出结果：
发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/144127.html原文链接：https://javaforall.cn