基于java的实验——银行家算法

合集下载

操作系统——银行家算法(java实现)

操作系统——银行家算法(java实现)

操作系统——银⾏家算法(java实现)1.数据结构1. 可利⽤的资源向量Available:⼀个含有m个元素的数组,其中每⼀个元素代表⼀类可利拥的资源数⽬,其初始值是系统中所配置的该类全部可⽤资源数⽬,其数值随该类资源的分配改变⽽改变。

如果Available[j]=K,则表⽰系统中现有R j类资源K个。

2. 最⼤需求矩阵Max:⼀个n×m的矩阵,它定义了系统中n个进程中的每⼀个进程对m类资源的最⼤需求。

如果Max[i,j]=K,则表⽰进程i需要R j类资源的最⼤数⽬为K。

3. 分配矩阵Allocation:⼀个n×m的矩阵,它定义了系统中每⼀类资源当前已分配给每⼀进程的资源数。

如果Allocation[i,j]=K,则表⽰进程i当前已分得R j类资源的数⽬为K。

4. 需求矩阵Need:⼀个n×m的矩阵,⽤以表⽰每⼀个进程尚需的各类资源数。

如果Need[i,j]=K,则表⽰进程i还需要R j类资源K个⽅能完成其任务。

Need[i,j]=Max[i,j]-Allocation[i,j]2.银⾏家算法在避免死锁的⽅法中,所施加的限制条件较弱,有可能获得令⼈满意的系统性能。

在该⽅法中把系统的状态分为安全状态和不安全状态,只要能使系统始终都处于安全状态,便可以避免发⽣死锁。

银⾏家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。

它是最具有代表性的避免死锁的算法。

设进程cusneed提出请求REQUEST [i],则银⾏家算法按如下规则进⾏判断。

(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i],则转(2);否则,出错。

(2)如果REQUEST [cusneed] [i]<= AVAILABLE[i],则转(3);否则,等待。

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

银行家算法实验报告

银行家算法实验报告

答卷封面(COVER)评阅结果Final mark评阅人Examiner课程名称(Subject):操作系统课程设计编号(No.):12-13-1-050154系别(Department): 信息科学系专业(Major):计算机科学与技术姓名(Name):王静学号(Student’s Number):BC10331133注意事项(Notes)1.考生需将上述有关项目填写清楚。

2.字迹要清楚,保持卷面清洁。

3.交卷时请将本答卷和题签一起上交,题签作为封面下一页装订。

1、Candidates should fill in the information appropriately.2、Keep the handwriting clear and the paper tidy.3、Candidate should hand in this cover and paper together; the answer sheet should be attached to the cover.机密(Confidential)编号(No.):12-13-1-050154试题(Test)课程名称(Subject):操作系统课程设计考核类别(Type of test):考查课程类别(Type of course) : 实践环节考试形式(Test type) : 论文使用范围(Target group):计算机科学与技术要求:一、通过本课程设计,使学生在上机实验中体会计算机操作系统的基本原理,训练学生模拟实现操作系统管理和控制资源的能力。

二、学生可在下列13个题目中任选1个。

(1)先来先服务调度算法、短作业优先调度算法、时间片轮转调度算法、优先级调度算法(2)生产者-消费者问题(3)最先适应算法、最佳适应算法、最坏适应算法(4)先进先出算法、最久未使用淘汰算法、理想淘汰算法(5)银行家算法(6)小型文件系统三、模拟实现算法在Windows平台下,可用C语言、C++语言和Java 语言等。

银行家算法的java编程实现

银行家算法的java编程实现

淮海工学院计算机工程学院实验报告书课程名:《操作系统原理》题目:实验二:银行家算法学号: ***********姓名:***一、实验目的:通过实验,了解死锁的预防方法,对银行家算法有更为深入的认识。

二、实验内容:利用所学语言(不限)编写一个银行家算法的模拟程序,数据自行定义,要求能够对整个过程进行展现,编写程序并模拟验证。

要求:本次实验共计四课时,前两课时要求对银行家算法有较为深入的了解,着手进行程序编制,作出大致的程序框架,编写实验报告;后两课时中,主要是程序的调试,完成实验报告。

三、实验步骤1、程序代码(java实现)Java语言的特点:代码的可复用性比较可以在不同的系统中运行不需要考虑所使用的平台是什么,Java的代码比较简洁易于学习,功能强大,高效。

/*银行家算法java语言实现*/此处是函数部分因实现的功能不是核心故而略去class TheBanker{int m;int n;int[][] max;int[][] maxbak;//备份用int[][] allocation; //已分配资源int[][] allocationbak;//备份用int[][] need; //需要资源int[][] needbak;//备份用int[] available;//剩余资源int[] availablebak;//备份用public TheBanker(){ //银行家算法函数Scanner s = new Scanner(System.in);System.out.println("初始化==============");System.out.print("请依次输入系统中的【进程数】和【资源类型数】:");m = s.nextInt();n = s.nextInt();max =new int[m][n];maxbak = new int[m][n];allocation = new int[m][n];allocationbak = new int[m][n];need = new int[m][n];needbak = new int[m][n];available = new int[n];availablebak = new int[n];//分配资源for(int i=0;i<max.length;i++){//初始化向量MAX、ALLOCATION、NEED、A V AILABLE System.out.print("请依次输入第" + i + "进程的各资源数:");for(int j=0;j<max[i].length;j++){max[i][j] = s.nextInt();maxbak[i][j] = max[i][j];}}for(int i=0;i<allocation.length;i++){System.out.print("请依次输入第" + i + "进程中已分配资源的数量:");for(int j=0;j<allocation[i].length;j++){allocation[i][j] = s.nextInt();allocationbak[i][j] = allocation[i][j];}}for(int i=0;i<need.length;i++){for(int j=0;j<need[i].length;j++){need[i][j] = max[i][j] - allocation[i][j];needbak[i][j] = need[i][j];}}for(int i=0;i<available.length;i++){System.out.print("请输入系统中第" + i + "种资源的剩余量:");available[i] = s.nextInt();availablebak[i] = available[i];}System.out.println("初始化结果=============");System.out.println(" MAX ALLOCATION NEED A VAILABLE");for(int i=0;i<m;i++){System.out.print("P" + i + ": ");for(int j=0;j<n;j++){if(max[i][j]>9){//如果是两位数,控制格式,在数字前少输出一个" "。

操作系统课程设计报告银行家算法的设计与实现(java语言)

操作系统课程设计报告银行家算法的设计与实现(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。

操作系统实验六(编程模拟实现银行家算法)

操作系统实验六(编程模拟实现银行家算法)

实验六编程模拟实现银行家算法(综合性编程实验4学时)一. 目的要求通过对银行家算法的模拟,了解死锁概念、死锁的本质以及掌握解决死锁的方法。

二.实验任务编程模拟银行家算法中的安全性算法,系统当前状态(最大资源需求、进程已占有的资源、进程还需要的资源)以某种形式输入,程序输出是否安全和不安全的结果。

三.实验环境、设备硬件:586以上的PC系列机,主频大于166M,内存大于16MB,硬盘空闲空间大于500MB。

软件:选择一个自己熟悉的计算机操作系统(如DOS、Windows98/2000/XP、UNIX、linux等,根据各学校的条件与环境而定)和程序设计语言(如Turbo C、C语言、PASCAL语言等)。

编程语言由各位同学自己选择确定,不做统一规定。

四.实验指导模拟银行家算法中的安全性算法,系统当前状态(最大资源需求。

进程已占有的资源、进程还需要的资源)以某种形式输入,程序输出是否安全和不安全的结果。

为简单以见,以教材中的例子做为输入,实现安全性算法。

1.主要数据结构①可用资源数组work,它的长度为资源类型数2,如果work [1]= k表示当前状态下B种资源的可用个数为k个。

例:work[1]=3,表示B类资源当前空闲3台。

②分配矩阵allo(alloction),它是一个[5,2]的矩阵,allo [3,1]= k表示第4个进程已分配k个B类型的资源数.③剩余需求矩阵need,它是一个[5,2]的矩阵,need[3,1]=k表示第4个进程还需要k个B类型的资源数.④系统拥有资源向量max,它的长度为资源类型数2,如果max [1]= k,表示系统中拥有B种资源数为k个.⑤安全状态标示数组finish,他的长度为进程个数5,用它来表示当前状态下系统是否有足够资源分配给该进程。

2.程序说明该程序对于每一种资源进行安全检验,进行检验的算法详见《操作系统》,该程序没有实现每个进程在系统安全时进行动态的分配资源,而是在静态的条件下输入系统的状态,和每个进程拥有.资源的状态,来判断系统是否安全.因此在程序中定义的request矩阵,没有起到作用.如要实规模拟动态的资源分配,在该程序的基础上稍加改动即可.五.实验源代码import java.util.*;public class os{public static void main(String args[]){int max[][]={{7,5},{3,2},{9,0},{2,2},{4,3}};int allo[][]={{0,1},{2,0},{3,0},{2,1},{0,0}};int need[][]={{7,4},{1,2},{6,0},{0,1},{4,3}};int work[]={3,3};boolean finish[]={false,false,false,false,false};int count=5;int i;while(count>0){for( i=0;i<5;i++){if(finish[i]==false&&need[i][0]<=work[0]&&need[i][1]<=work[1]){work[0]+=allo[i][0];work[1]+=allo[i][1];finish[i]=true;count--;break;}}}if(count==0)System.out.println("系统安全!");elseSystem.out.println("系统不安全!");} }。

银行家算法的设计与实现(JAVA语言).doc

银行家算法的设计与实现(JAVA语言).doc

银行家算法的设计与实现(JAVA语言).doc淘豆网网友近日为您收集整理了关于操作系统课程设计报告-银行家算法的设计与实现(java语言)的文档,希望对您的工作和学习有所帮助.以下是文档介绍:操作系统课程设计报告题目:银行家算法的设计与实现院(系):计算机科学与工程学院专业:信息对抗专业班级:学生:学号:指导教师:2011年12月1基于计算机操作系统银行家算法实现摘要此次课程设计的主要内容是模拟实现资源分配.同时要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生具体用银行家算法实现资源分配.要求如下:(1)设计一个3个并发进程共享3类不同资源的系统,进程可动态地申请资源和释放资源,系统按各进程的申请动态地分配资源.(2)设计用银行家算法和随机分配算法,实现资源分配的两个资源分配程序,应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况.(3)确定一组各进程依次申请资源数的序列,在相同的情况下分别运行上述两种资源分配程序,观察运行结果.银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序.加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法.死锁的产生,必须同时满足四个条件,即一个资源每次只能由一个进程占用:第二个为等待条件,即一个进程请求资源不能满足时,它必须等待,但它仍继续保持已得到的所有其他资源:第四个为循环等待条件,系统中存在若干个循环等待的进程,即其中每一个进程分别等待它前一个进程所持有的资源.防止死锁的机构只能确保上述四个条件之一不出现,则系统就不会发生死锁.通过这个算法可用解决生活中的实际问题,如银行贷款等.通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升.关键词:死锁;安全状态;安全序列;银行家算法;安全性检查2目录1概述..................................................(3)1.1设计目的....................................................(3)1.2开发环境....................................................(3)2需求分析 (4)2.1死锁概念....................................................(4)2. 2死锁的结论..................................................(4)2.3资源分类....................................................(4)2. 4产生死锁的必要条件..........................................(4)2.5死锁的解决方案..............................................(4)2.5.1产生死锁的例子........................................(4)2.5.2死锁预防..............................................(5)2.5.3安全状态与不安全状态..................................(5)3数据结构分析设计.............................................(6)3.1可利用资源向量矩阵available[]..............................(6)3.2最大需求矩阵max[][]......................................(6)3.3分配矩阵allocation[][]...................................(6)3.4需求矩阵need[][].........................................(6)4算法的实现....................................................(7)4. 1初始化 (7)4.2银行家算法..................................................(7)4.3安全性检查算法..............................................(7)4.4各算法流程图................................................(8)5测试与实例分析..............................................(10)6心得体会.. (14)7.参考文献与源程序清单(附录).................................(15)31概述1.1设计目的银行家算法是一种最有代表性的避免死锁的算法.把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款.操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配.当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量.若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配.本次课程设计通过用java语言编写和调试实现银行家算法的程序,达到进一步掌握银行家算法,理解系统产生死锁的原因以及系统避免死锁的方法,增强理论联系实际的能力的目的.1.2开发环境操作系统:windowsxp编译工具:myeclipse8.6生成文件:×××.java源代码文件和×××.class编译文件42需求分析2.1死锁概念死锁就是指多个进程在运行中因争夺资源而造成的一种僵局,当进程出于这种僵持状态时,若无外力作用,它们都将无法再向前推进.2.2死锁的结论产生死锁的原因是:竞争资源和进程间推进顺序不当.处理死锁的基本方法是:①预防死锁②避免思索③检测死锁④解除死锁2.3资源分类1.可剥夺性资源,某些进程在获得此类资源后,该资源可以再被其他进程或系统剥夺.cpu和内存均属于可剥夺性资源.2.不可剥夺性资源,当系统把这类资源分配给进程后,再不能强行回收,只能在进程用完后自动释放,如磁带机,打印机.3.非剥夺性资源,在系统中所配置的非剥夺性资源,由于它们的数量不能满足诸进程运行的需要,会使进程在运行构成中,因争夺这些资源而陷入僵局.4.临时性资源,它是指由一个进程产生,被另一个进程使用一短暂时间后便无用的资源,也称之为消耗性资源..2.4产生死锁的必要条件1.互斥条件:进程对它所分配到的资源进行排他性使用,即在一段时间内某资源由一个进程占有.如果此时还有其它进程请求该资源,则请求者只能等待,直至占有该资源的进程用毕释放.2.请求和保持条件:进程已经保持了至少一个资源,但又提出新的资源请求,而该资源又被其他进程占有,此时请求进程阻塞,但又对自己获得的其他资源保持不放.3.不剥夺条件:进程已经获得的资源,在未使用完之前,不能被剥夺,只有在使用完是由自己释放.4.环路等待条件:发生死锁时,必然存在一个进程--资源的环形链.2.5死锁的解决方案2.5.1产生死锁的例子5该例子是由于进程推进顺序非法引发的死锁:进程p1和p2并发执行,如果按顺序①执行:p1:request(r1)——p1:request(r2)——p1:release(r1)——p1:release(r2)——p2:request(r2)——p2:request(r1)——p2:release(r2)——p2:release(r1),两个进程可顺利完成.如果按曲线②执行:p1和p2将进入不安全区d,p1保持了资源r1,p2保持了r2,接下来p2将申请不到r1,p1申请不到r2,系统处于不安全状态,往前推进将发生死锁.图3-152.5.2死锁预防预防死锁的方法是使产生死锁的四个必要条件中的2、3、4条件之一不能成立.即:1、摒弃“请求和保持”条件.系统规定所有进程在开始运行之前,都必须一次性申请其在整个运行过程中所需的全部资源.使该进程再整个运行过程中不会提出资源请求,因而摒弃了请求条件.又由于进程在等待期间没有占有任何资源,所以也摒弃了保持条件.2、摒弃“不剥夺”条件.系统规定,进程逐个提出对资源的要求,当一个已经保持了某些资源的进程,再提出新的资源请求而未被满足时,必须释放已经保持的所有资源,待以后需要是在再重新申请.3、摒弃“环路等待”条件.系统规定所有资源按类型进行线性排队,并赋予不同的序号.所有进程对资源的请求都必须严格按资源序号递增的顺序提出.2.5.3安全状态与不安全状态在避免死锁的方法中,允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次资源分配的安全性.若此次分配不会导致系统进入不安全状态,6则将资源分配给进程;否则,令进程等待所谓安全状态是指,系统能按某种进程顺序(p1,p2,p3,…,pn),来为每个进程分配所需资源,直至满足每个进程对资源的最大需求,是每个进曾都可以顺利完成.如果系统找不到这样一个序列,系统就处于不安全状态.虽然并非所有的不安全状态都是死锁状态,但当系统进入不安全状态后,便可能进入死锁状态.只要系统处于安全状态,系统便可以避免进入不安全状态.因此,避免死锁的实质在于:系统在进行资源分配时,如何使系统不进入不安全状态安全序列:一个进程序列{p1,…,pn}是安全的,如果对于每一个进程pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程pj(j<i)当前占有资源量之和.银行家算发就是用具避免死锁的一个有效方法3数据结构分析设计3.1可利用资源向量矩阵available[]这是一个含有m个元素的数组,其中的每一个元素代表一类可利用的资源数目,其初始值是系统中所配置的该类全部可用资源的数目,其数值随该类资源的分配和回收而动态地改变.如果available[j]=k,则表示系统中现有r类资源k个3.2最大需求矩阵max[][]这是一个n*m的矩阵,用以表示每一个进程对m类资源的最大需求.如果max[i,j]=k,则表示进程i需要r类资源的数目为k.3.3分配矩阵allocation[][]这也是一个n*m的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数.如果allocation[i,j]=k,则表示进程i当前已分得r类资源的数目为k.3.4需求矩阵need[][]这也是一个n*m的矩阵,用以表示每一个进程尚需的各类资源数.如果need[i,j]=k,则表示进程i还需要r类资源k个,才能完成其任务.上述矩阵存在下述关系:7need[i,j]=max[i,j]﹣allocation[i,j]4算法的实现4.1初始化1.创建available[]数组,用以存放系统中可用的资源数目;2.创建max[][]数组,用以存放各个进程对各类资源的最大需求数目;3.创建allocation[][]数组,用以存放各个进程已经分得的各类资源数目;4.创建need[][]数组,用以存放各个进程还需要的各类资源数目;5.创建allocation1[][];need1[][];available1[],用以存放系统试分配资源前系统资源分配情况;4.2银行家算法设requesti是进程pi的请求向量,requesti=k表示进程pi需要k个j类资源.pi 发出资源请求后,按下列步骤进行检查:1.如果req uesti[j]≤need[i,j],转向步骤②;否则报错,所需要的资源数已超过它所宣布的最大值;2.如果requesti[j]≤available[j],转向步骤③;否则报错,尚无足够资源pi需等待;3.尝试将资源分配给进程pi,并修改下面数据结构中的数值:available[j]:=available[j]-raquesti[j];allocation[i,j]:=allocation[i,j]+raquesti[j];ne ed[i,j]:=need[i,j]-raquesti[j];4.执行安全性算法,检查此次资源分配后,系统是否出于安全状态.若安全,才正式将资源分配给进程pi,已完成本次分配;否则,将本次试探分配作废,恢复原来的资源分配状态,让pi等待.4.3安全性检查算法1.设置两个向量:一、工作向量work:表示系统可提供给进程继续运行所需的各类资源数目,执行安全性算法开始时work:=available;二、finish标志:表示系统是否有足够的资源分配给进程,使之运行完成.初始化finish[i]:=false;有足够资源分配给进程时,令finish[i]:=true.2.从进程集合中找到一个能满足下述条件的进程8finish[i]=false;need[i,j]≤work[j];找到执行步骤③,否则执行步骤④3.当进程pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:work[j]:=work[i]+allocation[i,j];finish[i]:=true;gotoste p②;4.如果所有进程的finish[i]=true都满足,则表示系统处于安全状态;否则,系统处于不安全状态.4.4各算法流程图1.初始化算法流程:92.银行家算法流程图:播放器加载中,请稍候...系统无法检测到您的adobeflashplayer版本建议您在线安装最新版本的flashplayer在线安装。

java银行家算法代码实现

java银行家算法代码实现

java银行家算法代码实现=================一、算法简介------银行家算法是一种用于避免系统发生死锁的算法,它通过分析系统资源分配情况,判断系统是否处于安全状态,从而避免死锁的发生。

Java银行家算法是一种基于Java语言的实现,它通过模拟系统资源分配情况,判断系统是否处于安全状态。

二、算法实现------以下是一个简单的Java银行家算法代码实现:```javapublicclassBankerAlgorithm{//资源数量和最大需求量privateint[]resource=newint[10];//例如:包括x,y,z三种资源,分别对应i-x1-x2-z...-xi-yi-zi...privateint[]maxDemand=newint[10];privateint[]available=newint[10];//当前可用资源数量privateint[]allocation=newint[10];//当前已分配资源数量privateint[]need=newint[10];//当前进程需求量privateint[]saved=newint[10];//已保存的安全序列中最后一个进程的资源需求量privateint[]process=newint[5];//进程集合,包括进程编号和进程所需资源量privateint[]processMax=newint[5];//进程最大需求量集合privateint[]systemSafe=0;//系统是否处于安全状态的标志位privateinttotalSystemSafe=0;//总共是否有足够资源可以安全运行的标志位//初始化资源分配信息publicvoidinitialize(int[][]allocationMatrix){for(inti=0;i<allocationMatrix.length;i++){process[i]=allocationMatrix[i][0];//进程编号processMax[i]=allocationMatrix[i][1];//进程最大需求量available[i]=allocationMatrix[i][2];//当前可用资源数量need[i]=allocationMatrix[i][3];//当前进程需求量maxDemand[i]=allocationMatrix[i][4];//当前进程最大需求量}systemSafe=true;//系统默认处于安全状态totalSystemSafe=true;//总共是否有足够资源可以安全运行的标志位默认设置为true}//检查系统是否处于安全状态,并返回检查结果和可能的执行序列(从开始到结束)publicboolean[]checkAndPrintSafePath(){intcurrentSystemSafe=false;//检查后的系统是否处于安全状态的标志位boolean[]safePath=newboolean[process.length];//安全序列for(inti=0;i<process.length;i++){if(need[i]<=available[i]){//如果当前进程需要的资源小于等于当前可用资源数量,则可以继续执行下去safePath[i]=true;//将当前进程标记为已执行过,并加入到安全序列中available[i]-=need[i];//将当前可用资源数量减去当前进程的已分配量,表示系统多出来的资源数量为已分配的减去需求的currentSystemSafe=true;//将当前系统的安全状态标记为true,因为已经有至少一个进程能够执行下去了}else{//如果当前进程需要的资源大于当前可用资源数量,则需要检查系统是否有足够的资源可以继续执行下去intavailableSum=0;//系统剩余的可用资源数量之和for(intj=0;j<process.length;j++){//将所有可用资源的数量累加起来availableSum+=available[j];}if(availableSum>=processMax[i]){//如果系统剩余的可用资源数量之和大于等于当前进程的最大需求量,则系统可以继续执行下去,否则需要重新分配资源并返回结果重新开始执行安全序列为null;如果为空说明不满足要求否则输出一个安全的执行序列,开始输出可执行的进程数以及所分配的资源和后续的系统安全状态标记等信息totalSystemSafe=false;//将当前系统安全状态的标志位置为false,因为此时不满足安全状态的要求,需要重新开始执行程序,且此次循环的完整性和执行性需要考虑已经完成过的安全序列重新考虑这些因素的修改可能会被重用)确保安全性序列不再更改);再次输出完整的信息需要重新考虑这些因素以确保安全性序列不再更改)并返回结果;如果为true则说明系统已经处于安全状态并输出一个安全的执行序列;如果为false则说明。

银行家算法java代码

银行家算法java代码

银行家算法java代码银行家算法是一种用于避免死锁的算法,它可以保证系统在分配资源时不会陷入死锁状态。

在操作系统中,银行家算法被广泛应用于进程调度和资源管理中。

本文将介绍银行家算法的原理和实现,并提供Java代码示例。

一、银行家算法原理银行家算法是基于资源分配图的理论基础上发展而来的。

资源分配图是描述进程和资源之间关系的一种图形表示方法。

在资源分配图中,每个进程和每个资源都表示为一个节点,进程需要的资源和已经被占用的资源之间连接一条边。

银行家算法通过模拟进程请求和释放资源的过程来判断是否会出现死锁。

当一个进程请求某些资源时,如果系统能够满足其请求,则该进程可以继续执行;否则,该进程必须等待直到有足够的资源可用。

当一个进程释放掉已经占用的某些资源时,系统会将这些资源重新分配给其他需要它们的进程。

为了避免死锁,银行家算法采取了预防措施:在分配任何一个新任务之前,先检查该任务所需求各类资料是否超过了系统现有的资料总量,如果超过了,则不予分配。

否则,再检查该任务所需求各类资料是否超过了系统现有的未分配资料总量,如果超过了,则不予分配。

二、银行家算法实现银行家算法的实现需要考虑以下几个方面:1.资源分配图的表示方法:可以使用邻接矩阵或邻接表来表示资源分配图。

2.进程请求和释放资源的模拟:可以使用数组来存储进程占用和需要的资源数量,并通过对数组的修改来模拟进程请求和释放资源的过程。

3.死锁检测:可以使用安全序列或银行家算法来判断是否会出现死锁。

下面是一个基于银行家算法实现的简单Java代码示例:public class BankerAlgorithm {// 进程数private int n;// 资源数private int m;// 各进程已占用资源数量private int[][] allocation;// 各进程尚需资源数量private int[][] need;// 系统剩余可用资源数量private int[] available;/*** 构造函数* @param n 进程数* @param m 资源数* @param allocation 各进程已占用资源数量* @param need 各进程尚需资源数量* @param available 系统剩余可用资源数量*/public BankerAlgorithm(int n, int m, int[][] allocation, int[][] need, int[] available) {this.n = n;this.m = m;this.allocation = allocation;this.need = need;this.available = available;}/*** 模拟进程请求资源* @param pid 进程ID* @param request 请求的资源数量* @return 是否满足请求*/public boolean requestResources(int pid, int[] request) { // 检查请求是否超过进程所需的资源数量for (int i = 0; i < m; i++) {if (request[i] > need[pid][i]) {return false;}}// 检查请求是否超过系统剩余的资源数量for (int i = 0; i < m; i++) {if (request[i] > available[i]) {return false;}}// 模拟进程占用资源的过程for (int i = 0; i < m; i++) {available[i] -= request[i];allocation[pid][i] += request[i];need[pid][i] -= request[i];}return true;}/*** 模拟进程释放资源* @param pid 进程ID* @param release 释放的资源数量*/public void releaseResources(int pid, int[] release) { // 模拟进程释放资源的过程for (int i = 0; i < m; i++) {available[i] += release[i];allocation[pid][i] -= release[i];need[pid][i] += release[i];}}/*** 判断系统是否安全* @return 是否安全*/public boolean isSafe() {// 初始化工作数组int[] work = new int[m];for (int i = 0; i < m; i++) {work[i] = available[i];}boolean[] finish = new boolean[n]; for (int i = 0; i < n; i++) {finish[i] = false;}// 查找可用的进程int count = 0;while (count < n) {boolean found = false;for (int i = 0; i < n; i++) {if (!finish[i]) {boolean canRun = true;for (int j = 0; j < m; j++) { if (need[i][j] > work[j]) { canRun = false;break;}}if (canRun) {finish[i] = true;found = true;count++;for (int j = 0; j < m; j++) {work[j] += allocation[i][j];}}}}if (!found) {return false;}}return true;}}三、总结银行家算法是一种重要的避免死锁的算法,它可以在系统分配资源时避免出现死锁状态。

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

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

操作系统银行家算法实验报告操作系统银行家算法实验报告引言:操作系统是计算机科学中的一个重要领域,它负责管理计算机的硬件和软件资源,以提供良好的用户体验。

在操作系统中,银行家算法是一种重要的资源分配和调度算法,它可以确保系统中的进程安全地访问资源,避免死锁的发生。

本实验旨在通过实践运用银行家算法,深入理解其原理和应用。

实验目的:1. 理解银行家算法的基本原理;2. 掌握银行家算法的实现方法;3. 分析银行家算法在资源管理中的应用。

实验过程:1. 实验环境的搭建在本次实验中,我们使用了一台运行Windows操作系统的计算机,并安装了Java开发环境。

同时,我们使用了一个模拟的资源管理系统,以便更好地理解和实践银行家算法。

2. 银行家算法的原理银行家算法是通过对系统中的资源进行合理分配,以避免死锁的发生。

它基于以下几个假设:- 每个进程对资源的最大需求量是已知的;- 系统中的资源数量是有限的;- 进程在请求资源时必须先声明其最大需求量;- 进程在释放资源后,不能再重新请求。

3. 银行家算法的实现银行家算法的实现主要包括以下几个步骤:- 初始化:获取系统中的资源总量和每个进程的最大需求量;- 安全性检查:通过模拟分配资源并检查系统是否处于安全状态,以确定是否可以满足进程的资源请求;- 资源分配:根据安全性检查的结果,决定是否分配资源给进程。

4. 银行家算法的应用银行家算法在实际应用中具有广泛的用途,尤其是在多任务操作系统中。

它可以用于资源的分配和调度,以确保系统中的进程能够安全地访问资源,避免死锁的发生。

结论:通过本次实验,我们深入了解了银行家算法的原理和应用。

银行家算法作为一种重要的资源管理和调度算法,可以有效地避免死锁的发生,提高系统的可靠性和稳定性。

在今后的学习和工作中,我们将继续深入研究操作系统相关的算法和原理,以提升自己在该领域的专业能力。

用java编写的银行家算法

用java编写的银行家算法

public void printSystemVariable() { System.out.println("此时资源分配量如下:"); System.out.println("进程 "+" Max "+" Alloction "+" Need "+" Available "); for(int i=0;i<5;i++) { System.out.print("P"+i+" "); for(int j=0;j<3;j++) { System.out.print(Max[i][j]+" "); } System.out.print(" "); for(int j=0;j<3;j++) { System.out.print(Alloction[i][j]+" "); } System.out.print(" "); for(int j=0;j<3;j++) { System.out.print(Need[i][j]+" "); } System.out.print(" "); if(i==0) { for(int j=0;j<3;j++) { System.out.print(Available[j]+" "); } } System.out.println(); } }
package 银行家算法; import java.util.Scanner; public class Banker { public static char[] Name = {'A', 'B', 'C'}; public static int[] Available = {3,3,2}; public int[][] Max = {{7,5,3},{3,2,2},{9,0,2}, {2,2,2},{4,3,3}}; public int[][] Alloction ={{0,1,0},{2,0,0}, {3,0,2},{2,1,1},{0,0,2}}; public int[][] Need = {{7,4,3},{1,2,2},{6,0,0}, {0,1,1},{4,3,1}}; public int[] Request = new int[3]; public int[] Work = new int[3]; int num = 0;//进程编号 Scanner in = new Scanner(System.in); public static void main(String[] args) { boolean Choose = true; String C; Scanner in = new Scanner(System.in); Banker T = new Banker(); System.out.println("银行家算法"); T.printSystemVariable(); T.SecurityAlgorithm(); while (Choose == true) { T.setRequest(); System.out.println("是否还要进行请求: y/n?"); C = in.nextLine(); if (C.endsWith("n")) { Choose = false; } } }

银行家算法试验报告

银行家算法试验报告

一、实验题目:银行家算法的实现二、设计内容设计一个n 个并发进程共享m 个系统资源的系统。

进程可动态申请资源和释放资源,系统按各进程的申请动态的分配资源。

要求采用银行家算法实现。

三、开发环境windows环境,java1.5平台。

四、分析设计<一>实验原理♦银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作的客户。

如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全的。

♦与预防死锁的几种方法相比较,限制条件少,资源利用程度提高了。

♦缺点:该算法要求客户数保持固定不变,这在多道程序系统中是难以做到的;该算法保证所有客户在有限的时间内得到满足,但实时客户要求快速响应,所以要考虑这个因素;由于要寻找一个安全序列,实际上增加了系统的开销.Banker algorithm 最重要的一点是:保证操作系统的安全状态!这也是操作系统判断是否分配给一个进程资源的标准!那什么是安全状态?举个小例子,进程P 需要申请8 个资源(假设都是一样的),已经申请了 5 个资源,还差3 个资源。

若这个时候操作系统还剩下 2 个资源。

很显然,这个时候操作系统无论如何都不能再分配资源给进程P 了,因为即使全部给了他也不够,还很可能会造成死锁。

若这个时候操作系统还有 3 个资源,无论P 这一次申请几个资源,操作系统都可以满足他,因为操作系统可以保证P 不死锁,只要他不把剩余的资源分配给别人,进程P 就一定能顺利完成任务。

为什么银行家算法是可行的呢?这里需要严格的证明一下。

不管任何时候,操作系统分配资源的时候都可以保证当前接受资源的进程不会陷入死锁,因为操作系统总是可以满足该进程需要的资源的。

假设有n 个进程{p1, p2, p3, …pn} ,最后一个分配到资源的是pi ,pi 还需要mi 个资源,假设此时操作系统还有m 个资源剩余。

那么很显然m>=mi !而且如果之后操作系统又把资源分配给其他进程了,假设是pj ,pj 还需要mj 个资源,同理可知m>=mj !也就是说在所有的进程中,还需要的资源数总是有小于m 的!这样就可以保证资源数永远不会为0 ,即使可能暂时性为0 。

银行家算法实验报告

银行家算法实验报告

操作系统实验报告1银行计算法的实现班级:计算机科学与技术082班级姓名:学号:老师:霍林实验目的:计算机科学与技术专业学生学习完《计算机操作系统》课程后,进行的一次全面的综合训练,其目的在于加深催操作系统基础理论和基本知识的理解,加强学生的动手能力.银行家算法是避免死锁的一种重要方法。

通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法实验环境:Windos XP系统,java编程实验分析:1.实验背景银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。

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

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

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

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

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

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

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

计算机操作系统课程设计(JAVA语言)计算机操作系统银行家算法实现

计算机操作系统课程设计(JAVA语言)计算机操作系统银行家算法实现

操作系统课程设计报告题目:银行家算法的设计与实现院(系):计算机科学与工程学院专业:信息对抗专业班级:班学生:学号:指导教师:2011年12月基于计算机操作系统银行家算法实现摘要此次课程设计的主要内容是模拟实现资源分配。

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

要求如下:(1) 设计一个3个并发进程共享3类不同资源的系统,进程可动态地申请资源和释放资源,系统按各进程的申请动态地分配资源。

(2) 设计用银行家算法和随机分配算法,实现资源分配的两个资源分配程序,应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况。

(3) 确定一组各进程依次申请资源数的序列,在相同的情况下分别运行上述两种资源分配程序,观察运行结果。

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

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

死锁的产生,必须同时满足四个条件,即一个资源每次只能由一个进程占用:第二个为等待条件,即一个进程请求资源不能满足时,它必须等待,但它仍继续保持已得到的所有其他资源:第四个为循环等待条件,系统中存在若干个循环等待的进程,即其中每一个进程分别等待它前一个进程所持有的资源。

防止死锁的机构只能确保上述四个条件之一不出现,则系统就不会发生死锁。

通过这个算法可用解决生活中的实际问题,如银行贷款等. 通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升.关键词:死锁;安全状态;安全序列;银行家算法;安全性检查目录1 概述 (3)1.1设计目的 (3)1.2开发环境 (3)2 需求分析 (4)2.1死锁概念 (4)2.2死锁的结论 (4)2.3资源分类 (4)2.4产生死锁的必要条件 (4)2.5死锁的解决方案 (4)2.5.1产生死锁的例子 (4)2.5.2死锁预防 (5)2.5.3安全状态与不安全状态 (5)3 数据结构分析设计 (6)3.1可利用资源向量矩阵available[ ] (6)3.2最大需求矩阵max[ ][ ] (6)3.3分配矩阵allocation[ ][ ] (6)3.4需求矩阵need[ ][ ] (6)4 算法的实现 (7)4.1初始化 (7)4.2银行家算法 (7)4.3安全性检查算法 (7)4.4各算法流程图 (8)5 测试与实例分析 (10)6 心得体会 (14)7.参考文献与源程序清单(附录) (15)1概述1.1设计目的银行家算法是一种最有代表性的避免死锁的算法。

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

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

实验报告四实验名称:一、编程实现银行家算法二、测试算法日期:2015-11-24 班级:13级计科学号:姓名:一、实验目的银行家算法是操作系统中避免死锁的典型算法,本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。

二、实验内容用java语言编写一个简单的银行家算法模拟程序,用银行家算法实现资源分配。

程序能模拟多个进程共享多种资源的情形。

进程可以动态地申请资源,系统按照各个进程的申请动态地分配资源。

要求程序具有显示和打印各个进程的某一时刻的资源分配和安全序列;显示和打印各个进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。

三、项目要求与分析1.要找出某一状态下所有的安全序列,程序该如何实现?要找出这个状态下的所有的安全序列,前提是要使这个系统先处于安全状态,而系统的状态可以通过以下来描述:(1)进程剩余申请数=最大申请数-占有数;(2)可分配资源数=总数-占有数之和;2.银行家算法的局限性有哪些?银行家算法是一个最具有代表性的避免死锁的算法。

银行家算法把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求资源相当于用户向银行家贷款。

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

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

但任何一种算法都存在其缺点,对各种进程的资源分配要求严格,经常使其处于不安全状态,银行家算法的主要局限是过于谨慎和检查各申请者对各类资源的最大需求量开销较大。

四、具体实现1.资源类代码:// 资源类假设一共三类资源;class Sources {private int A;private int B;private int C;public Sources(int a, int b, int c) {super();this.B = b;this.A = a;this.C = c;}public Sources(Sources sources) {super();this.B = sources.getB();this.A = sources.getA();this.C = sources.getC();}public int getB() {return B;}public void setB(int B) {this.B = B;}public int getA() {return A;}public void setA(int A) {this.A = A;}public int getC() {return C;}public void setC(int C) {this.C = C;}2.进程类代码://进程类,包进程使用最大内存,当前已分配内存,和需要分配内存class Processor {private String name;private Sources maxSources;private Sources allSources;private Sources needSources;public String getName() {return name;}public void setName(String name) { = name;}public Sources getMaxSources() {return maxSources;}public void setMaxSources(Sources maxSources) {this.maxSources = maxSources;}public Sources getNeedSources() {return needSources;}public void setNeedSources(Sources needSources) {this.needSources = needSources;}public Sources getAllSources() {return allSources;}public void setAllSources(Sources allSources) {this.allSources = allSources;}3.相关显示测试代码// 显示当前系统和各个进程的资源使用情况public void showdata(Processor[] processors) {// 显示当前可用资源System.out.print("当前系统可分配资源为:");showSources(allSources);System.out.println("-----------------进程状态-------------"); System.out.println("进程号 Max Allocation Need ");System.out.println(" A B C A B C A B C");for (int i = 0; i < processors.length; i++) {System.out.print(processors[i].getName() + " "+ processors[i].getMaxSources().getA() + " "+ processors[i].getMaxSources().getB() + " "+ processors[i].getMaxSources().getC() + " "); System.out.print(processors[i].getAllSources().getA() + " "+ processors[i].getAllSources().getB() + " "+ processors[i].getAllSources().getC() + " "); System.out.println(processors[i].getNeedSources().getA()+ " "+ processors[i].getNeedSources().getB() + " "+ processors[i].getNeedSources().getC() + " ");}System.out.println("-----------------------------------");}4.运行结果:五、所遇问题与解决方法这个银行家算法只有申请资源的相应操作,没有其他的添加资源,删除资源等的操作,但由于水平有限,没来得及解决。

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

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

实验三银行家算法实验报告一、实验目的银行家算法是一种用于避免死锁的算法,本次实验旨在通过编程实现银行家算法,并通过模拟银行家算法的运行过程来加深对该算法的理解。

二、实验过程及结果1. 系统设计为了模拟银行家算法的运行过程,需要设计一个包含多个进程和资源的系统。

每个进程都有一定的最大需求资源数和已分配资源数。

系统中还有一定数量的可用资源,进程可以请求资源和释放资源。

2. 算法实现在程序中实现银行家算法需要以下几个关键的函数:(1)银行家算法的主函数:实现进程的请求资源和释放资源操作,并在此过程中判断是否产生死锁;(2)安全检查函数:用于判断系统状态是否安全,即是否存在一个安全序列,如果存在则表示系统处于安全状态,否则表示系统处于不安全状态;(3)资源请求函数:用于进程请求资源的操作,根据银行家算法的要求进行判断;(4)资源释放函数:用于进程释放资源的操作。

3. 算法运行通过对编写的程序进行多次运行测试,模拟不同进程对资源的请求和释放,观察系统是否能够始终处于安全状态。

在每次运行中,记录并输出系统的安全序列和进程的状态等信息。

4. 实验结果分析通过实验运行结果的分析,可以得出以下结论:(1)银行家算法能够有效地避免死锁的发生;(2)系统中资源的分配和释放过程需要合理,否则可能导致系统陷入死锁;(3)资源的分配策略对系统的安全状态有重要影响。

三、实验总结通过本次实验,深入了解了银行家算法的原理和实现过程,并通过编程实践加深了对该算法的理解。

银行家算法是一种重要的死锁避免算法,能够保证系统处于安全状态下运行,并且能够合理地分配系统资源,避免系统陷入死锁。

四、参考文献[1] 《操作系统概念》,Abraham Silberschatz,Peter B. Galvin,Greg Gagne,电子工业出版社,2014年五、附录(示例代码省略)以上是本次实验的实验报告,通过实验我们深入了解了银行家算法,了解了它在操作系统中的应用和重要性。

Java银行家算法

Java银行家算法

Java银⾏家算法实验存档,代码特别烂。

测试.javapackage operating.test;import operating.entity.bank.Bank;import operating.entity.bank.EngineeringTeam;public class TestBank {public static void main(String[] args) {Bank bank = new Bank(10);for (int i = 0; i != 3; ++i) {new Thread(new EngineeringTeam(5, bank)).start();}}}/银⾏.javapackage operating.entity.bank;import java.util.ArrayList;public class Bank {/*** ⼯程队数量*/private static final int NUM = 3;/*** 当前可⽤的资⾦数⽬*/private int available;/*** 已分配矩阵*/private int[] allocation = new int[NUM];/*** 需求矩阵*/private int[] need = new int[NUM];public Bank(int available) {this.available = available;}/*** 向银⾏借钱* @param id ⼯程队id* @param request ⼯程队需求资⾦* @return⼀个布尔值,如果借钱成功返回真,否则返回假*/public synchronized boolean borrow(int id, int request) {System.out.println("银⾏还剩 " + available + " 万元。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

仲恺农业工程学院实验报告纸东哥实验三银行家算法一.实验目的:1、理解死锁概念,以及死锁产生的必要条件。

2、理解银行家算法基本原理。

3、掌握一种资源和多种资源的银行家算法的设计与实现。

二.实验内容:1、设计出管理的资源种类和数量2、设计出银行家算法的基本数据结构3、设计出完成该资源的银行家算法4、设计出简单的进程创建、运行资源需求、结束的过程5、采用高级语言实现该应用程序三.实验步骤和过程1.死锁基本概念所谓死锁: 是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。

此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。

由于资源占用是互斥的,当某个进程提出申请资源后,使得有关进程在无外力协助下,永远分配不到必需的资源而无法继续运行,这就产生了一种特殊现象死锁。

2. 产生死锁的原因(1.竞争资源引起进程死锁当系统中供多个进程共享的资源如打印机、公用队列的等,其数目不足以满足诸进程的需要时,会引起诸进程对资源的竞争而产生死锁。

(2.进程推进顺序不当引起死锁由于进程在运行中具有异步性特征,这可能使P1和P2两个进程按下述两种顺序向前推进。

(3. P或V操作不当、同类资源分配不均或对某些资源的使用未加限制等等。

3. 产生死锁的必要条件1)互斥条件:指进程对所分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用。

如果此时还有其它进程请求资源,则请求者只能等待,直至占有资源的进程用毕释放。

系统中存在临界资源,进程应互斥地使用这些进程。

2)占有和等待条件:指进程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求进程阻塞,但又对自己已获得的其它资源保持不放。

3)不剥夺条件:指进程已获得的资源,在未使用完之前,不能被剥夺,只能在使用完时由自己释放。

4)循环等待条件:指在发生死锁时,必然存在一个进程——资源的环形链,即进程集合{P0,P1,P2,···,Pn}中的P0正在等待一个P1占用的资源;P1正在等待P2占用的资源,……,Pn正在等待已被P0占用的资源。

造成这组进程处于永远的等待状态!4、处理死锁的基本方法1) 预防死锁。

这是一种较简单和直观的事先预防的方法。

方法是通过设置某些限制条件,去破坏产生死锁的四个必要条件中的一个或者几个,来预防发生死锁。

预防死锁是一种较易实现的方法,已被广泛使用。

但是由于所施加的限制条件往往太严格,可能会导致系统资源利用率和系统吞吐量降低。

2) 避免死锁。

该方法同样是属于事先预防的策略,但它并不须事先采取各种限制措施去破坏产生死锁的的四个必要条件,而是在资源的动态分配过程中,用某种方法去防止系统进入不安全状态,从而避免发生死锁。

3)检测死锁。

这种方法并不须事先采取任何限制性措施,也不必检查系统是否已经进入不安全区,此方法允许系统在运行过程中发生死锁。

但可通过系统所设置的检测机构,及时地检测出死锁的发生,并精确地确定与死锁有关的进程和资源,然后采取适当措施,从系统中将已发生的死锁清除掉。

4)解除死锁。

这是与检测死锁相配套的一种措施。

当检测到系统中已发生死锁时,须将进程从死锁状态中解脱出来。

常用的实施方法是撤销或挂起一些进程,以便回收一些资源,再将这些资源分配给已处于阻塞状态的进程,使之转为就绪状态,以继续运行。

死锁的检测和解除措施,有可能使系统获得较好的资源利用率和吞吐量,但在实现上难度也最大。

5.银行家算法基本原理我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

为保证资金的安全,银行家规定:(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;(2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量;(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;(4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金.操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

当进程在执行中继续申请资源时,先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。

若超过则拒绝分配资源,若能满足则按当前的申请量分配资源,否则也要推迟分配。

6.银行家算法的数据结构1)可利用资源向量Available是个含有m个元素的数组,其中的每一个元素代表一类可利用的资源数目。

如果Available[j]=K,则表示系统中现有Rj类资源K个。

2)最大需求矩阵Max这是一个n×m的矩阵,它定义了系统中n个进程中的每一个进程对m 类资源的最大需求。

如果Max[i,j]=K,则表示进程i需要Rj类资源的最大数目为K。

3)分配矩阵Allocation这也是一个n×m的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。

如果Allocation[i,j]=K,则表示进程i当前已分得Rj类资源的数目为K。

4)需求矩阵Need。

这也是一个n×m的矩阵,用以表示每一个进程尚需的各类资源数。

如果Need[i,j]=K,则表示进程i还需要Rj类资源K个,方能完成其任务。

Need[i,j]=Max[i,j]-Allocation[i,j]7、银行家算法流程图8、运行环境Widows7操作系统,eclipse平台!9.程序设计及测试结果1)本程序是没有窗口界面,比较容易实现,整个命令行执行结果如下截图:2)部分程序:初始化各个变量public class Banker {int resourceType; // 资源种类int processCount;// 进程数量int max[][];// 每个进程的最大需求量int allocated[][];// 已经为每个进程分配的数量int need[][]; // 各个进程还需要的资源数量int available[];//还可用的资源量boolean echo = true;BufferedReader dong; //从System.in读数据Init函数的初始化void init() {try {dong = new BufferedReader(new InputStreamReader(System.in));} catch (Exception e) {e.printStackTrace();System.exit(0);}System.out.println("《银行家算法》");System.out.println(" T时刻系统资源分配");System.out.println("请输入资源种类数:");resourceType = readInt();// 获得输入的资源数量available = new int[resourceType];// 资源种类数量arraySystem.out.println("请输入资源个数向量,共" + resourceType + "个整数,以空格隔开:\n");available = readIntArray();// 资源种类数量array初始化System.out.print("请输入进程数量:");processCount = readInt(); // 获得输入的进程数量max = new int[processCount][resourceType];// 各进程需要的各类资源的最大数矩阵allocated = new int[processCount][resourceType]; // 各进程已分配的各类资源的数量矩阵need = new int[processCount][resourceType]; // 各进程尚需要的各类资源的数量矩阵System.out.print("请输入进程的最大资源需求量矩阵(max矩阵,每行" + resourceType+ "个整数,以空格分隔,共" + processCount + "行):\n");for (int i = 0; i < processCount; i++)max[i] = readIntArray();System.out.print("请输入进程的已分配资源量矩阵(allocated矩阵,每行" + resourceType+ "个整数,以空格分隔,共" + processCount + "行):\n");for (int i = 0; i < processCount; i++)allocated[i] = readIntArray();for (int i = 0; i < resourceType; i++)for (int j = 0; j < processCount; j++)need[j][i] = max[j][i] - allocated[j][i]; // 计算出need矩阵for (int i = 0; i < resourceType; i++)for (int j = 0; j < processCount; j++) {available[i] -= allocated[j][i];// 重新计算available矩阵if (available[i] < 0) {System.out.println("警醒:第" + (i + 1)+ "个可用资源数不足以分配给进程,请检查资源总量和已分配资源矩阵!");System.exit(0);}}}四、实验总结与心得本次实验中,主要目的是如何理解死锁概念,以及死锁产生的必要条件。

理解银行家算法基本原理。

掌握一种资源和多种资源的银行家算法的设计与实现。

本实验主要是利用java来实现银行家算法的问题,让我更加明白了银行家算法的原理和如何来避免死锁的现象!参考文献[1] 孙钟秀,费翔林,骆斌. 操作系统教程[M]. 北京: 高等教育出版社, 2008.[2] 耿祥义、张跃平Java面向对象程序设计[M] 清华大学出版社2010.。

相关文档
最新文档