实验二 银行家算法报告

合集下载

操作系统银行家算法实验报告_(1)-5页word资料

操作系统银行家算法实验报告_(1)-5页word资料

银行家算法实验报告【实验目的】(1)根据设计题目的要求,充分地分析和理解题目,叙述系统的要求,明确程序要求实现的功能以及限制条件。

(2)明白自己需要用代码实现的功能,清楚编写每部分代码的目的,做到有的放矢,有条理不遗漏的用代码实现银行家算法。

【实验要求】(1)了解和理解死锁;(2)理解利用银行家算法避免死锁的原理;(3)会使用某种编程语言。

【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。

二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。

系统按下述步骤进行安全检查:(1)如果Request i≤Need i则继续以下检查,否则显示需求申请超出最大需求值的错误。

(2)如果Request i≤Available则继续以下检查,否则显示系统无足够资源,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]-Requesti[j];(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。

若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。

三、安全性算法(1)设置两个向量:①工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程,使之运行完成。

开始时先做Finish[i]∶=false; 当有足够资源分配给进程时,再令Finish [i]∶=true。

操作系统实验二:银行家算法

操作系统实验二:银行家算法

操作系统实验⼆:银⾏家算法实验⼆银⾏家算法⼀、实验⽬的1、了解什么是操作系统安全状态和不安全状态;2、了解如何避免系统死锁;3、理解银⾏家算法是⼀种最有代表性的避免死锁的算法,掌握其实现原理及实现过程。

⼆、实验内容根据银⾏家算法的基本思想,编写和调试⼀个实现动态资源分配的模拟程序,并能够有效避免死锁的发⽣。

三、实验原理进程申请资源时,系统通过⼀定的算法判断本次申请是否不可能产⽣死锁(处于安全状态)。

若可能产⽣死锁(处于不安全状态),则暂不进⾏本次资源分配,以避免死锁。

算法有著名的银⾏家算法。

1、什么是系统的安全状态和不安全状态?所谓安全状态,是指如果系统中存在某种进程序列<P1,P2,…,Pn>,系统按该序列为每个进程分配其所需要的资源,直⾄最⼤需求,则最终能使每个进程都可顺利完成,称该进程序列<P1,P2,…,Pn,>为安全序列。

如果不存在这样的安全序列,则称系统处于不安全状态。

2、银⾏家算法把操作系统看作是银⾏家,操作系统管理的资源相当于银⾏家管理的资⾦,进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。

为保证资⾦的安全,银⾏家规定:(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客;(2) 顾客可以分期贷款,但贷款的总数不能超过最⼤需求量;(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时,对顾客的贷款可推迟⽀付,但总能使顾客在有限的时间⾥得到贷款;(4) 当顾客得到所需的全部资⾦后,⼀定能在有限的时间⾥归还所有的资⾦。

操作系统按照银⾏家制定的规则设计的银⾏家算法为:(1)进程⾸次申请资源的分配:如果系统现存资源可以满⾜该进程的最⼤需求量,则按当前的申请量分配资源,否则推迟分配。

(2)进程在执⾏中继续申请资源的分配:若该进程已占⽤的资源与本次申请的资源之和不超过对资源的最⼤需求量,且现存资源能满⾜该进程尚需的最⼤资源量,则按当前申请量分配资源,否则推迟分配。

(3)⾄少⼀个进程能完成:在任何时刻保证⾄少有⼀个进程能得到所需的全部资源⽽执⾏到结束。

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

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

江南大学理学院实验报告课程名称:计算机操作系统实验名称:银行家算法实验日期:2013.11.29 班级:信计1103 姓名:陈鹭学号:1301110301实验报告要求:1.实验目的 2.实验内容与要求 3.流程图与模块调用 4.实验分析5.运行情况6.实验体会1.实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。

本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序,了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生,以加深对课堂上所讲授的知识的理解。

2.实验内容与要求内容:银行家算法流程安全算法流程要求:设计有n个进程共享m个系统资源的系统,进程可动态的申请和释放资源,系统按各进程的申请动态的分配资源。

系统能显示各个进程申请和释放资源,以及系统动态分配资源的过程,便于用户观察和分析;3.流程图与模块调用数据结构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。

Allocation 表示进程i的分配向量,有矩阵Allocation的第i行构成。

i4.需求矩阵Need,这是一个n×m的矩阵,用以表示每个进程还需要的各类资源的数目。

如果Need (i,j)=k,表示进程i还需要Rj类资源k个,才能完成其任务。

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

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

操作系统实验报告二一:实验标题:实现死锁避免算法:银行家算法。

二:实验环境:操作系统:windows7编译器:Visual Studio 2010三:设计方案:1.实验目的通过程序模拟银行家算法,理解如何应用银行家算法避免死锁。

2.实验手段直接在C源程序定义整形进程数量、资源种类;用2维数组表示最大需求、已分配的资源。

从文件获取相关数量。

3.验证方式检验当前资源是否有安全序列,是的话输出安全序列。

四:实验代码:#include<stdio.h>#include<stdlib.h>#define P_num 5#define R_num 3int Allocation[P_num][R_num],Avaliable[R_num],Max[P_num][R_num]; int Need[P_num][R_num];int compare(int *a,int *b,int n){ int i;for(i = 0;i < n;i ++)if(a[i] < b[i])return 0;return 1;}void add(int *a,int *b,int n){ int i;for(i = 0;i < n;i++)a[i] += b[i];}void substract(int *a,int *b,int n){ int i;for(i = 0;i < n;i++)a[i] -= b[i];}void assign(int *a,int *b,int n){ int i;for(i = 0;i < n;i ++)a[i] = b[i];}void input(){FILE *fp;int i,j;if((fp = fopen("banker.txt","r")) == 0){ printf("cannot open the file");exit(0);}for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Allocation[i][j]);}for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Max[i][j]);}for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Avaliable[j]);}fclose(fp);for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){Need[i][j] = Max[i][j] - Allocation[i][j];}}int issafe(int *sp){int i;int count = 0;int n = 0;int work[R_num],finish[P_num];assign(work,Avaliable,R_num);for(i = 0;i < P_num;i ++)finish[i] = 0;n = P_num;while(n --){for(i = 0;i < P_num;i ++)if((finish[i] == 0) && compare(work,Need[i],R_num)){ add(work,Allocation[i],R_num);finish[i] = 1;sp[count] = i;count ++;}if(count >= P_num)return 1;}return 0;}int request(int pid,int *r,int n){int i;int sp[P_num];if(compare(Need[pid],r,n) == 1 && compare(Avaliable,r,n) == 1){ substract(Avaliable,r,n);add(Allocation[pid],r,n);substract(Need[pid],r,n);if(issafe(sp)){printf("Security Path:\n\t");for(i = 0;i < P_num;i ++)printf("p[%d] ",sp[i]);printf("\n");return 1;}else{add(Avaliable,r,n);substract(Allocation[pid],r,n);add(Need[pid],r,n);printf("no Security Parh on this request\n");return 0;}}else{printf("no Security Parh on this request\n");return 0;}}void main(){int id,i;int r[R_num],sp[P_num];input();if(issafe(sp)){printf("Security Path:\n\t");for(i = 0;i < P_num;i ++)printf("p[%d] ",sp[i]);printf("\n");}elseprintf("failed\n");printf("input the new request's id:");scanf("%d",&id);printf("input the new request:");for(i = 0;i < R_num;++ i)scanf("%d",&r[i]);request(id,r,R_num);}banker.txt文件内容:0 1 02 0 03 0 22 1 10 0 27 5 33 2 29 0 22 2 24 3 33 3 2所得结果:Security Path:P[1] p[3] p[4] p[0] p[2] Intput the new request's id:0Input the new request:0 2 0Security Path:p[3] p[1] p[2] p[0] p[4] 问题和想法:。

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

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

竭诚为您提供优质文档/双击可除银行家算法操作系统实验报告篇一:计算机操作系统银行家算法实验报告计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

三、问题分析与设计: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 如找到,执行步骤(3);否则,执行步骤(4)。

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

实验二:银行家算法实验报告书

实验二:银行家算法实验报告书

淮海工学院计算机工程学院实验报告书课程名:《操作系统原理A》题目:银行家算法班级:学号:姓名:操作系统原理实验——银行家算法实验报告1目的与要求:1)本实验目的是通过使用银行家算法实现系统资源的分配和安全性检查模拟,提高学生对操作系统资源分配功能的深刻理解,并培养学生对操作系统开发的兴趣与应用能力;2)实验前必须认真阅读和理解银行家算法的基本原理和实现方法;3)独立使用C或VC++编程语言编写银行家算法模拟程序;4)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及相关实验数据与运行结果)5)于2015年5月10日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。

2 实验内容或题目1)设计五个进程{P0,P1,P2,P3,P4}共享三类资源{A,B,C}的系统,{A,B,C}的资源总数量分别为10,5,7。

(参考书上用例)2)并行进程可动态地申请资源和释放资源(程序交互输入申请或释放资源数量),系统按各进程的申请动态地分配资源。

3)每当进程动态申请资源或释放资源时,模拟程序应能及时显示或打印各个进程在此时刻的资源分配表、系统可用资源量和安全序列等资源分配信息和安全检查信息。

4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。

3 实验步骤与源程序#include<string.h>#include<stdio.h>#define M 5 //定义进程数#define N 3 //定义资源数 s#define False 0#define True 1int Max[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; //每个进程对每类资源的最大需求int Allocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};// 系统已分配资源int Avaliable[3]={3,3,2}; //系统可利用资源int Need[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//还需要资源int Request[3];void showdata()//显示资源矩阵{int i,j;printf("系统目前可利用的资源数量:\n A,B,C\n"); printf("resouce: ");for (j=0;j<N;j++)printf("%d,",Avaliable[j]);//输出分配资源printf("\n");printf("各进程的资源需求:\n");for (i=0;i<M;i++){printf("pr%d: ",i);for (j=0;j<N;j++){printf("%d,",Max[i][j]);//输出最大需求资源数}printf("\n");}printf("各进程得到资源:\n");for (i=0;i<M;i++){printf("pr%d: ",i);for(j=0;j<N;j++)printf("%d,",Allocation[i][j]);//输出已分配资源数printf("\n");}printf("各进程还需求资源:\n");for (i=0;i<M;i++){printf("pr%d: ",i);for(j=0;j<N;j++)printf("%d,",Need[i][j]);//输出还需要资源数printf("\n");}}void release(int i)//判断是否安全,若不安全则释放第j类资源{int j;for (j=0;j<N;j++){Avaliable[j]=Avaliable[j]+Request[j];Allocation[i][j]=Allocation[i][j]-Request[j];Need[i][j]=Need[i][j]+Request[j];}}void distribute(int i)//若符合条件则对第j类资源进行分配{int j;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];}}void safeAlgorithm()//安全性算法{int Work[3],Finish[M]={0},result[M],run;/* work:表示系统可提供给进程继续运行的所需的各类资源数目finish:表示系统是否有足够的资源分配给进程result用来存放依次执行成功的线程*/int i,j,k=0,m,demand;for(i=0;i<3;i++){Work[i]=Avaliable[i]; //开始的时候work=available}for(i=0;i<M;i++){demand=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){ demand++;if(demand==3)//只有ABC三类资源都满足才把相应的线程记入数组result中{for(m=0;m<N;m++)Work[m]=Work[m]+Allocation[i][m];//重新分配第i 类线程的当前可利用资源Finish[i]=True;result[k]=i;i=-1;k++;}}elseif(Finish[i]==False){if(i==M-1){printf("系统不安全\n");//如果不成功,输出系统不安全run=False;}break;}}printf("系统资源分配成功!");//如果安全,输出成功printf("分配的序列:\n");for(i=0;i<M;i++)//输出运行进程数{printf("pr%d ",result[i]);}}void bankerAlgorithm()//利用银行家算法对申请资源对进行判定{int i,j,OK=1,run=True;printf("\n请输入第一个要求分配的资源进程号从(0 to 4):");scanf("%d",&i);//输入须申请的资源号printf("请输入进程 %d 申请的资源:\n",i);for(j=0;j<3;j++){printf("第 %d 个资源:",j+1);scanf("%d",&Request[j]);//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错{printf("进程%d 申请的资源大于它需要的资源",i);printf(" error!\n");OK=0;break;}else{if(Request[j]>Avaliable[j]) //判断申请是否大于当前资源,若大于则出错{printf("进程 %d 申请的资源大于当前可利用资源",i);printf(" error!\n");OK=0;break;}}}if(OK==1) //若都符合条件,则进行分配{distribute(i); //根据进程请求分配资源showdata(); //显示变换后的资源safeAlgorithm(); //通过安全算法判断该序列是否安if(run==False) //若不安全,则进行释放第I类资源release(i);}}}void main()//主函数{int choice;showdata();safeAlgorithm();do{ printf("\n输入接下来你要进行的操作1:分配资源 2:显示资源否则按任意键退出");scanf("%d",&choice);switch(choice){ case 1: bankerAlgorithm(); break;case 2: showdata(); break;default: break;}}while((choice==1)||(choice==2));}4 测试数据与实验结果(可以抓图粘贴)5 结果分析与实验体会(学生自己填写)2. 版面格式:(1)各级标题:黑体,小四,段前/段后:6磅(2)正文内容:宋体、五号,行间距1.25倍;(3)程序代码:宋体、五号,单倍行间距;(4)A4纸,上、下、左、右边距:2厘米注:蓝色字体部分为注释,正式报告中将其删除。

实验二银行家算法汇总

实验二银行家算法汇总

淮海工学院计算机科学系实验报告书课程名:《操作系统原理》题目:银行家算法班级:学号:姓名:操作系统原理实验——银行家算法实验报告1目的与要求:1)本实验目的是通过使用银行家算法实现系统资源的分配和安全性检查模拟,提高学生对操作系统资源分配功能的深刻理解,并培养学生对操作系统开发的兴趣与应用能力;2)实验前必须认真阅读和理解银行家算法的基本原理和实现方法;3)独立使用C或VC++编程语言编写银行家算法模拟程序;4)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)5)于2007年6月1日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。

2 实验内容或题目1)设计五个进程{P0,P1,P2,P3,P4}共享三类资源{A,B,C}的系统,{A,B,C}的资源总数量分别为10,5,7。

(参考书上用例)2)并行进程可动态地申请资源和释放资源(程序交互输入申请或释放资源数量),系统按各进程的申请动态地分配资源。

3)每当进程动态申请资源或释放资源时,模拟程序应能及时显示或打印各个进程在此时刻的资源分配表、系统可用资源量和安全序列等资源分配信息和安全检查信息。

4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。

3 实验步骤与源程序实验流程图:#include "string.h"#include "iostream.h"#include "stdio.h"#define M 5 //总进程数#define N 3 //总资源数#define FALSE 0#define TRUE 1int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};int AVAILABLE[N]={3,3,2};int ALLOCATION[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};int NEED[M][N]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};int Request[N]={0,0,0};int p[M]={0,1,2,3,4};void ChangeData(int k);void RestoreData(int k);int Compare(int need[ ],int work[ ]);int Compare1(int need[ ],int work[ ]);int IsSecurity(int available[],int need[][N],int request[]);void out();void out(int t){printf("PCB Max Allocation Need Available\n");printf("PRO A B C A B C A B C A B C\n");int i;for(i=0;i<5;i++){if(p[i]==t)printf("%d %d %d %d %d %d %d %d %d %d %d %d %d\n",p[i],MAX [p[i]][0],MAX[p[i]][1],MAX[p[i]][2],ALLOCATION[p[i]][0],ALLOCATION[p[i]][1],ALLOCATION [p[i]][2],NEED[p[i]][0],NEED[p[i]][1],NEED[p[i]][2],AVAILABLE[0],AVAILABLE[1],AVAILABL E[2]);elseprintf("%d %d %d %d %d %d %d %d %d %d\n",p[i],MAX[p[i]][0],MAX[p [i]][1],MAX[p[i]][2],ALLOCATION[p[i]][0],ALLOCATION[p[i]][1],ALLOCATION[p[i]][2],NEED[ p[i]][0],NEED[p[i]][1],NEED[p[i]][2]);}};void ChangeData(int k) //为进程k分配请求的资源数量{int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}};void RestoreData(int k) //恢复已分配的数据为分配前状态{int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}};int Compare1(int need[ ],int work[ ]){int j;for(j=0;j<N;j++) {if(need[j]>=work[j]){}elsereturn TRUE;}return FALSE;};int Compare(int need[ ],int work[ ]) //安全检查过程中判断进程需求资源是否大于现有资源{int j;for(j=0;j<N;j++) {if(need[j]>work[j]){return FALSE;}}return TRUE;};int IsSecurity(int available[],int need[][N],int request[]){//安全检查程序段int i,j,k=0,flag,finish[M],work[N];for(i=0;i<M;i++) {finish[i]=FALSE;}for(j=0;j<N;j++) {work[j]=available[j];}while(TRUE) {//寻找安全进程序列flag=FALSE;for(i=0;i<M;i++) { //每一趟循环将找到当前可分配资源的进程,并回收其已分配资源if(finish[i]==FALSE&&Compare(need[i],work)==TRUE) {for(j=0;j<N;j++) work[j]+=ALLOCATION[i][j];finish[i]=TRUE;p[k++]=i;//将进程序号填入数组,后面根据它打印安全序列flag=TRUE;break; //结束FOR循环,表示WORK中资源满足某一进程的资源需求}}if(flag==FALSE) { //只要有一个进程全部资源得到满足,则继续while(TRUE)循环for(i=0;i<M;i++) {if(finish[i]==FALSE) return FALSE; //遇到某一进程的finish[i]不成立,则不安全}return TRUE; //对所有进程检查后,finish[i]均为TRUE,则有安全序列}}};void main(){int pro=-1;while(1){//1.打印当前进程的资源需求状态和系统可用资源状态out(pro);//2.从键盘输入某个进程的资源请求,注意进程号,下面比较资源时要用到//int pro; //存放申请资源的进程号printf("请输入进程号和该进程的资源请求量:\n");scanf("%d%d%d%d",&pro,&Request[0],&Request[1],&Request[2]);if(Compare1(NEED[pro],Request))//此处的比较操作可通过改造ppt中的compare 函数完成 ,下同{printf("资源请求大于该进程的需求值,出错了,退出循环!\n");//输出信息:资源请求大于该进程的需求值,出错了,退出循环break;}else{if(Compare1(AVAILABLE,Request)){printf("资源请求大于系统可用资源总数,不能满足要求,请重新输入!\n");//输出信息:资源请求大于系统可用资源总数,不能满足要求,请重新输入!continue;}else // 下面开始进行资源预分配,并判断系统是否安全{ChangeData(pro);//3.资源预分配代码if(IsSecurity(AVAILABLE,NEED,Request)==TRUE){//输出信息:系统处于安全状态,该进程的资源请求获准printf("系统处于安全状态,该进程的资源请求获准!\n");//4.打印进程的安全序列,就是将P数组中的内容输出for(int m=0;m<5;m++){printf("%d\t",p[m]);}printf("\n");}else{//输出信息:系统处于不安全状态,可能导致死锁,该进程的资源请求不能批准,请重新输入资源请求printf("系统处于不安全状态,可能导致死锁,该进程的资源请求不能批准,请重新输入0资源请求!\n");//5.将预分配资源进行恢复RestoreData(pro);}}}}} //输出信4 测试数据与实验结果(可以抓图粘贴)5 结果分析与实验体会通过本次银行家算法的实验,我对银行家算法有了更进一步的了解,虽说我对操作系统这门课的兴趣不大,但是老师上课非常的认真、负责,对银行家算法讲解的非常详细。

银行家算法实验报告

银行家算法实验报告

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

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

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

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分配资源。

银行家算法实验报告

银行家算法实验报告

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

三、问题分析与设计: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)。

2.操作系统试验--死锁的避免——银行家算法

2.操作系统试验--死锁的避免——银行家算法

操作系统实验二死锁的避免——银行家算法一、实验目的银行家算法是避免死锁的一种重要算法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

二、实验要求:编制程序, 依据银行家算法判定本次分配是否安全。

三.算法所用數據結構讲解1.数据结构假设有m个进程N类资源,则有如下数据结构MAX[M*N] M个进程对N 类资源的最大需求量;A V AILABEL[N] 系统可用资源数;ALLOCATION[M*N] M个进程已得到N 类资源的资源量;NEED[M*N] M个进程还需要N 类资源的资源量;2.行家算法设进程I 提出请求Request[N],则(1)若Request[N]<= NEED[I,N],则转(2);否则出错。

(2)若NEED[I,N] <= A V AILABEL[N],则转3;否则出错。

3.安全性检查(1)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=false; ②Needi≤Work.如找到,执行步骤(2);否则执行步骤(3)。

(2)当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故执行:Work:=Work+Allocation; Finish[i]:=true; Goto step1;(3)如果所有进程的Finish[i]=true,则表示系统处于安全状态;否则,系统处于不安全状态。

四.实验报告要求1.写出实验目的2。

写出实验要求3。

写出实验内容(包括算法,程序流程图及部分实验结果)4.实验总结与体会附:#include "stdio.h"#define M 5 /*总进程数*/#define N 3 /*总资源数*/#define FALSE 0#define TRUE 1/*M个进程对N类资源最大资源需求量*/int MAX[M][N]= {{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*系统可用资源数*/int A V AILABLE[N]={3,3,2};/* M个进程已经得到N类资源的资源量*/int ALLOCATION[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};/* M个进程还需要N类资源的资源量*/int NEED[M][N]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};int Request[N]={0,0,0};int i=0,j=0;void main(){char flag='Y';void showdata();void changdata(int);void rstordata(int);int chkerr(int);showdata();while (flag=='Y'||flag=='y'){printf("输入申请资源的进程号(0~4):");scanf("%d",&i);while (i<0||i>=M){printf("输入的进程号不存在,请重输入申请资源的进程号(0~4):");scanf("%d",&i);}for(j=0;j<N;j++){printf("申请资源%d :",j);scanf("%d",&Request[j]);if (Request[j]>NEED[i][j]){printf("进程%d申请的资源数大于进程%d还需要%d类资源的资源量!",i,i,j);printf("申请不合理,出错!请重新选择\n");exit(0);}else{if (Request[j]>A V AILABLE[j]){printf("进程%d 申请的资源数大于系统可用%d类资源的资源量!",i,j);printf("本次分配不成功。

实验二银行家算法实验报告

实验二银行家算法实验报告

《操作系统原理》实验报告实验二银行家算法实验专业:计算机科学与技术学号:030840204姓名:简郸实验日期:2010-5-22一、实验目的通过银行家算法理解操作系统安全状态和不安全状态。

二、实验要求根据课本第204页在T0时刻系统分配的资源,用银行家算法判断系统是否处于安全序列,它的安全序列怎样。

三、实验方法内容1.算法设计思路我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

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

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

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

2.算法流程图3.主要的常量变量n:系统中进程的总数m:资源类总数Available: ARRAY[1..m] of integer;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 请求资源4.主要模块当进程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] of Boolean;安全性检查的步骤: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;goto step(2)step (4) 若对所有i,Finish=true,则系统处于安全状态,否则处于不安全状态/* 银行家算法,操作系统概念(OS concepts Six Edition)reedit by Johnny hagen,SCAU,run at vc6.0*/四、实验代码#include "malloc.h"#include "stdio.h"#include "stdlib.h"#define alloclen sizeof(struct allocation)#define maxlen sizeof(struct max)#define avalen sizeof(struct available)#define needlen sizeof(struct need)#define finilen sizeof(struct finish)#define pathlen sizeof(struct path)struct allocation{int value;struct allocation *next;};struct max{int value;struct max *next;};struct available /*可用资源数*/{int value;struct available *next;};struct need /*需求资源数*/{int value;struct need *next;};struct path{int value;struct path *next;};struct finish{int stat;struct finish *next;};int main(){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;struct finish *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=(struct need*)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=(struct path*)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");return 0;}五、实验结果1.执行结果果分析现时系统剩余的资源矩阵能满足进程的请求,并且能使系统处于安全状态六、实验总结多个进程同时运行时,系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列,使得系统能快速且安全地运行进程,不至发生死锁。

实验2 银行家算法

实验2 银行家算法

实验2 银行家算法(2学时)一、实验目的理解银行家算法,掌握进程安全性检查的方法及资源分配的方法。

二、实验内容编写程序实现银行家算法,并验证程序的正确性。

三、实验要求编制模拟银行家算法的程序,并以下面给出的例子验证所编写的程序的正确性。

例子:某系统有A、B、C、D 4类资源共5个进程(P0、P1、P2、P3、P4)共享,各进程对资源的需求和分配情况如下表所示。

现在系统中A、B、C、D 4类资源分别还剩1、5、2、0个,请按银行家算法回答下列问题:(1)现在系统是否处于安全状态?(2)如果现在进程P1提出需求(0、4、2、0)个资源的请求,系统能否满足它的请求?#include <stdio.h>//#include <tchar.h>#include <iostream>using namespace std;#define Maxprocess 50 /*最大进程数*/#define Maxresource 100 /*最大资源数*/int Available[Maxresource]; /*可用资源数组*/int MAX[ Maxprocess][Maxresource]; /*最大需求矩阵*/int Allocation[ Maxprocess][Maxresource]; /*分配矩阵*/int need [Maxprocess][Maxresource]; /*需求矩阵*/int Request[Maxprocess][Maxresource]; /*进程需要资源数*/bool finish[Maxprocess]; /*系统是否有足够的资源分配*/int p[Maxprocess]; /*记录序列*/int m,n; /*m个进程,n个资源*/void Init();/*初始化算法*/bool Safe(); /*安全性算法*/void Bank(); /*银行家算法*/int main(){Init();Safe();Bank();return 1;}void Init() /*初始化算法*/{int i,j;cout<<"请输入进程的数目:"; /*m个进程,n个资源*/cin>>m;cout<<"请输入资源的种类数:";cin>>n;cout<<"请输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>MAX[i][j];cout<<"请输入每个进程已分配的各资源数,也按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++){for(j=0;j<n;j++){cin>>Allocation[i][j];need[i][j]=MAX[i][j]-Allocation[i][j];if(need[i][j]<0){cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl;j--;continue;}}}cout<<"请输入各个资源现有的数目:"<<endl;for(i=0;i<n;i++){cin>>Available[i];}}void Bank() /*银行家算法*/{int i,cusneed;char again;while(1){cout<<"请输入要申请资源的进程号(注:第1个进程号为0,依次类推)"<<endl;cin>>cusneed;cout<<"请输入进程所请求的各资源的数量"<<endl;for(i=0;i<n;i++){cin>>Request[cusneed][i];}for(i=0;i<n;i++){if(Request[cusneed][i]>need[cusneed][i]){cout<<"您输入的请求数超过进程的需求量!请重新输入!"<<endl;continue;}if(Request[cusneed][i]>Available[i]){cout<<"您输入的请求数超过系统有的资源数!请重新输入!"<<endl;continue;}}for(i=0;i<n;i++){Available[i]-=Request[cusneed][i];Allocation[cusneed][i]+=Request[cusneed][i];need[cusneed][i]-=Request[cusneed][i];}if(Safe()){cout<<"同意分配请求!"<<endl;}else{cout<<"您的请求被拒绝!"<<endl;for(i=0;i<n;i++){Available[i]+=Request[cusneed][i];Allocation[cusneed][i]-=Request[cusneed][i];need[cusneed][i]+=Request[cusneed][i];}}for(i=0;i<m;i++){finish[i]=false;}cout<<"您还想再次请求分配吗?是请按y/Y,否请按其它键"<<endl;cin>>again;if(again=='y'||again=='Y'){continue;}break;}}bool Safe() /*安全性算法*/ {int i,j,k,l=0;int Work[Maxresource];for(i=0;i<n;i++)Work[i]=Available[i];for(i=0;i<m;i++){finish[i]=false;}for(i=0;i<m;i++){if(finish[i]==true){continue;}else{for(j=0;j<n;j++){if(need[i][j]>Work[j]){break;}}if(j==n){finish[i]=true;for(k=0;k<n;k++){Work[k]+=Allocation[i][k];cout<<Work[k];}p[l++]=i;i=-1;}else{continue;}}if(l==m){cout<<"系统是安全的"<<endl;cout<<"安全序列:"<<endl;for(i=0;i<l;i++){cout<<p[i];if(i!=l-1){cout<<"-->";}}cout<<""<<endl;return true;}}cout<<"系统是不安全的"<<endl;return false;}。

银行家算法实验报告 (2)

银行家算法实验报告 (2)

一.绪论这次课程设计要求完成一个资源管理系统,该系统必须包括资源的添加、删除和修改等功能,并且允许其它进程来申请这里的资源,任何一个进程来申请资源时,必须先登记该进程对资源的申请要求,然后由系统检查当前资源的状况,并用银行家算法和安全性算法来检查是否允许分配资源给进程。

通过课程设计,加深我们对利用银行家算法避免死锁的理解。

在设计中主要的难点是用语言编写银行家算法和安全性算法,使系统资源分配能安全进行,避免系统死锁。

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

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

虽然进程在运行过程中,可能发生死锁,但死锁的发生必须同时具备四个条件:互斥条件、请求和保持条件、不剥夺条件、环路等待条件;防止死锁的机构只须确保上述四个条件之一不出现,则系统不会发生死锁。

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

所谓安全状态,是指系统能按某种进程顺序(P1,P2,…,P n),来为每个进程P i分配其所需分配,直至满足每个进程对资源的最大需求,使每个进程都可顺利地完成。

如果系统无法找到一个这样地安全系列,则称系统处于不安全状态。

在操作系统中研究资源分配策略时也有类似的问题,系统中有限的资源要供多个进程使用,必须保证得到资源的进程能在有限的时间内归还资源,以供它进程使用资源。

如果资源分配不得当就会发生进程循环等待资源,各进程都无法继续执行下去的死锁现象。

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

银行家算法是避免死锁的一种重要方法,在课程设计中用C语言编写一个资源管理系统,并要用银行家算法和安全性算法检查是否允许分配资源给进程,避免死锁。

通过课程设计,加深我们对了解有关资源申请、避免死锁等概念,并加深我们对银行家算法理解。

(word完整版)实验二银行家算法

(word完整版)实验二银行家算法

实验二银行家算法一、目的:加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用银行家算法,有效地防止和避免死锁的发生。

二、内容:银行家算法是避免死锁的一种重要方法,本实验要求编写和调试一个简单的银行家算法程序。

用银行家算法实现资源分配。

三、编程思想:首先分析银行家算法的数据结构,分析可利用资源向量Available、最大需求矩阵Max、分配矩阵Allocation、需求矩阵Need 、进程申请资源的关系,由所学知识可知;Need[i,j]=Max[I,j]—Allocation[i,j];当进程申请资源的时候;a)Request i>Need[i]。

这种情况表示该进程的资源需求已超过系统所宣布的最大值,出错。

b)Request i=Need[i]。

这种情况表示该进程现在对他所需的全部资源一次申请完成。

c)Request i〉Need[i]。

这种情况表示该进程现在对它所需资源再进行部分的申请,剩余的资源以后再次申请。

发出资源请求后;当进程pia)如果Request i<=Need[i],转向步骤b,否则显示为出错,因为所需的资源数超过事先要求的最大值。

b)Request i<=Available,便转向步骤三,否则则表示尚无足够资源,p i需等待。

c)假如系统将资源分配给p i 则:Available=Available—RequestiAllocation[i]=Allocation[i]+RequestiNeed[i]=Need[i]-Request安全性算法检查(1)设置向量:工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目,在执行安全性算法开始时,Work[]= Available[]。

Finish[],它表示系统是否有足够的资源分配给每个进程,使之运行完成。

银行家算法实验报告-9页文档资料

银行家算法实验报告-9页文档资料

计算机学院《操作系统》课程设计报告设计题目:银行家算法的实现姓名:学号:班级: 06网络工程班完成日期: 2009年6月13日银行家算法分析、设计与实现一、设计理论描述本设计的目的是通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。

要求如下:(1)模拟一个银行家算法;(2)初始化时让系统拥有一定的资源;(3)用键盘输入的方式申请资源;(4)如果预分配后,系统处于安全状态,则修改系统的资源分配情况;(5)如果预分配后,系统处于不安全状态,则提示不能满足请求,设计的主要内容是模拟实现动态资源分配。

同时编写和调试一个系统动态资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生。

银行家算法.顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。

在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其他进程使用资源。

如果资源分配不得到就会发生进程循环等待资源,则进程都无法继续执行下去的死锁现象。

把一个进程需要和已占有资源的情况记录在进程控制中,假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。

当进程在处于等待态时,表示系统不能满足该进程当前的资源申请。

“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。

显然,,每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.二、算法描述及数据结构模型1.银行家算法:设进程i提出请求Request[n],则银行家算法按如下规则进行判断。

(1)如果Request[n]>Need[i,n],则报错返回。

(2)如果Request[n]>Available,则进程i进入等待资源状态,返回。

银行家算法实验报告

银行家算法实验报告

银行家算法一、课题内容和要求银行家算法是一种最有代表性的避免死锁的算法。

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

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

二、需求分析本设计的目的是通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。

总体要求如下:(1)模拟一个银行家算法;(2)了解算法中用的各种数据结构;(3)系统的初始状态信息从文本文件读取;(4)判断是否存在安全序列,输出任意一个安全序列即可;(5)判断系统是否可以满足进程的请求。

此次课程设计的主要内容时模拟实现动态资源分配。

同时要求编写和调试一个系统动态资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生。

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

三、概要设计1.银行家算法的设计思路先对用户提出的请求进行合法性检查,即检查请求的是不大于需要的,是否不大于可利用的。

若请求合法,则进行试分配。

最后对试分配后的状态调用安全性检查算法进行安全性检查。

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

2.银行家算法中用到的主要数据结构可利用资源向量 int Available[j] j为资源的种类。

最大需求矩阵 int Max[i][j] i为进程的数量。

分配矩阵 int Allocation[i][j]需求矩阵 int need[i][j]= Max[i][j]- Allocation[i][j]申请各类资源数量 int Request i[j] i进程申请j资源的数量工作向量 int Work[x] int Finish[y]3.银行家算法bank()进程i发出请求申请k个j资源,Request i[j]=k(1)检查申请量是否不大于需求量:Request i[j]<=need[i,j],若条件不符重新输入,不允许申请大于需求量。

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

昆明理工大学信息工程与自动化学院学生实验报告(2011 —2012 学年第二学期)一、实验目的和要求银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

二、实验内容1.设计进程对各类资源最大申请表示及初值确定。

2.设定系统提供资源初始状况。

3.设定每次某个进程对各类资源的申请表示。

4.编制程序,依据银行家算法,决定其申请是否得到满足。

三、实验说明1.数据结构假设有M个进程N类资源,则有如下数据结构:MAX[M*N] M个进程对N类资源的最大需求量AVAILABLE[N] 系统可用资源数ALLOCATION[M*N] M个进程已经得到N类资源的资源量NEED[M*N] M个进程还需要N类资源的资源量2.银行家算法设进程I提出请求Request[N],则银行家算法按如下规则进行判断。

(1)如果Request[N]<=NEED[I,N],则转(2);否则,出错。

(2)如果Request[N]<=AVAILABLE,则转(3);否则,出错。

(3)系统试探分配资源,修改相关数据:AVAILABLE=AVAILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待。

3.安全性检查(1)设置两个工作向量WORK=AVAILABLE;FINISH[M]=FALSE(2)从进程集合中找到一个满足下述条件的进程,FINISH[i]=FALSENEED<=WORK如找到,执行(3);否则,执行(4)(3)设进程获得资源,可顺利执行,直至完成,从而释放资源。

WORK=WORK+ALLOCATIONFINISH=TRUEGO TO 2(4)如所有的进程Finish[M]=true,则表示安全;否则系统不安全。

四、程序流程图初始化算法流程图:五、程序代码#include<iostream.h># include<string.h>#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 showdata()//显示资源矩阵{int i,j;cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<endl;for (j=0;j<N;j++)cout<<Avaliable[j]<<" ";//输出分配资源cout<<endl;cout<<" Max Allocation Need"<<endl;cout<<"进程名";for(j=0;j<3;j++){for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<" ";}cout<<endl;for(i=0;i<M;i++){cout<<" "<<i<<" ";for(j=0;j<N;j++)cout<<Max[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Allocation[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Need[i][j]<<" ";cout<<endl;}}int changdata(int i)//进行资源分配{int j;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];}return 1;}int safe()//安全性算法{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){cout<<"系统不安全"<<endl;//不成功系统不安全return -1;}}cout<<"系统是安全的!"<<endl;//如果安全,输出成功cout<<"分配的序列:";for(i=0;i<M;i++){//输出运行进程数组cout<<temp[i];if(i<M-1) cout<<"->";}cout<<endl;return 0;}void share()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch='y';cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";cin>>i;//输入须申请的资源号cout<<"请输入进程"<<i<<" 申请的资源:"<<endl;for(j=0;j<N;j++){cout<<name[j]<<":";cin>>Request[j];//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错{cout<<"进程"<<i<<"申请的资源大于它需要的资源";cout<<" 分配不合理,不予分配!"<<endl;ch='n';break;}else {if(Request[j]>Avaliable[j])//判断申请是否大于当前资源,若大于则{ //出错cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";cout<<" 分配出错,不予分配!"<<endl;ch='n';break;}}}if(ch=='y') {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}void addresources(){//添加资源int n,flag;cout<<"请输入需要添加资源种类的数量:";cin>>n;flag=N;N=N+n;for(int i=0;i<n;i++){cout<<"名称:";cin>>name[flag];cout<<"数量:";cin>>Avaliable[flag++];}showdata();safe();}void delresources(){//删除资源char ming;int i,flag=1;cout<<"请输入需要删除的资源名称:";do{cin>>ming;for(i=0;i<N;i++)if(ming==name[i]){flag=0;break;}if(i==N)cout<<"该资源名称不存在,请重新输入:"; }while(flag);for(int j=i;j<N-1;j++){name[j]=name[j+1];Avaliable[j]=Avaliable[j+1];}N=N-1;showdata();safe();}void changeresources(){//修改资源函数cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(int i=0;i<N;i++)cout<<name[i]<<":"<<Avaliable[i]<<endl; cout<<"输入系统可用资源[Avaliable]:"<<endl; cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2]; cout<<"经修改后的系统可用资源为"<<endl;for (int k=0;k<N;k++)cout<<name[k]<<":"<<Avaliable[k]<<endl; showdata();safe();}void addprocess(){//添加作业int flag=M;M=M+1;cout<<"请输入该作业的最打需求量[Max]"<<endl; for(int i=0;i<N;i++){cout<<name[i]<<":";cin>>Max[flag][i];Need[flag][i]=Max[flag][i]-Allocation[flag][i];}showdata();safe();}int main()//主函数{int i,j,number,choice,m,n,flag;char ming;cout<<"*****************资源管理系统的设计与实现*****************"<<endl;cout<<"请首先输入系统可供资源种类的数量:";cin>>n;N=n;for(i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>ming;name[i]=ming;cout<<"资源的数量:";cin>>number;Avaliable[i]=number;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m;cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>Max[i][j];do{flag=0;cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j])flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)cout<<"申请的资源大于最大需求量,请重新输入!\n";}while(flag);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){cout<<"**************银行家算法演示***************"<<endl;cout<<" 1:增加资源"<<endl;cout<<" 2:删除资源"<<endl;cout<<" 3:修改资源"<<endl;cout<<" 4:分配资源"<<endl;cout<<" 5:增加作业"<<endl;cout<<" 0:离开"<<endl;cout<<"*******************************************"<<endl;cout<<"请选择功能号:";cin>>choice;switch(choice){case 1: addresources();break;case 2: delresources();break;case 3: changeresources();break;case 4: share();break;case 5: addprocess();break;case 0: choice=0;break;default: cout<<"请正确选择功能号(0-5)!"<<endl;break;}}return 1;}六、程序运行结果截图:七、实验总结和体会银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资料申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

相关文档
最新文档