银行家算法中数据结构主要是几个数组
1、可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available[j]=K，则表示系统中现有Rj类资源K个。
2、最大需求矩阵Max。这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K，则表示进程i需要Rj类资源的最大数目为K。
3、分配矩阵Allocation。这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果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]
银行家模块：
设Request i是进程Pi的请求向量，如果Request i[j]=K，表示进程P i需要K个R j类型的资源。当P i发出资源请求后，系统按下述步骤进行检查：
(1) 如果Request i[j]<=Need[i,j]，便转向步骤(2)；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
(2) 如果Request i[j]≤Available[j]，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。
(3) 系统试探着把资源分配给进程P i，并修改下面数据结构中的数值：
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]；
(4) 系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
安全性检查模块：
(1) 设置两个向量：
① 工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work:=Available。
② Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]:=false；当有足够资源分配给进程时，再令Finish[i]:=true。
(2) 从进程集合中找到一个能满足下述条件的进程：
① Finish[i]=false；
② Need[i,j]≤Work[j]；若找到，执行步骤(3)，否则，执行步骤(4)。
(3) 当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]:= Work[j]+Allocation[i,j]；
Finish[i]:=true；
go to step （2）；
(4) 如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。
例如：
假定系统中有五个进程{P0，P1，P2，P3，P4}和三类资源{A，B，C}，各种资源的数量分别为10、5、7，在T0时刻的资源分配情况如图示。 （先忽略P1第二行的括号）
(1) T0时刻的安全性：利用安全性算法对T0时刻的资源分配情况进行分析如下图可知，在T0时刻存在着一个安全序列{P1，P3，P4，P2，P0}，故系统是安全的。
(2) P1请求资源：P1发出请求向量Request1(1，0，2)，系统按银行家算法进行检查：
① Request1(1，0，2)≤Need1(1，2，2)
② Request1(1，0，2)≤Available1(3，3，2)
③ 系统先假定可为P1分配资源，并修改Available，Allocation1和Need1向量，形成的资源变化情况如下图圆括号所示
④ 再利用安全性算法检查此时系统是否安全。
(4) P0请求资源：P0发出请求向量Requst0(0，2，0)，系统按银行家算法进行检查：
① Request0(0，2，0)≤Need0(7，4，3)；
② Request0(0，2，0)≤Available(2，3，0)；
③ 系统暂时先假定可为P0分配资源，并修改有关数据
(5) 进行安全性检查：可用资源Available(2，1，0)已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。
以上讲解摘抄自博客https://blog.csdn.net/weixin_39478524/article/details/80604876，代码部分加入了自己的思考和优化
代码部分：
#include <iostream>
#include<stdio.h>
#include<string>
#include<cstring>
#include <vector>
using namespace std;
const int MAX_N=100;
const int MAX_M=50;
int n_process;//表示进程的个数
int m_resource;//表示资源的个数
int resource[MAX_M];//表示资源的总数
int available[MAX_M];//表示系统当前剩下的资源
int max_need[MAX_N][MAX_M];//表示进程对每类资源的最大需求量
int allocation[MAX_N][MAX_M];//表示系统给进程已分配每类资源的数目
int need[MAX_N][MAX_M];//表示进程还需各类资源数目
int request[MAX_M];//表示请求的各个资源数量
int work[MAX_M];//表示安全性检查的中间变量
bool finish[MAX_N];//表示资源是否被安全性检查过
vector<int> safe_order;//表示安全序列
void menu(){
cout<<"输入1初始化"<<endl;
cout<<"输入2申请资源"<<endl;
cout<<"输入3显示资源分配情况"<<endl;
cout<<"输入4退出"<<endl;
}
bool checkInit(){
for(int i=0;i<m_resource;i++){
if(available[i]<0)return false;
}
for(int i=0;i<n_process;i++){
for(int j=0;j<m_resource;j++){
if(need[i][j]<0)return false;
}
}
return true;
}
bool safeCheck(){//安全性算法
for(int i=0;i<m_resource;i++){
work[i]=available[i];
}
fill(finish,finish+n_process,false);
safe_order.clear();
for(int i=0;i<n_process;i++){
int h=-1;
for(int j=0;j<n_process;j++){
if(!finish[j]){
bool t=true;
for(int k=0;k<m_resource;k++){
if(need[j][k]>work[k]){
t=false;
break;
}
}
if(t){
h=j;
break;
}
}
}
if(h==-1)return false;
else {
finish[h]=true;
for(int j=0;j<m_resource;j++){
work[j]+=allocation[h][j];
}
safe_order.push_back(h);
}
}
return true;
}
void init(){
cout<<"资源数:"<<endl;
cin>>m_resource;
cout<<"各个资源总量:"<<endl;
for(int i=0;i<m_resource;i++)cin>>resource[i];
cout<<"进程数:"<<endl;
cin>>n_process;
for(int i=0;i<n_process;i++){
cout<<"P"<<i<<"对各个资源的最大需求量:"<<endl;
for(int j=0;j<m_resource;j++)cin>>max_need[i][j];
cout<<"P"<<i<<"各个资源已分配量:"<<endl;
for(int j=0;j<m_resource;j++)cin>>allocation[i][j];
for(int j=0;j<m_resource;j++)need[i][j]=max_need[i][j]-allocation[i][j];
}
memcpy(available,resource,sizeof(available));
for(int i=0;i<n_process;i++){
for(int j=0;j<m_resource;j++){
available[j]-=allocation[i][j];
}
}
if(!checkInit())cout<<"初始化失败！"<<endl;
if(!safeCheck())cout<<"系统处于不安全状态，初始化失败!"<<endl;
else{
cout<<"分配成功！其中一个安全序列:"<<endl;
for(int i=0;i<safe_order.size();i++){
cout<<safe_order[i]<<" ";
}
cout<<endl;
}
}
void order(){
int id;
cout<<"输入进程号："<<endl;
cin>>id;
cout<<"输入各个资源的请求数量："<<endl;
for(int i=0;i<m_resource;i++){
cin>>request[i];
}
for(int i=0;i<m_resource;i++){
if(request[i]>need[id][i]){
cout<<"错误,请求量大于需求量!"<<endl;
return;
}
}
for(int i=0;i<m_resource;i++){
if(request[i]>available[i]){
cout<<"错误,请求量大于系统剩余量!"<<endl;
return;
}
}
for(int i=0;i<m_resource;i++){
available[i]-=request[i];
allocation[id][i]+=request[i];
need[id][i]-=request[i];
}
if(!safeCheck()){
for(int i=0;i<m_resource;i++){
available[i]+=request[i];
allocation[id][i]-=request[i];
need[id][i]+=request[i];
}
cout<<"系统处于不安全状态，资源分配失败!"<<endl;
}
else{
cout<<"分配成功！其中一个安全序列:"<<endl;
for(int i=0;i<safe_order.size();i++){
cout<<safe_order[i]<<" ";
}
cout<<endl;
}
}
void display(){
cout <<"进程 \t max_need \t allocation \t need \t\t available"<< endl;
for(int i=0;i<n_process;i++){
cout<<"P"<<i<<" \t ";
for(int j=0;j<m_resource;j++){
cout<<max_need[i][j]<<" ";
}
cout<<" \t ";
for(int j=0;j<m_resource;j++){
cout<<allocation[i][j]<<" ";
}
cout<<" \t ";
for(int j=0;j<m_resource;j++){
cout<<need[i][j]<<" ";
}
cout<<" \t ";
if(i==0){
for(int j=0;j<m_resource;j++){
cout<<available[j]<<" ";
}
}
cout<<endl;
}
}
int main(){
int t;
menu();
while(cin>>t){
if(t==1){
init();
}
else if(t==2){
order();
}
else if(t==3){
display();
}
else if(t==4){
break;
}
else{
cout<<"输入出错"<<endl;
}
menu();
}
return 0;
}
/*
1
3
10 5 7
5
7 5 3
0 1 0
3 2 2
2 0 0
9 0 2
3 0 2
2 2 2
2 1 1
4 3 3
0 0 2
*/
1815
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
