银行家算法设计-操作系统课程设计报告书
- 格式:doc
- 大小:196.50 KB
- 文档页数:17
银行家算法实验报告一、实验题目为了了解系统的资源分配情况,假定系统的任何一种资源在任一种资源在任意时刻只能被一个进程使用。
任何进程已经占用的资源只能由进程自己释放,而不能任由其他进程抢占。
当进程申请的资源不能满足时,必须等待。
因此,只要资源分配算法能保证进程的资源请求,且不出现循环等待,则系统不会出现死锁。
而银行家算法是避免死锁的一种重要方法。
通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法二、实验要求要求编写系统进行资源调度的程序,模拟进程的资源分配算法,了解死锁的产生和避免的办法。
一个是随机动态地进行资源分配的模拟程序,即只要系统当前剩余资源满足进程的当前要求,就立即将资源分配给进程,以观察死锁产生情况;一个是采用银行家算法,有效地避免死锁的产生。
要求用银行家算法和随机算法实现资源分配。
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获得所申请资源七、总结这次实验中我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统课程设计报告院(系):计算机工程学院专业:计算机科学与技术专业学生姓名:__班级:__计算073 _学号:题目:仿真模拟银行家算法对死锁的避免起迄日期:__2010-7-6至2010-7-16_设计地点: 2号实验楼402指导教师:2009—2010年度第 2 学期完成日期: 2010 年 7 月 16 日一、课程设计目的《操作系统》是一门重要的专业基础课,是涉及较多硬件知识的计算机系统软件课程。
在计算机软硬件课程的设置上,它起着承上启下的作用。
操作系统对计算机系统资源实施管理,是所有其他软件与计算机硬件的唯一接口,所有用户在使用计算机时都要得到操作系统提供的服务。
操作系统课程设计的主要任务是研究计算机操作系统的基本原理和算法,掌握操作系统的进程管理、存储管理、文件管理和设备管理的基本原理与主要算法。
目的是使学生掌握常用操作系统(如DOS、Windows或Linux)的一般管理方法,了解它是如何组织和运作的,对操作系统的核心概念和算法有一个透彻的理解,并对系统运行的机制有一个全面的掌握,从而充分理解系统调用与程序设计之间的关系。
二、课程设计内容仿真模拟银行家算法对死锁的避免。
对于进程死锁的避免问题,分为两种状态:安全状态和非安全状态。
在避免死锁的方法中,允许进程动态地申请资源分配之前,应先计算此次资源分配的安全性。
若此次分配不会导致系统进入不安全状态,则将资源分配给进程;否则,令进程等待。
所谓安全状态是指系统能按某种进程顺序,来为每个进程pi分配所需的资源,直至满足每个进程对资源的最大需求,使每个进程都可顺利地完成。
如果系统无法找到这样一个序列,则系统处于不安全状态。
只要系统处于安全状态,系统便可避免进入死锁状态。
因此避免死锁的实质在于:系统在进行资源分配时,如何使系统不进入不安全状态。
银行家算法就是一种最有代表性的避免死锁的算法。
三、系统分析与设计1、系统分析系统分析的主要任务是将在系统详细调查中所得到的文档资料集中到一起,对组织内部整体管理状况和信息处理过程进行分析。
《操作系统》课程设计报告系别:信息科学与技术系专业班级:学生姓名:指导教师:(课程设计时间:2010年7月5日——2010年7月9日)目录一、课程设计目的和意义 (3)二、课程设计题目描述及算法 (3)三、课程设计报告内容 (3)1.算法描述 (3)2.数据结构 (4)3.主要函数说明 (4)4.算法流程图 (5)5.运行结果及说明 (7)6.附录清单及分析 (8)四、总结 (14)一、课程设计目的和意义了解掌握银行家算法,学会模拟实现资源分配,同时有要求编写和调试一个系统分配资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生二、课程设计题目描述及算法题目:银行家算法设计设计要求:编制银行家算法通用程序,并检测所给状态的系统安全性。
设进程I提出请求Request[N],则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[I,N],则转(2);否则,出错。
(2)如果Request[N]<=AVAILABLE,则转(3);否则,出错。
(3)系统试探分配资源,修改相关数据:AVAILABLE=AVAILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待。
上述三个矩阵存在如下关系:Need[i,j]= Max[i,j]- Allocation[i,j]三、课程设计报告内容1.算法描述设Request[i] 是进程Pi的请求向量,如果Requesti[j]=K,表示进程Pi需要K 个Rj类型的资源,当Pi发出资源请求后,系统按下面步骤进行检查:(1)如果Requesti[j]<=Need[i,j],便转向步骤2;否则认为出错,因为它所需要的资源数已超过它所宣布的最大值。
(2)如果Requesti[j]<=Available[j],便转向步骤3;否则,表示尚无足够资源,Pi须等待。
操作系统课程设计报告-银行家算法的设计与实现(JAVA语言)操作系统课程设计题目院系专业班级学生学号指导教师年月基于计算机此次课程设计的主要内容是模拟实现资源分配同时要求编写和调试一个系统动态分配资源的简单模拟程序观察死锁产生的条件并使用适当的算法有效的防止和避免死锁的发生具体用银行家算法实现资源分配要求如下1 设计一个3个并发进程共享3类不同资源的系统进程可动态地申请资源和释放资源系统按各进程的申请动态地分配资源2 设计用银行家算法和随机分配算法实现资源分配的两个资源分配程序应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况3 确定一组各进程依次申请资源数的序列在相同的情况下分别运行上述两种资源分配程序观察运行结果银行家算法是避免死锁的一种重要方法本实验要求用高级语言编写和调试一个简单的银行家算法程序加深了解有关资源申请避免死锁等概念并体会和了解死锁和避免死锁的具体实施方法死锁的产生必须同时满足四个条件即一个资源每次只能由一个进程占用第二个为等待条件即一个进程请求资源不能满足时它必须等待但它仍继续保持已得到的所有其他资源第四个为循环等待条件系统中存在若干个循环等待的进程即其中每一个进程分别等待它前一个进程所持有的资源防止死锁的机构只能确保上述四个条件之一不出现则系统就不会发生死锁通过这个算法可用解决生活中的实际问题如银行贷款等通过对这个算法的设计让学生能够对书本知识有更深的理解在操作和其它方面有更高的提升关键词死锁安全状态安全序列银行家算法安全性检查目录1 概述 311设计目的 312开发环境 32 需求分析 421死锁概念 422死锁的结论 423资源分类 424产生死锁的必要条件 425死锁的解决方案 4com锁的例子 4com防 5com态与不安全状态 53 数据结构分析设计 631可利用资源向量矩阵available[ ] 6 32最大需求矩阵[ ][ ] 633分配矩阵allocation[ ][ ] 634需求矩阵need[ ][ ] 64 算法的实现 741初始化 742银行家算法 743安全性检查算法 744各算法流程图 85 测试与实例分析 106 心得体会 147参考文献与源程序清单附录 15概述11设计目的银行家算法是一种最有代表性的避免死锁的算法把操作系统看作是银行家操作系统管理的资源相当于银行家管理的资金进程向操作系统请求分配资源相当于用户向银行家贷款操作系统按照银行家制定的规则为进程分配资源当进程首次申请资源时要测试该进程对资源的最大需求量如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源否则就推迟分配当进程在执行中继续申请资源时先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量若超过则拒绝分配资源若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量若能满足则按当前的申请量分配资源否则也要推迟分配本次课程设计通过用JAVA语言编写和调试实现银行家算法的程序达到进一步掌握银行家算法理解系统产生死锁的原因以及系统避免死锁的方法增强理论联系实际的能力的目的12开发环境操作系统Windows XP编译工具Myeclipse86生成文件×××java源代码文件和×××class编译文件2 需求分析21死锁概念死锁就是指多个进程在运行中因争夺资源而造成的一种僵局当进程出于这种僵持状态时若无外力作用它们都将无法再向前推进22死锁的结论产生死锁的原因是竞争资源和进程间推进顺序不当处理死锁的基本方法是①预防死锁②避免思索③检测死锁④解除死锁23资源分类1可剥夺性资源某些进程在获得此类资源后该资源可以再被其他进程或系统剥夺CPU和内存均属于可剥夺性资源2不可剥夺性资源当系统把这类资源分配给进程后再不能强行回收只能在进程用完后自动释放如磁带机打印机3非剥夺性资源在系统中所配置的非剥夺性资源由于它们的数量不能满足诸进程运行的需要会使进程在运行构成中因争夺这些资源而陷入僵局4临时性资源它是指由一个进程产生被另一个进程使用一短暂时间后便无用的资源也称之为消耗性资源24产生死锁的必要条件1互斥条件进程对它所分配到的资源进行排他性使用即在一段时间内某资源由一个进程占有如果此时还有其它进程请求该资源则请求者只能等待直至占有该资源的进程用毕释放2请求和保持条件进程已经保持了至少一个资源但又提出新的资源请求而该资源又被其他进程占有此时请求进程阻塞但又对自己获得的其他资源保持不放3不剥夺条件进程已经获得的资源在未使用完之前不能被剥夺只有在使用完是由自己释放4环路等待条件发生死锁时必然存在一个进程--资源的环形链25死锁的解决方案com锁的例子该例子是由于进程推进顺序非法引发的死锁进程P1 和P2并发执行如果按顺序①执行P1RequestR1P1RequestR2P1ReleaseR1P1ReleaseR2P2RequestR2P2RequestR1P2R eleaseR2P2ReleaseR1两个进程可顺利完成如果按曲线②执行P1 和P2将进入不安全区DP1保持了资源R1P2保持了R2接下来P2将申请不到R1P1申请不到R2系统处于不安全状态往前推进将发生死锁图3-15com防预防死锁的方法是使产生死锁的四个必要条件中的234条件之一不能成立即1摒弃请求和保持条件系统规定所有进程在开始运行之前都必须一次性申请其在整个运行过程中所需的全部资源使该进程再整个运行过程中不会提出资源请求因而摒弃了请求条件又由于进程在等待期间没有占有任何资源所以也摒弃了保持条件2摒弃不剥夺条件系统规定进程逐个提出对资源的要求当一个已经保持了某些资源的进程再提出新的资源请求而未被满足时必须释放已经保持的所有资源待以后需要是在再重新申请3摒弃环路等待条件系统规定所有资源按类型进行线性排队并赋予不同的序号所有进程对资源的请求都必须严格按资源序号递增的顺序提出com态与不安全状态在避免死锁的方法中允许进程动态地申请资源但系统在进行资源分配之前应先计算此次资源分配的安全性若此次分配不会导致系统进入不安全状态则将资源分配给进程否则令进程等待所谓安全状态是指系统能按某种进程顺序P1 P2 P3Pn来为每个进程分配所需资源直至满足每个进程对资源的最大需求是每个进曾都可以顺利完成如果系统找不到这样一个序列系统就处于不安全状态虽然并非所有的不安全状态都是死锁状态但当系统进入不安全状态后便可能进入死锁状态只要系统处于安全状态系统便可以避免进入不安全状态因此避免死锁的实质在于系统在进行资源分配时如何使系统不进入不安全状态安全序列一个进程序列 P1Pn 是安全的如果对于每一个进程Pi 1≤i≤n它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj j i 当前占有资源量之和银行家算发就是用具避免死锁的一个有效方法3 数据结构分析设计31可利用资源向量矩阵available[ ]这是一个含有m个元素的数组其中的每一个元素代表一类可利用的资源数目其初始值是系统中所配置的该类全部可用资源的数目其数值随该类资源的分配和回收而动态地改变如果available [j] K则表示系统中现有R类资源K个32最大需求矩阵[ ][ ]这是一个nm的矩阵用以表示每一个进程对m类资源的最大需求如果[ij] K 则表示进程i需要R类资源的数目为K33分配矩阵allocation[ ][ ]这也是一个nm的矩阵它定义了系统中每一类资源当前已分配给每一进程的资源数如果allocation [ij] K则表示进程i当前已分得R类资源的数目为K 34需求矩阵need[ ][ ]这也是一个nm的矩阵用以表示每一个进程尚需的各类资源数如果need [ij] K则表示进程i还需要R类资源K个才能完成其任务上述矩阵存在下述关系need[ij] [ij]- allocation[ij]4 算法的实现41初始化1创建available[]数组用以存放系统中可用的资源数目2创建[][]数组用以存放各个进程对各类资源的最大需求数目3创建allocation[][]数组用以存放各个进程已经分得的各类资源数目 4创建need[][]数组用以存放各个进程还需要的各类资源数目5创建 allocation1[][]need1[][]available1[]用以存放系统试分配资源前系统资源分配情况42银行家算法设Requesti是进程Pi的请求向量Requesti K表示进程Pi需要K个j类资源Pi发出资源请求后按下列步骤进行检查1如果requesti[j]≤need[ij]转向步骤②否则报错所需要的资源数已超过它所宣布的最大值2如果requesti[j]≤available[j]转向步骤③否则报错尚无足够资源Pi需等待3尝试将资源分配给进程Pi并修改下面数据结构中的数值available[j] available[j]-raquesti[j]allocation[ij] allocation[ij]raquesti[j]need[ij] need[ij]-raquesti[j]4 执行安全性算法检查此次资源分配后系统是否出于安全状态若安全才正式将资源分配给进程Pi已完成本次分配否则将本次试探分配作废恢复原来的资源分配状态让Pi等待43安全性检查算法1设置两个向量一工作向量work表示系统可提供给进程继续运行所需的各类资源数目执行安全性算法开始时work available二finish标志表示系统是否有足够的资源分配给进程使之运行完成初始化finish[i] false有足够资源分配给进程时令finish[i] true2从进程集合中找到一个能满足下述条件的进程finish[i] falseNeed[ij]≤work[j]找到执行步骤③否则执行步骤④3当进程Pi获得资源后可顺利执行直至完成并释放出分配给它的资源故应执行Work[j] work[i]allocation[ij]Finish[i] trueGo to step ②4如果所有进程的finish[i] true都满足则表示系统处于安全状态否则系统处于不安全状态44各算法流程图1初始化算法流程2银行家算法流程图5 测试与实例分析1下列状态是否安全四个进程共享12个同类资源资源进程A B C AllocationA B C NeedA B C Available A B C P03 2 21 0 02 2 22 1 2P16 1 34 1 12 0 2P23 1 42 1 11 0 3P34 2 20 0 24 2 0利用银行家算法程序进行检测打开程序输入上述数据初始化数据后显示进行安全检测经检查系统为安全状态存在安全序列p1 p2 p3 p02考虑下列系统状态系统是否安全若安全就给出所有的安全序列如果此时p0和p1均提出资源请求Request 101 能否立即给予满足解继续执行银行家算法程序1P0申请资源101申请不成功系统不为其分配资源继续执行银行家算法程序2P1申请资源101申请成功存在安全序列p1 p2 p3 p0所以对p2来说能得到立即满足如果此刻P2继续请求资源Reques101则就有系统将资源试分给P1则可用资源数变为111然后继续试分配给p0 Request 101 它小于Avalable可以分配但分配后很明显找不到一个安全序列发现系统处于不安全状态不能分配给它于是回收资源系统的可用资源恢复到1116 心得体会通过一个周的课程设计虽然理解起来很容易但想用算法具体去实现它还是有一定的难度虽然做起来比较吃力但当我通过自己亲手做出来时使我更加加深了对银行家算法的理解掌握了银行家算法避免死锁的过程和方法理解了死锁产生的原因和条件以及避免死锁的方法并且还巩固了JAVA知识掌握了用JAVA实现银行家算法的方法所编写程序基本实现了银行家算法的功能并在其基础上考虑了输出显示格式的美观性使界面尽可能友好并且在编程时将主要的操作都封装在方法中如输入进程和资源信息放在了一个构造方法public TheBanker 中进行安全性检测的方法Security_check 进行申请资源的方法checkRequest 打印当前各资源的方法print 这样使程序可读性增强使程序更加清晰明了当然由于JAVA学的也就是些基础平时的不常联系使得我实际操作能力的很欠缺我在编写和调试过程中遇到了许多的问题通过网上查询资料翻阅课本向同学请教多次调试等方法逐渐解决了大部分问题这次课程设计非常有意义它让我收获很多不仅掌握了课本所学的知识也巩固了JAVA的相关知识7 参考文献与源程序清单汤子瀛哲凤屏汤小丹计算机操作系统西安电子科技大学出版社20062 美威尔顿麦可匹克 Java入门经典第3版施宏斌译北京清华大学出版社2009 美 Bruce Eckel Java编程思想陈昊鹏译北京机械工业出版社2007 import comnerpublic class TestBankerpublic static void main String[] argsSycomtln "-----操作系统银行家算法-------"TheBanker tb new TheBankerboolean flag truewhile flagSycomtln "1死锁避免检验是否安全"Sycomtln "2死锁检测"Sycomtln "3退出"Sycomtln "Sycomtln "请选择"Scanner input new Scanner Systemin int num inputnextIntswitch numcase 1tbSecurity_checkflag truebreakcase 2tbcheckRequest 死锁检测flag truebreakcase 3Sycomtln "谢谢使用再见"flag falsebreakimport comnerpublic class TheBankerint m 进程个数int n 每个进程的资源个数int[][] 最大需求矩阵int[][] allocation 以分配的资源已占有的资源int[][] need 需求的资源int[] available 可利用的资源int[] p 记录安全序列boolean[] finish 标志一个进程是否完成true 表示完成 false 表示未完成Scanner input new Scanner Systeminpublic TheBankerSycomtln "请输入系统中的进程数"m inputnextIntSycomtln "请输入进程的资源类型数"n inputnextIntnew int[m][n]allocation new int[m][n]need new int[m][n]available new int[n]finish new boolean[m]Sycomtln "请输入一个"m"行"n"列的各进程的最大需求量"for int i 0i lengthi 依次输入进程的各个最大资源数Sycomtln "请输入第p " i1 " 进程的"for int j 0j [i]lengthj[i][j] inputnextIntSycomtln "请输入一个"m"行"n"列的各进程的各占有量"for int i 0i allocationlengthi 依次输入进程的各个占有资源数Sycomtln "请输入第p " i1 " 进程中的Alloction"for int j 0j allocation[i]lengthjallocation[i][j] inputnextIntfor int i 0i needlengthi 计算出各个进程需求的资源数 for int j 0j need[i]lengthjneed[i][j] [i][j] - allocation[i][j]Sycomtln "请输入可用资源数Avallable" 输入进程的可用资源数for int i 0i niavailable[i] inputnextIntSycomtln "初始化结果为下表"print显示列表public void printSycomtln "Sycomtln "\t\tAllocation\tNeed\tAvalable"Sycomtln "\tA B C\tA B C\t\tA B C\tA B C"for int i 0i miSycomt "P "i" "Sycomt " "for int j 0j njSycomt [i][j]" "Sycomt "\t"for int j 0j njSycomt allocation[i][j]" "Sycomt "\t\t"for int j 0j njSycomt need[i][j]" "Sycomt "\t"if i 0for int j 0j njSycomt available[j]" "SycomtlnSycomtln "public boolean Security_checkint[] work new int[n]for int i 0i niwork[i] available[i] 把available的值赋给workfinish new boolean[m]for int i 0 i m i 开始把进程全部置未分配状态都为falsefinish[i] falseint num 0 对每个进程都要把所有资源都进行比较int num1 0int count 0 记录可以分配的序列int count1 0 记录所有序列是否分配p new int[m] 找到安全序列while num1 mfor int i 0i miif finish[i] false 判断finish的状态如果为true说明刚才已经找到不需要重复for int j 0j njif need[i][j] work[j] 比较一个进程的各种资源是否满足条件numif num n 如果一个进程所有资源都满足条件need work则找到了一个进程满足for int k 0k nkwork[k] work[k] allocation[i][k]finish[i] true 找到一个进程满足p[count] i 记录找到的是第几个进程num 0 必须把它清零重新来找下个资源种类的每种是否都满足条件num1记录有多少个序列for int i 0i miif finish[i] truecount1 检测是否所有的进程最后都是trueif count1 m 如果序列里面总数等于总共有多少程序就找到了安全的序列并且输出反之没有找到Sycomtln "存在一个安全序列安全序列为"for int i 0i miif i m-1Sycomt "P"p[i]"-- "elseSycomtln "P"p[i]Sycomtln "return trueelseSycomtln "没有找到一个安全序列系统处于不安全状态"return falsepublic void checkRequestint process 0 记录输入的是第几个进程int count2 0 记录试分配过程中满足条件的个数boolean flag true 主要防止输入的数字已经超出了本来process数量则要求重新输入Sycomtln "请输入要申请的第几个进程注意进程p下标是从0开始的"while flagprocess inputnextIntif process mflag trueSycomtln "输入超出了本来进程的范围请重新输入"elseflag falseSycomtln "第"process"个进程提出请求"int[] request new int[n]Sycomtln "输入要请求的资源Request"for int i 0i nirequest[i] inputnextInt判断是否可以分配for int i 0i niif request[i] need[process-1][i] request[i] available[i]count2 判断是否每个进程的所有资源都满足试分配的要求并记录if count2 n 如果每一种资源都满足要求则可以进程请求试分配for int j 0j njallocation[process-1][j] request[j] 注意数组下标是从0开始的need[process-1][j] - request[j]available[j] - request[j]Sycomtln "试分配如下-------- "print 打印试分配的结果Sycomtln "进行安全性判断"flag Security_check 判断是否为安全序列if flag false 如果是分配后不能找到一个安全序列则返回不进行分配for int j 0j njallocation[process-1][j] - request[j] 注意数组下标是从0开始的need[process-1][j] request[j]available[j] request[j]elseSycomtln "不能进行试分配也就找不到安全序列"西安工业大学课程设计1。
竭诚为您提供优质文档/双击可除银行家算法操作系统实验报告篇一:计算机操作系统银行家算法实验报告计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计: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)。
操作系统课程设计报告题目:银行家算法院(系):专业:班级:学生:学号:指导教师:2010年12月操作系统课程设计报告题目:银行家算法院(系):专业:班级:学生:学号:指导教师:2010年12月银行家算法摘要本次的课程设计内容是银行家算法,在操作系统当中,由于竞争非剥夺性资源和进程推进的不当,对系统的安全造成威胁,所以,银行家算法就是为了避免对系统产生死锁而存在的.银行家算法包括对请求资源的试分配和对安全性的考量,当系统的安全性不能够满足的时候,则对系统进行保护。
在编写银行家算法的时候需要定义Need(需求矩阵),Allocation(分配矩阵),Max(最大需求矩阵)以及Available(可利用资源量)。
在实现一系列的功能的时候使用的数组的结构,便于进行矩阵的加减运算,可以提高程序的运行效率.通过编写可以基本上实现银行家算法所要达到的基本目的,在输入正确的情况下能够输出正确的安全序列,在不安全的情况下可以做出提醒,并且恢复原有输入数据。
关键字:银行家算法最大需求矩阵分配矩阵需求矩阵可利用资源量目录摘要 (i)1 绪论 (1)2需求分析.................................................................。
(2)2.1 问题描述.........................................................。
. (2)2.2 产生条件..........................................................。
(2)2.3 运行环境.........................................................。
. (2)2.4 程序功能.........................................................。
衡阳师范学院《操作系统》课程设计题目处理机调度模拟设计——短作业先调度、先来先服务调度、最高响应比调度算法专业计算机科学与技术班级1001班学号10190134 10190136姓名张德旺屈金指导教师王玉奇2012 年12 月日目录1、概述 (1)1.1、设计目的 (1)1.2、设计内容 (1)1.3、开发环境 (1)1.4、任务分配 (1)2、需求分析 (2)2.1、死锁概念: (2)2.2、关于死锁的一些结论: (2)2.3、资源分类: (2)2.4、产生死锁的四个必要条件: (3)2.5、死锁的解决方案 (3)2.5.1 产生死锁的例子 (3)2.5.2死锁预防: (4)2.6.安全状态与不安全状态 (5)3、数据结构设计 (5)3.1、定义全局变量 (5)3.2、函数声明 (5)3.3、主函数结构 (6)4、算法的实现 (7)4.1、初始化 (7)4.2、银行家算法 (7)4.3、安全性检查算法 (7)4.4、程序模块划分 (8)4.5程序运行结果显示 (9)4.6、各算法流程图 (11)4.7、源程序清单 (12)5、心得与体会: (22)6、参考文献 (22)1、概述1.1、设计目的(1)了解多道程序系统中,多个进程并发执行的资源分配。
(2)掌握死锁的产生的原因、产生死锁的必要条件和处理死锁的基本方法。
(3)掌握预防死锁的方法,系统安全状态的基本概念。
(4)掌握银行家算法,了解资源在进程并发执行中的资源分配策略。
(5)理解死锁避免在当前计算机系统不常使用的原因。
1.2、设计内容利用银行家算法来实现资源的分配。
先对用户提出的请求进行合法性检查,再进行预分配,利用安全性检查算法进行安全性检查。
1.3、开发环境1.4、任务分配2、需求分析2.1、死锁概念:在多道程序系统中,虽可借助于多个进程的并发执行,来改善系统的资源利用率,提高系统的吞吐量,但可能发生一种危险━━死锁。
所谓死锁(Deadlock),是指多个进程在运行中因争夺资源而造成的一种僵局(Deadly_Embrace),当进程处于这种僵持状态时,若无外力作用,它们都将无法再向前推进。
实验四:银行家算法的实现一.实验目的(1)加深了解有关资源申请、避免死锁等概念。
(2)体会和了解死锁和避免死锁的具体实施方法。
二.实验属性该实验为设计性实验。
三.实验仪器设备及器材普通PC386以上微机四.实验要求本实验要求2学时完成。
本实验要求完成如下任务:(1)设计进程对各类资源最大申请表示及初值的确定。
(2)设定系统提供资源的初始状况。
(3)设定每次某个进程对各类资源的申请表示。
(4)编制程序,依据银行家算法,决定其资源申请是否得到满足。
(5)显示资源申请和分配时的变化情况。
五、实验设计及其思路数据结构:Available[m] 用来表示可利用资源的数目初始值是该类全部可用资源的数目。
MAX[n][m] 用来定义n个进程中的每一个进程对m类资源的最大需求Allocation[i][j] 用来表示i个进程中的每一个进程对j类资源已经拥有的数值Need[i][j] 用来表示i个进程中的每一个进程对j类资源还需要的数值在此程序中通过输入输出流从txt文档中读取数据进入以上数据数组中通过控控制台向request[i][j]数组输入值 此数组用来表示进程i 向j 资源请求申请资源个数 银行家算法流程图开始进程发出资源请求(request )所需要资源小于目前最大值Request<=need所需要资源小于可利用值Request<=avilable把资源分配给此进程并改变相关数值安全性算法 返回值是Y否出错(该系统无法执行此类进程)该进程暂时无法获得此资源 需等待还原相关数据是否分配成功结束是是否安全性算法流程图六 输出结果向其中输入三组数据1 p1发出请求向量request (1,0,2) 正确结果为分配资源2 p4发出请求向量request (3,3,0) 正确结果会产生安全问题要等待3 p0发出请求向量request (0,2,0)正确结果产生安全隐患需等待开始定义可以用的资源数目work 还有是否能在有限的资源条件下完成线程的标志finish ,并给他们所有的线程都可以顺利完成count 等于进程总数 尽可能多的找到满足(finish==false 和need<=work 这两个条件的线程)并对资源做相应的更改更改次数用count 计录 返回 N返回Y 结束是 否七、代码#include<iostream.h>#include<fstream.h>#include<stdio.h>int *avilable;//表示现在可利用的各类资源的数目int **max1;//用二维数组存储各给线程最多能够申请到个资源的数目int **allocation;//用二维数组存储目前各个线程已占用各类资源的数量int **need;//用二维数组存储目前每个进程还需要各类资源的数量方能完成工作int*xiancheng;//用来存储安全序列int m,n;//m用来记录资源的总数,n用来计算进程的总数void show();//用来向控制台输出allocation,needmax1,avilable的数据int correct();//安全性算法void createavilable();//为目前可利用资源赋初值void createmax();//为每一个进程对各类资源的最大需求赋初值void createallocation();//为目前各个进程已经申请到的资源赋初值void createneed();//为完成该进程所需要的各类资源数量赋初值int banker();//银行家算法int main(){ int choice=1;createavilable();createmax();createallocation();createneed();while(choice!=0){banker();cout<<"请输入你的选择(1继续,2重来 0 退出)"<<endl;cin>>choice;if(choice==1) show();if(choice==2){createavilable();createmax();createallocation();createneed(); }}return 0;}void createavilable(){ifstream inFile;int i;i=0;inFile.open("avilable.txt");//从txt文件中读取数据为其赋值inFile>>m;inFile.get();avilable=new int[m];cout<<"avilable:"<<endl;cout<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;while(inFile){inFile>>avilable[i];cout<<avilable[i]<<'\t';//显示到控制台上char c;inFile.get(c);//用来准确定读取时位真正的结束位置i++;}cout<<endl;}void createmax(){ifstream inFile1;inFile1.open("max.txt");inFile1>>n;inFile1.get();max1=new int*[n];//实现为二维数组动态分配内存for(int k=0;k<n;k++)max1[k]=new int[m];cout<<"max:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ if(inFile1) inFile1>>max1[i][j];cout<<max1[i][j]<<'\t';}cout<<endl;}}void createallocation(){ifstream inFile1;inFile1.open("allocation.txt");allocation=new int*[n];for(int k=0;k<n;k++)allocation[k]=new int[m];cout<<"allocation:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ if(inFile1) inFile1>>allocation[i][j]; cout<<allocation[i][j]<<'\t';}cout<<endl;}}void createneed(){need=new int*[n];for(int k=0;k<n;k++)need[k]=new int[m];cout<<"need:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ need[i][j]=max1[i][j]-allocation[i][j];//根据max allocation和need的关系为need赋值cout<<need[i][j]<<'\t';}cout<<endl;}}int correct(){int *work;//工作向量bool *finish,flag;//finish用来表示进程是否可以在特定的资源下完成工作,flag用来标记循环是否结束int i, k,count1,count;work=new int[m];xiancheng=new int[m];for( i=0;i<m;i++)work[i]=avilable[i];finish=new bool[n];//初值都为falsefor(k=0;k<n;k++)finish[k]=false;count=0;do{for(i=0;i<n;i++){flag=false;count1=0;for(k=0;k<m;k++)if(need[i][k]<=work[k]) count1++;//判断i个进程对各类资源的需要是小于该类资源的工作数量并记录小于的个数else break;if(count1==m&&finish[i]==false)//判断对每类资源来说都是所需小于工作数量并且该类线程并没有完成任务{ for(k=0;k<m;k++){work[k]=work[k]+allocation[i][k];finish[i]=true;flag=true;}xiancheng[count]=i;count++;}}}while(flag==true);//可能多的找到满足(finish==false和need<=work 这两个条件的线程)并对资源做相应的更改更改次数用count计录cout<<count<<endl;if(count==n)return 1;elsereturn 0;}int banker(){int *request,i,j,count;request=new int[m];//资源请求i=count=0;cout<<"哪个进程请求资源"<<endl;cin>>j;cout<<"请依次输入a,b,c资源的请求数"<<endl;while(i<m) {cin>>request[i]; i++;}for(i=0;i<m;i++)if(request[i]<=need[j][i]) count++;else break;if(count!=m) //判断所需要资源小于目前最大值Request<=need {cout<<"此操系统不能完成这个进程"<<endl;return 0;}count=0;for(i=0;i<m;i++)if(request[i]<=avilable[i]) count++;else break;if(count!=m)//所需要资源小于可利用值Request<=avilable {cout<<"现在可利用资源不能满足需要,需要等候"<<endl; return 0;}for(i=0;i<m;i++){avilable[i]=avilable[i]-request[i];allocation[j][i]=allocation[j][i]+request[i];need[j][i]=need[j][i]-request[i];}if(correct()==1)//安全性算法{cout<<"可以将资源分配给"<<"p"<<j<<"进程,其中安全序列可以是:"<<endl;for(i=0;i<n;i++)cout<<"p"<<xiancheng[i]<<'\t';cout<<endl;}else{cout<<"因为会造成系统不安全,所以不分配资源给"<<"p"<<j<<"进程"<<endl;for(i=0;i<m;i++){avilable[i]=avilable[i]+request[i];allocation[j][i]=allocation[j][i]-request[i];need[j][i]=need[j][i]+request[i];}}return 0;}void show(){ int i,j;cout<<"avilable:"<<endl;cout<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for( i=0;i<m;i++)cout<<avilable[i]<<'\t';cout<<endl;cout<<"max:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for( i=0;i<n;i++){ cout<<"p"<<i<<'\t';for( j=0;j<m;j++){cout<<max1[i][j]<<'\t';}cout<<endl;}cout<<"allocation:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl; for(i=0;i<n;i++){ cout<<"p"<<i<<'\t'; for( j=0;j<m;j++){cout<<allocation[i][j]<<'\t';}cout<<endl;}cout<<"need:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl; for( i=0;i<n;i++){cout<<"p"<<i<<'\t';for( j=0;j<m;j++){cout<<need[i][j]<<'\t';}cout<<endl;}}。
操作系统课程设计报告题目:银行家算法操作系统课程设计报告题目:银行家算法摘要在多道操作系统中,可以利用多个进程并发执行来改善系统资源利用率,提高系统的吞吐量,但也可能发生人们不想看到的危险——死锁。
为了解决这个问题,人们引入了多种机制处理死锁问题。
本文主要介绍了操作系统如何运用银行家算法和安全性算法避免死锁的产生。
同时运用Java编程语言模拟计算机内部资源分配的过程。
让读者对银行家算法有更深刻的认识。
关键字:死锁银行家算法安全性算法资源分配IAbstractIn much road OS, improve the systematic handling capacity, but also may people happened not thinking of dangerous dead lock seeing that to come to improve system resource utilization ratio being able to make use of many course concurrency to carry out. Have led into various mechanism for problem , people resolving this handle lock fast problem. The main body of a book has been introduced mainly how to apply the banker algorithm and the security algorithm to avoid lock fast creation. Wield Java programming language analog computer inside resource assignment process at the same time. Let reader have deeper cognition to banker algorithm.Key words: Algorithmic algorithmic security of dead lock banker resource assignmentII目录中文摘要 (I)英文摘要 (II)1绪论 (1)2需求分析 (2)3概要设计 (3)4详细设计 (4)5测试与分析 (6)6总结 (11)7参考文献 (12)附录 (13)1绪论银行家算法诞生的背景:操作系统作为裸机上安装的第一层软件,起着控制和管理计算机内部软硬件资源,合理组织计算机工作流程,提高计算机工作效率,用户和计算机硬件接口的重要作用。
3 课程设计三银行家算法(参考1)1设计目的(1)了解多道程序系统中,多个进程并发执行的资源分配。
(2)掌握死锁产生的原因、产生死锁的必要条件和处理死锁的基本方法。
(3)掌握预防死锁的方法,系统安全状态的基本概念。
(4)掌握银行家算法,了解资源在进程并发执行中的资源分配策略。
(5)理解避免死锁在当前计算机系统不常使用的原因。
2.算法描述Dijkstra(1965年)提出了一种能够避免死锁的调度方法,称为银行家算法,它的模型基于一个小城镇的银行家,现将该算法描述如下:假定一个银行家拥有资金,数量为Σ,被N个客户共享。
银行家对客户提出下列约束条件:(1)每个客户必须预先说明自已所要求的最大资金量;(2)每个客户每次提出部分资金量申请各获得分配;(3)如果银行满足了客户对资金的最大需求量,那么,客户在资金动作后,应在有限时间内全部归还银行。
只要每个客户遵守上述约束,银行家将保证做到:若一个客户所要求的最大资金量不超过Σ,则银行一定接纳该客户,并可处理他的资金需求;银行在收到一个客户的资金申请时,可能因资金不足而让客户等待,但保证在有限时间内让客户获得资金。
在银行家算法中,客户可看做进程,资金可看做资源,银行家可看做操作系统。
3. 环境操作系统Windows XP SP2,开发工具VC++6.0或者BCB6.0。
4 功能模块说明1.银行家所能够提供的资源typedef struct node{int a;int b;int c;int remain_a;int remain_b;int remain_c;}bank;2.进程所占用的资源typedef struct node1{char name[20];int a;int b;int c;int need_a;int need_b;int need_c;}process;main()函数:完成对系统运行环境的初始化,定义了简单的选择菜单,调用各功能函数。
操作系统原理课程设计题目:银行家算法院系:计算机科学技术学院班级学号: ***************** 姓名: ****** 同组成员: ************ 指导教师: *******2014年**月**日操作系统原理课程设计任务书一、题目:银行家算法二、设计要求(1)*****负责设计与实现,定义全局变量,签名函数和主函数以及显示分配情况函数showdata();*****负责设计与实现系统初始化函数chushihua();安全性算法函数safe();*****负责设计与实现银行家算法函数bank()。
(2)查阅相关资料,自学具体课题中涉及到的新知识。
(3)采用结构化、模块化程序设计方法,功能要完善,具有一定的创新。
(4)所设计的程序应有输入、输出。
(5)按要求写出课程设计报告,于设计结束后1周内提交。
其主要内容包括:封皮、课程设计任务书,指导教师评语与成绩、目录、概述、软件总体设计、详细设计、软件的调试、总结、致谢、附录(带中文注释的程序清单)、参考文献。
总体设计应配合软件总体模块结构图来说明软件应具有的功能;详细设计应用传统或N-S流程图和屏幕抓图说明;调试的叙述应配合出错场景的抓图来说明出现了哪些错误,如何解决的。
三、课程设计工作量一般每人的程序量在200行有效程序行左右。
四、课程设计工作计划2013年12月30日,指导教师讲解布置题目,学生根据题目准备资料;2013年12月30日,进行总体方案设计;2013年12月31日~2014年1月3日,完成程序模块并通过独立编译;2014年1月4日~1月6日,将各模块集成为一完整的系统,并录入足够数据进行调试运行;2014年1月7日~1月12日,验收、撰写课程设计报告。
指导教师签章:专业主任签章:操作系统原理课程设计指导教师评语与成绩指导教师评语:课程设计表现成绩:课程设计验收成绩:课程设计报告成绩:课程设计总成绩:指导教师签章2014年1 月13 日。
操作系统课程设计报告题目:银行家算法院(系):专业:班级:学生:学号:指导教师:操作系统课程设计报告摘要Dijkstra提出的银行家算法,是最具代表性的避免死锁的算法。
本文对如何用银行家算法来处理操作系统给进程分配资源做了详细的说明,包括需求分析、概要设计、详细设计、测试与分析、总结、源程序清单。
首先做了需求分析,解释了什么是银行家算法,并指出它在资源分配中的重要作用。
然后给出了银行家算法的概要设计,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等。
在概要设计的基础上,又给出了详细的算法设计,实现概要设计中定义的所有函数,对每个函数写出核心算法,并画出了流程图。
接着对编码进行了测试与分析(并在最后附上Java编写的程序代码)。
最后对整个设计过程进行了总结。
关键词:安全状态;安全序列;银行家算法;安全性算法;安全序列;流程图。
目录摘要 (1)1绪论 (4)1.1前言 (5)1.2研究意义 (5)1.3结构安排 (5)2需求分析 (4)2.1题目描述 (5)2.2银行家算法 (5)2.3基本要求 (5)2.4目的 (5)3概要设计 (4)3.1基本思路 (5)3.2银行家算法步骤 (5)3.3安全型算法步骤 (5)3.4数据结构 (5)3.4.1主要用到的数据结构 (6)3.4.2程序模块 (6)3.4.3各模块间的调用关系 (6)4详细设计 (4)4.1主要函数的核心代码 (5)4.1程序流程图 (5)5测试 (4)5.1测试用例 (5)5.1测试结果分析和截图 (5)6总结 (4)参考文献 (4)附录:原程序清单 (4)1绪论1.1前言:Dijkstra (1965)提出了一种能够避免死锁的调度算法,称为银行家算法。
它的模型基于一个小城镇的银行家,他向一群客户分别承诺了一定的贷款额度,每个客户都有一个贷款额度,银行家知道不可能所有客户同时都需要最大贷款额,所以他只保留一定单位的资金来为客户服务,而不是满足所有客户贷款需求的最大单位。
操作系统课程设计报告――银行家算法中原工学院信息商务学院操作系统课程设计报告操作系统课程设计报告课程设计名称:银行家算法的模拟实现专业:计算机科与技术(软件工程方向)班级:软件***班学号:*** *学生姓名:锦超 9817 指导教师:杨**2021 年 6 月 26 日星期六中原工学院信息商务学院操作系统课程设计报告目录一、实验目的...........................................................................2 二、实验内容...........................................................................2 三、实验步骤...........................................................................3 (1)需求分析...............................................................................3 (2)概要设计...............................................................................3 (3)详细设计...............................................................................3 (4)调试分析..............................................................................11 (5)测试结果..............................................................................11 (6)使用说明:............................................................................15 四、实验总结...........................................................................15 五、附录:程序清单...............................................................15 六、参考资料. (26)- 1 -中原工学院信息商务学院操作系统课程设计报告银行家算法的模拟实现一、实验目的( 1)了解进程产生死锁的原因,了解为什么要进行死锁的避免。
操作系统课程设计银行家算法报告《操作系统--银行家算法》课程设计报告姓名:学号:班级:计科班专业:计算机科学与技术指导教师:时间:20XX年XX大学计算机科学与信息学院目录1 课程设计目的…………………………………………………… 12 课程设计的要求………………………………………………… 13 课程设计题目1/ 28描述……………………………………………… 2 4 课程设计之银行家算法原理…………………………………… 2 5 源程序结构分析及代码实现…………………………………… 4 6 课程设计总结…………………………………………………… 25 一、课程设计的目的操作系统是计算机系统的核心系统软件,它负责控制和管理整个系统的资源并组织用户协调使用这些资源,使计算机高效的工作。
《操作系统课程设计》是《操作系统》理论课的必要补充,是复习和检验所学课程的重要手段,本课程设计的目的是综合应用学生所学知识,通过实验环节,加深学生对操作系统基本原理和工作过程的理解,提高学生独立分析问题、解决问题的能力,增强学生的动手能力。
二、课程设计的要求1.分析设计内容,给出解决方案(要说明设计实现的原理,采用的数据结构)。
2.画出程序的基本结构框图和流程图。
3.对程序的每一部分要有详细的设计分析说明。
4.源代码格式要规范。
5.设计合适的测试用例,对得到的运行结果要有分析。
6.设计中遇到的问题,设计的心得体会。
7.按期提交完整的程序代码、可执行程序和课程设计报告。
三、课程设计题目描述银行家算法是一种最有代表性的避免死锁的算法。
2/ 28要解释银行家算法,必须先解释操作系统安全状态和不安全状态。
安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。
安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。
不安全状态不一定导致死锁。
那么什么是安全序列呢?安全序列:一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j i )当前占有资源量之和。
主函数 (15)一.设计目的:本设计的目的是通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。
二.设计内容:编制银行家算法通用程序,并检测所给状态的系统安全性。
设进程I提出请求Request[N],则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[I,N],则转(2);否则,出错。
(2)如果Request[N]<=AVAILABLE,则转(3);否则,出错。
(3)系统试探分配资源,修改相关数据:AVAILABLE=AVAILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待。
三.设计过程实现功能void showdata() //函数showdata,输出资源分配情况void changdata(int k) //函数changdata,改变可用资源和已经拿到资源和还需要的资源的值void rstordata(int k) //函数rstordata,恢复可用资源和已经拿到资源和还需要的资源的值int check(int s) //函数check,检查是否安全void bank() //银行家算法添加功能无设计思路银行家算法,顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。
在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其他进程使用资源。
如果资源分配不得到就会发生进程循环等待资源,则进程都无法继续执行下去的死锁现象。
把一个进程需要和已占有资源的情况记录在进程控制中,假定进程控制块PCB 其中“状态”有就绪态、等待态和完成态。
当进程在处于等待态时,表示系统不能满足该进程当前的资源申请。
“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。
显然,,每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.算法和流程图1.银行家算法:设进程i提出请求Request[n],则银行家算法按如下规则进行判断。
(1)如果Request[n]>Need[i,n],则报错返回。
(2)如果Request[n]>Available,则进程i进入等待资源状态,返回。
(3)假设进程i的申请已获批准,于是修改系统状态:Available=Available-RequestAllocation=Allocation+RequestNeed=Need-Request四.操作界面截图及分析1.输入数据2.输出数据3.银行家算法检查安全性(1)输入正确的进程请求序列,结果:(2)输入错误的进程请求序列,结果:4.测试输入非法数据:五.设计总结:银行家算法就是为了使系统保持安全状态,避免死锁的发生。
我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。
在实现过程中没遇到什么大问题,主要是一开始没深刻理解银行家算法原理,以致出现了逻辑上的错误,于是我花了好一段时间去研究该算法,网上有各种各样的解释方法,把它们都看了之后,我感觉算是理解透了。
在真正理解了原理之后,再去实现,问题就不大了。
也由此我得到了一个经验,磨刀不费斩柴功,做好分析设计、明白清楚实现原理,代码实现就可以事半功倍了。
若能满足则按当前的申请量分配资源,否则也要推迟分配。
附录:各程序主要函数及注释(用红色黑体标注自己设计的函数)#include "string.h"#include "iostream"using namespace std;#define FALSE 0#define TRUE 1#define W 10#define R 20int M ; //总进程数int N ; //资源种类int ALL_RESOURCE[W];//各种资源的数目总和int MAX[W][R]; //M个进程对N类资源最大资源需求量int A V AILABLE[R]; //系统可用资源数int ALLOCATION[W][R]; //M个进程已经得到N类资源的资源量int NEED[W][R]; //M个进程还需要N类资源的资源量int Request[R]; //请求资源个数///////////////////////////////////////////////////////////////////////////////////////////////void showdata() //函数showdata,输出资源分配情况{int i,j;cout<<"各种资源的总数量(all):"<<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<<": "<<A V AILABLE[j];cout<<endl<<endl;cout<<" 各进程还需要的资源量(need):"<<endl<<endl;cout<<" 资源0"<<" 资源1"<<" 资源2"<<endl;for (i=0;i<M;i++)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;cout<<" 资源0"<<" 资源1"<<" 资源2"<<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) //函数changdata,改变可用资源和已经拿到资源和还需要的资源的值{int j;for (j=0;j<N;j++){A V AILABLE[j]=A V AILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}//////////////////////////////////////////////////////////////////////////////void rstordata(int k) //函数rstordata,恢复可用资源和已经拿到资源和还需要的资源的值{int j;for (j=0;j<N;j++){A V AILABLE[j]=A V AILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}////////////////////////////////////////////////////////////////////////////////////设计的函数//check检查安全性函数int check(int s) //函数check,检查是否安全{ int WORK[R],FINISH[W];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){WORK[j]=AVAILABLE[j];i=s;do{if(FINISH[i]==FALSE&&NEED[i][j]<=WORK[j])WORK[j]=WORK[j]+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++; }}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){cout<<endl;cout<<" 系统不安全!!! 本次资源申请不成功!!!"<<endl; cout<<endl;return 1;}}cout<<endl;cout<<" 经安全性检查,系统安全,本次分配成功。