计算机操作系统——银行家算法

1.实验目的：

银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。本实验通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。

2.实验内容：

（1）模拟一个银行家算法：

设置数据结构

设计安全性算法

（2）初始化时让系统拥有一定的资源；

（3）用键盘输入的方式申请资源；

（4）如果预分配后，系统处于安全状态，则修改系统的资源分配情况；

（5）如果预分配后，系统处于不安全状态，则提示不能满足请求

3.算法思路：

先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。

若请求合法，则进行试分配。最后对试分配后的状态调用安全性检查算法进行安全性检查。

若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。

4.主要数据结构

§可利用资源向量int Available[m] m为资源种类

§最大需求矩阵int Max[n][m] n为进程的数量

§分配矩阵int Allocation[n][m]

§还需资源矩阵 int need[i][j] = Max[i][j]- Allocation[i][j]

§申请资源数量int Request [m]

§工作向量int Work[m] int Finish[n]

5.算法描述

1. 银行家算法bank()函数

Requesti：进程Pi的请求向量。 0<=j<=m-1

(1)若Requesti[j] ≤Need[i,j]，转向(2)，否则出错。

(2)若 Requesti[j] ≤Available[j]，转向(3)，否则等待。

(3)系统试探着把资源分配给进程Pi，修改下面内容：

Available[j]= Available[j] – Requesti[j];

Allocation[i,j]= Allocation[i,j]+ Requesti[j];

Need[i,j]= Need[i,j]–Requesti[j];

(4)试分配后，执行安全性算法，检查此次分配后系统是否处于安全状态。若安全，才正式分配；否则，此次试探性分配作废，进程Pi等待。

2. 安全性算法safe()函数

(1)初始化：设置两个向量Work(1×m)和Finish(1×n)

Work– 系统可提供给进程继续运行所需各类资源数，初态赋值Available

Finish– 系统是否有足够资源分配给进程，初值false.

(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 (2).

(4)若所有进程Finish[i]= true，表示系统处于安全状态，否则处于不安全状态。

6.程序结构

程序共有以下五个部分：

§(1).初始化chushihua()：输入进程数量、资源种类、资源可利用量、进程资源已分配量、进程最大需求量

§(2).当前安全性检查safe()：用于判断当前状态安全。

§(3).银行家算法bank()：进行银行家算法模拟实现的模块

§(4).显示当前状态show()：显示当前资源分配详细情况

(5).主程序main()：逐个调用初始化、显示状态、安全性检查、银行家算法函数，使程序有序的进行。

程序：

#include<iostream>

#include<cstring>

#define False 0

#define True 1

using namespace std;

/********

主要数据结构

********/

int N=50;//进程的最大数

int M=100;//资源的最大数

char NAME[100]={0};//资源的名称

int Avaliable[100]={0};//可用资源矩阵

int Max[50][100]={0};//最大需求矩阵

intAllocation[50][100]={0};//系统已分配矩阵

int Need[50][100]={0};//还需要资源矩阵

int Request[100]={0};//请求资源向量

int Security[50]={0};//存放安全序列

int Work[100]={0};//存放系统可提供资源

int Finish[50]={0};

/********

初始化数据：输入进程数量、资源种类、

各种资源可利用数量、

各进程的资源已分配数量、

各进程对资源最大需求量等。

********/

void chushihua()

{

/* n为进程个数，即矩阵行数，m为资源个数，即矩阵列数。*/

int i,j,n,m;

int number,flag;

char name;//输入资源名称

cout<<"系统可用资源个数为:";

cin>>m;

M=m;

for(i=0;i<m;i++)

{

cout<<"资源"<<i<<"的名称:";

cin>>name;

NAME[i]=name;

cout<<"资源"<<name<<"的初始个数为:";

cin>>number;

Avaliable[i]=number;

}

cout<<endl;

cout<<"请输入进程的数量:";

cin>>n;

N=n;

cout<<"请输入各进程的最大需求矩阵的值("<<n<<"*"<<m<<"矩阵)[Max]:"<<endl;

for(i=0;i<n;i++)

for(j=0;j<m;j++)

cin>>Max[i][j];

int temp[100]={0};

do{

flag=0;

cout<<"请输入各进程已经分配的资源量("<<n<<"*"<<m<<"矩阵)[Allocation]:"<<endl;

for(i=0;i<n;i++)

for(j=0;j<m;j++){

cin>>Allocation[i][j];

if(Allocation[i][j]>Max[i][j]) flag=1;

}

if(flag==1)

cout<<"申请的资源大于最大需求量，请重新输入!";

cout<<endl;

}while(flag);

for(i=0;i<n;i++)

for(j=0;j<m;j++){

Need[i][j]=Max[i][j]-Allocation[i][j];

temp[j]+=Allocation[i][j];//每种资源已分配的总量

}

for(j=0;j<m;j++)

Avaliable[j]=Avaliable[j]-temp[j];

}

/********

显示资源分配矩阵

********/

void showdata()

{

int i,j;

cout<<endl;

cout<<"*************************************************************"<<endl;

cout<<"系统目前可用的资源[Avaliable]:"<<endl;

for(i=0;i<M;i++)

cout<<NAME[i]<<" ";

cout<<endl;

for (j=0;j<M;j++)

cout<<Avaliable[j]<<"";//输出分配资源

cout<<endl;

cout<<"系统当前的资源分配情况如下："<<endl;

cout<<" Max Allocation Need"<<endl;

cout<<"进程名 ";

for(j=0;j<3;j++){

for(i=0;i<M;i++)

cout<<NAME[i]<<" ";

cout<<" ";

}

cout<<endl;

for(i=0;i<N;i++){

cout<<" P"<<i<<" ";

for(j=0;j<M;j++)

cout<<Max[i][j]<<" ";

cout<<" ";

for(j=0;j<M;j++)

cout<<Allocation[i][j]<<" ";

cout<<" ";

for(j=0;j<M;j++)

cout<<Need[i][j]<<" ";

cout<<endl;

}

/********

安全性算法

********/

int safe()

{

int i,j,k=0,p,all;

//重新初始化Finish

for (j=0;j<N;j++)

Finish[j]=False;

for (j=0;j<M;j++)

Work[j]=Avaliable[j];

//找安全序列

for(i=0;i<N;i++){

all=0;//借助all来判断Need中某一行的每一列是否都小于等于对应的Work的每一列

for(j=0;j<M;j++){

if (Finish[i]==False&&Need[i][j]<=Work[j]){

all++;

if(all==M){

for(p=0;p<M;p++)

Work[p]=Work[p]+Allocation[i][p];//变分配数

Finish[i]=True;

Security[k]=i;

k++;//安全序列指针后移一位

i=-1; //循环结束后执行i++,使得i=0，保证每次查找安全序列都从第一个进程开始找。

}

for(i=0;i<N;i++){

if(Finish[i]==False){

cout<<"系统不安全"<<endl;//不成功系统不安全

return -1;

}

cout<<"系统是安全的!"<<endl;//如果安全，输出成功

cout<<"存在一个安全序列:";

for(i=0;i<N;i++){//输出运行进程数组

cout<<"P"<<Security[i];

if(i<N-1) cout<<"->";

}

cout<<endl;

return 0;

}

/********

利用银行家算法对申请资源对进行试分配

********/

void bank()

{

char ch;

int i,j,k;

int allow=1;

ch='y';

cout<<"请输入请求分配资源的进程号(0-"<<N-1<<"):";

cin>>i;//输入须申请资源的进程号

cout<<"请输入进程P"<<i<<"要申请的资源个数:"<<endl;

for(j=0;j<M;j++)

{

cout<<NAME[j]<<":";

cin>>Request[j];//输入需要申请的资源

}

for (j=0;j<M;j++){

if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错

{

cout<<"进程P"<<i<<"申请的资源大于它需要的资源";

cout<<" 分配不合理，不予分配！"<<endl;

ch='m';

break;

}

else {

if(Request[j]>Avaliable[j])//判断申请是否大于当前可分配资源，若大于则出错

{

cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";

cout<<endl;

cout<<" 系统尚无足够资源，不予分配!"<<endl;

ch='m';

break;

}

if(ch=='y') {

//根据进程需求量变换资源

for (j=0;j<M;j++) {

Avaliable[j]=Avaliable[j]-Request[j];

Allocation[i][j]=Allocation[i][j]+Request[j];

Need[i][j]=Need[i][j]-Request[j];

}

showdata();//根据进程需求量显示变换后的资源

safe();//根据进程需求量进行银行家算法判断

//如果不安全拒绝分配

for(k=0;k<N;k++)

{

if(Finish[k]==False) {allow=0; break;}

}

if (allow ==0)

{

for (j=0;j<M;j++) {

Avaliable[j]=Avaliable[j]+Request[j];

Allocation[i][j]=Allocation[i][j]-Request[j];

Need[i][j]=Need[i][j]+Request[j];}

cout<<"应拒绝进程P"<<i<<"的申请，此次尝试分配作废";

cout<<endl;

cout<<"还原资源分配矩阵";

showdata();

}

int main()//主函数

{

char choice;

cout<<"\t---------------------------------------------------"<<endl;

cout<<"\t|| ||"<<endl;

cout<<"\t|| 实验二：银行家算法的实现 ||"<<endl;

cout<<"\t|| ||"<<endl;

cout<<"\t|| 在此输入个人姓名：****** ||"<<endl;

cout<<"\t|| ||"<<endl;

cout<<"\t---------------------------------------------------"<<endl;

chushihua();//初始化数据

showdata();//显示各种资源

safe();//用银行家算法判定系统是否安全

while(1){

cout<<endl;

cout<<"\t-------------------银行家算法演示------------------"<<endl;

cout<<"是否请求分配吗?是请按y/Y,否请按其它键"<<endl;

cin>>choice;

if(choice=='y'||choice=='Y')

bank();

else break;

}

计算机操作系统——银行家算法相关推荐

银行家算法计算机操作系统,计算机操作系统银行家算法.doc
银行家算法 //breaker.h文件代码 #include using namespace std; int Test_Request(int *,int *); //测试函数 void Assig ...
计算机操作系统——银行家算法详解（C语言版）
目录一.实验目的二.实验内容三.实验要点说明数据结构银行家算法bank()函数安全性算法safe()函数银行家算法实例程序结构四.实验代码五.结果展示一.实验目的通过编写一个模 ...
计算机操作系统——先到先服务算法（C#））
计算机操作系统--先到先服务算法(C#) 什么是先到先服务周转时间以及带权周转时间流程图源代码运行截图什么是先到先服务如果早就绪的进程排在就绪队列的前面,迟就绪的进程排在就绪队列的后面,那 ...
操作系统——银行家算法（银行家和房地产开发商的爱恨情仇）
操作系统--银行家算法什么是银行家算法银行家算法(Banker's Algorithm)是一个避免死锁(Deadlock)的著名算法,是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避 ...
操作系统银行家算法计算机四级,【NCRE四级网络工程师】操作系统多选题
友情提示:此篇文章大约需要阅读 7分钟54秒,不足之处请多指教,感谢您的阅读. 保存在进程控制块中的是进程标识符进程当前状态代码段指针 PCB的内容可以分为调度信息和现场信息两大部分.调度信息供 ...
操作系统 | 银行家算法及代码实现
参考博客 [操作系统]死锁避免之银行家算法_少侠露飞的学习笔记-CSDN博客 [操作系统]避免死锁--银行家算法_明昕ztoy的博客-CSDN博客_银行家算法避免死锁实现思路当一个进程申请使用资源 ...
操作系统-银行家算法(Java实现)
一.银行家算法思想银行家算法是最著名的死锁避免算法,其思想是:将操作系统视为银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款.操作系统按照银行家制定 ...
[操作系统] 银行家算法
文章目录安全序列通俗理解模型初始借完钱分析借钱的安全序列银行家算法核心思想资源表示安全性算法分析系统状态银行家算法实现思路分析银行家算法步骤安全性算法步骤升华思维安全序列 ...
c语言银行家算法模拟程序,C语言实现操作系统银行家算法
/**************************************************** 银行家算法算法思想: 1. 在多个进程中,挑选资源需求最小的进程Pmin, 可能存在多类资 ...

计算机操作系统——银行家算法

计算机操作系统——银行家算法相关推荐

最新文章

热门文章