模拟实现银行家算法c语言

大家好，又见面了，我是你们的朋友全栈君。

因为课设要做银行家算法，就写着记录一下。在网上看了很多，有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．系统试探分配请求的资源给进程
第三模块：安全性算法

1. 设置两个向量
   ①　工作向量:Work=Available(表示系统可提供给进程继续运行所需要的各类资源数目)
   ②　Finish:表示系统是否有足够资源分配给进程(True:有;False:没有).初始化为False
2. 若Finish[i]=False&&Need<=Work,则执行3;否则执行4(i为资源类别)
3. 进程P获得第i类资源,则顺利执行直至完成，并释放资源: Work=Work+Allocation; Finish[i]=true;转2
4. 若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!
   截图展示：
   
   
   
   
   
   
   结果分析：
5. T0时刻，利用安全性算法对T0时刻的资源分配情况进行分析，可知，在T0时刻存在着一个安全序列{P[2],P[4],P[5],P[1],P[3]},故系统是安全的。
6. 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所申请的资源分配给它。
7. 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等待
8. 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;		
    }
}

我是把计数的部分直接删除，让每个进程的状态直接判断。
剩下的没咋变。我可以想通之前那个代码的逻辑，但是运行有错误。如果有想法的，可以讨论一下。