银行家算法——c语言实现

合集下载

银行家算法c语言流程图代码全

银行家算法c语言流程图代码全
操作系统教程
——银行家算法
院系 班级 学号 姓名
计算机与软件学院 08 软件工程 2 班
20081344066 何丽茗
一、实验目的
银行家算法是避免死锁的一种重要方法。通过编写一个模拟动态资源分配的银行家算法 程序�进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念�并掌握避免死锁 的具体实施方法。
四、实验代码以及运行示例
1. 源代码�
#include<iostream>
#include<string.h>
#include<stdio.h>
#define False 0
#define True 1
using namespace std;
intMax[100][100]={0};//各进程所需各类资源的最大需求
for(j=0;j<N;j++)
cout<<Allocation[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Need[i][j]<<" ";
cout<<endl;
}
}
intchangdata(inti)//进行资源分配 {
int j; for (j=0;j<M;j++) {
Y
i加1
提示 错误 重新 输入
所有进程运行 都结束
结束
初始化 need 矩阵 Y Need 矩阵为 0
N
任选一个进程作为当前进程
Need 向量为 0 N

银行家算法(C代码)

银行家算法(C代码)

#include<stdio.h>int MaxNeed[5][3];int Allocation[5][3];int Need[5][3];int All[1][3];int Available[1][3];void Head()//开始{int i=0;int j=0;for(i=0;i<15;i++){printf(" \020");}printf("\n");printf(" 欢迎使用银行家算法!\n");for(j=0;j<15;j++){printf(" \020");}printf("\n");}void InitArray()//各个数组初始化{int i;int j;for(i=0;i<5;i++){int l=i+1;printf("请输入P%d进程最大需求的信息:\n",l);printf(" A资源,B资源,C资源:");scanf("%d%d%d",&MaxNeed[i][0],&MaxNeed[i][1],&MaxNeed[i][2]);}for(j=0;j<5;j++){int l=j+1;printf("请输入P%d进程已获得资源的信息:\n",l);printf(" A资源,B资源,C资源:");scanf("%d%d%d",&Allocation[j][0],&Allocation[j][1],&Allocation[j][2]);}printf("请输入总资源的信息:\n");printf(" A资源,B资源,C资源:");scanf("%d%d%d",&All[0][0],&All[0][1],&All[0][2]);void CalculateAvailable()//计算可利用的资源{int i=0;int a=0;int b=0;int c=0;for(i=0;i<5;i++){a=a+Allocation[i][0];b=b+Allocation[i][1];c=c+Allocation[i][2];}Available[0][0]=All[0][0]-a;Available[0][1]=All[0][1]-b;Available[0][2]=All[0][2]-c;}void CalculateNeed()//计算每个进程还需要的资源{int i=0;int j=0;for(i=0; i<5; i++){for(j=0;j<3;j++){Need[i][j]=MaxNeed[i][j]-Allocation[i][j] ;}}}void PrintMaxNeed()//打印每个进程的最大需求量{int i=0;int j=0;for(i=0; i<5; i++){for(j=0;j<3;j++){printf("%5d", MaxNeed[i][j]);}printf("\n");}printf("\n");}void PrintAllocation()//打印每个进程已分配的资源{int i=0;for(i=0; i<5; i++){for(j=0;j<3;j++){printf("%5d", Allocation[i][j]);}printf("\n");}printf("\n");}void PrintNeed()//打印每个进程还需要的资源数量{int i=0;int j=0;for(i=0; i<5; i++){for(j=0;j<3;j++){printf("%5d", Need[i][j]);}printf("\n");}printf("\n");}void PrintAll()//打印总共资源数量{int i=0;for(i=0; i<3; i++){printf("%5d", All[0][i]);}printf("\n");}void PrintAvailable()//打印还可利用的资源数量{int i=0;for(i=0; i<3; i++){printf("%5d", Available[0][i]);}printf("\n");}void JudgeSafeCondition()//判断安全状态{int i=0;int j=0;int k=0;int count=0;int SafeSequence[5]={7,7,7,7,7};for(i=0;i<5;i++)int a;for(j=0;j<5;j++){a=((Available[0][0]>=Need[j][0])&&(Available[0][1]>=Need[j][1])&&(Available[0][2]>=Need[j] [2]));if(a==1&&j!=SafeSequence[0]&&j!=SafeSequence[1]&&j!=SafeSequence[2]&&j!=SafeSequenc e[3]&&j!=SafeSequence[4]){count=count+1;SafeSequence[i]=j;Available[0][0]=Allocation[j][0]+Available[0][0];Available[0][1]=Allocation[j][1]+Available[0][1];Available[0][2]=Allocation[j][2]+Available[0][2];printf("调用进程P%d后的Available资源:",j+1);PrintAvailable();printf("\n");break;}}}if(count==5){printf("存在安全序列:\n");for(k=0;k<5;k++){printf("P%d ",SafeSequence[k]+1);}printf("\n");}else{printf("查找安全序列失败!\n");}}void ApplySource()//T0时刻申请资源{int pro;//请求资源进程数int s_a,s_b,s_c;//请求资源的数量printf("请选择要请求资源的进程数[1,2,3,4,5]:");scanf("%d",&pro);printf("请输入还需要的A,B,C的资源数:");Available[0][0]=Available[0][0]-s_a;Available[0][1]=Available[0][1]-s_b;Available[0][2]=Available[0][2]-s_c;Allocation[pro-1][0]=Allocation[pro-1][0]+s_a;Allocation[pro-1][1]=Allocation[pro-1][1]+s_b;Allocation[pro-1][2]=Allocation[pro-1][2]+s_c;CalculateNeed();}void main(){char app_source;Head();InitArray();CalculateAvailable();CalculateNeed();printf("MaxNeed:\n");PrintMaxNeed();printf("Allocation:\n");PrintAllocation();printf("Need:\n");PrintNeed();printf("All:\n");PrintAll();printf("Available:\n");PrintAvailable();printf("是否有进程要申请资源[y/n]:");fflush(stdin);scanf("%c",&app_source);switch(app_source){case 'y':{ApplySource();printf("Allocation:\n");PrintAllocation();printf("Need:\n");PrintNeed();printf("All:\n");PrintAll();printf("Available:\n");PrintAvailable();JudgeSafeCondition();break;}case 'n':break;}}。

C语言实验报告范例

C语言实验报告范例

C语言实验报告范例
实验题目:C语言实现银行家算法
实验目的:掌握C语言实现银行家算法的基本思想,并能熟练应用矩阵处理实现银行
家算法的功能。

实验内容:
1. 利用C语言实现银行家算法的核心思想,利用矩阵处理实现其核心功能模块。

2. 银行家算法是一种负责实现“当前分配”的基于矩阵的编程模型。

该算法可以通
过利用安全状态来识别一次可行解,从而解决请求和分配资源的冲突问题。

3. 根据上述信息,我们设计了C语言实现银行家算法的基本框架,包括初始化步骤、可行性检查步骤、回滚步骤以及主步骤。

4. 在初始化步骤中,我们采用矩阵存储技术,将银行家算法中的各个参数保存起来,具体过程中采用数组存储。

5. 在可行性检查步骤中,我们判断当前系统状态是否处于安全状态,如果处于安全
状态,则继续完成下一步余额检查;否则,处理发生冲突时,回滚处理。

6. 在主步骤中,我们过程中判断若系统处于可行状态,则继续分配资源;否则,则
执行回滚操作,将系统恢复到上一状态。

实验结果和结论:
通过实验,我们学会了如何使用C语言来实现银行家算法,进而通过实现矩阵处理,
实现了该算法的核心功能模块。

此外,我们还学习了安全状态机制,进行系统可行性检查,和完成系统的分配工作,以达到有效地实现银行家算法的目的。

本次实验结论如下:
1. 通过C语言实现银行家算法中的核心功能模块,使系统的可行性检查得以有效实现;
2. 利用矩阵存储来实现系统的可行性检查,从而有效地节省时间和提高资源分配的
效率;
3. 通过回滚处理,有效地解决资源请求和分配冲突问题,使系统能够有效地实现安
全状态。

c语言银行家算法

c语言银行家算法

c语言银行家算法在C语言中实现银行家算法,首先需要了解该算法的基本概念和原理。

银行家算法是一种避免死锁的资源分配算法,它模拟了银行贷款的过程。

当一个进程请求资源时,系统先检查分配后是否安全,如果是,则分配资源。

否则,进程必须等待,直到足够的资源可用。

以下是一个简单的银行家算法的C语言实现:```c#include <stdio.h>#define MaxProcs 5#define MaxResources 3int Allocation[MaxProcs][MaxResources] = {0};int Max[MaxProcs][MaxResources] = {0};int Allocation[MaxProcs][MaxResources] = {0};int Available[MaxResources] = {0};int Need[MaxProcs][MaxResources] = {0};int Work[MaxResources] = {0};int safeSeq[MaxProcs] = {0};int count = 0;void calcNeed() {for (int p = 0; p < MaxProcs; p++) {for (int r = 0; r < MaxResources; r++) {Need[p][r] = Max[p][r] - Allocation[p][r];}}}void checkSafe() {int finish[MaxProcs] = {0};int k, j;for (k = 0; k < MaxProcs; k++) {safeSeq[k] = -1;}while (count < MaxProcs) {for (k = 0; k < MaxProcs; k++) {if (finish[k] == 0) {for (j = 0; j < MaxResources; j++) {if (Need[k][j] > Work[j]) {break;}}if (j == MaxResources) {for (j = 0; j < MaxResources; j++) {Work[j] += Allocation[k][j];safeSeq[count++] = k;finish[k] = 1;}}}}}if (count == MaxProcs) {printf("系统是安全的\n");} else {printf("系统是不安全的\n");}}```。

操作系统实验报告--C语言实现银行家算法

操作系统实验报告--C语言实现银行家算法

实验报告程序源代码:#include <stdio.h>#include <stdlib.h>#include <conio.h># define m 50int no1; //进程数int no2; //资源数int r;int allocation[m][m],need[m][m],available[m],max[m][m];char name1[m],name2[m]; //定义全局变量void main(){void check();void print();int i,j,p=0,q=0;char c;int request[m],allocation1[m][m],need1[m][m],available1[m];printf("**********************************************\n");printf("* 银行家算法的设计与实现 *\n");printf("**********************************************\n");printf("请输入进程总数:\n");scanf("%d",&no1);printf("请输入资源种类数:\n");scanf("%d",&no2);printf("请输入Max矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&max[i][j]); //输入已知进程最大资源需求量printf("请输入Allocation矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&allocation[i][j]); //输入已知的进程已分配的资源数for(i=0;i<no1;i++)for(j=0;j<no2;j++)need[i][j]=max[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值printf("请输入Available矩阵\n");for(i=0;i<no2;i++)scanf("%d",&available[i]); //输入已知的可用资源数print(); //输出已知条件check(); //检测T0时刻已知条件的安全状态if(r==1) //如果安全则执行以下代码{do{q=0;p=0;printf("\n请输入请求资源的进程号(0~4):\n");for(j=0;j<=10;j++){scanf("%d",&i);if(i>=no1){printf("输入错误,请重新输入:\n");continue;}else break;}printf("\n请输入该进程所请求的资源数request[j]:\n");for(j=0;j<no2;j++)scanf("%d",&request[j]);for(j=0;j<no2;j++)if(request[j]>need[i][j]) p=1;//判断请求是否超过该进程所需要的资源数if(p)printf("请求资源超过该进程资源需求量,请求失败!\n");else{for(j=0;j<no2;j++)if(request[j]>available[j]) q=1;//判断请求是否超过可用资源数if(q)printf("没有做够的资源分配,请求失败!\n");else //请求满足条件{for(j=0;j<no2;j++){available1[j]=available[j];allocation1[i][j]=allocation[i][j];need1[i][j]=need[i][j];//保存原已分配的资源数,仍需要的资源数和可用的资源数available[j]=available[j]-request[j];allocation[i][j]+=request[j];need[i][j]=need[i][j]-request[j];//系统尝试把资源分配给请求的进程}print();check(); //检测分配后的安全性if(r==0) //如果分配后系统不安全{for(j=0;j<no2;j++){available[j]=available1[j];allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];//还原已分配的资源数,仍需要的资源数和可用的资源数}printf("返回分配前资源数\n");print();}}}printf("\n你还要继续分配吗?Y or N ?\n");//判断是否继续进行资源分配c=getche();}while(c=='y'||c=='Y');}}void check() //安全算法函数{int k,f,v=0,i,j;int work[m],a[m];bool finish[m];r=1;for(i=0;i<no1;i++)finish[i]=false; // 初始化进程均没得到足够资源数并完成for(i=0;i<no2;i++)work[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数k=no1;do{for(i=0;i<no1;i++){if(finish[i]==false){f=1;for(j=0;j<no2;j++)if(need[i][j]>work[j])f=0;if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程{finish[i]=true;a[v++]=i; //记录安全序列号for(j=0;j<no2;j++)work[j]+=allocation[i][j]; //释放该进程已分配的资源}}}k--; //每完成一个进程分配,未完成的进程数就减1 }while(k>0);f=1;for(i=0;i<no1;i++) //判断是否所有的进程都完成{if(finish[i]==false){f=0;break;}}if(f==0) //若有进程没完成,则为不安全状态{printf("系统处在不安全状态!");r=0;}else{printf("\n系统当前为安全状态,安全序列为:\n");for(i=0;i<no1;i++)printf("p%d ",a[i]); //输出安全序列}}void print() //输出函数{int i,j;printf("\n");printf("*************此时刻资源分配情况*********************\n");printf("进程名/号 | Max | Allocation | Need |\n"); for (i = 0; i < no1; i++){printf(" p%d/%d ",i,i);for (j = 0; j < no2; j++){printf("%d ",max[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",allocation[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",need[i][j]);}printf("\n");}printf("\n");printf("各类资源可利用的资源数为:");for (j = 0; j < no2; j++){printf(" %d",available[j]);}printf("\n");}程序运行调试结果:1、程序初始化2、检测系统资源分配是否安全结果。

操作系统-银行家算法C语言实现

操作系统-银行家算法C语言实现

银行家算法C语言实现以下便是代码实现#include"stdio.h"#include"stdlib.h"#include"string.h"int n,m;struct info{int claim[50];int allocation[50];int need[50];}pro[50];int available[50];int request[50];void init(){ int i,j;printf("请输入资源种类数:");scanf("%d",&n);for(i=0;i<n;i++){ printf("请输入第%d个资源的最大资源数:\n",i);scanf("%d",&available[i]);}printf("请输入进程数:");scanf("%d",&m);printf("请输入各进程对各资源的最大需求数:\n");for(i=0;i<m;i++){ printf("请输入第%d进程对各资源的最大需求数:\n",i);for(j=0;j<n;j++){scanf("%d",&pro[i].claim[j]);pro[i].allocation[j]=0;pro[i].need[j]=pro[i].claim[j];}}printf("\n");}int safe(){ int work[101];int finish[101];int xulie[101];int i,j,k,w=0;int flag=1,t=0;for(i=0;i<m;i++)finish[i]=0;for(i=0;i<n;i++)work[i]=available[i];for(i=0;i<m;i++){for(j=0;j<m;j++){if(finish[j]==0){for(k=0;k<n ;k++){if(flag==1&&work[k]>=pro[j].need[k])flag=1;elseflag=0;}if(flag==1){for(k=0;k<n;k++)work[k]=work[k]+pro[j].allocation[k];finish[j]=1;xulie[w++]=j;}flag=1;}}}for(i=0;i<m;i++)if(finish[i]==0) break;if(i<m){printf("系统是不安全的,进程等待,请重新输入进程\n");return 0;}else{printf("系统是安全的。

C语言实现银行家算法源代码

C语言实现银行家算法源代码

C语言实现银行家算法源代码#include &quot;stdio.h&quot;#define MAXPROCESS 50 /*最大进程数*/#define MAXRESOURCE 100 /*最大资源数*/#define true 1#define false 0int AVAILABLE[MAXRESOURCE]; /*可用资源数组*/int MAX[MAXPROCESS][MAXRESOURCE]; /*最大需求矩阵*/int ALLOCATION[MAXPROCESS][MAXRESOURCE]; /*分配矩阵*/int NEED[MAXPROCESS][MAXRESOURCE]; /*需求矩阵*/int REQUEST[MAXPROCESS][MAXRESOURCE]; /*进程需要资源数*/int FINISH[MAXPROCESS]; /*系统是否有足够的资源分配*/ int p[MAXPROCESS]; /*记录序列*/int m,n; /*m个进程,n个资源*/void Init();int Safe();void Bank();void main(){Init();Safe();Bank();} /*最大资源数*/void Init() /*初始化算法*/{int i,j;printf(&quot;请输入进程的数目:\n&quot;);scanf(&quot;%d&quot;,&amp;m);printf(&quot;请输入资源的种类:\n&quot;);scanf(&quot;%d&quot;,&amp;n);printf(&quot;请输入每个进程最多所需的各资源数,按照%dx%d矩阵输入\n&quot;,m,n); for(i=0;i&lt;m;i++)for(j=0;j&lt;n;j++)scanf(&quot;%d&quot;,&amp;MAX[i][j]);printf(&quot;请输入每个进程已分配的各资源数,也按照%dx%d矩阵输入\n&quot;,m,n); for(i=0;i&lt;m;i++){for(j=0;j&lt;n;j++){scanf(&quot;%d&quot;,&amp;ALLOCATION[i][j]);NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];if(NEED[i][j]&lt;0){printf(&quot;您输入的第%d个进程所拥有的第%d个资源数错误,请重新输入:\n&quot;,i+1,j+1); j--;continue;}}}printf(&quot;请输入各个资源现有的数目:\n&quot;);for(i=0;i&lt;n;i++){scanf(&quot;%d&quot;,&amp;AVAILABLE[i]);}}int Safe() /*安全性算法,返回值:true,false*/{int i,j,k,l=0;int Work[MAXRESOURCE]; /*工作数组*/for(i=0;i&lt;n;i++)Work[i] = AVAILABLE[i];for(i=0;i&lt;m;i++){FINISH[i] = false;}for(i=0;i&lt;m;i++){if(FINISH[i] == true){continue;}else{for(j=0;j&lt;n;j++){if(NEED[i][j]&gt;Work[j]){break;}}if(j==n){FINISH[i]=true;for(k=0;k&lt;n;k++){Work[k]+=ALLOCATION[i][k];}p[l++]=i;i=-1;}else{continue;}}if(l==m){//cout&lt;&lt;&quot;系统是安全的&quot;&lt;&lt;endl;printf(&quot;系统是安全的\n&quot;);//cout&lt;&lt;&quot;安全序列:&quot;&lt;&lt;endl;printf(&quot;安全序列:\n&quot;);for(i=0;i&lt;l;i++){//cout&lt;&lt;p[i];printf(&quot;%d&quot;,p[i]);if(i!=l-1){printf(&quot;--&gt;&quot;);}}return true;}}printf(&quot;系统是不安全的\n&quot;);return false;}void Bank() /*银行家算法*/{int i,cusneed;char again;while(1){printf(&quot;请输入要申请资源的进程号(注:第1个进程号为0,依次类推)\n&quot;); scanf(&quot;%d&quot;,&amp;cusneed);printf(&quot;请输入进程所请求的各资源的数量\n&quot;);for(i=0;i&lt;n;i++){scanf(&quot;%d&quot;,&amp;REQUEST[cusneed][i]);}for(i=0;i&lt;n;i++){if(REQUEST[cusneed][i]&gt;NEED[cusneed][i]){printf(&quot;您输入的请求数超过进程的需求量!请重新输入!\n&quot;); continue;}if(REQUEST[cusneed][i]&gt;AVAILABLE[i]){printf(&quot;您输入的请求数超过系统有的资源数!请重新输入!\n&quot;); continue;}}for(i=0;i&lt;n;i++){AVAILABLE[i]-=REQUEST[cusneed][i];ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];NEED[cusneed][i]-=REQUEST[cusneed][i];}if(Safe()){printf(&quot;同意分配请求!\n&quot;);}else{printf(&quot;您的请求被拒绝!\n&quot;);for(i=0;i&lt;n;i++){AVAILABLE[i]+=REQUEST[cusneed][i];ALLOCATION[cusneed][i]-=REQUEST[cusneed][i];NEED[cusneed][i]+=REQUEST[cusneed][i];}}for(i=0;i&lt;m;i++){FINISH[i]=false;}printf(&quot;您还想再次请求分配吗?是请按y/Y,否请按其它键\n&quot;); scanf(&quot;%c&quot;,&amp;again);if(again==&#39;y&#39;||again==&#39;Y&#39;) {continue;}break;}}。

银行家算法C语言代码

银行家算法C语言代码

for(int i=0;i<SMAX;++i)
{
cout<<Available[i]<<"\t";
}
cout<<"\n\n未执行进程目前已得到的资源[Allocation]:"<<endl;
for(i=0;i<PMAX;++i)
{
cout<<"\n进程["<<i<<"] : ";
void SourceRequest(); //资源请求
void FreeSource(); // 资源释放
void ShowProcess(); // 显示已执行进程的顺序
void GrantSource(int i); // 进程i资源分配
bool IsSafe();
bool FindS(int i); //进程i已经是false 现在需要确认每个资源 是不是满足Need[i][j] <= Work[j]
{
cout<<"需要的资源大于资源总量,请重新输入\n";
--j;
continue;
}
cout<<"输入进程["<<i<<"]已经拥有资源["<<j<<"]的数量 :";
cin>>Allocation[i][j];
if(Allocation[i][j] > AvailableTemp[j])
#include <iostream>

银行家算法解析及其C语言程序实现

银行家算法解析及其C语言程序实现

银行家算法解析及其C语言程序实现摘要:银行家算法是《计算机操作系统》课程中重点和难点之一,就笔者所在学校学生而言,大部分学生可以应用该算法理论做对课本习题,但对计算机利用该算法避免死锁的思想往往一知半解。

本文旨在对该算法进行更直观形象的论述,同时用C程序编写了一个该算法的程序,读者可以不加修改即可在VC6.0上运行,以进一步加深对银行家算法的理解。

关键词: 银行家算法安全状态安全序列银行家算法是一种最有代表性的避免死锁的算法。

其基本原理是将系统分为安全状态和不安全状态,并始终保持系统在安全状态下运行,从而避免发生死锁。

安全状态是指系统中存在一个以上安全序列的系统状态,在安全状态下可以保证系统不发生死锁。

反之则为不安全状态,在不安全状态下若无外力因素系统将不可避免的发生死锁。

那么什么是安全序列呢?安全序列是指系统中所有进程构成的全排列,如果按照此排列所规定的顺序执行各进程,则可以保证每个进程都能获得足够的资源,从而避免系统死锁。

例如:系统某时刻有n个进程,那么它们所组成的全排列总数是n!个,如果系统按p1,p2,...pn顺序执行各个进程,每个进程都能得到足够的资源,那么该排列就是一个安全序列。

需要注意的是:不是所有的全排列都是安全系列,安全序列的个数和长度是动态变化的,因为系统中的进程数和资源的分配情况在随时改变。

我们可以这样通俗的来描述银行家算法:把操作系统看作银行家,操作系统管理的各种计算机资源相当于银行的资金。

把进程看作银行的客户,进程向操作系统请求分配资源相当于客户向银行贷款。

银行家在批准客户的每一笔贷款时都要事先进行评估,以保证银行最终可以为所有的客户提供完整的贷款数量,避免出现所有客户获得的贷款都不完整。

这样一方面客户不能偿还银行贷款(贷款总额没完成),另一方面银行又没有资金继续为客户提供剩余贷款(此即计算机的死锁状态)。

那么银行在发放贷款时当然事先要有一套可以推算该笔贷款是否能够引起上述情况的方法,即银行家算法。

银行家算法C语言代码

银行家算法C语言代码

实验名称:银行家算法*名:***学号:********** 专业班级:创新实验班111 指导老师:**实验题目银行家算法实验目的更深层的了解银行家算法是如何避免死锁的设计思想银行家算法是根据进程的请求,假设在已分配给该进程请求的资源后,进行安全性算法,如果都能满足其他进程的请求,则满足该进程的请求,否则挂起该进程的请求。

假设在一个系统中,知道相应的进程的状态(最大需求、已占用的资源量、还需要的资源量和可利用的资源数),某个进程发出请求,在请求满足两大请求(小于还需要的资源并小于可利用资源数)时,分配给该进程相应的资源,再进行安全检测,在确认安全的情况下,才把资源真正分配给该进程,否则终止请求!主要数据结构根据算法的相应需求,需要定义int max[M][M];int allocation[M][M];int need[M][M];int available[M];int work[M];等数组流程图否运行结果图(1)分配进程的相应状态图(2)请求和请求完全部资源后释放资源图(3)继续请求并释放其他进程图(2)所有进程请求完成后系统资源还原附录原代码如下:# include "stdio.h"# define M 50int max[M][M];int allocation[M][M];int need[M][M];int available[M];int i, j, n, m, anquan,x=0;/*7 5 3 0 1 0 7 4 3 3 3 23 2 2 2 0 0 1 2 29 0 2 3 0 2 6 0 02 2 2 2 1 1 0 1 14 3 3 0 0 2 4 3 1*/main(){ void check();int p,q,control;int req[M],allocation1[M][M],need1[M][M],available1[M];printf("输入进程总数:");scanf("%d", &n);printf("输入资源种类数量:");scanf("%d", &m);printf("输入需求矩阵Max:\n");for(i=0;i<n; i++)for(j=0;j<m; j++)scanf("%2d",&max[i][j]);printf("输入已分配矩阵Allocation:\n");for(i=0;i<n; i++)for(j=0;j<m; j++)scanf("%d", &allocation[i][j]);for (i=0;i<n; i++)for(j=0;j<m; j++)need[i][j]=max[i][j]-allocation[i][j];printf("输入资源的系统初始值:\n");for (j=0;j<m;j++)scanf("%d", &available[j]);for (j=0;j<m;j++)for(i=0;i<n;i++)available[j]=available[j]-allocation[i][j];check();if (anquan==1) //如果已知的状态安全则执行以下代码{for(control=0;;control++){ p=0,q=0;printf("输入请求的进程号: ");scanf("%d", &i);printf("输入该进程的请求资源数组:");for(j=0;j<m; j++)scanf("%d",&req[j]);for(j=0;j<m; j++)if(req[j]>need[i][j])p=1;if(p)printf("请求资源大于该进程还需要的资源!\n");else{for(j=0;j<m; j++)if(req[j]>available[j])//判断请求是否大于可用资源q=1;if(q)printf("可用资源不能满足请求!\n");else{for(j=0;j<m; j++) //满足两大条件{available1[j]=available[j]; //保持资源的当前allocation1[i][j]=allocation[i][j];need1[i][j]=need[i][j];available[j]=available[j]-req[j]; //尝试把资源分配给进程allocation[i][j]=allocation[i][j]+req[j];need[i][j]=need[i][j]-req[j];if(need[i][j]==0)x=x+1; //当进程满足时释放资源}if(x==m)for(j=0;j<m;j++){available[j]=available[j]+allocation[i][j];allocation[i][j]=0;available1[j]=available[j];x--;}else x=0;check();if(anquan==0){for (j=0;j<m; j++){ available[j]=available1[j]; //还原分配前的状态allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];}printf("执行该进程不安全!返回继续操作。

操作系统银行家算法C语言代码实现

操作系统银行家算法C语言代码实现

操作系统银⾏家算法C语⾔代码实现 计算机操作系统课设需要,写了两个下午的银⾏家算法(陷在bug⾥出不来耽误了很多时间),参考计算机操作系统(汤⼦瀛) 实现过程中不涉及难度较⼤的算法,仅根据银⾏家算法的思想和步骤进⾏实现。

以下为详细步骤: 定义:max1[ ][ ] : 最⼤需求矩阵,max1[i][j]为第i条进程的第j项资源的最⼤需求数⽬; allocation[ ][ ] : 分配矩阵,allocation[i][j]为第i条进程已分得的第j项资源的数⽬; need[ ][ ] : 需求矩阵,need[i][j]为第i条进程尚需要的第j项资源的数⽬; available[ ] : 可利⽤资源量,available[i]为系统中第i项资源的可分配数⽬; request[ ][ ] : 请求矩阵,request[i][j]表⽰第i条进程对第j项资源的请求数⽬;//可以改成⼀维数组 int safe (int n,int m,int work) : n条进程,m项进程,返回值为1时当前状态安全,否则不安全; 程序流程: 1. 键盘输⼊max1矩阵,allocation矩阵,available数组,计算出need矩阵。

2. 判断当前时刻系统的状态是否安全。

true 转向3,false转向7 3. 判断当前时刻request<=need。

true 转向4,false 转向7 4. 判断当前时刻request<=available。

true 转向5,false 转向75. 进⾏安全性算法检测。

true 转向6,false 转向76. 系统分配资源并继续等待指令。

7. 系统不予分配资源并输出原因。

安全性算法:每次从第⼀个进程开始检测,如遇到所有的m项资源都可以满⾜时,work+=allocation,否则转⼊下⼀个进程的检测。

两种情况跳出第20⾏的循环。

1. 所有finish均为1,i⽆法置为-1 ,i==N时跳出循环2. 存在为0的finish,但直⾄i==N时,仍未有新的work<need出现(从最近的⼀次i==-1算起),i==N时跳出循环 第50⾏进⾏检测区分上述两种情况,如安全返回1,否则返回0;以下为完整的代码实现:(另附测试数据)1 #include<bits/stdc++.h>2int max1[1000][1000]= {0};3int allocation[1000][1000]= {0};4int need[1000][1000]= {0};5int finish[1000]= {0};6int available[1000]= {0};7int request[1000][1000]= {0};8int waitq[1000]= {0};9int waitnum=0;10int safeq[1000]= {0};11int safe (int N , int M ,int work[])12 {13int s=0;14 memset(finish,0,1000*sizeof(int));15for(int i=0; i<M; i++)16 {17 work[i]=available[i];18 }19int flag=1;20for(int i=0; i<N; i++)21 {22 flag=1;23if(!finish[i])24 {25for(int j=0; j<M; j++)26 {27if(need[i][j]>work[j])28 {29 flag=0;30break;31 }32 }33if(flag)34 {35for(int j=0; j<M; j++)36 {37 work[j]+=allocation[i][j];38 printf(" %d ",work[j]);39 }40for(int j=0; j<3; j++)41 printf("%d ",available[j]);42 printf("program %d\n",i);43 safeq[s++]=i;44 finish[i]=1;45 i=-1;46 }47 }48 }49int te=1;50for(int i=0; i<5; i++)51if(!finish[i])52 te=0;53return te;54 }55void print(int pn,int yn)56 {57 printf("current status\n");58char a='A';59int i2=0;60for(i2=0; i2<4; i2++)61 {62switch(i2)63 {64case0:65 printf("Max:");66for(int i=0; i<yn-1; i++)67 printf("");68 printf("");69break;70case1:71 printf("Allocation:");72for(int i=0; i<yn-3; i++)73 printf("");74 printf("");75break;76case2:77 printf("Need:");78for(int i=0; i<yn-1; i++)79 printf("");80break;81case3:82 printf("Available:");83for(int i=0; i<yn-2; i++)84 printf("");85 printf("");86 printf("\n");87break;88 }89 }90for(i2=0; i2<4; i2++)91 {92switch(i2)93 {94case0:95for(int j=0; j<yn; j++)96 printf("%c ",a+j);97break;98case1:99for(int j=0; j<yn; j++)100 printf("%c ",a+j);101break;102case2:103for(int j=0; j<yn; j++)104 printf("%c ",a+j);105break;106case3:107for(int j=0; j<yn; j++)108 printf("%c ",a+j);109break;110111 }112 }113 printf("\n");114for(int i=0; i<pn; i++)115 {116for(int j=0; j<yn; j++)117 {118 printf("%d ",max1[i][j]);119 }120for(int j=0; j<yn; j++)121 {122 printf("%d ",allocation[i][j]);123 }124for(int j=0; j<yn; j++)125 {126 printf("%d ",need[i][j]);127 }128if(i==0)129for(int j=0; j<yn; j++)130 printf("%d ",available[j]);131 printf("\n");132 }133 }134int main()135 {136int work[1000]= {0};137int pn,yn;138 printf("Please input the number of the program\n");139 scanf("%d",&pn);140 printf("Please input the number of the element\n");141 scanf("%d",&yn);142 printf("Please input Max and Allocation of the program \n");143for(int i=0; i<pn; i++)144 {145for(int j=0; j<yn; j++)146 {147 scanf("%d",&max1[i][j]);148 }149for(int j=0; j<yn; j++)150 {151 scanf("%d",&allocation[i][j]);152 }153for(int j=0; j<yn; j++)154 {155 need[i][j]=max1[i][j]-allocation[i][j];156 }157 }158 printf("Please input the Available \n");159for(int i=0; i<yn; i++)160 {161 scanf("%d",&available[i]);162 work[i]=available[i];163 }164165if(safe(pn,yn,work))166 {167 printf("it is safe now \n");168for(int i=0; i<pn; i++)169 printf("%d ",safeq[i]);170 printf("\n");171 printf("is the one of the safe sequence \n");172 }173else174 printf("it is not safe now\n");175176177if(safe(pn,yn,work))178 {179while(1)180 {181int num;182int ex;183int judge=1;184 printf("if you want to exit , please input 0 else input 1 \n"); 185 scanf("%d",&ex);186if(!ex)187break;188 printf("Please input the number of the request program \n"); 189 scanf("%d",&num);190 printf("Please input the Request \n");191for(int i=0; i<yn; i++)192 {193 scanf("%d",&request[num][i]);194if(request[num][i]>need[num][i])195 {196 judge=0;197 printf("error!\n");198break;199 }200 }201if(judge)202 {203int wait=0;204for(int i=0; i<yn; i++)205 {206if(request[num][i]>available[i])207 {208 wait=1;209 printf("wait because request>available!\n"); 210break;211 }212 }213if(!wait)214 {215216for(int j1=0; j1<yn; j1++)217 {218 available[j1]-=request[num][j1];219 allocation[num][j1]+=request[num][j1]; 220 need[num][j1]-=request[num][j1];221 }222if(safe(pn,yn,work))223 {224 printf("it is safe now \n");225for(int i=0; i<pn; i++)226 printf("%d ",safeq[i]);227 printf("\n");228 printf("is the one of the safe sequence \n"); 229 printf("complete !!!!!!!\n");230 }231else232 {233for(int j1=0; j1<yn; j1++)234 {235 available[j1]+=request[num][j1];236 allocation[num][j1]-=request[num][j1]; 237 need[num][j1]+=request[num][j1];238 }239 printf("wait because it is not safe \n"); 240 }241 }242243 }244 }245 }246 print(pn,yn);247 }248249/*250525132527 5 3 0 1 02533 2 2 2 0 02549 0 2 3 0 22552 2 2 2 1 12564 3 3 0 0 22573 3 2258125912601 0 2261126242633 3 0264126502660 2 02670268269270*/。

C语言实现银行家算法

C语言实现银行家算法
x[k] = i;
k++;
//释放该进程后,可利用资源数Work+Allocation
for(j=0;j<scount;j++)
{
printf("%3d",Work[j]);
}printf("\t 1");
printf("\n");
}
}
}
//如果可用资源不能满足任何进程的需要 跳出循环
//例如n=1 done<1则跳出
int requs(int scount,int * Requestnumber,int Request[10],int Allocation[10][10],int Need[10][10],int Available[10])
{
//判断是否有进程提出请求
bool isrequest;
int i,j;
while(true)
{
init(&pcount,&scount,Allocation,Need,Available); //调用初始化函数
print(pcount,scount,Allocation,Need,Available); //调用打印函数
int isreque = requs(scount,&number,Request,Allocation,Need,Available); //调用是否请求函数
C语言实现银行家算法(源码、运行结果)
一、源码
/*
银行家算法 10-22
*/
#include<stdio.h>
//函数声明
void init(int * pcount,int * scount,int Allocation[10][10],int Need[10][10],int Available[10]);

银行家算法-C语言实现

银行家算法-C语言实现
status = 0;
alloctemp = allochead;
maxtemp = maxhead;
for (i = 0; i < row; i++)
for (j = 0; j < colum; j++) {
if (status == 0) {
needhead = need1 = need2 = (struct need *)malloc(needlen);
workhead->next = work2;
status++;
}
available1->next = available2;
available1 = available2;
work1->next = work2;
work1 = work2;
}
}
available2->next = NULL;
work2->next = NULL;
if (status == 1) {
needhead->next = need2;
status++;
}
need1->next = need2;
need1 = need2;
}
maxtemp = maxtemp->next;
alloctemp = alloctemp->next;
}
need2->next = NULL;
work2 = (struct available *)malloc(avalen);
scanf("%d,%d", &available2->value);

操作系统实验银行家算法C语言实现

操作系统实验银行家算法C语言实现

#include<stdio.h>#include<stdlib.h>#include<string.h>#define a 10#define b 10//****银行家算法中的数据结构***********************int Available[a]; //.............各资源可利用的数量int Max[b][b]; //..................各进程对各类资源的最大需求数int Allocation[b][b]; //.............各进程当前已分配的资源数量int Need[b][b]; //.................尚需多少资源//*************************************************int Request[a]; //.................申请多少资源int Work[a]; //...................工作向量,表示系统可提供给进程继续运行所需的各类资源数量int Finish[b]; //...................表示系统是否有足够的资源分配给进程,1为是//**********函数声明************************************void init();//..................创建进程,资源种类与分配等,初始化函数int banker();//..........................银行家分配算法void safe(); //...........................判断算法的安全性//**********************************************//******过程中定义的全局变量********************int i,j,x,y,l,counter=0;int p; //记录是哪个进程正在申请资源int q[b]; //存储安全序列//*************************************************//*************************创建进程*************************void init()//初始化{printf("输入当前进程量:\n");scanf("%d",&x);printf("输入资源的种类数目:\n");scanf("%d",&y);printf("***输入各种资源当前可用的数量***\n");for( i=0;i<y;i++){printf("请输入资源%d的资源可利用量\n",i);scanf("%d",&Available[i]);Work[i]=Available[i]; //初始化Work[i],它的初始值就是当前可用的资源数}printf("请输入每个进程申请到的资源\n");for( j=0;j<x;j++){for(i=0;i<y;i++){printf("请输入进程%d的申请到的资源%d:\n",j,i);scanf("%d",&Allocation[j][i]);}Finish[j]=0;//初始化Finish[j]}printf("请输入每个进程需要的最大的资源数目:\n");for(j=0;j<x;j++){for(i=0;i<y;i++){printf("请输入进程%d需要的最大的资源数目%d:\n",j,i);scanf("%d",&Max[j][i]);if (Max[j][i]>=Allocation[j][i]) //根据需求量=需要最大资源数目-已分配数目,计算需求量needNeed[j][i]=Max[j][i]-Allocation[j][i];elseNeed[j][i]=0;//资源充足,不需要再申请}}printf("初始化完成\n");}//安全性算法函数void safe(){l=0;for (j=0; j<y;j++){if (Finish[j]==0){ //逐个查找Finish[j]==0的进程条件一counter=0; //记数器for (i=0; i<x; i++){ if (Work[i]>=Need[j][i])counter=counter+1;//可用大于需求,记数}if(counter==x) //i进程的每类资源都符合Work[i]>=Need[j][i] 条件二{ q[l]=j; //存储安全序列Finish[j]=1; //i进程标志为可分配for (i=0; i<x;i++)Work[i]=Work[i]+Allocation[j][i]; //释放资源l=l+1; //记数,现在有L个进程是安全的,当L=N时说明满足安全序列j= -1; //从第一个进程开始继续寻找满足条件一二的进程}}}}//*************************银行家算法***********************int banker()//..........................银行家分配算法{printf("请输入请求资源的进程\n");scanf("%d",&p);printf("\n请输入此进程请求各种资源的个数\n");for(i=0;i<x;i++){do {printf("进程%d申请资源%d的数量",p,i);scanf("%d",&Request[i]);if(Request[i]>Need[p][i])//申请量不能超过需求量printf("申请量超过需求量出错;!!请重新输入!!\n");else if(Request[i]>Available[i]){ printf("资源不充足,目前可用资源只有%d,进程要等待!!",Available[i]);Finish[p]=0; //该进程等待return 0;}}while(Request[i]>Need[p][i]||Request[i]>Available[i]);for (i=0; i<x; i++){Available[i]=Available[i]-Request[i];Allocation[p][i]=Allocation[p][i]+Request[i];Need[p][i]=Need[p][i]-Request[i];Work[i]=Available[i];}//改变Avilable、Allocation、Need的值}//判断银行家算法的安全性if(l<x){l=0;printf("试分配不成功,不与分配,恢复原状态!!");for (i=0; i<x; i++){Available[i] = Available[i]+Request[i];Allocation[p][i] = Allocation[p][i]-Request[i];Need[p][i] = Need[p][i]+Request[i];Work[i] = Available[i];}for (j=0; j<y; j++)Finish[j]=0; //进程置为未分配状态}else{l=0;printf("\n申请资源成功\n");for(i=0;i<x;i++){if(Need[p][i]==0);else { //有一种资源还没全部申请到,该进程还处于就绪态l=1; //判断标志break;}}if(l!=1){ //进程可以执行,释放该进程的所有资源for (i=0;i<x;i++){Available[i]=Available[i]+Allocation[p][i];Allocation[p][i]=0;}printf("有需求资源,执行后将释放其所有拥有资源!");l=0; //归零printf("安全序列为:\n");printf("进程%d",q[0]); //输出安全序列,考虑显示格式,先输出第一个Finish[0]=0;for (i=1; i<y; i++){printf(" 进程%d",q[i]);Finish[i]=0; //重新将所有进程置为未分配状态}printf(" \n\n\n");}return 0;}void main(){printf("\n************************************************************\n"); printf("\n 银行家算法模拟\n");printf("\n************************************************************\n"); init();//safe(); //判断当前状态的安全性if(l<y)printf("找不到安全序列,拒绝申请\n");else{int m;printf("当前序列是安全的,安全序列为:\n");printf("进程%d\n",q[0]);Finish[m]=0;for(m=1;m<x;m++){printf("进程%d\n\n",q[m]);Finish[m]=0;}}banker(); //调用银行家算法函数}。

银行家算法(用C语言实现)课程设计报告

银行家算法(用C语言实现)课程设计报告

课程设计报告题目银行家算法程序设计课程名称操作系统课程设计院部名称信息技术学院专业计算机科学与技术班级学生姓名* *学号**********课程设计地点课程设计学时20指导教师* ********教务处制操作系统课程设计报告摘要Dijkstra提出的银行家算法,是最具代表性的避免死锁的算法。

本文对如何用银行家算法来处理操作系统给进程分配资源做了详细的说明,包括需求分析、概要设计、详细设计、测试与分析、总结、源程序清单。

首先做了需求分析,解释了什么是银行家算法,并指出它在资源分配中的重要作用。

然后给出了银行家算法的概要设计,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等。

在概要设计的基础上,又给出了详细的算法设计,实现概要设计中定义的所有函数,对每个函数写出核心算法,并画出了流程图。

接着对编码进行了测试与分析(并在最后附上Java编写的程序代码)。

最后对整个设计过程进行了总结。

关键词:安全状态;安全序列;银行家算法;安全性算法;安全序列;流程图。

目录摘要 (1)目录 (2)1.绪论 (3)1.1前言 (3)1.2研究意义 (4)1.3结构安排 (4)2.需求分析 (5)2.1题目描述 (5)2.2银行家算法 (5)2.3基本要求 (5)2.4目的 (6)3.概要设计 (7)3.1设备环境 (7)3.2算法思路 (7)3.3银行家算法步骤 (7)3.4安全性算法步骤 (8)3.5数据结构 (9)3.6系统结构图 (12)4.详细设计 (13)4.1主要函数的核心代码 (13)4.2程序流程图 (13)5.测试 (16)5.1测试用例 (16)5.2测试结果截图 (17)6.总结 (22)参考文献 (24)致谢 (25)附录 (26)1绪论1.1前言:Dijkstra (1965)提出了一种能够避免死锁的调度算法,称为银行家算法。

它的模型基于一个小城镇的银行家,他向一群客户分别承诺了一定的贷款额度,每个客户都有一个贷款额度,银行家知道不可能所有客户同时都需要最大贷款额,所以他只保留一定单位的资金来为客户服务,而不是满足所有客户贷款需求的最大单位。

银行家算法解析及其C语言程序实现

银行家算法解析及其C语言程序实现
aval一>next=NULL; flag=0;
/,通过已分配矩阵和各系统资源总数计算available向基的实 际值:
aUoetemp=allochead; avatemp=avahead;
for(i=O;i<row;i++) {follj=O;j<eoloum;j++)

avatemp->value-=alloetemp->value;
maxtemp=maxtemp一>next;
alloctemp=alloctemp->next;

2009年第10期·总355期

need2一>next=NUEL;
flag=O;
用上面初始化系统中各种资源总数的方法初始化finish向 量。读者可自行在此添加。
f阱算available商量
//先创建available向量并赋初始值为各系统资源总数
for(k=O;k<rew;k++) f
alloctemp=alloehead; needtemp=needhead;
finishtemp-朝nishhead;
worktemp=workhead;
for(i=O;i<row;i++,finishtemp-珊nishtemp->next) {
worktemp--workhead;
alloetemp=alloehead; maxtemp=maxhead;
for(i=0;i<row;i++) {
forO=O;j<eoloum;j++) {
if(nag=---0) {
needhead=needl=need2=new(struet need);
needl——>next=need2·—>next=NULL;
prinff(”请输入已分配给进程p%d的R%d类资

银行家算法解析及其C语言程序实现

银行家算法解析及其C语言程序实现

银行家算法解析及其C语言程序实现摘要:银行家算法是《计算机操作系统》课程中重点和难点之一,就笔者所在学校学生而言,大部分学生可以应用该算法理论做对课本习题,但对计算机利用该算法避免死锁的思想往往一知半解。

本文旨在对该算法进行更直观形象的论述,同时用C程序编写了一个该算法的程序,读者可以不加修改即可在VC6.0上运行,以进一步加深对银行家算法的理解。

关键词: 银行家算法安全状态安全序列银行家算法是一种最有代表性的避免死锁的算法。

其基本原理是将系统分为安全状态和不安全状态,并始终保持系统在安全状态下运行,从而避免发生死锁。

安全状态是指系统中存在一个以上安全序列的系统状态,在安全状态下可以保证系统不发生死锁。

反之则为不安全状态,在不安全状态下若无外力因素系统将不可避免的发生死锁。

那么什么是安全序列呢?安全序列是指系统中所有进程构成的全排列,如果按照此排列所规定的顺序执行各进程,则可以保证每个进程都能获得足够的资源,从而避免系统死锁。

例如:系统某时刻有n个进程,那么它们所组成的全排列总数是n!个,如果系统按p1,p2,...pn顺序执行各个进程,每个进程都能得到足够的资源,那么该排列就是一个安全序列。

需要注意的是:不是所有的全排列都是安全系列,安全序列的个数和长度是动态变化的,因为系统中的进程数和资源的分配情况在随时改变。

我们可以这样通俗的来描述银行家算法:把操作系统看作银行家,操作系统管理的各种计算机资源相当于银行的资金。

把进程看作银行的客户,进程向操作系统请求分配资源相当于客户向银行贷款。

银行家在批准客户的每一笔贷款时都要事先进行评估,以保证银行最终可以为所有的客户提供完整的贷款数量,避免出现所有客户获得的贷款都不完整。

这样一方面客户不能偿还银行贷款(贷款总额没完成),另一方面银行又没有资金继续为客户提供剩余贷款(此即计算机的死锁状态)。

那么银行在发放贷款时当然事先要有一套可以推算该笔贷款是否能够引起上述情况的方法,即银行家算法。

c实现银行家算法

c实现银行家算法

银行家算法银行家算法是一种最有代表性的避免死锁的算法。

要解释银行家算法,必须先解释操作系统安全状态和不安全状态。

安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。

安全状态一定是没有死锁发生。

不安全状态:不存在一个安全序列。

不安全状态不一定导致死锁。

那么什么是安全序列呢?安全序列:一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j <i )当前占有资源量之和。

银行家算法:我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。

若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。

算法:n:系统中进程的总数m:资源类总数Available: ARRAY[1..m]ofinteger;Max: ARRAY[1..n,1..m] of integer;Allocation:ARRAY[1..n,1..m]of integer;Need:ARRAY[1..n,1..m] of integer;Request: ARRAY[1..n,1..m] of integer;符号说明:Available 可用剩余资源Max 最大需求Allocation已分配资源Need 需求资源Request请求资源当进程pi提出资源申请时,系统执行下列步骤:(“=”为赋值符号,“==”为等号)step(1)若Request<=Need, goto step(2);否则错误返回step(2)若Request<=Available, goto step(3);否则进程等待step(3)假设系统分配了资源,则有:Available=Available-Request;Allocation=Allocation+Request;Need=Need-Request若系统新状态是安全的,则分配完成若系统新状态是不安全的,则恢复原状态,进程等待为进行安全性检查,定义数据结构:Work:ARRAY[1..m] of integer;Finish:ARRAY[1..n]ofBoolean;安全性检查的步骤:step (1):Work=Available;Finish=false;step (2)寻找满足条件的i:a.Finish==false;b.Need<=Work;如果不存在,goto step(4)step(3)Work=Work+Allocation;Finish=true;gotostep(2)step (4) 若对所有i,Finish=true,则系统处于安全状态,否则处于不安全状态/* 银行家算法,操作系统概念(OS concepts Six Edition)reeditbyJohnnyhagen,SCAU,run atvc6.0*/#include"malloc.h"#include "stdio.h"#include "stdlib.h"#definealloclensizeof(struct allocation)#define maxlen sizeof(structmax)#define avalensizeof(struct available)#defineneedlen sizeof(structneed)#define finilensizeof(structfinish)#definepathlen sizeof(structpath)struct allocation{int value;structallocation *next;};struct max{int value;struct max*next;};struct available/*可用资源数*/{int value;struct available *next;};struct need /*需求资源数*/{int value;struct need *next;};struct path{intvalue;struct path *next;};structfinish{int stat;struct finish*next;};intmain(){int row,colum,status=0,i,j,t,temp,processtest;struct allocation *allochead,*alloc1,*alloc2,*alloctemp;struct max*maxhead,*maxium1,*maxium2,*maxtemp;struct available *avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1;struct need*needhead,*need1,*need2,*needtemp;structfinish *finihead,*finish1,*finish2,*finishtemp;struct path *pathhead,*path1,*path2;printf("\n请输入系统资源的种类数:");scanf("%d",&colum);printf("请输入现时内存中的进程数:");scanf("%d",&row);printf("请输入已分配资源矩阵:\n");for(i=0;i<row;i++){for(j=0;j<colum;j++){printf("请输入已分配给进程p%d的%c种系统资源:",i,'A'+j);if(status==0){allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);alloc1->next=alloc2->next=NULL;scanf("%d",&allochead->value);status++;}else{alloc2=(struct allocation*)malloc(alloclen);scanf("%d,%d",&alloc2->value);if(status==1){allochead->next=alloc2;status++;}alloc1->next=alloc2;alloc1=alloc2;}}}alloc2->next=NULL;status=0;printf("请输入最大需求矩阵:\n");for(i=0;i<row;i++){for(j=0;j<colum;j++){printf("请输入进程p%d 种类%c 系统资源最大需求:",i,'A'+j);if(status==0){maxhead=maxium1=maxium2=(struct max*)malloc(maxlen); maxium1->next=maxium2->next=NULL;scanf("%d",&maxium1->value);status++;}else{maxium2=(struct max *)malloc(maxlen);scanf("%d,%d",&maxium2->value);if(status==1){maxhead->next=maxium2;status++;}maxium1->next=maxium2;maxium1=maxium2;}}maxium2->next=NULL;status=0;printf("请输入现时系统剩余的资源矩阵:\n");for(j=0;j<colum;j++){printf("种类%c的系统资源剩余:",'A'+j);if(status==0){avahead=available1=available2=(struct available*)malloc(avalen); workhead=work1=work2=(struct available*)malloc(avalen);available1->next=available2->next=NULL;work1->next=work2->next=NULL;scanf("%d",&available1->value);work1->value=available1->value;status++;}else{available2=(struct available*)malloc(avalen);work2=(struct available*)malloc(avalen);scanf("%d,%d",&available2->value);work2->value=available2->value;if(status==1){avahead->next=available2;workhead->next=work2;status++;}available1->next=available2;available1=available2;work1->next=work2;work1=work2;}}available2->next=NULL;work2->next=NULL;status=0;alloctemp=allochead;maxtemp=maxhead;for(i=0;i<row;i++)for(j=0;j<colum;j++)if(status==0){needhead=need1=need2=(structneed*)malloc(needlen); need1->next=need2->next=NULL;need1->value=maxtemp->value-alloctemp->value;status++;}else{need2=(struct need*)malloc(needlen);need2->value=(maxtemp->value)-(alloctemp->value);if(status==1){needhead->next=need2;status++;}need1->next=need2;need1=need2;}maxtemp=maxtemp->next;alloctemp=alloctemp->next;}need2->next=NULL;status=0;for(i=0;i<row;i++){if(status==0){finihead=finish1=finish2=(struct finish*)malloc(finilen);finish1->next=finish2->next=NULL;finish1->stat=0;status++;}else{finish2=(struct finish*)malloc(finilen);finish2->stat=0;if(status==1){finihead->next=finish2;status++;finish1->next=finish2;finish1=finish2;}}finish2->next=NULL; /*Initialization compleated*/status=0;processtest=0;for(temp=0;temp<row;temp++){alloctemp=allochead;needtemp=needhead;finishtemp=finihead;worktemp=workhead;for(i=0;i<row;i++){worktemp1=worktemp;if(finishtemp->stat==0){for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next)if(needtemp->value<=worktemp->value)processtest++;if(processtest==colum){for(j=0;j<colum;j++){worktemp1->value+=alloctemp->value;worktemp1=worktemp1->next;alloctemp=alloctemp->next;}if(status==0){pathhead=path1=path2=(struct path*)malloc(pathlen);path1->next=path2->next=NULL;path1->value=i;status++;}else{path2=(structpath*)malloc(pathlen);path2->value=i;if(status==1){pathhead->next=path2;status++;}path1->next=path2;path1=path2;}finishtemp->stat=1;}else{for(t=0;t<colum;t++)alloctemp=alloctemp->next;finishtemp->stat=0;}}elsefor(t=0;t<colum;t++){needtemp=needtemp->next;alloctemp=alloctemp->next;}processtest=0;worktemp=workhead;finishtemp=finishtemp->next;}}path2->next=NULL;finishtemp=finihead;for(temp=0;temp<row;temp++) {if(finishtemp->stat==0){printf("\n系统处于非安全状态!\n");exit(0);}finishtemp=finishtemp->next;}printf("\n系统处于安全状态.\n");printf("\n安全序列为:\n");do{printf("p%d",pathhead->value);}while(pathhead=pathhead->next);printf("\n");return0;}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
cin>>YesOrNo;
if(YesOrNo=='y'||YesOrNo=='Y'||YesOrNo=='n'||YesOrNo=='N')
break;
else
{
cout<<"请按要求输入!\n";
continue;
}
Need[mi][i]+=Request[mi][i];
}
for(i=0;i<m;i++)
Finish[i]=0;
char YesOrNo;
cout<<"你还想再次请求分配吗?是请按y/Y,否请按n/N,再确定\n";
while(1)
{
{
int i,j,mi;
cout<<"输入进程的数目:\n";
cin>>m;
cout<<"输入资源的种类:\n";
cin>>n;
cout<<"输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入\n";
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
IsSafe();
while(1)
{
cout<<"输入要申请的资源的进程号(注:第一个进程号为0,以此类推)\n";
cin>>mi;
cout<<"输入进程所请求的各资源的数量\n";
for(i=0;i<n;i++)
cin>>Request[mi][i];
for(i=0;i<n;i++)
{
cout<<"你输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源错误,请重新输入:\n";
j--;
continue;
}
}
}
cout<<"请输入各资源现有的数目:\n";
for(i=0;i<n;i++)
cin>>Available[i];
Finish[i]=0;
for(i=0;i<m;i++)
{
if(Finish[i]==1)
continue;
else
{
for(j=0;j<n;j++)
{
if(Need[i][j]>Work[j])
break;
}
if(j==n)
cout<<"安全序列是:\n";
for(i=0;i<l;i++)
{
cout<<p[i];
if(i!=l-1)
cout<<"-->";
}
cout<<'\n';
return l;
}
}
return 0;
}
int main()//银行家算法
cin>>Max[i][j];
}
cout<<"输入每个进程已分配的各资源数,也按照"<<m<<"x"<<n<<"矩阵输入\n";
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
cin>>Allocation[i][j];
if(Need[i][j]<0)
{
if(Request[mi][i]>Need[mi][i])
{
cout<<"你输入的请求数超过进程的需求量!\n";
return 0;
}
if(Request[mi][i]>Available[i])
{
cout<<"你输入的请求数超过系统有的资源数!\n";
if(IsSafe())
cout<<"同意分配请求!\n";
else
{
cout<<"你的请求被拒绝!\n";
for(i=0;i<n;i++)
{
Available[i]+=Request[mi][i];
Allocation[mi][i]-=Request[mi][i];
}
if(YesOrNo=='y'||YesOrNo=='Y')
continue;
else
break;
}
}
return 0;
}
{
Finish[i]=1;
for(int k=0;k<n;k++)
Work[k]+=Allocation[i][k];
p[l++]=i;
ቤተ መጻሕፍቲ ባይዱ i-=1;
}
else continue;
}
if(l==m)
{
cout<<"系统是安全的"<<'\n';
#include<iostream.h>
int Available[100];//可利用资源数组
int Max[50][100];//最大需求矩阵
int Allocation[50][100];//分配矩阵
int Need[50][100];//需求矩阵
int Request[50][100];
return 0;
}
}
for(i=0;i<n;i++)
{
Available[i]-=Request[mi][i];
Allocation[mi][i]+=Request[mi][i];
Need[mi][i]-=Request[mi][i];
}
int Finish[50];
int p[50];
int m,n;//m个进程,n个资源
int IsSafe()
{
int i,j,l=0;
int Work[100];//可利用资源数组
for(i=0;i<n;i++)
Work[i]=Available[i];
for(i=0;i<m;i++)
相关文档
最新文档