银行家算法实验报告 昆工

合集下载

银行家算法实验报告 昆工

银行家算法实验报告 昆工

昆明理工大学信息工程与自动化学院学生实验报告(2010 —2011 学年第二学期)课程名称:操作系统开课实验室:计算中心444 2011 年 4 月28 日一、实验目的通过编写银行家算法,要求学生进一步掌握如何实现死锁的避免,进一步熟练使用数组进行程序的设计及实现。

二、实验原理及基本技术路线图(方框原理图)用C语言或C++语言开发。

实现银行家算法、安全性检测算法。

银行家算法就是对每一个请求进行检查,检查如果满足它是否会导致不安全状态。

若是,则不满足该请求;否则便满足。

利用银行家算法,我们可以来检测CPU为进程分配资源的情况,决定CPU是否响应某进程的的请求并为其分配资源,从而很好避免了死锁的产生。

算法的思路:先对用户提出的请求进行合法性检查,即检查请求是否大于需要的,是否大于可利用的。

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

若安全,则分配;若不安全,则拒绝申请,恢复到原来的状态,拒绝申请。

银行家算法的步骤:(1)如果Request<or =Need,则转向步骤(2);否则,认为出错,因为它所需要的资源数已超过它所宣布的最大值。

(2)如果Request<or=Available,则转向步骤(3);否则,表示系统中尚无足够的资源,进程必须等待。

(3)系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值:Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。

安全性检测算法:(1)设置两个向量①工作向量Work。

它表示系统可提供进程继续运行所需要的各类资源数目,执行安全算法开始时,Work=Allocation;②标志向量Finish。

它表示系统是否有足够的资源分配给进程,使之运行完成,开始时先做Finish[i]=0,当有足够资源分配给进程时,令Finish[i]=1。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告银行家算法实验报告引言:在计算机科学领域中,银行家算法是一种用于避免死锁的资源分配算法。

它是由荷兰计算机科学家艾兹赫尔·迪科斯彻在1965年提出的。

银行家算法通过合理的资源分配和安全性检查,确保系统中的进程能够安全地执行,避免了资源竞争和死锁的发生。

本篇文章将详细介绍银行家算法的原理、实验设计和结果分析。

一、银行家算法的原理银行家算法基于资源的最大需求和可用性进行资源分配。

它将系统中的资源分为若干类别,并为每个类别分配一个初始数量。

当进程请求资源时,银行家算法会检查该请求是否能够满足,如果满足则分配资源,否则将进程置于等待状态。

算法的核心思想是避免分配资源后导致系统无法满足其他进程的资源需求,从而避免死锁的发生。

二、实验设计为了验证银行家算法的有效性,我们设计了一个模拟实验。

实验中,我们创建了一个包含多个进程和资源的系统,并模拟了进程对资源的请求和释放。

每个进程都有自己的资源需求和最大需求量,系统中的资源总量也是有限的。

首先,我们初始化系统的资源数量和每个进程的最大需求量。

然后,模拟进程的请求和释放过程。

当一个进程请求资源时,银行家算法会检查该请求是否能够满足,如果满足则分配资源,否则将进程置于等待状态。

当一个进程释放资源时,系统将回收该资源并重新分配给其他进程。

实验的关键是设计合理的资源分配策略和进程请求顺序,以模拟不同的场景。

我们通过调整进程的最大需求量和资源数量,观察系统的运行情况和死锁的发生情况。

三、实验结果分析通过多次实验,我们得出了以下结论:1. 资源数量的合理分配对避免死锁非常重要。

如果资源数量过少,无法满足进程的最大需求量,系统容易发生死锁。

如果资源数量过多,系统的资源利用率低,效率低下。

因此,需要根据系统的实际需求合理分配资源数量。

2. 进程的最大需求量与资源数量的关系也是影响死锁的重要因素。

当进程的最大需求量超过系统资源数量的一半时,系统容易发生死锁。

银行家算法_实验报告

银行家算法_实验报告

银⾏家算法_实验报告课程设计报告课程设计名称共享资源分配与银⾏家算法系(部)专业班级姓名学号指导教师年⽉⽇⽬录⼀、课程设计⽬的和意义 (3)⼆、⽅案设计及开发过程 (3)1.课题设计背景 (3)2.算法描述 (3)3.数据结构 (4)4.主要函数说明 (4)5.算法流程图 (5)三、调试记录与分析四、运⾏结果及说明 (6)1.执⾏结果 (6)2.结果分析 (7)五、课程设计总结 (8)⼀、程设计⽬的和意义计算机科学与技术专业学⽣学习完《计算机操作系统》课程后,进⾏的⼀次全⾯的综合训练,其⽬的在于加深催操作系统基础理论和基本知识的理解,加强学⽣的动⼿能⼒.银⾏家算法是避免死锁的⼀种重要⽅法。

通过编写⼀个模拟动态资源分配的银⾏家算法程序,进⼀步深⼊理解死锁、产⽣死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施⽅法⼆、⽅案设计及开发过程1.课题设计背景银⾏家算法⼜称“资源分配拒绝”法,其基本思想是,系统中的所有进程放⼊进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做⽐较,找出剩余资源能满⾜最⼤需求量的进程,从⽽保证进程运⾏完成后还回全部资源。

这时系统将该进程从进程集合中将其清除。

此时系统中的资源就更多了。

反复执⾏上⾯的步骤,最后检查进程的集合为空时就表明本次申请可⾏,系统处于安全状态,可以实施本次分配,否则,只要进程集合⾮空,系统便处于不安全状态,本次不能分配给他。

请进程等待2.算法描述1)如果Request[i] 是进程Pi的请求向量,如果Request[i,j]=K,表⽰进程Pi 需要K个Rj类型的资源。

当Pi发出资源请求后,系统按下述步骤进⾏检查:如果Requesti[j]<= Need[i,j],便转向步骤2;否则认为出错,因为它所需要的资源数已超过它所宣布的最⼤值。

2)如果Requesti[j]<=Available[j],便转向步骤3,否则,表⽰尚⽆⾜够资源,进程Pi须等待。

计算机操作系统银行家算法实验报告

计算机操作系统银行家算法实验报告

计算机操作系统实验报告一、实验名称:银行家算法二、实验目得:银行家算法就是避免死锁得一种重要方法,通过编写一个简单得银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会与了解死锁与避免死锁得具体实施方法。

三、问题分析与设计:1、算法思路:先对用户提出得请求进行合法性检查,即检查请求就是否大于需要得,就是否大于可利用得.若请求合法,则进行预分配,对分配后得状态调用安全性算法进行检查。

若安全,则分配;若不安全,则拒绝申请,恢复到原来得状态,拒绝申请。

2、银行家算法步骤:(1)如果Requesti<or=Need,则转向步骤(2);否则,认为出错,因为它所需要得资源数已超过它所宣布得最大值。

(2)如果Request〈or=Available,则转向步骤(3);否则,表示系统中尚无足够得资源,进程必须等待。

(3)系统试探把要求得资源分配给进程Pi,并修改下面数据结构中得数值:Available=Available—Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法,检查此次资源分配后,系统就是否处于安全状态。

3、安全性算法步骤:(1)设置两个向量①工作向量Work。

它表示系统可提供进程继续运行所需要得各类资源数目,执行安全算法开始时,Work=Allocation;②布尔向量Finish。

它表示系统就是否有足够得资源分配给进程,使之运行完成,开始时先做Finish[i]=false,当有足够资源分配给进程时,令Finish[i]=true。

(2)从进程集合中找到一个能满足下述条件得进程:①Finish[i]=false②Need<or=Work如找到,执行步骤(3);否则,执行步骤(4)。

(3)当进程P获得资源后,可顺利执行,直至完成,并释放出分配给它得资源,故应执行:Work=Work+Allocation;Finish[i]=true;转向步骤(2).(4)如果所有进程得Finish[i]=true,则表示系统处于安全状态;否则,系统处于不安全状态.四、程序源代码:#include〈stdio、h>#define W 5//最大进程数W=5#define R 3//最大资源总数=3int Available[3];//可利用资源向量int Max[5][3];//最大需求矩阵int Allocation[5][3]; //分配矩阵intNeed[5][3];//需求矩阵int Request[3];//进程请求向量void dispose(){printf(”请输入可利用资源向量Available(格式:a,b,c)\n”);scanf("%d,%d,%d”,&Available[0],&Available[1],&Available[2]);printf(”请输入最大需求数Max(格式:a,b,c)\n");for(int j=0;j<5;j++){printf("进程%d:\n”,j);ﻩscanf("%d,%d,%d",&Max[j][0],&Max[j][1],&Max[j][2]);}printf("请输入分配数Allocation(格式:a,b,c)\n");for(j=0;j〈5;j++){printf("进程%d\n”,j);scanf(”%d,%d,%d",&Allocation[j][0],&Allocati on[j][1],&Allocation[j][2]);}//输入Max[5][3],Available[5][3],Allocation[5][3]for(j=0;j〈5;j++)for(int i=0;i〈3;i++)Need[j][i]=Max[j][i]—Allocation[j][i];//求出Need[5][3]}main(){ﻩprintf(”银行家算法 \n");dispose();printf("安全性检查\n");int Work[3];//系统可提供进程继续运行所需得各类资源数char Finish[5];//表示系统就是否有足够得资源分配for(int i=0;i<5;i++)Finish[i]='f';for(intk=0;k<3;k++)Work[k]=Available[k];int q[5];for(int x=0;x〈50;x++){printf(”请输入一个序列:\n”);scanf("%d,%d,%d,%d,%d",&q[0],&q[1],&q[2],&q[3],&q[4]);for(i=0;i<5;i++){if((Need[q[i]][0]〈=Work[0])&&(Need[q[i]][1]〈=Work[1])&&(Need[q[i]][2]<=Work[2]))//比较Need[i][j]与Work[j]{ﻩ for(k=0;k<3;k++)Work[k]=Work[k]+Allocation[q[i]][k];ﻩ Finish[i]='t';ﻩ}}if((Finish[0]=='t’)&&(Finish[1]==’t')&&(Fin ish[2]=='t')&&(Finish[3]=='t')&&(Fin ish[4]=='t'))//通过Finish[i]判断系统就是否安全ﻩbreak;elseﻩprintf("此序列不就是安全序列,请重新输入一个序列!\n");ﻩif(x==49)ﻩreturn 0;}printf("这个系统安全!\n");int a;printf("请输入Request进程:\n”);scanf(”%d”,&a);printf("该进程Request(a,b,c)\n");scanf("%d,%d,%d",&Request[0],&Request[1],&Request[2]);//输入请求量Request[3]if((Request[0]<=Need[a][0])&&(Request[1]<=Need[a][1])&&(Request[2]〈=Need[a][2]))//判断Request[i]<=Need[a][i]{if((Request[0]<=Need[a][0])&&(Request[0]<=Need[a][1])&&(Request[0]〈=Need[a][2]))//判断Request[i]<=Available[a][i]ﻩ{ﻩfor(int k=0;k<3;k++){ﻩAvailable[k]=Available[k]—Request[k];ﻩAllocation[a][k]=Allocation[a][k]+Reques t[k];ﻩNeed[a][k]=Need[a][k]—Request[k];ﻩﻩﻩ//如果上述判断成功,则修改相应得Available[k],Allocation [a][k],Need[a][k]ﻩﻩ}ﻩprintf("资源分配成功!\n”);ﻩ}ﻩelse{ﻩprintf(”资源分配失败!\n");return 0;ﻩ}}else{printf("资源分配失败!\n");ﻩreturn 0;}}程序截图:五、实验总结多个进程同时运行时,系统根据各类系统资源得最大需求与各类系统得剩余资源为进程安排安全序列,使得系统能快速且安全地运行进程,不至发生死锁。

银行家算法实验报告

银行家算法实验报告

操作系统实验报告——银行家算法计科101班张昊翔1007300204一.实验目的1. 加深对死锁概念的理解。

2. 能够利用银行家算法,有效避免死锁的发生,或检测死锁的存在。

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

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

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

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

三.实验原理在多道程序系统中,虽可借助于多个进程的并发执行,来改善系统的资源利用率,提高系统的吞吐量,但可能发生一种危险——死锁。

所谓死锁,是指多个进程在运行过程中因争夺资源而造成的一种僵局,当进程处于这种僵局状态时,若无外力作用,它们都将无法再向前推进。

为保证系统中诸进程的正常运行,应事先采取必要的措施,来预防死锁。

最有代表性的避免死锁的方法,是Dijkstra的银行家算法。

银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

死锁的产生,必须同时满足四个条件,第一个为互斥条件,即一个资源每次只能由一个进程占用;第二个为请求和保持条件,指进程已经保持了至少一个资源,但又提出了新的资源请求,而该资源又被其他进程占有,此时请求进程阻塞,但又对自己已获得的其他资源保持不放;第三个为非剥夺条件,即在出现死锁的系统中一定有不可剥夺使用的资源;第四个为循环等待条件,系统中存在若干个循环等待的进程,即其中每一个进程分别等待它前一个进程所持有的资源。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告关键字:银行家算法、安全状态、不安全状态、向量矩阵、进程、死锁、资源、就绪状态、执行状态、阻塞状态;一实验名称进程同步互斥问题二实验目的2.1切实加深对进程死锁的认识;2.2正确理解系统的安全状态与不安全状态;2.3更进一步地理解和掌握银行家算法;三实验要求3.1将本实验分成两个阶段,第一阶段实现系统安全性检测算法;第二阶段实现银行家算法;3.2要求用户能自主地输入不同的向量矩阵;3.3你的程序能正确输出不同的运算结果;3.4你的程序应具备良好的容错能力;3.5力求用户界面的简洁美观;四实验原理4.1 进程及进程死锁;4.1.1 进程:是操作系统中最基本、最重要的概念,但直到目前还没有一个统一的定义,下面通过能反映进程实质的几点描述来认识进程:①进程是程序的一次执行;②进程是可以和别的计算并发执行的计算;③进程是程序在一个数据集合上运行的过程,是系统进行资源分配和调度的一个独立单位;④进程是一个具有一定功能的程序关于某个数据集合的一次运行活动。

进程具有几个基本的特征:动态性、并发性、独立性、异步性;每个进程通常由程序段、数据段和进程控制块三部分组成,其中进程控制块能唯一标识一个进程。

进程执行时间的间断性,决定了进程可能具有多种状态。

事实上,运行中的进程至少具有以下三种基本状态:就绪状态:进程已获得除处理机以外的所有资源,一旦分到了处理机就可以立即执行,这时进程所处的状态为就绪状态;执行状态:又称运行状态。

当一个进程获得必要的资源,并占有处理机,即在处理机上运行,此时进程所处的状态为执行状态;阻塞状态:又称等待状态,正在执行的进程,由于发生了某事件而暂时无法执行下去(如等待输入/输出完成),此时进程所处的状态称为阻塞状态。

进程并非固定处于某一状态,它随着自身的推进和外界条件的变化而发生变化。

4.1.2 进程死锁进程死锁是因多个进程因竞争资源而造成的一种僵局,若无外力作用,这些进程都无法向前推进。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告实验目的:了解和掌握银行家算法,进一步熟悉进程和如何避免死锁。

实验内容:1、主要程序结构(a)resource allocation algorithm如果要求的资源量+占有的资源总的资源需求量可以carry out allocation(b) test for safety algorithm注:《--- 》中的内容为未具体写明但说明其功能的程序段bool safe(struct state new ){bool possible = true,found=false;process rest[n];//正在执行的进程号int p=n;// 正在执行的进程数量int currentavail[m];//可用资源的一个副本《---为rest和currentavail赋值---》while(possible==true&&p>0){int g=0;《---寻找可以执行完成的进程---》if(found==true){int c=0;《---假设可以执行完的进程以完成,及currentavail[*]=currentavail[*]+new.alloc[g][*];---》rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}2、实验步骤1)设计结构体#ifndef STATE_H_#define m 3#define n 5struct state{int resource[m];int available[m];int claim[n][m];int alloc[n][m];} ;#define STATE_H_#endif /* STATE_H_ */2)设计实现程序的结构的具体程序Safe算法的具体代码bool safe(struct state new ){bool possible = true,found=false;process rest[n]; //正在执行的进程号int f=0,p=n;// 正在执行的进程数量do{rest[f]=f;++f;}while(f<n);int currentavail[m]; //可用资源的一个副本int i=0;do{currentavail[i]=new.available[i];++i;}while(i<m);while(possible==true&&p>0){int g=0;/*------------------寻找可以执行完成的进程------------------------------------------*/ while(g<n){int h = 0;/*while(h<m){if((new.claim[g][h]-new.alloc[g][h])<=currentavail[h]&&rest[g]!=(-1)){if(h==m-1){found=true;}}++h;}if(found==true)break;++g;}/*-------------------------------------------------------------------------------------*/ if(found==true){int c=0;while(c<m){currentavail[c]=currentavail[c]+new.alloc[g][c];c++;}rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}实验代码:/*============================================================================ Name : pre.cAuthor :Version :Copyright : Your copyright noticeDescription : Hello World in C, Ansi-style============================================================================ */#include <stdio.h>#include <stdlib.h>#include"state.h"#define bool int#define process int#define false 0#define true 1int main(void) {bool alloc(int,int[],struct state );struct state sta1={{10,5,7},{3,3,2},{{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}},{{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}};int request[m];int k=0;while(k>=0){puts("输入要改变资源的进程号");scanf("%d",&k);puts("输入要改变的资源");int i =0;while(i<m){scanf("%d",&request[i]);i++;}if(alloc(k,request,sta1)==true){i=0;puts("输出个进程占用的资源");while(i<n){int j=0;printf("%d ",i);while(j<m){if(i==k){sta1.alloc[k][j]=request[j]+sta1.alloc[k][j];sta1.available[j]=sta1.available[j]-request[j];}printf("%d ",sta1.alloc[i][j]);j++;}printf("\n");++i;}}puts("银行家算法");}return 0;}bool alloc(int l,int request[m],struct state nest){bool safe(struct state news);bool t = false;int i=0;while(i<m){if(nest.alloc[l][i]+request[i]>nest.claim[l][i]){puts("!!resource request error!!");return false;}else if(request[i]>nest.available[i]){puts("suspend process");return false;}else{if(i==m-1){int f=0;while(f<m){nest.alloc[l][f]=nest.alloc[l][f]+request[f];nest.available[f]=nest.available[f]-request[f];f++;}if(safe(nest)==true){t=true;}else{puts(" no safe suspend process");t=false;}}}i++;}return t;}bool safe(struct state new ){bool possible = true,found=false;process rest[n];int f=0,p=n;do{rest[f]=f;++f;}while(f<n);int currentavail[m];int i=0;do{currentavail[i]=new.available[i];++i;}while(i<m);while(possible==true&&p>0){int g=0;while(g<n){int h = 0;while(h<m&&(new.claim[g][h]-new.alloc[g][h])<=currentavail[h]&&rest[g]!=(-1)){if(h==m-1){found=true;}++h;}if(found==true)break;++g;}if(found==true){int c=0;while(c<m){currentavail[c]=currentavail[c]+new.alloc[g][c];c++;}rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告引言:在计算机科学领域,由于资源的有限性,进程资源分配问题一直备受关注。

而银行家算法被广泛应用于操作系统中,用于确保资源的安全分配。

本文旨在介绍银行家算法的原理和应用,并通过实验报告来验证该算法的有效性和可行性。

1. 银行家算法简介银行家算法是由美国学者Dijkstra提出的一种资源分配和避免死锁的算法。

其基本思想是通过银行家的原则来避免系统陷入死锁状态,保证资源分配的安全性和可行性。

银行家算法适用于具有多个进程和多个资源的并发系统中。

2. 银行家算法原理银行家算法基于两个重要的概念:安全性和可分配性。

安全性表示在系统当前状态下,是否存在一种资源分配序列可以使系统避免死锁状态。

可分配性表示系统是否能够满足进程对资源的请求。

银行家算法的实现需要以下几个关键步骤:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。

(2) 效验:判断系统当前状态下资源是否满足所有进程的需求,即判断系统是否处于安全状态。

(3) 分配:若系统处于安全状态,则根据某种资源分配策略,为进程分配资源。

(4) 请求:进程请求资源。

(5) 回收:进程释放资源。

3. 银行家算法的实验验证为了验证银行家算法的有效性和可行性,我们设置了一个简单的实验环境,模拟一个有限的资源系统,包含3个进程和3种不同类型的资源。

实验过程如下:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。

设置3个进程的最大需求量分别为{5, 4, 3},已分配资源量分别为{1, 2, 2},需求资源量分别为{3, 2, 0}。

(2) 效验:判断系统当前状态下资源是否满足所有进程的需求。

经过实验验证,我们发现系统当前状态下资源无法满足进程2的资源需求。

为了保证系统的安全性和避免死锁,根据银行家算法原理,我们将不满足资源需求的进程2暂停,并回滚到初始状态。

重新调整资源分配后,系统进入了安全状态。

(3) 分配:为进程1和进程3分配资源。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

昆明理工大学信息工程与自动化学院学生实验报告(2010 —2011 学年第二学期)课程名称:操作系统开课实验室:计算中心444 2011 年 4 月28 日一、实验目的通过编写银行家算法,要求学生进一步掌握如何实现死锁的避免,进一步熟练使用数组进行程序的设计及实现。

二、实验原理及基本技术路线图(方框原理图)用C语言或C++语言开发。

实现银行家算法、安全性检测算法。

银行家算法就是对每一个请求进行检查,检查如果满足它是否会导致不安全状态。

若是,则不满足该请求;否则便满足。

利用银行家算法,我们可以来检测CPU为进程分配资源的情况,决定CPU是否响应某进程的的请求并为其分配资源,从而很好避免了死锁的产生。

算法的思路:先对用户提出的请求进行合法性检查,即检查请求是否大于需要的,是否大于可利用的。

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

若安全,则分配;若不安全,则拒绝申请,恢复到原来的状态,拒绝申请。

银行家算法的步骤:(1)如果Request<or =Need,则转向步骤(2);否则,认为出错,因为它所需要的资源数已超过它所宣布的最大值。

(2)如果Request<or=Available,则转向步骤(3);否则,表示系统中尚无足够的资源,进程必须等待。

(3)系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值:Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。

安全性检测算法:(1)设置两个向量①工作向量Work。

它表示系统可提供进程继续运行所需要的各类资源数目,执行安全算法开始时,Work=Allocation;②标志向量Finish。

它表示系统是否有足够的资源分配给进程,使之运行完成,开始时先做Finish[i]=0,当有足够资源分配给进程时,令Finish[i]=1。

(2)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=0②Need<or=Work如找到,执行步骤(3);否则,执行步骤(4)。

(3)当进程P获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:Work=Work+Allocation;Finish[i]=1;转向步骤(2)。

(4)如果所有进程的Finish[i]=1,则表示系统处于安全状态;否则,系统处于不安全状态。

主要的数据结构:(1)最大需求矩阵Max[ ][ ];(2)系统已分配资源Allocation[ ][ ] (3)资源的名称name[ ] (4)还需要资源Need[ ][ ] (5)请求资源向量Request[ ] (6)存放安全序列temp[ ] (7)存放系统可提供资源Work[ ] (8)Flag 标志程序模块:main( )//系统的主函数display()// 显示资源矩阵int safe()//安全性算法safe();//用银行家算法判定系统是否安系统结构图:程序流程图:银行家算法流程图安全性算法流程图-6-三、所用仪器、材料(设备名称、型号、规格等)。

计算机一台四、实验方法、步骤#include<stdio.h>#define False 0#define True 1int Max[100][100]={0};//各进程所需各类资源的最大需求int Avaliable[100]={0};//系统可用资源char name[100]={0};//资源的名称int Allocation[100][100]={0};//系统已分配资源int Need[100][100]={0};//还需要资源int Request[100]={0};//请求资源向量int temp[100]={0};//存放安全序列int Work[100]={0};//存放系统可提供资源int M=100;//作业的最大数为100int N=100;//资源的最大数为100void display()//******************显示资源矩阵******************************************{int i,j;printf("系统目前可用的资源[Avaliable]:\n");printf("资源名称: ");for(i=0;i<N;i++)printf("%d ",name[i]);printf("\n");printf("可用资源数量: ");for (j=0;j<N;j++)printf("%d ",Avaliable[j]);-7-printf(" \n Max Allocation Need Avaliable\n");printf("进程名 ");for(j=0;j<4;j++){for(i=0;i<N;i++)printf("%d ",name[i]);printf(" ");}printf("\n");for(i=0;i<M;i++){printf("%d",i);printf(" ");for(j=0;j<N;j++)printf("%d ",Max[i][j]);printf(" ");for(j=0;j<N;j++)printf("%d ",Allocation[i][j]);printf(" ");for(j=0;j<N;j++)printf("%d ",Need[i][j]);printf(" ");if(i==0)for (j=0;j<N;j++)printf(" %d",Avaliable[j]);printf("\n ");}}int safe()//*************************安全性算法-8-************************************************** {int i,k=0,m,apply,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){apply=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){ apply++;if(apply==N){for(m=0;m<N;m++)Work[m]=Work[m]+Allocation[i][m];//变分配数 Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){-9-printf("\n系统不安全"); //不成功系统不安全return -1;}}printf("\n系统是安全"); //如果安全,输出成功printf("\n分配的序列:");for(i=0;i<M;i++){//输出运行进程数组printf("%d",temp[i]);if(i<M-1) printf("->");}return 0;}int main()//******************************************主函数*****************************************{int i,j,number,m,n,flag;char ming;printf("\n\t\t*****************BANK 银行家算法设计与实现*****************\n");printf("\t\t\t 请首先输入系统可供资源种类的数量:");scanf("%d",&n);N=n;for(i=0;i<n;i++){printf("\t\t资源%d的名称:",i+1);scanf("%d",&ming);name[i]=ming;printf("\t\t资源的数量:");scanf("%d",&number);Avaliable[i]=number;}printf("\t\t请输入作业的数量:");scanf("%d",&m);M=m;printf("\t\t请输入各进程的最大需求量%d*%d矩阵[Max]:\n",m,n);for(i=0;i<m;i++)for(j=0;j<n;j++){printf("\t\t");scanf("%d",&Max[i][j]);}do{flag=0;printf("\t\t请输入各进程已经申请的资源量%d*%d矩阵[Allocation]:\n",m,n); for(i=0;i<m;i++)for(j=0;j<n;j++){printf("\t\t");scanf("%d",&Allocation[i][j]);if(Allocation[i][j]>Max[i][j])flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)printf("\t\t申请的资源大于最大需求量,请重新输入!\n",m,n);}while(flag);int a;display();//显示各种资源safe();//用银行家算法判定系统是否安printf("按0继续,1结束进程\n");scanf("%d",&a);if(0) return 0;main();}五、实验过程原始记录(数据、图表、计算等)六、实验结果、分析和结论(误差分析与数据处理、成果总结等。

相关文档
最新文档