银行家算法模拟实现课程设计
操作系统课程设计——银行家算法的模拟实现
实验报告附录3程序源代码:#include<string.h>#include<stdio.h>#include<stdlib.h># define m 50# define false 0#define true 1int no1; //进程数int no2; //资源数int r;int allocation[m][m],need[m][m],available[m],max[m][m];char name1[m],name2[m]; //定义全局变量void main(){void check();void print();int i,j,p=0,q=0;char c;int request[m],allocation1[m][m],need1[m][m],available1[m];printf("**********************************************\n");printf("* 银行家算法的设计与实现*\n");printf("**********************************************\n");printf("请输入进程总数:\n");scanf("%d",&no1);printf("请输入资源种类数:\n");scanf("%d",&no2);printf("请输入Max矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&max[i][j]); //输入已知进程最大资源需求量printf("请输入Allocation矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&allocation[i][j]); //输入已知的进程已分配的资源数for(i=0;i<no1;i++)for(j=0;j<no2;j++)need[i][j]=max[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值printf("请输入Available矩阵\n");for(i=0;i<no2;i++)scanf("%d",&available[i]); //输入已知的可用资源数print(); //输出已知条件check(); //检测T0时刻已知条件的安全状态if(r==1) //如果安全则执行以下代码{do{printf("\n请输入请求资源的进程号(0~4):\n");for(j=0;j<=no2;j++){scanf("%d",&i);if(i>=no1){printf("输入错误,请重新输入:\n");continue;}else break;}printf("\n请输入该进程所请求的资源数request[j]:\n");for(j=0;j<no2;j++)scanf("%d",&request[j]);for(j=0;j<no2;j++)if(request[j]<=need[i][j]) p=0;//判断请求是否超过该进程所需要的资源数if(p)printf("请求资源超过该进程资源需求量,请求失败!\n");else{for(j=0;j<no2;j++)if(request[j]<=available[j]) q=0; //判断请求是否超过可用资源数if(q)printf("没有做够的资源分配,请求失败!\n");else //请求满足条件{for(j=0;j<no2;j++){available1[j]=available[j];allocation1[i][j]=allocation[i][j];need1[i][j]=need[i][j];//保存原已分配的资源数,仍需要的资源数和可用的资源数available[j]=available[j]-request[j];allocation[i][j]=allocation+request[j];need[i][j]=need[i][j]-request[j];//系统尝试把资源分配给请求的进程}print();check(); //检测分配后的安全性if(r==0) //如果分配后系统不安全{for(j=0;j<no2;j++){available[j]=available1[j];allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];//还原已分配的资源数,仍需要的资源数和可用的资源数}printf("返回分配前资源数\n");print();}}}printf("\n你还要继续分配吗?Y or N ?\n");//判断是否继续进行资源分配c=getchar();}while(c=='y'||c=='Y');}}void check() //安全算法函数{int k,f,v=0,i,j;int work[m],a[m];int finish[m];r=1;for(i=0;i<no1;i++)finish[i]=false; // 初始化进程均没得到足够资源数并完成for(i=0;i<no2;i++)work[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数k=no1;do{for(i=0;i<no1;i++){if(finish[i]==false){f=1;for(j=0;j<no2;j++)if(need[i][j]>work[j])f=0;if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程{finish[i]=true;a[v++]=i; //记录安全序列号for(j=0;j<no2;j++)work[j]+=allocation[i][j]; //释放该进程已分配的资源}}}k--; //每完成一个进程分配,未完成的进程数就减1}while(k>0);f=1;for(i=0;i<no1;i++) //判断是否所有的进程都完成{if(finish[i]==false){f=0;break;}}if(f==0) //若有进程没完成,则为不安全状态{printf("系统处在不安全状态!");r=0;}else{printf("\n系统当前为安全状态,安全序列为:\n");for(i=0;i<no1;i++)printf("p%d ",a[i]); //输出安全序列}}void print() //输出函数{int i,j;printf("\n");printf("*************此时刻资源分配情况*********************\n");printf("进程名/号| Max | Allocation | Need |\n");for (i = 0; i < no1; i++){printf(" p%d/%d ",i,i);for (j = 0; j < no2; j++){printf("%d ",max[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",allocation[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",need[i][j]);}printf("\n");}printf("\n");printf("各类资源可利用的资源数为:");for (j = 0; j < no2; j++){printf(" %d",available[j]);}printf("\n");}(程序结束)附录 4程序运行调试结果:1、程序初始化2、检测系统资源分配是否安全结果。
操作系统课程设计银行家算法算法的模拟实现
枣庄学院信息科学与工程学院课程设计任务书题目银行家算法算法的模拟实现学生1: __________________________________________________学生2: __________________________________________________专业: ________________ 计算机应用技术 __________________课程: ________________ 操作系统 _________________________指导教师:__________ 职称: ________________完成时间:2014年12月----2015年1月枣庄学院信息科学与工程学院制2014年12月10日课程设计任务书及成绩评定课程设计的任务和具体要求操作系统课程设计是操作系统课程学习的延续。
主要目的是配合操作系统课程的学习,对Linux操作系统有一定掌握,能够熟练操作,并能在Linux系统下模拟实现操作系统的功能,有助于对操作系统的理解。
本次课程设计共分两部分,其中第一部分为操作题,同学们需要对Linux的基本的命令(常用的几个,讲课的时候强调的),这部分,任课教师实时检查,让学生用命令完成一定的功能,然后,根据完成情况评定成绩。
第二部分为编程设计题,每组同学必须独立完成,可以选择进程调度,也可以根据自己的兴趣,选择模拟实现磁盘调度、银行家算法、页面置换算法等。
指导教师签字:_________________ 日期: ______________________________指导教师评语成绩:______________ 指导教师签字: _______________________ 日期: _____________目录1引言1.1linux 及其特点 .................. ... .. (4)1.1.1Linux 的概述 (4)1.2Linux 的结构 (4)1.3Linux 的版本............. ... . (5)2常用命令基本介绍2.1Linux目录命令 (5)2.2Linux文件命令 ...... (5)3银行家算法3.1实验目的......... (6)3.2实验内容.......................... ................................................................ .. (6)3.3实验方法........................................................................................... .. (7)3.3.1算法流程图............................................................................ ....... .. (7)3.3.2算法数据结构 (7)3.4实验代码........................................................................................................................................ …3.5运行示例 (17)4实验小结................................................................................................................................... .. (17)实用程序:的Linux标准系统都有一套称为应用程序的程序集,它们是专门的程序,包括文本编辑器,编程语言,X Win dow,办公套件,In ternet工具,数据库等1.3Lin ux 的版本:内核版本:根据约定,次版本号为奇数时,表示该版本加入新内容,但不一定很稳定,相当于测试版;次版本号为偶数时,表示这是一个可以使用的稳定版本。
操作系统课程设计报告银行家算法的设计与实现(java语言)
操作系统课程设计报告-银行家算法的设计与实现(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、提高学生的程序设计能力、提高算法设计质量与程序设计素质 ;设计任务 (在规定的时间内完成下列任务)思想:将一定数量的资金供多个用户周转使用,当用户对资金的最大申请量不超过现存资金时可接纳一个新客户,客户可以分期借款,但借款总数不能超过最大的申请量。
银行家对客户的借款可以推迟支付,但是能够使客户在有限的时间内得到借款,客户得到所有的借款后能在有限的时间内归还。
用银行家算法分配资源时,测试进程对资源的最大需求量,若现存资源能满足最大需求就满足当前进程的申请,否则推迟分配,这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束,然后归还资源,若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。
1. 需求分析1.1 课程设计题目编程序模拟银行家算法1.2 课程设计目的`1、银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
2、提高自己的程序设计能力、提高算法设计质量与程序设计素质;1.3 课程设计任务及要求思想:将一定数量的资金供多个用户周转使用,当用户对资金的最大申请量不超过现存资金时可接纳一个新客户,客户可以分期借款,但借款总数不能超过最大的申请量。
银行家对客户的借款可以推迟支付,但是能够使客户在有限的时间内得到借款,客户得到所有的借款后能在有限的时间内归还。
银行家算法在系统在分配资源时自始自终地做出正确的选择,这样可以避免死锁的发生。
用银行家算法分配资源时,测试进程对资源的最大需求量,若现存资源能满足最大需求就满足当前进程的申请,否则推迟分配,这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束,然后归还资源,若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。
编程模拟银行家算法实验报告
武汉理工大学华夏学院课程设计报告书课程名称:操作系统原理题目:编程序模拟银行家算法系名:信息工程系专业班级:计应2091姓名:王汝平学号: 10225509118 指导教师:苏永红2011 年 7 月 6 日课程设计任务书学生姓名:王汝平专业班级:计应2091指导教师:苏永红工作单位:信息工程系设计题目:编程序模拟银行家算法初始条件:Linux操作系统,GCC编译环境要求完成的主要任务:主要任务:银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
思想:将一定数量的资金供多个用户周转使用,当用户对资金的最大申请量不超过现存资金时可接纳一个新客户,客户可以分期借款,但借款总数不能超过最大的申请量。
银行家对客户的借款可以推迟支付,但是能够使客户在有限的时间内得到借款,客户得到所有的借款后能在有限的时间内归还。
用银行家算法分配资源时,测试进程对资源的最大需求量,若现存资源能满足最大需求就满足当前进程的申请,否则推迟分配,这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束,然后归还资源,若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。
设计报告撰写格式要求:1设计题目与要求 2 设计思想3系统结构 4 数据结构的说明和模块的算法流程图5 使用说明书(即用户手册):内容包含如何登录、退出、读、写等操作说明6 运行结果和结果分析(其中包括实验的检查结果、程序的运行情况)7 自我评价与总结 8 附录:程序清单,注意加注释(包括关键字、方法、变量等),在每个模块前加注释;时间安排7月 4日布置课程设计任务;分配题目后,查阅资料、准备程序;7月 5 ~7月7 日上机调试程序、书写课程设计报告;7月8 日提交课程设计报告及相关文档。
指导教师签名:2011年7月2日系主任签名:2011年7月3日目录1.需求分析 (4)1.1课程设计题目 (4)1.2课程设计目的 (4)1.3设计任务 (4)1.4设计思想 (4)2.设计思想和过程 (5)2.1 概要设计 (5)2.2程序源代码 (7)3.调试及运行结果 (13)4.实验心得体会 (15)5.参考文献 (15)1.需求分析1.1课程设计题目:编程序模拟银行家算法1.2设计目的1.2.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()函数:完成对系统运行环境的初始化,定义了简单的选择菜单,调用各功能函数。
精品课程银行家算法的模拟实现
精品课程银行家算法的模拟实现1 课设简介:1.1 课程设计题目银行家算法的模拟实现1.2 课程设计目的通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。
1.3 课程设计内容模拟实现动态资源分配。
同时要求编写和调试一个系统动态资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生。
2 实验原理分析:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
死锁的产生,必须同时满足四个条件,即一个资源每次只能由一个进程张勇;第二个为等待条件,即一个进程请求资源不能满足时,它必须等待,单它仍继续宝石已得到的所有其他资源;第三个为非剥夺条件,即在出现死锁的系统中一定有不可剥夺使用的资源;第四个为循环等待条件,系统中存在若干个循环等待的进程,即其中每一个进程分别等待它前一个进程所持有的资源。
防止死锁的机构只能确保上述四个条件之一不出现,则系统就不会发生死锁。
通过这个算法可以用来解决生活中的实际问题,如银行贷款等。
3 程序结构分析:3.2 程序模块划分3.2.1.银行家算法:设进程i提出请求Request[n],则银行家算法按如下规则进行判断。
(1)如果Request[n]>Need[i,n],则报错返回。
(2)如果Request[n]>Available,则进程i进入等待资源状态,返回。
(3)假设进程i的申请已获批准,于是修改系统状态:Available=Available-RequestAllocation=Allocation+RequestNeed=Need-Request(4)系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待。
3.2.2.安全性检查(1)设置两个工作向量Work=Available;Finish[M]=False(2)从进程集合中找到一个满足下述条件的进程,Finish [i]=FalseNeed<=Work如找到,执行(3);否则,执行(4)(3)设进程获得资源,可顺利执行,直至完成,从而释放资源。
操作系统课程设计——银行家算法的模拟实现
信息科学与工程学院课程设计任务书题目:银行家算法的模拟实现学号:姓名:专业:课程:指导教师:完成时间:2012年5月----2012年6月信息科学与工程学院制2012 年6 月20 日目录1. 课设简介 (2)2. 实验原理分析 (2)3. 程序结构分析 (4)4. 数据结构分析 (6)5.各子模块相关函数代码 (9)6. 程序运行结果分析 (20)7. 心得体会 (30)8. 参考文献 (31)银行家算法的模拟实现1 课设简介:1.1 课程设计题目银行家算法的模拟实现1.2 课程设计目的1.2.1了解进程产生死锁原因,了解为什么要进行死锁的避免。
1.2.2掌握银行家算法的数据结构,了解算法的执行过程,加深对银行家算法的理解。
1.3 课程设计内容设计一个n 个并发进程共享m 个系统资源的系统。
进程可动态申请资源和释放资源,系统按各进程的申请动态的分配资源。
要求采用银行家算法实现。
2 实验原理分析:2.1 整个银行家算法的思路先对用户提出的请求进行合法性检查,再进行预分配,利用安全性检查算法进行安全性检查。
2.2 算法用到的主要数据结构和C语言说明。
2.2.1可利用资源向量 INT AVAILABLE[M] M为资源的类型。
2.2.2最大需求矩阵 INT MAX[N][M] N为进程的数量。
2.2.3已分配矩阵 INT ALLOCATION[N][M]2.2.4还需求矩阵 INT NEED[N][N]2.2.5申请各类资源数量int Request[x];2.2.6工作向量 int Work[x];2.2.7 int Finish[y]; //是否有足够的资源分配给进程,0为否,非0为是2.3 银行家算法主程序2.3.1系统初始化。
调用函数 chushihua(),输入进程数量,资源种类,各资源可用数量,各进程已分配、最大需求各资源数量等2.3.2安全性算法调用函数safe()检查当前资源分配状态。
操作系统课程设计银行家算法模拟实现
操作系统课程设计银行家算法模拟实现操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导老师完成日期信息工程学院题目:银行家算法的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进展的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统根底理论和重要算法的理解,加强学生的动手才能。
二、设计内容 1〕概述用C或C++语言编制银行家算法通用程序,并检测所给状态的系统平安性。
1.算法介绍:数据构造:1〕可利用资向量 Available;2〕最大需求矩阵Max;3〕分配矩阵Allocation;4〕需求矩阵Need 2.功能介绍模拟实现Dijkstra的银行家算法以防止死锁的出现,分两局部组成:第一局部:银行家算法〔扫描〕;第二局部:平安性算法。
2〕设计原理一.银行家算法的根本概念 1、死锁概念。
在多道程序系统中,虽可借助于多个进程的并发执行,来改善系统的资利用率,进步系统的吞吐量,但可能发生一种危险━━死锁。
所谓死锁(Deadlock),是指多个进程在运行中因争夺资而造成的一种僵局(Deadly_Embrace),当进程处于这种僵持状态时,假设无外力作用,它们都将无法再向前推进。
一组进程中,每个进程都无限等待被该组进程中另一进程所占有的资,因此永远无法得到的资,这种现象称为进程死锁,这一组进程就称为死锁进程。
2、关于死锁的一些结论:Ø参与死锁的进程最少是两个Ø〔两个以上进程才会出现死锁〕Ø参与死锁的进程至少有两个已经占有资Ø参与死锁的所有进程都在等待资Ø参与死锁的进程是当前系统中所有进程的子集注:假如死锁发生,会浪费大量系统资,甚至导致系统崩溃。
3、资分类。
永久性资:可以被多个进程屡次使用〔可再用资〕l 可抢占资 l 不可抢占资临时性资:只可使用一次的资;如信号量,中断信号,同步信号等〔可消耗性资〕“申请--分配--使用--释放”形式 4、产生死锁的四个必要条件:互斥使用〔资独占〕、不可侵占〔不可剥夺〕、恳求和保持〔局部分配,占有申请〕、循环等待。
操作系统课程设计模拟银行家算法避免死锁
模拟通过银行家算法避免死锁一、银行家算法产生的背景及目的1: 在多道程序系统中, 虽然借助于多个进程的并发执行来改善系统的运用率, 提高系统的吞吐量, 但也许发生一种危险—死锁。
死锁就是多个进程在运营过程中因争夺资源而导致的一种僵局, 当进程处在这种僵局状态时, 如无外力作用, 他们将无法再向前进行, 如再把信号量作为同步工具时, 多个Wait和Signal操作顺序不妥, 会产生进程死锁。
然而产生死锁的必要条件有互斥条件, 请求和保持条件, 不剥夺条件和环路等待条件。
在防止死锁的几种方法中, 都施加了较强的限制条件, 在避免死锁的方法中, 所施加的条件较弱, 有也许获得令人满意的系统性能。
在该方法中把系统的状态分为安全状态和不安全状态, 只要能使系统都处在安全状态, 便可避免死锁。
2:实验目的:让学生独立的使用编程语言编写和调试一个系统分派资源的简朴模拟程序, 了解死锁产生的因素及条件。
采用银行家算法及时避免死锁的产生, 进一步理解课堂上老师讲的相关知识点。
银行家算法是从当前状态出发, 逐个按安全序列检查各客户中谁能完毕其工作, 然后假定其完毕工作且归还所有贷款, 再进而检查下一个能完毕工作的客户。
假如所有客户都能完毕工作, 则找到一个安全序列, 银行家才是安全的。
二: 银行家算法中的数据结构1:可运用资源向量Available。
这是一个具有m个元素的数组, 其中的每个元素代表一类可运用的资源数目, 其初始值是系统中所配置的该类所有可用资源的数目, 其数值随该类资源的分派和回收而动态的改变。
假如Available[j]=k, z则表达系统中现有Rj类资源K 个。
2: 最大需求矩阵Max。
这是一个n*m的矩阵, 它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
假如Max[i,j]=k, 表达第i个进程需要第Rj类资源的最大数目k个.3: 分派矩阵Allocation,也是n*m的矩阵, 若Allocation[i,j]=k,表达第i个进程已分派Rj类资源的数目为k个。
银行家算法课程设计报告
《计算机操作系统》课程设计报告书选题:银行家算法模拟姓名:包玉霞学号: 1班级:软件1001指导老师:徐向英2012年6月目录一. 课程设计目的二. 课题内容三. 设计思路四. 源代码五. 运行与测试六. 心得体会1.设计目的计算机系统中有很多资源,在多道程序设计环境中,若干程序往往要共享这些资源,而一个进程所需的资源不止一个,这样,系统就会容易发生死锁现象。
然而系统产生死锁不仅浪费大量的系统资源,甚至导致整个系统的崩溃,带来灾难性的后果。
而银行家算法是最具有代表性的避免死锁的一种重要方法,如果在并发执行的进程中能够寻找一个安全序列,则系统按照此序列分配资源,系统就不会产生死锁现象。
2.课题内容1.复习银行家算法,设计一个具有若干(不少于3种)资源和若干(不少于5个)进程的系统。
2.定义系统的初始状态,即进程获得的资源数,还需要的资源数以及系统可用的资源数。
3.以用户输入的方式提出资源请求,并用银行家算法避免可能发生的死锁,若系统安全,允许用户继续申请资源。
4.设计的系统要求结构清晰,与用户的交互界面友好,能动态地实现资源的申请和分配。
3.设计思路银行家算法可分为几个主要的功能模块,其描述如下:1.初始化由用户输入数据,分别对运行的进程数、总的资源种类数、总资源数、各进程所需要的最大资源数量(Max),已分配的资源数量赋值。
初始化算法流程图:2.安全性检查算法(1)设置两个工作向量Work=AVAILABLE;FINISH=false;(2)从进程集合中找到一个满足下述条件的进程,FINISH==false;NEED<=Work;如找到,执行(3);否则,执行(4)(3)设进程获得资源,可顺利执行,直至完成,从而释放资源。
Work+=ALLOCATION;Finish=true;(4).如所有的进程Finish= true,则表示安全;否则系统不安全。
安全性算法流程图:3.银行家算法在避免死锁的方法中,所施加的限制条件较弱,有可能获得令人满意的系统性能。
银行家算法的实现课程设计报告
《操作系统》课程设计报告设计题目:银行家算法的实现姓名:梅济民学号: 2012015014 同组人姓名:赵宇昊学号: 2012012962班级: 2012级信息与计算科学完成日期: 2015年 11 月 12 日银行家算法分析、设计与实现一、理论描述银行家算法要求每个进程的最大资源需求,其基本思想是:始终保持系统处于安全状态,当设计进程提出资源请求时,系统先进行预分配,再判断系统分配后是否仍然处于安全状态。
如果仍然处于安全状态,就进行实际分配;如果处于不安全状态,则拒绝该进程的资源请求。
二、算法描述及数据结构模型#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;//资源的最大数为10三、源代码void showdata()//显示资源矩阵{int i,j;printf("系统目前可用的资源[Avaliable]:\n");for(i=0;i<N;i++)printf("%c ",name[i]);printf("\n");for (j=0;j<N;j++)printf("%d ",Avaliable[j]);//输出分配资源printf("\n");printf(" Max Allocation Need \n"); printf("进程名");for(j=0;j<3;j++){for(i=0;i<N;i++)printf("%c ",name[i]);printf(" ");}printf("\n");for(i=0;i<M;i++){printf(" %d ",i);for(j=0;j<N;j++)printf("%d ",Max[i][j]);printf(" ");for(j=0;j<N;j++)printf("%d ",Allocation[i][j]);printf(" ");for(j=0;j<N;j++)printf("%d ",Need[i][j]);printf("\n");}}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){printf("系统不安全\n");//不成功系统不安全return -1;}}printf("系统是安全的!\n");//如果安全,输出成功printf("分配的序列:");for(i=0;i<M;i++){//输出运行进程数组printf("%d",temp[i]);if(i<M-1) printf("->");}printf("\n");return 0;}void share()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch='y';printf("请输入要求分配的资源进程号(0-%d):",M-1);scanf("%d",&i);//输入须申请的资源号printf("请输入进程%d 申请的资源:\n",i);for(j=0;j<N;j++){printf("%c:",name[j]);scanf("%d",&Request[j]);//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错{printf("进程%d申请的资源大于它需要的资源, 分配不合理,不予分配!\n",i);ch='n';break;}else {if(Request[j]>Avaliable[j])//判断申请是否大于当前资源,若大于则出错{printf("进程%d申请的资源大于系统现在可利用的资源\n",i);printf(" 分配出错,不予分配!\n");ch='n';break;}}}if(ch=='y') {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}int main()//主函数{int i,j,q,choice,m,n,flag;char ming;printf("请首先输入系统可供资源种类的数量:");scanf("%d",&n);N=n;for(i=0;i<n;i++){printf("资源%d的名称:",i+1);scanf("%s",&ming);name[i]=ming;printf("资源%d的数量:",i+1);scanf("%d",&q);Avaliable[i]=q;}// printf("\n");printf("请输入作业的数量:");scanf("%d",&m);M=m;printf("请输入各进程的最大需求量%d*%d矩阵[Max]:\n",m,n);for(i=0;i<m;i++){for(j=0;j<n;j++)scanf("%d",&Max[i][j]);//printf("\n");}do{flag=0;printf("请输入各进程已经申请的资源量(%d*%d矩阵)[Allocation]:\n",m,n);for(i=0;i<m;i++)for(j=0;j<n;j++){scanf("%d",&Allocation[i][j]);if(Allocation[i][j]>Max[i][j]) flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)printf("申请的资源大于最大需求量,请重新输入!\n");}while(flag);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){printf("\n");printf(" 0:离开\n");printf(" 1:分配资源\n");printf("请选择功能号:");scanf("%d",&choice);switch(choice){case 1: share();break;case 0: break;default: printf("请正确选择功能号(0-1)!\n");break;}}return 1;四、程序运行结果及分析时刻的资源分配表(各种资源的数量分别为:10、5、7) T运行结果五、课程设计心得与体会通过这次实验,我了解了银行家算法的原理,在编写和调试程序过程中,我的算法和编程能力提高了很多六.参考文献:《计算机操作系统》第四版,《C程序设计教程》谭浩强。
模拟银行家算法实现死锁避免课程设计报告
模拟银行家算法实现死锁避免课程设计报告《操作系统》课程设计报告院系:计算机与信息工程学院题目:模拟银行家算法实现死锁避免评分表:目录题目:模拟银行家算法实现死锁避免 (1)评分表: (2)一课程设计目的 (3)二课程设计内容 (3)三课程设计环境 (4)四课程设计步骤 (4)41.需求分析 (4)4.1.1 问题的提出 (4)4.1.2 银行家算法原理 (4)4.1.3银行家算法详细解析 (5)4.1.4 银行安全性算法目的 (6)4.2概要设计 (6)4.2.1 功能模块设计如下: (6)4.2.2 功能模块描述 (7)4.3详细设计 (7)4.3.1基本数据结构的设计 (7)4.3.2算法的设计 (8)五课程设计结果 (9)5.1运行结果 (9)5.2测试分析 (12)六课程设计心得与体会 (12)总结 (12)七参考文献 (13)八程序清单 (14)8.1 操作主界面代码: (14)8.2 功能实现代码: (17)一课程设计目的在熟练掌握死锁发生原理和解决死锁问题的基础上,利用一种程序设计语言模拟实现利用银行家算法实现死锁避免,一方面加深对原理的理解,另一方面提高学生通过编程根据已有原理解决实际问题的能力,为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。
二课程设计内容模拟实现银行家算法对系统资源进行分配,以防止死锁的出现。
本课题肯定不可能实现对实际操作系统的资源管理,而是通过对模拟资源数据的处理,检测银行家算法在防止死锁出现的作用。
银行家算法描述:第一部分:银行家算法(扫描)1.如果Request<=Need,则转向2;否则,出错2.如果Request<=Available,则转向3,否则等待3.系统试探分配请求的资源给进程4.系统执行安全性算法第二部分:安全性算法1.设置两个向量(1).工作向量:Work=Available(表示系统可提供给进程继续运行所需要的各类资源数目)(2).Finish:表示系统是否有足够资源分配给进程(True:有;False:没有).初始化为False2.若Finish[i]=False&&Need<=Work,则执行3;否则执行4(i为资源类别)3.进程P获得第i类资源,则顺利执行直至完成,并释放资源:Work=Work+Allocation;Finish[i]=true;转2请充分理解以上银行家算法描述的核心思想。
操作系统课程设计银行家算法模拟实现
课程设计报告课程设计名称:银行家算法模拟实现系:学生姓名:班级:学号:成绩:指导教师:开课时间:学年学期题目要求:一.设计题目银行家算法模拟实现二.主要内容设计目的1、了解多道程序系统中,多个进程并发执行的资源分配。
2、掌握思索的产生原因、产生死锁的必要条件和处理死锁的基本方法。
3、掌握预防死锁的方法,系统安全状态的基本概念。
4、掌握银行家算法,了解资源在进程并发执行中的资源分配策略。
5、理解死锁避免在当前计算机系统不常使用的原因。
三.具体要求设计一个n个并发进程共享m个系统资源的系统,进程可动态申请资源和释放资源,系统按各进程的申请动态的分配资源。
要求采用银行家算法实现。
四.进度安排五.成绩评定考核方法:根据学生平时表现、测试检查、课程设计报告、运行演示和学生回答问题相结合的形式作为考核依据,考察学生的动手能力,独立分析解决问题的能力和创新精神,并根据学生的学习态度综合考评。
平时表现(占30%),课程设计报告(占40%),课程答辩(占30%)。
成绩评定:成绩分“优秀”、“良好”、“中等”、“及格”、“不及格”五个级别。
“优秀”为100分到90分,“良好”为89分到80分,“中等”为79分到70分,“及格”为69分到60分,“不及格”为60分以下。
目录1.需求分析 (4)2.概要设计 (4)3.详细设计 (6)4.调试分析 (12)5.总结 (16)6.参考文献 (16)1.需求分析1、始化这组进程的最大资源请求和一次申请的资源序列。
把各进程已占用和需求资源情况记录在进程控制块中。
假定进程控制块的内容包括:进程名,状态,当前申请量,资源需求总量,已占资源量,能执行完标志。
其中,进程的状态有:就绪,等待和完成。
当系统不能满足进程的资源请求时,进程出于等待状态。
资源需求总量表示进程运行过程中对资源的总的需求量。
已占资源量表示进程目前已经得到但还为归还的资源量。
因此,进程在以后还需要的剩余资源量等于资源需要总量减去已占资源量。
银行家算法(用C语言实现)课程设计报告
课程设计报告题目银行家算法程序设计课程名称操作系统课程设计院部名称信息技术学院专业计算机科学与技术班级学生姓名* *学号**********课程设计地点课程设计学时20指导教师* ********教务处制操作系统课程设计报告摘要Dijkstra提出的银行家算法,是最具代表性的避免死锁的算法。
本文对如何用银行家算法来处理操作系统给进程分配资源做了详细的说明,包括需求分析、概要设计、详细设计、测试与分析、总结、源程序清单。
首先做了需求分析,解释了什么是银行家算法,并指出它在资源分配中的重要作用。
然后给出了银行家算法的概要设计,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等。
在概要设计的基础上,又给出了详细的算法设计,实现概要设计中定义的所有函数,对每个函数写出核心算法,并画出了流程图。
接着对编码进行了测试与分析(并在最后附上Java编写的程序代码)。
最后对整个设计过程进行了总结。
关键词:安全状态;安全序列;银行家算法;安全性算法;安全序列;流程图。
目录摘要 (1)目录 (2)1.绪论 (3)1.1前言 (3)1.2研究意义 (4)1.3结构安排 (4)2.需求分析 (5)2.1题目描述 (5)2.2银行家算法 (5)2.3基本要求 (5)2.4目的 (6)3.概要设计 (7)3.1设备环境 (7)3.2算法思路 (7)3.3银行家算法步骤 (7)3.4安全性算法步骤 (8)3.5数据结构 (9)3.6系统结构图 (12)4.详细设计 (13)4.1主要函数的核心代码 (13)4.2程序流程图 (13)5.测试 (16)5.1测试用例 (16)5.2测试结果截图 (17)6.总结 (22)参考文献 (24)致谢 (25)附录 (26)1绪论1.1前言:Dijkstra (1965)提出了一种能够避免死锁的调度算法,称为银行家算法。
它的模型基于一个小城镇的银行家,他向一群客户分别承诺了一定的贷款额度,每个客户都有一个贷款额度,银行家知道不可能所有客户同时都需要最大贷款额,所以他只保留一定单位的资金来为客户服务,而不是满足所有客户贷款需求的最大单位。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
其占有的全部资源归还给系统。 重复第a)步和第b )步,直到所有进程都标记为终止进程,或直到一个 死锁发生。若所有进程都标记为终止进程,则系统的初始状态是安全 的,否则为不安全的。若安全,则正式将资源分配给它,否则假定的分 配作废,让其等待。
2
实验原理分析:
2.1 算法的来源及基本思想 银行家算法,顾名思义是来源于银行的借贷业务,通过这个算法可 以用来解决生活中的实际问题,如银行贷款等。一定数量的本金要应多 个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷 款,必须考察其是否能限期归还。在操作系统中研究资源分配策略时也 有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资 源的进程能在有限的时间内归还资源,以供其他进程使用资源。如果资 源分配不得到就会发生进程循环等待资源,则进程都无法继续执行下去 的死锁现象。 2.2 死锁产生的条件 银行家算法是用来避免死锁的一种重要方法,通过编写一个简单的 银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和 了解死锁和避免死锁的具体实施方法。 死锁的产生,必须同时满足四个条件: A、即一个资源每次只能由一个进程使用; B、第二个为等待条件,即一个进程请求资源不能满足时,它必须 等待,单它仍继续宝石已得到的所有其他资源; C、第三个为非剥夺条件,即在出现死锁的系统中一定有不可剥夺 使用的资源; D、第四个为循环等待条件,系统中存在若干个循环等待的进程,
4
-7
5
-8
6
- 14
7
计简介:
1.1 课程设计题目 银行家算法的模拟实现。应用银行家算法验证进程安全性检查及分 配资源。 1.2 课程设计目的
本设计的目的是通过编写和调试一个系统动态分配资源的简单模 拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免 死锁地发生。 A、了解进程产生死锁的原因,了解为什么要进行死锁的避免。 B、掌握银行家算法的数据结构,了解算法的执行过程,加深对银 行家算法的理解。 1.3 课程设计要求 设计一个n 个并发进程共享m 个系统资源的系统。进程可动态申请资源 和释放资源,系统按各进程的申请动态的分配资源。要求采用银行家算 法实现。 (1) 初始化这组进程的最大资源请求和依次申请的资源序列。把各 进程已占用和需求资源情况记录在进程控制块中。假定进程控 制块的内容包括:进程名,状态,当前申请量,资源需求总 量,已占资源量,能执行完标志。其中,进程的状态有:就 绪、等待和完成。当系统不能满足进程的资源请求时,进程处 于等待态。资源需求总量表示进程运行过程中对资源的总的需 求量。 已占资源量表示进程目前已经得到但还未归还的资源量。因此,进程 在以后还需要的剩余资源量等于资源需要总量减去已占资源量。显 然每个进程的资源需求总量不应超过系统拥有的资源总量。 (2) 银行家算法分配资源的原则是:当某个进程提出资源请求时, 假定先分配资源给它,然后查找各进程的剩余请求,检查系统 的剩余资源量是否由于进程的分配而导致系统死锁。若能,则 让进程等待,否则,让进程的假分配变为真分配。 (a) 查找各进程的剩余请求,检查系统的剩余资源量是否能满 足其中一进程。如果能,则转b)。 (b) 将资源分配给所需的进程,这样,该进程已获得资源最大 请求,最终能运行完成。标记这个进程为终止进程,并将
即其中每一个进程分别等待它前一个进程所持有的资源。 防止死锁的机构只能确保上述四个条件之一不出现,则系统就不会发生 死锁。银行家算法是避免死锁的方法中,施加的限制条件较弱的,有利 于获得令人满意的系统性能的方法。在该方法中把系统的状态分为安全 状态和不安全状态,只要能使系统始终都处于安全状态,便可以避免发 生死锁。 2.3 模拟进程申请资源 把一个进程需要和已占有资源的情况记录在进程控制中,假定进程 控制块PCB其中“状态”有就绪态、等待态和完成态。当进程在处于等 待态时,表示系统不能满足该进程当前的资源申请。“资源需求总 量”表示进程在整个执行过程中总共要申请的资源量。显然,,每个进 程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分 配可以避免死锁.
5 代码设计:
#include<string.h>
#include<stdio.h> #include<stdlib.h> #define FALSE 0 #define TRUE 1 #define W 10 #define R 20 int M ; //总进程数 int N ; //资源种类 int ALL_RESOURCE[W];//各种资源的数目总和 int MAX[W][R]; //M个进程对N类资源最大资源需求量 int AVAILABLE[R]; //系统可用资源数 int ALLOCATION[W][R]; //M个进程已经得到N类资源的资源量 int NEED[W][R]; //M个进程还需要N类资源的资源量 int Request[R]; //请求资源个数 void showdata() //函数showdata,输出资源分配情况 { int i,j; printf("\n\n各种资源的总数量(all):\n"); for (j=0;j<N;j++) printf(" 资源 %d: %d\n",j+1,ALL_RESOURCE[j]); printf("\n\n"); printf("系统目前各种资源可用的数为(available):\n"); for (j=0;j<N;j++) printf(" 资源 %d: %d\n", j+1, AVAILABLE[j]); printf("\n\n"); printf("各进程还需要的资源量(need):\n\n"); printf(" 进程 "); for(i=0;i<N;i++) printf(" 资源%d ",i+1); printf("\n"); for (i=0;i<M;i++) { printf("进程p%d:",i+1); for (j=0;j<N;j++) printf(" %d ",NEED[i][j]); printf("\n");
全。 3. 银行家算法 在避免死锁的方法中,所施加的限制条件较弱,有可能 获得令人满意的系统性能。在该方法中把系统的状态分为安 全状态和不安全状态,只要能使系统始终都处于安全状态, 便可以避免发生死锁。 银行家算法的基本思想是分配资源之前,判断系统是否是 安全的;若是,才分配。它是最具有代表性的避免死锁的算 法。 设进程j提出请求REQUEST [i],则银行家算法按如下 规则进行判断。 (1).如果REQUEST [j] [i]<= NEED[j][i],则转(2);否 则,出错。 (2).如果REQUEST [j] [i]<= AVAILABLE[j][i],则转(3); 否则,出错。 (3).系统试探分配资源,修改相关数据: AVAILABLE[i]-=REQUEST[j][i]; ALLOCATION[j][i]+=REQUEST[j][i]; NEED[j][i]-=REQUEST[j][i]; 用到的数据结构: 实现银行家算法要有若干数据结构,它们用来表示资源分配系统的 状态。令n表示系统中进程的数目,m表示资源的分类数。还需要以下数 据结构: 1).Available是一个长度为m的向量,它表示每类资源可用的数量。 Available [j]=k,表示j类资源可用的数量为k。 2).Max是一个n×m矩阵,它表示每个进程对资源的最大需求。Max [i,j]=k,表示进程pi至多可以申请k个j类资源单位。 3).Allocation是一个n×m矩阵,它表示当前分给每个进程的资源数 目。Allocation [i,j]=k,表示进程i当前分到k个j类资源。 4).Need是一个n×m矩阵,它表示每个进程还缺少多少资源。 Need[i,j]=k,表示进程pi尚需k个j类资源才能完成其任务。显然 Need[i,j]= Max [i,j]- Allocation [i,j]。
盐城工学院
计算机操作系统程序设计 课程考核报告 银行家算法模拟实现
班 级: 09软件(1) 学 号: 姓 名: 指导老师:
2011年12月 19日
目录
1. 课程设计简介---------------------------------------------1.1课程设计题目------------------------------------------------------------- 3 1.2课程设计目的-----------------------------------------3 1.3 课程设计要求----------------------------------------3 实验原理分析------------------------------------------
3
概要设计:
银行家算法可分为个主要的功能模块,其描述如下: 1.初始化 由用户输入数据,分别对运行的进程数、总的资源种类 数、总资源数、各进程所需要的最大资源数量(Max),已分配 的资源数量赋值。 2.安全性检查算法 (1)设置两个工作向量Work=AVAILABLE;FINISH=false; (2)从进程集合中找到一个满足下述条件的进程, FINISH==false; NEED<=Work; 如找到,执行(3);否则,执行(4) (3)设进程获得资源,可顺利执行,直至完成,从而释放资源。 Work+=ALLOCATION; Finish=true; (4).如所有的进程Finish= true,则表示安全;否则系统不安
4 详细设计:
1主函数main()
要求在主函数中输入运行的进程数、总的资源种类数、总 资源数、各进程所需要的最大资源数量(Max),已分配的资源 数量,并对这些数据进行有效性检验,不符合条件的数据要进 行重新输入。 2函数showdata( ) Showdata()函数用来输出资源的分配情况。对各进程资源的总 数量、系统目前可利用的资源数量、各进程还需要的资源数量及各 进程已分配的资源数量进行输出。 3函数bank( ) Bank()函数为银行家算法,对需申请资源的进程号j和所要申请 的资源数量Request[j]进行输入,并分别将Request[j]与Need[i][j] 和Available[j]进行比较,观察所要申请的资源数目是否合理。如 合理,则判断此时系统是否安全,若安全则输出资源的分配情况, 否则输出原来的系统资源分配情况,重新输入申请资源的数量。 4函数changdata( ) Changdata()函数用来改变可用资源和已经拿到资源和还需要的 资源的值。当申请的资源数目合理时,对现在的系统资源分配情况 进行刷新。 5函数chkerr() Chkerr()函数用来检查系统此时的安全性。如果系统能够找 到一个安全执行的序列,则各进程能正常运行终结,否则,此进程 进入阻塞状态。 6函数 rstordata( ) Changdata()函数,改变可用资源和已经拿到资源和还需要的资 源的值。若判断出申请资源后系统是安全的,则要改变系统现在的 资源分配情况: Available[j]= Available[j]+Request[j]; Allocation[k][j]= Allocation [k][j]-Request[j]; Need[k][j]=Need[k][j]+Request[j]