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语言银行家算法

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");}}```。

毕业论文银行家算法避免死锁的研究与实现【范本模板】

毕业论文银行家算法避免死锁的研究与实现【范本模板】
(2)顾客可以分次贷款,但贷款的总数不能超过最大需求量;
(3)当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
(4)当顾客得到所需的资金后,一定能在有限的时间里归还所有的资金。
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量.若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。
(3)接受进程请求,试分配的程序流程图
首先,p指针指向弧的结点。如果为空,则输出无此进程,然后,输入请求向量,检查合法性,进行试分配。如图6所示.
(4)对试分配后的系统,进行安全性检查的程序流程图
和图5大致一样,唯一一点在于当找不到安全序列时,将本次试分配作废,恢复该次试分配之前的数据结构.如图7所示。
图10 安全模块Safety_Algorithm的调试的安全状态
图11 安全模块Safety_Algorithm的调试的不安全状态
试分配后的安全算法,结果如果输出一个安全性序列,并且经过人工检查该安全性序列,确实有效,则该模块正确,如图12所示;否则,之前的试分配作废,恢复试分配前的资源状态.如图13所示。
(4)安全性检查,负责试分配后的安全性检查,以及系统不安全时的资源恢复.
3。2 模块调用关系
银行家算法系统有四个模块,各模块之间的调用关系如图2所示:
图2 模块调用关系图

避免死锁的一个著名算法

避免死锁的一个著名算法

避免死锁的一个著名算法:银行家算法死锁的避免,不是严格地限制死锁的必要条件,而是在系统运行过程中小心地避免死锁的最终发生。

最著名的死锁避免算法是银行家算法。

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

又被称为“资源分配拒绝”法在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待。

为实现银行家算法,系统必须设置若干数据结构。

死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。

此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。

银行家算法:设Request(i)是进程Pi的请求向量,如果Request(i)[j]=k,表示进程Pi需要K个R(j)类型的资源。

当Pi发现资源请求后系统将进行下列步骤(1)如果Request(i)[j] <= Need[i,j],边转向步骤2),否则认为出错,因为它所请求的资源数已超过它所宣布的最大值。

(2)如果Request(i)[j] <= Available[i,j],便转向步骤3),否则,表示尚无足够资源,Pi需等待。

(3)系统试探着把资源分配给进程Pi,并需要修改下面数据结构中的数值;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)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。

操作系统课程设计之模拟通过银行家算法避免死锁

操作系统课程设计之模拟通过银行家算法避免死锁

模拟通过银行家算法避免死锁一、银行家算法产生的背景及目的1:在多道程序系统中,虽然节奏、虽然借助于多个进程的并发执行来改善系统的利用率,提高系统的吞吐量,但可能发生一种危险—死锁。

,死锁就是多个进程在运行过程中因争夺资源而造成的一种僵局,当进程处于这种僵局状态时,如无外力作用,他们将无法再向前进行,如再把信号量作为同步工具时,多个Wait和Signal操作顺序不当,会产生进程死锁。

然而产生死锁的必要条件有互斥条件,请求和保持条件,不剥夺条件和环路等待条件。

在预防死锁的几种方法中,都施加了较强的限制条件,在避免死锁的方法中,所施加的条件较弱,有可能获得令人满意的系统性能。

在该方法中把系统的状态分为安全状态和不安全状态,只要能使系统都处于安全状态,便可避免死锁。

2:实验目的:让学生独立的使用编程语言编写和调试一个系统分配资源的简单模拟程序,了解死锁产生的原因及条件。

采用银行家算法及时避免死锁的产生,进一步理解课堂上老师讲的相关知识点。

银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作的客户。

如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全的。

二:银行家算法中的数据结构1:可利用资源向量Available。

这是一个含有m个元素的数组,其中的每个元素代表一类可利用的资源数目,其初始值是系统中所配置的该类全部可用资源的数目,其数值随该类资源的分配和回收而动态的改变。

如果Available[j]=k,z 则表示系统中现有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个。

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;}。

c语言银行家算法实验报告

c语言银行家算法实验报告

c语言银行家算法实验报告C语言银行家算法实验报告引言:计算机科学领域中,操作系统的资源管理是一个十分重要的课题。

在多任务处理系统中,多个进程同时竞争有限的资源,如何合理地分配和调度资源,以保证系统的稳定性和效率,是一个关键问题。

银行家算法(Banker's Algorithm)是一种经典的资源分配算法,它通过分析系统的资源状态和进程的资源需求,来判断是否能够安全地分配资源,从而避免产生死锁。

一、实验目的本次实验旨在通过C语言编程实现银行家算法,加深对资源管理和死锁问题的理解,并通过实际案例验证银行家算法的有效性。

二、实验环境本次实验使用C语言进行编程,并在Linux操作系统下进行测试。

三、实验过程1. 设计数据结构在开始编写代码之前,我们需要先设计适合的数据结构来表示系统资源和进程的状态。

在银行家算法中,我们需要记录系统中的可用资源数量、各个进程的最大需求资源数量、已分配资源数量和需要资源数量等信息。

通过定义合适的数据结构,我们可以方便地进行资源的分配和回收。

2. 实现银行家算法根据银行家算法的原理,我们可以将其分为两个步骤:安全性检查和资源分配。

在安全性检查中,我们需要判断当前系统状态下是否存在安全序列,即是否能够满足所有进程的资源需求,避免死锁的发生。

在资源分配中,我们需要根据当前系统状态和进程的资源需求,动态地分配和回收资源。

3. 编写测试用例为了验证银行家算法的正确性和有效性,我们需要编写一些测试用例。

测试用例应该包括各种不同的进程资源需求和系统资源状态,以覆盖不同情况下的资源分配和回收。

4. 运行测试用例在编写完测试用例后,我们可以运行程序,观察输出结果。

通过比较实际输出与预期结果,我们可以判断银行家算法的正确性和有效性。

四、实验结果与分析通过运行多个测试用例,我们可以得出以下结论:1. 银行家算法能够有效地避免死锁的发生。

在安全性检查过程中,如果存在安全序列,那么系统可以继续分配资源,否则需要阻塞等待。

银行家算法避免死锁

银行家算法避免死锁
cout<<"P"<<*(Order+i)<<" ";
cout<<endl<<"系统安全!";
return true;
}
else
{
cout<<endl<<"系统不安全!"<<endl;
return false;
}
}
else
{
*(*(Need+num)+i)-=*(Request+i);
}
int ret=Security(Allocation,Need,Work,Finish,Order,n,m,temp);
if(ret)
{
cout<<endl<<"系统已分配资源给进程P"<<num<<"!";
}
}
void Banker(int *Available,int **Allocation,int **Need,int *Work,int *Finish,int *Order,int n,int m)
{
int i,num,flag=true,flag2=true,temp=0;
char answer;
exit(0);
else
cout<<endl<<"输入错误!没有输入的机会了!!!";
}
}
else
{
cout<<endl<<"系统无法分配资源给进程P"<<num<<"!请等待.....";
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

for(i=0;i<n;i++) //假设系统将申请资源数分配给该进程, 对数据进行相关修改 { Available[i] -= Request[i]; Need[number-1][i] -= Request[i]; Allocation[number-1][i] += Request[i]; } if(Safe_test()) //安全性检查结果为安全 { cout<<"系统可以为该进程分配资源.\n"; return ; } else //安全性检查结果为不安全 { cout<<"系统不为该进程分配资源\n"; //x=temp; //将相关矩阵修改过来, 表示资源不分配资源 return ; } }
} } cout<<"开始设置需求矩阵..."<<'\n'; for(i=0;i<m;i++) //设置需求矩阵 { for(j=0;j<n;j++) { Need[i][j]=Max[i][j]-Allocation[i][j]; } } cout<<"需求矩阵设置完毕。"<<'\n'; cout<<"输入可利用资源向量:"<<'\n'; for(i=0;i<n;i++) //设置可利用资源向量 { cin>>Available[i]; } }
} for(i=0;i<m;i++)//检查标志数组,若有一个为 false 则找不 到安全序列 { if(!Finish[i]) { cout<<"找不到安全序列,系统处于不安全状态!\n"; return 0; }
else { cout<<" 找到安全序列 :"; // 找到安全序列并显示该 序列
void Initilize(); //初始化 int Safe_test(); //检查安全性 void Resoure_allocate(); //系统对进程资源申请的处理 void csh();//主函数中调用初始化 void Sqzy();//调用申请资源 int m,n;//输入进程和资源种类数
else { if(b==3) { system("cls"); system("exit"); } else { cout<<"您的输入有误,请重新输入:"<<endl; Sqzy(); } } } } BankAlgorithm.cpp 文件 #include " BankAlgorithm.h " void main() { csh(); }
} } }
void Sqzy()//是否进入申请资源 { int b; cout<<"为进程申请资源请输入 1,返回初始化请输入 2, 退出请输入 3:"<<endl; cin>>b; if(b==1) { Resoure_allocate(); Sqzy(); } else { if(b==2) { system("cls"); csh(); }
for(i=0;i<m;i++) cout<<"P"<<safeprocess[i]+1<<" "; cout<<"\n 系统处于安全状态.\n";
} } return 1; }
void Resoure_allocate() { //bank temp=x; //临时变量存储 x 的初值 int Request[MaxrResource]; //请求向量 int number; //进程号 int i;
break; //不满足则跳出 } if(j==n) //第 i 个进程满足执行条件 { safeprocess[k++]=b; // 将进程号存入安全序列 向量 for(int q=0;q<n;q++) //修改空闲资源矩阵 work[q]+=Allocation[b][q]; Finish[b]=true; //标志该进程可完成 } } }
vout<<"模拟利用银行家算法避免死锁"<<endl; cout<<"进入初始化过程请输入 1,退出请输入 2"<<endl; cin>>a; if(a==1) { Initilize(); Safe_test(); Sqzy(); }else { if(a==2) { system("cls");//清屏 system("exit");//退出 } else { cout<<"您的输入有误,请重新输入:"<<endl; cin>>a; csh();
cout<<"请输入要申请资源的进程序号:\n"; cin>>number; cout<<"请输入请求向量:\n"; for(i=0;i<n;i++) cin>>Request[i]; //输入请求向量 for(i=0;i<n;i++) { if(Request[i]>Need[number-1][i]) // 所 需 资 源 数 大 于 需 求量 { cout<<" 进程所需要的资源数已超过它所宣布的最 大值,系统不予分配资源!\n"; return ; } if(Request[i]>Available[i]) // 所需资源数大于可利用资 源 { cout<<"系统中无足够的资源满足进程的申请, 系统 不予分配资源!\n"; return ; } }
BankAlgorithm.h 文件 #include <iostream.h> #include<stdlib.h>
#define /*最大进程数*/ #define /*最大资源数*/
MaxProcess
50
MaxrResource
200
int Available[MaxrResource]; //可利用资源向量 int Max[MaxProcess][MaxrResource]; //最大需求矩阵 int Allocation[MaxProcess][MaxrResource]; //分配矩阵 int Need[MaxProcess][MaxrResource]; //需求矩阵
int Safe_test() { int i,j; int safeprocess[MaxProcess]; //安全序列向量
int work[MaxrResource]; //空闲资源矩阵 int Finish[MaxProcess]; //进程完成标志矩阵 for(i=0;i<n;i++) //开始时可利用资源向量就是空闲资源矩 阵 { work[i]=Available[i]; } for(i=0;i<m;i++)//初始化标志矩阵为 false { Finish[i]=false; } int k=0; //安全序列排列号 for(i=0;i<m;i++) //每次都从第一个进程开始做循环 { for(int b=0;b<m;b++) { if(Finish[b]==false) { for(j=0;j<n;j++) { if(Need[b][j]>work[j]) // 判断当前进程需求矩 阵能否得到满足
void Initilize()
{ int i,j;
cout<<"初始化过程,输入相关数据:\n"; cout<<"请输入系统进程数 m:"<<endl; cin>>m; cout<<"请输入系统资源种类 n:"<<endl; cin>>n; cout<<"输入最大需求矩阵 Max:"<<'\n'; for(i=0;i<m;i++) //设置最大需求矩阵 { for(j=0;j<n;j++) { cin>>Max[i][j]; } } cout<<"输入分配矩阵 Allocation:"<<'\n'; for(i=0;i<m;i++) //设置分配矩阵 { for(j=0;j<n;j++) { cin>>Allocation[i][j];
相关文档
最新文档