因为课设要做银行家算法，就写着记录一下。在网上看了很多，有java也有c。借鉴别人的，自己试着改了一下。
银行家算法：
第一模块：银行家算法中的数据结构
为了实现银行家算法，在系统中必须设置这样四个数据结构，分别用来描述系统中可用的资源，所有进程对资源的最大需求，系统中的资源分配，以及所有的进程话需要多少资源的情况。
1.可利用资源向量Available。这是一个含有m个元素的数组，其中的而每一个元素代表一类可利用资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态的改变。如果Available[j]=K,则表示系统中现有Rj类资源K个。
2.最大需求矩阵Max。这是一个nm的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K；则表示进程i需要Rj类资源的最大数目为K。
3.分配矩阵Allocation。这也是一个nm的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K，则表示进程i当前已分得Rj类资源的数目为K。
4.需求矩阵Need。这也是一个n*m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K,则表示进程i还需要Rj类资源K个，方能完成任务。
上述三个矩阵间存在下述关系：Need[i,j]=Max[i,j]-Allocation[i,j]
第二模块：银行家算法：
1．如果Request<=Need,则转向2;否则,出错
2．如果Request<=Available,则转向3,否则等待
3．系统试探分配请求的资源给进程
第三模块：安全性算法
- 设置两个向量
① 工作向量:Work=Available(表示系统可提供给进程继续运行所需要的各类资源数目)
② Finish:表示系统是否有足够资源分配给进程(True:有;False:没有).初始化为False - 若Finish[i]=False&&Need<=Work,则执行3;否则执行4(i为资源类别)
- 进程P获得第i类资源,则顺利执行直至完成，并释放资源: Work=Work+Allocation; Finish[i]=true;转2
- 若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!
截图展示：
结果分析： - T0时刻，利用安全性算法对T0时刻的资源分配情况进行分析，可知，在T0时刻存在着一个安全序列{P[2],P[4],P[5],P[1],P[3]},故系统是安全的。
- P2请求资源：P2发出请求向量Request2（1,0,2），系统按银行家算法进行检查：
① Request 2(1,0,2)<=Need 2(1,2,2,)
② Request 2(1,0,2)<=Available 2(3,3,2)
系统先假定可为P2分配资源，并修改Available，Allocation2和Need2向量，再利用安全性算法检查此时系统是否安全；找到一个安全序列{P[2],P[4],P[5],P[1],P[3]}，因此，系统是安全的，可立即将P2所申请的资源分配给它。 - P5请求资源：P5发出请求向量Request5（3,3,0），系统按照银行家算法进行检查：
① Request 5(3,3,0)<=Need 5(4,3,1)
② Request 5(3,3,0)<=Available 5(2,3,0)，让P5等待 - P1请求资源：P1发出请求向量Request1（0,2,0），系统按照银行家算法进行检查：
① Request 1(0,2,0)<=Need 2(7,4,3)
② Request 1(0,2,0)<=Available 2(2,3,0)
系统先假定可为P0分配资源，并修改数据，进行安全性检查：
可用资源Available（2,1，0）已不能满足任何进程需求，故系统进入不安全状态，此时系统不分配资源。
主要代码：
1.一些基本的定义
int Available[10]; //可使用资源向量
int Max[10][10]; //最大需求矩阵
int Allocation[10][10] = { 0 }; //分配矩阵
int Need[10][10] = { 0 }; //需求矩阵
int Finish[10]; //是否有足够的资源分配，状态标志
int Request[10][10]; //进程申请资源向量
int Pause[10]; //工作向量相当于work[10]
int arr[] = { 0 }; //各类资源总数
int i, j; //i个进程，j个资源
int n; //系统资源总数
int m; //总的进程数
int a; //当前申请的进程号
int b = 0, c = 0, g = 0; //计数器 b计数比较Need<=Work的次数，f计数进程true的次数
2.银行家算法
界面展示：
void menu()
{
printf("\n\n\t\t卐卍※§ 银行家算法 §※卐卍\n");
printf("\n\n\t\t\t1:初始化");
printf("\n \t\t\t2:进程进行资源申请");
printf("\n \t\t\t3.资源分配状态");
printf("\n \t\t\t4:安全性检查");
printf("\n \t\t\t5:退出程序");
printf("\n\n\t\t\t\t\t 请输入你的选择: ");
}
main函数
用了switch方法
int main()
{
int key = 0;
printf("\n\n");
while (1)
{
menu();
scanf("%d", &key);
printf("\n\n");
switch (key)
{
case 1:
initialize();
break;
case 2:
mainrequest();
break;
case 3:
mainshow();
break;
case 4:
securitycheck();
break;
case 5:
printf("\n\n\t\t\t谢谢使用 \n");
printf("\n\t\t\tSee you next time !\n\n\n");
system("pause");
return 0;
}
}
system("pause");
return 0;
}
输入的部分：
void initialize() //初始化
{
printf("请输入系统的资源种类数：");
scanf("%d", &n);
for (i = 1; i <= n; i++)
{
printf("第%d类资源总数：", i);
scanf("%d", &arr[i]);
}
printf("请输入进程总数：");
scanf("%d", &m);
for (i = 1; i <= m; i++)
{
for (j = 1; j <= n; j++)
{
printf("进程P[%d]对第%d类资源的最大需求量：", i, j);
scanf("%d", &Max[i][j]);
}
}
for (i = 1; i <= m; i++)
{
for (j = 1; j <= n; j++)
{
printf("进程P[%d]对第%d类资源已分配数：", i, j);
scanf("%d", &Allocation[i][j]);
Need[i][j] = Max[i][j] - Allocation[i][j];
}
}
for (i = 1; i <= n; i++)
{
for (j = 1; j <= m; j++)
{
arr[i] -= Allocation[j][i];
}
}
for (i = 1; i <= n; i++)
Available[i] = arr[i];
securitycheck();
}
输出的部分：
void mainshow()
{
printf("\n\n");
if (n)
{
printf(" Allocaiton Max Need\n进程");
}
for (i = 1; i <= 3; i++)
{
for (j = 1; j <= n; j++)
{
printf(" %d类", j);
}
}
for (i = 1; i <= m; i++)
{
printf("\nP[%d]", i);
for (j = 1; j <= n; j++)
{
printf(" %2d ", Allocation[i][j]);
}
for (j = 1; j <= n; j++)
{
printf(" %2d ", Max[i][j]);
}
for (j = 1; j <= n; j++)
{
printf(" %2d ", Need[i][j]);
}
}
printf("\n\n系统剩余资源量： ");
for (i = 1; i <= n; i++)
{
printf(" %d ", Available[i]);
}
printf("\n");
}
资源申请操作部分：
在试分配之后直接调用安全性算法，进行安全性检测
void mainrequest() //进程申请资源
{
printf("请输入申请资源的进程：");
scanf("%d", &a);
for (i = 1; i <= n; i++)
{
printf("请输入进程P[%d]对%d类资源的申请量：", a, i);
scanf("%d", &Request[a][i]);
if (Request[a][i] > Need[a][i])
{
printf("\n出错！进程申请的资源数多于它自己申报的最大需求量\n");
return;
}
if (Request[a][i] > Available[i])
{
printf("\nP[%d]请求的资源数大于可用资源数，必须等待\n", a);
return;
}
}
for (i = 1; i <= n; i++)
{
//试探性分配
Available[i] = Available[i] - Request[a][i];
Allocation[a][i] = Allocation[a][i] + Request[a][i];
Need[a][i] = Need[a][i] - Request[a][i];
}
securitycheck();
2.安全性算法：
int securitycheck() //安全性检测
{
printf("\n\n");
printf("\t\t\t※ 安全性检测 ※\n\n");
if (n)
{
printf(" work need Allocation work+Allocation\n进程 ");
for (c = 1; c <= 4; c++)//c计数资源情况
{
for (j = 1; j <= n; j++)
{
printf(" %d类", j);
}
}
}
for (i = 1; i <= m; i++)
{
Pause[i] = Available[i]; //Pause[i]只是一个暂时寄存的中间变量，为防止在下面安全性检查时修改到Available[i]而代替的一维数组
Finish[i] = false;
}
for (g = 1; g <= m; g++)//本层循环保证安全性序列要选m个进程
{
for (i = 1; i <= m; i++)//每次选择从m个进程里选一个
{
b = 0; //计数器初始化
Finish[i] == false;
for (j = 1; j <= n; j++)//每次选择要判断n个资源是否满足要求
{
if (Need[i][j] <=Pause[j]) //比较need<=work，找到一个能满足下述下述条件的进程
{
b = b + 1; //计数器次数加一
}
if (Finish[i] == false&& b == n)//进程顺利执行，直至完成，完成以下操作
{
Finish[i] = true;
printf("\nP[%d] ", i); //依次输出进程安全序列
for (j = 1; j <= n; j++)
{
printf(" %2d ", Pause[j]);
printf(" %2d ", Need[i][j]);
printf(" %2d ", Allocation[i][j]);
printf(" %2d ", Pause[j]+Allocation[i][j]);
Pause[j] = Pause[j] + Allocation[i][j];
}
}
}
}
}
printf("\n\n");
for (i = 1; i <= m; i++)
{
if (Finish[i] ==false) {
printf("不安全状态");
for (i = 1; i <= n; i++)
{
Available[i] = Available[i] + Request[a][i];
Allocation[a][i] = Allocation[a][i] - Request[a][i];
Need[a][i] = Need[a][i] + Request[a][i];
}
return 0;
}
else{
printf("安全状态!");
printf("\n\n系统剩余资源量： ");
for (i = 1; i <= n; i++)
{
printf(" %d ", Available[i]);
}
return 1;
}
}
}
void initialize() //初始化
{
printf("请输入系统的资源种类数：");
scanf("%d", &n);
for (i = 1; i <= n; i++)
{
printf("第%d类资源总数：", i);
scanf("%d", &arr[i]);
}
printf("请输入进程总数：");
scanf("%d", &m);
for (i = 1; i <= m; i++)
{
for (j = 1; j <= n; j++)
{
printf("进程P[%d]对第%d类资源的最大需求量：", i, j);
scanf("%d", &Max[i][j]);
}
}
以上就是所有的内容，我在看这个代码的过程中，遇到了一些问题。
比如在p1申请资源（0，2，0）时，最后可用资源不满足所有进程的需要，系统进入不安全状态。但是原先的代码会显示安全状态，而不显示安全序列。按照逻辑，当所有进程的状态都是Finish[i]=true时，表示系统进入安全状态。
这里贴上修改之前的代码：
for (i = 1; i <= m; i++)
{
if (Finish[i] == true) f=f+1; // f :统计Finish[i]＝＝true的个数
}
if (f = m) //所有进程都到达安全状态
{
printf("安全状态!");
printf("\n\n系统剩余资源量： ");
for (i = 1; i <= n; i++)
{
printf(" %d ", Available[i]);
}
f = 0; //将计数器f重新初始化，为下一次提出新的进程申请做准备
return 1;
}
else
{
printf("不安全状态");
for (i = 1; i <= n; i++)
{
Available[i] = Available[i] + Request[a][i];
Allocation[a][i] = Allocation[a][i] - Request[a][i];
Need[a][i] = Need[a][i] + Request[a][i];
}
return 0;
}
}
它用了一个f当作计数器，记录true的次数，判断true和进程数，相等时便表示所有进程都执行完毕，系统安全。
修改之后：
for (i = 1; i <= m; i++)
{
if (Finish[i] ==false) {
printf("不安全状态");
for (i = 1; i <= n; i++)
{
Available[i] = Available[i] + Request[a][i];
Allocation[a][i] = Allocation[a][i] - Request[a][i];
Need[a][i] = Need[a][i] + Request[a][i];
}
return 0;
}
else{
printf("安全状态!");
printf("\n\n系统剩余资源量： ");
for (i = 1; i <= n; i++)
{
printf(" %d ", Available[i]);
}
return 1;
}
}
我是把计数的部分直接删除，让每个进程的状态直接判断。
剩下的没咋变。我可以想通之前那个代码的逻辑，但是运行有错误。如果有想法的，可以讨论一下。
来源：CSDN
作者：啾啾的一只鲸鱼
链接：https://blog.csdn.net/qq_44441740/article/details/103718218