实验2银行家算法
操作系统实验二:银行家算法
操作系统实验⼆:银⾏家算法实验⼆银⾏家算法⼀、实验⽬的1、了解什么是操作系统安全状态和不安全状态;2、了解如何避免系统死锁;3、理解银⾏家算法是⼀种最有代表性的避免死锁的算法,掌握其实现原理及实现过程。
⼆、实验内容根据银⾏家算法的基本思想,编写和调试⼀个实现动态资源分配的模拟程序,并能够有效避免死锁的发⽣。
三、实验原理进程申请资源时,系统通过⼀定的算法判断本次申请是否不可能产⽣死锁(处于安全状态)。
若可能产⽣死锁(处于不安全状态),则暂不进⾏本次资源分配,以避免死锁。
算法有著名的银⾏家算法。
1、什么是系统的安全状态和不安全状态?所谓安全状态,是指如果系统中存在某种进程序列<P1,P2,…,Pn>,系统按该序列为每个进程分配其所需要的资源,直⾄最⼤需求,则最终能使每个进程都可顺利完成,称该进程序列<P1,P2,…,Pn,>为安全序列。
如果不存在这样的安全序列,则称系统处于不安全状态。
2、银⾏家算法把操作系统看作是银⾏家,操作系统管理的资源相当于银⾏家管理的资⾦,进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。
为保证资⾦的安全,银⾏家规定:(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客;(2) 顾客可以分期贷款,但贷款的总数不能超过最⼤需求量;(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时,对顾客的贷款可推迟⽀付,但总能使顾客在有限的时间⾥得到贷款;(4) 当顾客得到所需的全部资⾦后,⼀定能在有限的时间⾥归还所有的资⾦。
操作系统按照银⾏家制定的规则设计的银⾏家算法为:(1)进程⾸次申请资源的分配:如果系统现存资源可以满⾜该进程的最⼤需求量,则按当前的申请量分配资源,否则推迟分配。
(2)进程在执⾏中继续申请资源的分配:若该进程已占⽤的资源与本次申请的资源之和不超过对资源的最⼤需求量,且现存资源能满⾜该进程尚需的最⼤资源量,则按当前申请量分配资源,否则推迟分配。
(3)⾄少⼀个进程能完成:在任何时刻保证⾄少有⼀个进程能得到所需的全部资源⽽执⾏到结束。
民大-银行家算法-操作系统实验报告
银行家算法实验报告一、实验题目为了了解系统的资源分配情况,假定系统的任何一种资源在任一种资源在任意时刻只能被一个进程使用。
任何进程已经占用的资源只能由进程自己释放,而不能任由其他进程抢占。
当进程申请的资源不能满足时,必须等待。
因此,只要资源分配算法能保证进程的资源请求,且不出现循环等待,则系统不会出现死锁。
而银行家算法是避免死锁的一种重要方法。
通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法二、实验要求要求编写系统进行资源调度的程序,模拟进程的资源分配算法,了解死锁的产生和避免的办法。
一个是随机动态地进行资源分配的模拟程序,即只要系统当前剩余资源满足进程的当前要求,就立即将资源分配给进程,以观察死锁产生情况;一个是采用银行家算法,有效地避免死锁的产生。
要求用银行家算法和随机算法实现资源分配。
1.设计3-4个并发进程,共享系统的10个同类不可抢占的资源。
各进程动态进行资源的申请和释放。
2.用银行家算法和随机算法分别设计一个资源分配程序,运行这两个程序,观察系统运行情况,并对系统运行的每一步情况进行显示。
二、总的设计思想及语言环境、工具等1.算法设计思路银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。
这时系统将该进程从进程集合中将其清除。
此时系统中的资源就更多了。
反复执行上面的步骤,最后检查进程的集合为空时就表明本次申请可行,系统处于安全状态,可以实施本次分配,否则,只要进程集合非空,系统便处于不安全状态,本次不能分配给他,请进程等待。
2.语言环境、工具计算机基本配置要求:操作系统:WIN 98/2000/XP/2003 等Windows平台内存:256MB及以上主存64KB(Memory)(以KB为单位分配)开发语言:Visual C++ 6.0四、数据结构与模块说明(功能与框图)五、源程序(指导老师验收通过)#include<string.h>#include<iostream.h>#define FALSE 0#define TRUE 1#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20int M ;int N ;int ALL_RESOURCE[W];int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void inputdata(); //数据输入void showdata(); //数据显示void changdata(int k);//进程请求资源数据改变void restoredata(int k); //数据恢复int chksec(int s); //系统安全性的检测int chkmax(int s); //检测最大需求void bank(); //检测分配的资源是否合理void main(){ int i,j;inputdata();for(i=0;i<M;i++){ j=chksec(i);if (j==0) break;}if (i>=M)cout<<"错误提示:经安全性检查发现,系统的初始状态不安全\n"<<endl;else{ cout<<"提示:经安全性检查发现,系统的初始状态安全!"<<endl;bank();}}void inputdata(){ int i=0,j=0,p;cout<<"请输入总进程数:"<<endl;do{cin>>M;if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数,请重新输入:"<<endl;}while (M>W);cout<<endl;cout<<"请输入资源的种类数:"<<endl;do {cin>>N;if (N>R)cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数,请重新输入:"<<endl; }while (N>R);cout<<endl;cout<<"请依次输入各类资源的总数量,即设置向量all_resource:"<<endl;for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];cout<<endl;cout<<"请依次输入各进程所需要的最大资源数量,即设置矩阵max:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do { cin>>MAX[i][j];if (MAX[i][j]>ALL_RESOURCE[j])cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);}}cout<<endl;cout<<"请依次输入各进程已经占据的各类资源数量,即设置矩阵allocation:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do{ cin>>ALLOCATION[i][j];if (ALLOCATION[i][j]>MAX[i][j])cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;}while (ALLOCATION[i][j]>MAX[i][j]);}}cout<<endl;for (i=0;i<M;i++)for(j=0;j<N;j++)NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];for (j=0;j<N;j++){ p=ALL_RESOURCE[j];for (i=0;i<M;i++){ p=p-ALLOCATION[i][j];AVAILABLE[j]=p;if(AVAILABLE[j]<0)AVAILABLE[j]=0;}}}void showdata(){ int i,j;cout<<"各种资源的总数量,即向量all_resource为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];cout<<endl<<endl;cout<<"当前系统中各类资源的可用数量,即向量available为:"<<endl; cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<AVAILABLE[j];cout<<endl<<endl;cout<<"各进程还需要的资源数量,即矩阵need为:"<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<NEED[i][j]<<" ";cout<<endl;}cout<<endl;cout<<"各进程已经得到的资源量,即矩阵allocation为: "<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<" ";cout<<endl;} cout<<endl;}void changdata(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];}}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 chksec(int s){int WORK,FINISH[W];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){ WORK=AVAILABLE[j];i=s;do{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++;}}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){ return 1;}} return 0;}int chkmax(int s){ int j,flag=0;for(j=0;j<N;j++){if (MAX[s][j]==ALLOCATION[s][j]){ flag=1;AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];MAX[s][j]=0;}} return flag;}c{int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){i=-1;while(i<0||i>=M){ cout<<"请输入需申请资源的进程号(从P0到P"<<M-1<<",否则重新输入!):"; cout<<"p";cin>>i;if(i<0||i>=M)cout<<"输入的进程号不存在,重新输入!"<<endl;}cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;for (j=0;j<N;j++){ cout<<" 资源"<<j<<": ";cin>>Request[j];if(Request[j]>NEED[i][j]){ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}else{ if(Request[j]>AVAILABLE[j]){ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}}}if(flag=='Y'||flag=='y'){ changdata(i);if(chksec(i)){ cout<<endl;cout<<"该分配会导致系统不安全本次资源申请不成功,不予分配"<<endl;cout<<endl;restoredata(i);}else{ cout<<endl;cout<<"经安全性检查,系统安全,本次分配成功,且资源分配状况如下所示:"<<endl;cout<<endl;showdata();if(chkmax(i)){cout<<"在资源分配成功之后,由于该进程所需的某些资源的最大需求量已经满足,"<<endl;cout<<"因此在进程结束后系统将回收这些资源!"<<endl;cout<<"在资源收回之后,各进程的资源需求和分配情况如下所示:"<<endl;showdata();}}}cout<<endl;cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";cin>>flag; }}六、运行结果分析1.输入进程数、资源种类数、各类资源总数量、各进程所需要的最大资源数量、各进程所已经占据的各类资源数量2.经安全性检验,系统状态安全,进程P0申请资源3.经安全性检验,系统状态安全,进程P0获得所申请资源4.进程P3申请资源5.经安全性检验,系统状态安全,进程P3获得所申请资源6.进程P1申请资源7.经安全性检验,系统状态安全,进程P1获得所申请资源8.进程P2申请资源9.经安全性检验,系统状态安全,进程P2获得所申请资源5.进程P1申请资源6.经安全性检验,系统状态安全,进程P1获得所申请资源七、总结这次实验中我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
实验2 《银行家算法》实验报告
《操作系统》实验
实验二银行家算法
专业:班级:学号:姓名:
一.实验目的
1、理解死锁的定义、原因和必要条件。
2、掌握银行家算法和安全性算法的基本思想。
3、能够编程模拟利用银行家算法和安全性算法避免死锁的实现过程。
二.使用的设备和仪器
计算机+Windows XP +Visual C++6.0
三.实验内容及要求
编写一程序,能够模拟银行家算法和安全算法来避免死锁。
假设系统资源有A、B、C 三种,可以运行4个进程。
该程序具备的基本功能为:
1、程序可以输入3种资源的数目,4个进程对3种资源的最大需求量、已分配量和需求量。
2、能够判断某一时刻系统是否处于安全状态,如果处于安全状态能够给出安全序列。
3、当某进程提出资源申请时,能够判断是否能把资源分配给申请进程。
四.实验步骤
1、程序源代码
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. 理解银行家算法的基本原理;2. 掌握银行家算法的实现方法;3. 分析银行家算法在资源管理中的应用。
实验过程:1. 实验环境的搭建在本次实验中,我们使用了一台运行Windows操作系统的计算机,并安装了Java开发环境。
同时,我们使用了一个模拟的资源管理系统,以便更好地理解和实践银行家算法。
2. 银行家算法的原理银行家算法是通过对系统中的资源进行合理分配,以避免死锁的发生。
它基于以下几个假设:- 每个进程对资源的最大需求量是已知的;- 系统中的资源数量是有限的;- 进程在请求资源时必须先声明其最大需求量;- 进程在释放资源后,不能再重新请求。
3. 银行家算法的实现银行家算法的实现主要包括以下几个步骤:- 初始化:获取系统中的资源总量和每个进程的最大需求量;- 安全性检查:通过模拟分配资源并检查系统是否处于安全状态,以确定是否可以满足进程的资源请求;- 资源分配:根据安全性检查的结果,决定是否分配资源给进程。
4. 银行家算法的应用银行家算法在实际应用中具有广泛的用途,尤其是在多任务操作系统中。
它可以用于资源的分配和调度,以确保系统中的进程能够安全地访问资源,避免死锁的发生。
结论:通过本次实验,我们深入了解了银行家算法的原理和应用。
银行家算法作为一种重要的资源管理和调度算法,可以有效地避免死锁的发生,提高系统的可靠性和稳定性。
在今后的学习和工作中,我们将继续深入研究操作系统相关的算法和原理,以提升自己在该领域的专业能力。
实验二银行家算法实验报告
实验二银行家算法实验报告一、实验目的通过本次实验,主要学习了解了银行家算法的原理和实现方式,掌握银行家算法的应用场景,了解了安全序列的概念和判断方法,并通过代码实现加深对银行家算法的理解和掌握。
二、实验过程1、阅读银行家算法的相关理论知识。
2、编写银行家算法的代码实现。
3、根据实验要求,设置不同的初始资源分配和不同的进程请求资源情况,分别计算是否存在安全序列。
三、实验结果与分析1、首先按照实验要求设置一个初始的资源分配情况:可用的资源数目:4 4 4进程数目:4各进程对三种资源的最初需要数目:Max:7 5 33 2 29 0 22 2 2已分配资源数目:Allocation:0 1 02 0 03 0 22 1 1剩余资源数目:Need: 7 4 31 2 26 0 00 1 1根据上述数据,计算出该初试分配情况下的安全序列为:1 -> 3 -> 4 -> 2。
2、然后设置一个进程请求资源的情况:进程 1 请求资源 [3,3,0],进程 2 请求资源 [1,0,1],进程 3 请求资源 [2,2,0],进程 4 请求资源 [0,0,2]。
根据银行家算法,先进行安全性检测,发现该系统不存在安全序列,因此不满足银行家算法的要求,请求不被满足。
3、接着修改初始的资源分配情况和请求的资源情况,进行比较:通过以上的实验操作,得出结论:只有当请求的资源不会导致系统不再安全时,才会满足请求。
银行家算法基于这个假设进行运算,它管理着一个可以分配的表格,该表格显示系统的各种资源已经分配和未分配的情况,并确定哪些进程可以分配资源,哪些不可以。
四、实验总结本次实验通过对银行家算法的概念、原理和应用场景的了解,对该算法有了更深的认识和理解,并通过代码实现和实验操作,进一步巩固和掌握了该算法的应用方法。
在实验过程中,也有一些需要注意的问题:如需要按照一定的顺序输入原数据,正确地计算资源分配和剩余情况;核实每个请求的资源数目是否足够,才进行安全性检测;注意计算过程中数值的准确性和解题思路的正确性等。
c语言银行家算法实验报告
c语言银行家算法实验报告C语言银行家算法实验报告引言:计算机科学领域中,操作系统的资源管理是一个十分重要的课题。
在多任务处理系统中,多个进程同时竞争有限的资源,如何合理地分配和调度资源,以保证系统的稳定性和效率,是一个关键问题。
银行家算法(Banker's Algorithm)是一种经典的资源分配算法,它通过分析系统的资源状态和进程的资源需求,来判断是否能够安全地分配资源,从而避免产生死锁。
一、实验目的本次实验旨在通过C语言编程实现银行家算法,加深对资源管理和死锁问题的理解,并通过实际案例验证银行家算法的有效性。
二、实验环境本次实验使用C语言进行编程,并在Linux操作系统下进行测试。
三、实验过程1. 设计数据结构在开始编写代码之前,我们需要先设计适合的数据结构来表示系统资源和进程的状态。
在银行家算法中,我们需要记录系统中的可用资源数量、各个进程的最大需求资源数量、已分配资源数量和需要资源数量等信息。
通过定义合适的数据结构,我们可以方便地进行资源的分配和回收。
2. 实现银行家算法根据银行家算法的原理,我们可以将其分为两个步骤:安全性检查和资源分配。
在安全性检查中,我们需要判断当前系统状态下是否存在安全序列,即是否能够满足所有进程的资源需求,避免死锁的发生。
在资源分配中,我们需要根据当前系统状态和进程的资源需求,动态地分配和回收资源。
3. 编写测试用例为了验证银行家算法的正确性和有效性,我们需要编写一些测试用例。
测试用例应该包括各种不同的进程资源需求和系统资源状态,以覆盖不同情况下的资源分配和回收。
4. 运行测试用例在编写完测试用例后,我们可以运行程序,观察输出结果。
通过比较实际输出与预期结果,我们可以判断银行家算法的正确性和有效性。
四、实验结果与分析通过运行多个测试用例,我们可以得出以下结论:1. 银行家算法能够有效地避免死锁的发生。
在安全性检查过程中,如果存在安全序列,那么系统可以继续分配资源,否则需要阻塞等待。
(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[],它表示系统是否有足够的资源分配给每个进程,使之运行完成。
银行家算法实验报告
实验二银行家算法一、实验内容简要描述1.实验目标:加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用银行家算法,有效的防止和避免死锁的发生。
2.实验要求:银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。
用银行家算法实现资源分配。
设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统,例如,{A,B,C}的资源数量分别为10,5,7。
进程可动态地申请资源和释放资源,系统按进程的申请动态地分配资源,要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。
二、报告主要内容1.设计思路A、设计进程对各在资源最大申请表示及初值确定。
B、设定系统提供资源初始状态。
C、设定每次某个进程对各类资源的申请表示。
D、编制程序,依据银行家算法,决定其申请是否得到满足。
2.主要数据结构假设有M个进程N类资源,则有如下数据结构:MAX[M*N] M个进程对N类资源的最大需求量AVAILABLE[N] 系统可用资源数ALLOCATION[M*N] M个进程已经得到N类资源的资源量NEED[M*N] M个进程还需要N类资源的资源量3. 主要代码#include <iostream.h>#include "stdio.h"//#include "windows.h"const unsigned short c = 3;//资源类数const unsigned short t = 5;//进程数void Print(); //用于打印输出表格的函数void Input();//用于输入的函数void tryfenpei(int i);//试分配函数void refenpei(int i);//恢复数据函数void checksafe(int s);//安全检测函数//定义初始化数组int Available[c],Max[t][c],Allocation[t][c],Need[t][c],Request[c];int in;//用户选择的进程号/*----------------------------------------------------------------*/int main(int argc, char *argv[]){int i;char ch='Y';cout<<"初始化数据"<<endl;Input();//输入相关数据函数Print();//打印输出相关数据表函数cout<<"初始化完成!..."<<endl<<endl<<endl;do{if(ch=='Y'||ch=='y'){cout<<"欢迎进入实验!请稍后..."<<endl;// Sleep(1000);cout<<"已顺利进入实验..."<<endl;cout<<"请输入发起请求的进程号(0-4):";while(cin>>in){if(!(0<=in&&in<=4)){cout<<"不存在该进程,请重新输入"<<endl;}else break;};cout<<"您输入的是"<<"p["<<in<<"]"<<" 进程"<<endl;cout<<"该进程需求量为:";for(i=0;i<c;i++)cout<<Need[in][i]<<" ";cout<<endl;cout<<"请输入请求资源的数目:";//输入格式为X for(i=0;i<c;i++){while(cin>>Request[i]){if(Request[i]<0) cout<<"错误!输入的数字无效."<<endl;elseif(Request[i]>Need[in][i]) cout<<"错误!超出进程需求量"<<endl<<endl;if(Request[i]>Available[i]) cout<<"错误!系统还没有足够的可用资源量满足进程需要"<<endl<<endl;else break;}}cout<<"输入成功,您输入的是:"<<Request[0]<<" "<<Request[1]<<" "<<Request[2];cout<<endl;cout<<"开始执行银行家算法,下面进行试分配..."<<endl;tryfenpei(in);//分配函数//Sleep(1000);cout<<"试分配完成!"<<endl;cout<<"进入安全性检测..."<<endl;//Sleep(1000);checksafe(in);//安全性检测函数cout<<"需要继续实验吗?(y-继续n终止)";}elseif(ch=='N'||ch=='n'){cout<<"感谢您的使用,祝您愉快!"<<endl<<"正在退出..."<<endl;break;}elsecout<<"输入无效!请重新输入."<<endl;}while(cin>>ch);return 0;}/*---------------------main函数结束----------------------------------*//*-------------------------输出函数----------------------------------*/void Print(){int i,j;cout<<" 进程个数:"<<t<<" 资源个数:"<<c<<endl;cout<<"正在更新数据..."<<endl;//Sleep(1500);cout<<"|-----|----------|------------|----------|-----------|"<<endl;cout<<"|----|最大需求矩阵|已分配矩阵-|-需求矩阵-可用资源向量|"<<endl;cout<<"|\ 资源| Max | Allocation | Need | Available |"<<endl;cout<<"| \ | A B C | A B C | A B C | A B C |"<<endl;cout<<"|进程\ | | | | |"<<endl; cout<<"|-----|----------|------------|----------|-----------|"<<endl;for(i=0;i<5;i++){cout<<"| p"<<i<<" | ";for(j=0;j<3;j++){cout<<Max[i][j]<<" ";}cout<<"|";for(j=0;j<3;j++){cout<<" "<<Allocation[i][j];}cout<<" |";for(j=0;j<3;j++){cout<<" "<<Need[i][j];}cout<<" |";if(i==0){for(j=0;j<3;j++){cout<<" "<<Available[j];}cout<<" |";}if(i>0){cout<<" |";}cout<<endl;}cout<<"|-----|----------|------------|----------|-----------|"<<endl;}/*-------------------------输出函数结束--------------------------------*//*--------------------------输入函数----------------------------------*/void Input(){for(int j=0;j<c;j++){cout<<"请输入Available["<<j<<"]:";while(cin>>Available[j]){if(Available[j]<0)cout<<"输入数字无效,请重新输入"<<endl;else break;};}for(int k=1;k<4;k++)//其他三个属性和一次打印输出表{for(int l=0;l<t;l++)//五个进程循环输入{for(int m=0;m<c;m++)//三个类资源ABC循环输入{if(k==1&&m<t){cout<<"请输入Max["<<l<<"]["<<m<<"]:";while(cin>>Max[l][m]){if(Max[l][m]<0)cout<<"输入数字无效,请重新输入"<<endl;else break;};}if(k==2&&m<t){cout<<"请输入Allocation["<<l<<"]["<<m<<"]:";while(cin>>Allocation[l][m])if(Allocation[l][m]<0)cout<<"输入数字无效,请重新输入"<<endl;else break;//cout<<"Allocation["<<l<<"]["<<m<<"]="<<Allocation[l][m]<<endl;}if(k==3&&m<t)Need[l][m]=Max[l][m]-Allocation[l][m];}}}}//*-------------------------输入函数结束----------------------------------*//*-------------------------试分配函数----------------------------------*/void tryfenpei(int i){for(int f=0;f<c;f++){Available[f] = Available[f] - Request[f];Allocation[i][f] = Allocation[i][f] + Request[f];Need[i][f] = Need[i][f]-Request[f];}}/*-------------------------试分配函数结束----------------------------------*//*-------------------------恢复数据函数----------------------------------*/void refenpei(int i){for(int f=0;f<c;f++){Available[f] = Available[f] + Request[f];Allocation[i][f] = Allocation[i][f] - Request[f];Need[i][f] = Need[i][f]+Request[f];//cout<<Available[f]<<" "<<Allocation[i][f]<<" "<<Need[i][f]<<endl;}}/*-------------------------恢复数据函数结束----------------------------------*//*-------------------------安全检测函数----------------------------------*/void checksafe(int s){int Work,flag,temp[t],i,j,l=0,k=0;bool Finish[t];for(i=0;i<t;i++)Finish[i]=false;for(j=0;j<3;j++){Work=Available[j];//cout<<"Work="<<Work<<endl;for(i=0;i<t;i++){if(Finish[i]==true) l++;//用l是否达到5来判断这条进程A类资源或者B类资源是否通过安全检测,C类资源没有经过这里}if(l==5)//一共有三类资源A B C,一条进程下面的安全性检测只检测了A类。
实验二银行家算法实验报告
《操作系统原理》实验报告实验二银行家算法实验专业:计算机科学与技术学号: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.执行结果果分析现时系统剩余的资源矩阵能满足进程的请求,并且能使系统处于安全状态六、实验总结多个进程同时运行时,系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列,使得系统能快速且安全地运行进程,不至发生死锁。
银行家算法实验报告
银行家算法实验报告 The pony was revised in January 2021计算机操作系统实验报告何美西一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计: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)。
实验二 银行家算法
实验二银行家算法一、实验目的1.理解死锁避免相关内容; 2.掌握银行家算法主要流程;3.掌握安全性检查流程。
操作系统中的死锁避免部分的理论进行实验。
要求实验者设计一个程序,该程序可对每一次资源申请采用银行家算法进行分配。
二、实验设备PC机、windows2000 操作系统、Turbo C 2.0 三、实验要求本实验要求4学时完成。
1.设计多个资源(≥3);2.设计多个进程(≥3);3.设计银行家算法相关的数据结构;4.动态进行资源申请、分配、安全性检测并给出分配结果。
5.撰写实验报告,并在实验报告中画出银行家和安全性检查函数流程图;四、预备知识死锁避免定义:在系统运行过程中,对进程发出的每一个资源申请进行动态检查,并根据检查结果决定是否分配资源:若分配后系统可能发生死锁,则不予分配,否则予以分配。
由于在避免死锁的策略中,允许进程动态地申请资源。
因而,系统在进行资源分配之前预先计算资源分配的全安性。
若此次分配不会导致系统进入不安全状态,则将资源分配给进程;否则,进程等待。
其中最具有代表性的避免死锁算法是银行家算法。
1 系统安全状态 1)安全状态所谓系统是安全的,是指系统中的所有进程能够按照某一种次序分配资源,并且依次地运行完毕,这种进程序列{ P1 ,P2 …Pn}就是安全序列。
如果存在这样一个安全序列,则系统是安全的。
并非所有的不安全状态都会转为死锁状态,但当系统进入不安全状态后,便有可能进入死锁状态;反之,只要系统处于安全状态,系统便可避免进入死锁状态。
所以避免死锁的实质:系统在进行资源分配时,如何使系统不进入不安全状态。
2)安全状态之例假设系统有三个进程,共有12台磁带机。
各进程的最大需求和T0时刻已分配情况如下表:进程最大需求已分配可用 P1 10 5 P2 4 2 3 P3 9 2 问:T0时刻是否安全?答:T0时刻是安全的,因为存在安全序列:不安全序列:3)由安全状态向不安全状态的转换如果不按照安全序列分配资源,则系统可能会由安全状态进入不安全状态。
实验二(3)银行家算法
实验二(3)银行家算法一、实验目的1)掌握死锁的产生的原因、产生死锁的必要条件和处理死锁的基本方法。
2)了解多道程序系统中,多个进程并发执行的资源分配。
3)掌握预防死锁的方法,系统安全状态的基本概念4)掌握银行家算法,了解资源在进程并发执行中的资源分配策略。
二、实验内容设计一个n个并发进程共享m个系统资源的系统。
进程课动态申请资源和释放资源,系统按照进程的申请动态的分配资源。
用银行家算法设计实现。
三、实验原理我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全,银行家规定: (1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;(2) 顾客可以分歧贷款,但贷款的总数不能超过最大需求量; (3)当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款; (4)当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金. 操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。
- 1 -四、算法实现(1)初始化这组进程的最大资源请求和依次申请的资源序列。
把各进程已占用和需求资源情况记录在进程控制块中。
假定进程控制块的内容包括:进程名,状态,当前申请量,资源需求总量,已占资源量,能执行完标志。
其中,进程的状态有:就绪、等待和完成。
当系统不能满足进程的资源请求时,进程处于等待态。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
淮海工学院计算机工程学院实验报告书课程名:操作系统原理A题目:实验一银行家算法班级:网络131学号:姓名:一、目的与要求银行家算法是操作系统中避免死锁的典型算法,用Java或C/C++语言编写一个银行家算法的模拟程序。
通过本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。
二、实验内容用Java或C/C++语言编写一个简单的银行家算法模拟程序,用银行家算法实现资源分配。
程序能模拟多个进程共享多种资源的情形。
进程可动态地申请资源,系统按各进程的申请动态地分配资源。
要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。
实验说明实验中进程的数量、资源的种类以及每种资源的总量Total[j]最好允许动态指定。
初始时每个进程运行过程中的最大资源需求量Max[i,j]和系统已分配给该进程的资源量Allocation[i,j]均为已知(这些数值可以在程序运行时动态输入),而算法中其他数据结构的值(包括Need[i,j]、Available[j])则需要由程序根据已知量的值计算产生。
三、实验步骤1.认真理解好课本中银行家算法的实例。
2.根据课本中银行家算法的描述,画出程序流程图。
初始算法否银行家算法3.按照程序流程图,用Java或C/C++语言程并实现。
4.实验结果截图1)初界面2)添加资源3)输入进程MAX和Allocation4)请求资源5)输入p1发出请求request(1.0.2)5.实验心得通过本次上机实验,我更加充分的理解了课本上的知识,并能够加以扩展。
但是该方案仍然存在许多不足之处。
一开始关于如何写出银行家算法一点思路都没有,后来经过上网去查找资料,结合资料,对于银行家算法的不了解之处也解决了。
通过自己动手去做发现自己懂的东西真的特别有限,所以我会在后续的课程中,结合这次的经历好好学习。
附源码:import java.awt.Container;import java.awt.GridLayout;import java.awt.event.*;import javax.swing.*;public class mainWindow extends JFrame implements ActionListener{private static final long serialVersionUID = 1L;JFrame bankerAlgoritJFrame;//主界面JLabel[] l; //输入资源种类数,输入启动的进程数,资源请求,标签JTextField[] t; //对应于标签的文本框JButton[] b; //对应去标签的按钮JPanel[] p;int m=0;//添加的进程数int n=0;//添加的资源种类数int[] available;int[][] max;int[][] allocation;int[][] need;int[] request;String requestP;String[] processName;String[] processName_Safety;//保存一个安全推进序列String[] resourceName;JPanel[] l1;JTextField[] t1;public mainWindow(String name){super(name);setSize(320, 350);setLocation(500, 100);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);Container container = getContentPane();container.setLayout(null);l = new JLabel[3];t = new JTextField[2];b = new JButton[3];p = new JPanel[3];p[0] = new JPanel();p[1] = new JPanel();p[2] = new JPanel();p[0].setBounds(5, 20, 300, 30);p[1].setBounds(5, 120, 300, 30);p[2].setBounds(5, 220, 300, 30);l[0] = new JLabel("输入资源的种类数:"); l[1] = new JLabel("输入启动的进程数:"); l[2] = new JLabel("资源请求:");t[0] = new JTextField(3);t[1] = new JTextField(3);b[0] = new JButton("添加资源");b[0].addActionListener(this);b[1] = new JButton("启动进程");b[1].addActionListener(this);b[2] = new JButton("请求资源");b[2].addActionListener(this);p[0].add(l[0]);p[0].add(t[0]);p[0].add(b[0]);p[1].add(l[1]);p[1].add(t[1]);p[1].add(b[1]);p[2].add(l[2]);p[2].add(b[2]);container.add(p[0]);container.add(p[1]);container.add(p[2]);setVisible(true);}//定义添加资源窗口类class AddResourceWindow extends JFrame implements ActionListener{ private static final long serialVersionUID = 1L;JLabel ResourceNameL = new JLabel("资源名");JLabel AvailableL = new JLabel(" available");JButton addResourceOK = new JButton("确定");JLabel[] resourceNameJLabel = new JLabel[n];JTextField[] AvailableTextField = new JTextField[n];JPanel[] addResourceJPanels = new JPanel[n+2];public AddResourceWindow(){super("添加资源");setSize(320, 400);setLocation(500, 150);Container container = getContentPane();container.setLayout(null);addResourceJPanels[n+1] = new JPanel();addResourceJPanels[n+1].setBounds(5, 20, 300, 30);addResourceJPanels[n+1].add(ResourceNameL);addResourceJPanels[n+1].add(AvailableL);container.add(addResourceJPanels[n+1]);//动态的添加组件int y = 60;char a = 'A';for(int i=0; i<n; i++, y=y+40){addResourceJPanels[i] = new JPanel();resourceNameJLabel[i] = new JLabel(String.valueOf(a)+":");resourceName[i] = String.valueOf(a);a = (char)(a+1);AvailableTextField[i] = new JTextField(4);AvailableTextField[i].setHorizontalAlignment(JTextField.RIGHT);addResourceJPanels[i].setBounds(5, y, 300, 30);addResourceJPanels[i].add(resourceNameJLabel[i]);addResourceJPanels[i].add(AvailableTextField[i]);container.add(addResourceJPanels[i]);}addResourceJPanels[n] = new JPanel();addResourceJPanels[n].setBounds(5, y, 300, 30);addResourceJPanels[n].add(addResourceOK);addResourceOK.addActionListener(this);container.add(addResourceJPanels[n]);setVisible(true);}//将输入的资源名和数量存入available数组,若不填资源名默认为A,B,Cvoid getResource(){for(int i=0; i<n; i++){try {available[i] = Integer.parseInt(AvailableTextField[i].getText());} catch (Exception e) {JOptionPane.showMessageDialog(null,"available为正整数");return;}}this.dispose();}@Overridepublic void actionPerformed(ActionEvent e) {Object ob = e.getSource();if(ob == addResourceOK){getResource();}}}//定义启动进程的窗口类,用来输入进程名,max数组和allocation数组class StartProcess extends JFrame implements ActionListener{ private static final long serialVersionUID = 1L;JLabel resourceNameJLabel = new JLabel(" 进程名");JLabel maxJLabel = new JLabel(" max ");JLabel allocationJLabel = new JLabel("allocation ");JButton startProcessOK = new JButton("确定");JPanel[] startProcessJPanel = new JPanel[m+2];JLabel[] processNameJLabel = new JLabel[m];JTextField[][] maxJTextField = new JTextField[m][n];JTextField[][] allocationJTextField = new JTextField[m][n];public StartProcess(){super("启动进程");setSize(320, 400);setLocation(500, 150);Container container = getContentPane();container.setLayout(null);startProcessJPanel[m+1] = new JPanel();startProcessJPanel[m+1].setLayout(new GridLayout(1,3)); startProcessJPanel[m+1].setBounds(5, 20, 300, 30);startProcessJPanel[m+1].add(resourceNameJLabel);startProcessJPanel[m+1].add(maxJLabel);startProcessJPanel[m+1].add(allocationJLabel);container.add(startProcessJPanel[m+1]);// 添加表格(textfield组)进程名默认为p0,p1,p2,p3。