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

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

操作系统课程设计报告题目：银行家算法院（系)：专业：班级：学生:学号:指导教师：2010年12月操作系统课程设计报告题目:银行家算法院（系）：专业:班级：学生:学号：指导教师：2010年12月银行家算法摘要本次的课程设计内容是银行家算法，在操作系统当中，由于竞争非剥夺性资源和进程推进的不当，对系统的安全造成威胁，所以，银行家算法就是为了避免对系统产生死锁而存在的.银行家算法包括对请求资源的试分配和对安全性的考量,当系统的安全性不能够满足的时候，则对系统进行保护。

在编写银行家算法的时候需要定义Need（需求矩阵），Allocation（分配矩阵），Max（最大需求矩阵）以及Available（可利用资源量）。

在实现一系列的功能的时候使用的数组的结构，便于进行矩阵的加减运算，可以提高程序的运行效率.通过编写可以基本上实现银行家算法所要达到的基本目的，在输入正确的情况下能够输出正确的安全序列,在不安全的情况下可以做出提醒，并且恢复原有输入数据。

关键字：银行家算法最大需求矩阵分配矩阵需求矩阵可利用资源量目录摘要 (i)1 绪论 (1)2需求分析.................................................................。

(2)2.1 问题描述.........................................................。

. (2)2.2 产生条件..........................................................。

(2)2.3 运行环境.........................................................。

. (2)2.4 程序功能.........................................................。

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则说明。

操作系统课程设计－银行家算法(流程图+源代码+设计报告)一、实验目的：熟悉银行家算法，理解系统产生死锁的原因及避免死锁的方法,加深记意。

二、实验要求：用高级语言编写和调试一个描述银行家算法的程序。

三、实验内容：1、设计一个结构体，用于描述每个进程对资源的要求分配情况。

包括：进程名--name[5]，要求资源数目--command[m]（m类资源），还需要资源数目--need[m]，已分配资源数目--allo[m]。

2、编写三个算法，分别用以完成：①申请资源；②显示资源；③释放资源。

（动态完成）四、程序流程图五、源程序：最新版本：bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源（〉2）*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外，对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ /*四、程序流程图：五、源程序：最新版本：bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源（〉2）*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外，对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ #include "string.h"#include "stdio.h"#include "dos.h"#include "conio.h"#define MOVEIN 1#define GUIYUE 2#define ACC 3#define OK 1#define ERROR 0#define MAXSH 7#define MAXSHL 10#define MAXINPUT 50#define maxsize 100int act;int ip=0;int line=0; /*line为要写的行号，全局变量*/int writeok;int right;char wel[30] = {"Welcome To Use An_Li System"};char ente[76]={" 警告：未经作者同意不得随意复制更改！"};char rights[40]={"Copyright (c) 2002"};struct date today;struct time now;typedef struct{int data[maxsize];int top;}stack;int emptystack(stack *S){if(S->top==48&&S->data[S->top]==35)return(1); /*35 is '#'*/ else return(0);}int push(stack *S,int x){if(S->top>=maxsize-1)return(-1);else{S->top++;S->data[S->top]=x;return(0);}}int gettop(stack *S){return S->data[S->top];}int pop(stack *S){if(emptystack(S)){printf("the stack is empty\n");exit(1);}else S->top--;return S->data[S->top+1];}void initstack(stack *S){int i;S->top=0;S->data[S->top]=35;}/*****模拟打字机的效果*********/delay_fun(){int i;void music();for(i=0;;i++){if(wel!='\0'){delay(1000);textcolor(YELLOW);gotoxy(26+i,8);cprintf("%c",wel);printf("谢谢");printf("网络 ");music(1,60);}else break;}delay(500000);for(i=0; ; i++){if(ente!='\0'){delay(1000);textcolor(RED);/*显示警告及版权*/ gotoxy(2+i,11);cprintf("%c",ente);music(1,60);}else break;}delay(40000);for(i=0;;i++){if(rights != '\0'){delay(1000);textcolor(YELLOW);gotoxy(30+i,14);cprintf("%c",rights);music(1,60);}elsebreak;}getch();}/*********登陆后的效果**********/logined(){ int i;clrscr();gotoxy(28,10);textcolor(YELLOW);cprintf("程序正在载入请稍候.....");gotoxy(35,12);for(i=0;i<=50;i++){gotoxy(40,12);delay(8000);cprintf("%02d%已完成",i*2);gotoxy(i+15,13);cprintf("\n");cprintf("|");}main0();}/*********对PC扬声器操作的函数****/void music(int loop,int f) /* f为频率*/{ int i;for(i=0;i<30*loop;i++){sound(f*20);delay(200);}nosound();}int analys(int s,int a){int hh,pos;switch(a){case (int)'i':hh=0;break;case (int)'+':hh=1;break;case (int)'*':hh=2;break;case (int)'(':hh=3;break;case (int)')':hh=4;break;case (int)'#':hh=5;break;case (int)'E':hh=6;break;case (int)'T':hh=7;break;case (int)'F':hh=8;break;default:{printf(" \n analys()分析发现不该有的字符 %c !(位置:%d)",a,ip+1); writeerror('0',"\n............分析出现错误!!!");writeerror(a,"\n 错误类型: 不该有字符 ");printf("谢谢");printf("网 ");return ERROR;}}pos=(s-48)*10+hh;switch(pos){case 3:case 43:case 63:case 73:act=4;return MOVEIN;case 0:case 40:case 60:case 70:act=5;return MOVEIN;case 11:case 81: act=6;return MOVEIN;case 92:case 22:act=7;return MOVEIN;case 84:act=11;return MOVEIN;/*-------------------------------------------*/ case 91:case 94:case 95:act=1;return GUIYUE;case 21:case 24:case 25:act=2;return GUIYUE;case 101:case 102:case 104:case 105:act=3;return GUIYUE;case 31:case 32:case 34:case 35:act=4;return GUIYUE;case 111:case 112:case 114:case 115:act=5;return GUIYUE;case 51:case 52:case 54:case 55:act=6;return GUIYUE;/*+++++++++++++++++*/case 15:return ACC;/*******************************/case 6:return 1;case 7:case 47:return 2;case 8:case 48:case 68:return 3;case 46:return 8;case 67:return 9;case 78:return 10;default:{if(a=='#')printf("");else printf(" \n analys() 分析发现字符%c 不是所期望的!(位置:%d)",a,ip+1);writeerror('0',"\n ...........分析出现错误!!!");writeerror(a,"\n 错误类型: 字符 ");writeerror('0'," 不是所期望的! ");printf("谢谢");printf("网 ");return ERROR;}}}int writefile(int a,char *st){FILE *fp;fp=fopen("an_slr.txt","a");if(fp==0){printf("\nwrite error!!");writeok=0;}else{if(a==-1){fprintf(fp," %s ",st); /*若a==－1则为添加的注释*/}else if(a==-2){getdate(&today);gettime(&now);fprintf(fp,"\n 测试日期： %d-%d-%d",today.da_year,today.da_mon,today.da_day); fprintf(fp," 测试时间：%02d:%02d:%02d",now.ti_hour,now.ti_min,now.ti_sec);}else if(a>=0) fprintf(fp,"\n step: %02d , %s",a,st);writeok=1;fclose(fp);}return writeok;}int writeerror(char a,char *st) /*错误类型文件*/{FILE *fpp;fpp=fopen("an_slr.txt","a");if(fpp==0){printf("\nwrite error!!");writeok=0;}else{if(a=='0') fprintf(fpp," %s ",st); /*若a=='0' 则为添加的注释*/else fprintf(fpp," %s \'%c\'(位置:%d) ",st,a,ip+1);writeok=1;fclose(fpp);}return writeok;}/*^^^^^^^^^^^^^^^^^^^^^^*/main0(){int an,flag=1,action,lenr;char a,w[MAXINPUT];int len,s,ss,aa,ana;stack *st;char r[MAXSH][MAXSHL]; /*初始化产生式*/strcpy(r[0],"S->E");strcpy(r[1],"E->E+T");strcpy(r[2],"E->T");strcpy(r[3],"T->T*F");strcpy(r[4],"T->F");strcpy(r[5],"F->(E)");strcpy(r[6],"F->i");clrscr();printf("\nplease input analyse string:\n");gets(w);len=strlen(w);w[len]='#';w[len+1]='\0';initstack(st);push(st,48); /* (int)0 进栈*/writefile(-1,"\n------------------------SLR(1)词法分析器-------------------------");writefile(-1,"\n 计本003 安完成于2003.01.12 14:04");writefile(-1,"\n谢谢");writefile(-1,"网 ");writefile(-1,"\n 以下为串");writefile(-1,w);writefile(-1,"('#'为系统添加)的分析结果： ");writefile(-2," ");do{s=gettop(st);aa=(int)w[ip];action=analys(s,aa);if(action==MOVEIN){ss=48+act;push(st,aa);push(st,ss); /* if ss=4 int =52 */ip++;}else if(action==GUIYUE){lenr=strlen(r[act])-3;for(an=0;an<=2*lenr-1;an++)pop(st); /* #0 */s=gettop(st); /* s=0 */push(st,(int)r[act][0]);/*将产生式左端 F 进栈 */ana=analys(s,(int)r[act][0])+48;if(ana>59)printf("\分析出错:ana>59!!!");push(st,ana);/*analys(s,aa)即为goto(s',aa) */if((line+1)%20==0){printf("\nThis screen is full,press any key to continue!!!");getche();clrscr();}printf(" step %02d: %s\n",line++,r[act]);writefile(line,r[act]);}else if(action==ACC){flag=0;right=1;}else if(action==ERROR){flag=0;right=0;} /*接受成功*/else{flag=0;right=0;} /* 出错*/}while(flag==1);if(right==1)printf("\nok,输入串 %s 为可接受串!!",w);if(right==0)printf("\nsorry,输入串 %s 分析出错!!",w);if(writeok==1){printf("\nAnWin soft have wrote a file an_slr.txt");if(right==1)writefile(-1,"\n最终结果：输入串为可接受串!"); }}main() /*主函数*/{clrscr();delay_fun();logined();}六、测试报告－操作系统课程设计－银行家算法(流程图+源代码+设计报告)六、测试报告：（测试结果保存于系统生成的an.txt 文件中）以下为课本上的实例：：-------------------------------------------------------------------------------------========================银行家算法测试结果=========================-------------------------------------------------------------------------------------T0 时刻可用资源(Available) A:3, B:3, C:2测试日期： 2003-6-28 请求分配时间： 14:07:29经测试，可为该进程分配资源。

银行家算法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.实验内容与要求：●设计银行家算法的核心数据结构、安全性检查算法；●画出银行家算法流程图；●编程实现算法功能；●给出运行结果、测试界面截图、程序清单●工作量要求：完成以上设计要求中的所有算法功能可以用下面的数据作为测试数据假定系统中有五个进程｛P0, P1, P2, P3, P4｝和三类资源｛A, B, C｝，各种资源的数量分别为10、5、7，在T0时刻的资源分配情况如图所示。

T0时刻的资源分配表请求序列（1）P1发出请求向量Request1(1，0，2)（2）P4发出请求向量Request4(3，3，0)（3）P0发出请求向量Requst0(0，2，0) 3.提交源代码以及实验报告。

银行家算法流程图：源代码：#include<stdio.h>#define maxprocess 50#define maxresource 100int available[maxprocess];int max[maxprocess][maxresource];int allocation[maxprocess][maxresource];int need[maxprocess][maxresource];int request[maxprocess][maxresource];int finish[maxprocess];int p[maxprocess];int m,n;void Init();//初始化int Safe();//安全性算法void Bank();//银行家算法int main(){Init();Safe();Bank();}void Init(){int i,j;printf("请输入进程的数目：\n");scanf("%d",&m);printf("请输入资源的种类：\n");scanf("%d",&n);printf("请输入每个进程最多所需的各资源数，按照%dx%d矩阵输入\n",m,n);for(i=0;i<m;i++){for(j=0;j<n;j++){scanf("%d",&max[i][j]);}}printf("请输入每个进程已分配的各资源数，也按照%dx%d矩阵输入\n",m,n);for(i=0;i<m;i++){for(j=0;j<n;j++){scanf("%d",&allocation[i][j]);need[i][j]=max[i][j]-allocation[i][j];if(need[i][j]<0){printf("您输入的第%d个进程所拥有的第%d个资源数错误，请重新输入：",i+1,j+1);j--;continue;}}}printf("请输入各自资源现有的数目：\n");for(i=0;i<n;i++){scanf("%d",&available[i]);}}void Bank(){int i,cusneed;//char again;while(1){printf("请输入要申请资源的进程号\n");scanf("%d",&cusneed);printf("请输入进程所请求的各资源的数量\n");for(i=0;i<n;i++){scanf("%d",&request[cusneed][i]);}for(i=0;i<n;i++) {if(request[cusneed][i]>need[cusneed][i]){printf("您输入的请求数超过进程的需求量！请重新输入！\n");continue;}if(request[cusneed][i]>available[i]){printf("您输入的请求数超过系统现有的资源数！请重新输入！");continue;}}for(i=0;i<n;i++){available[i]-=request[cusneed][i];allocation[cusneed][i]+=request[cusneed][i];need[cusneed][i]-=request[cusneed][i];}if(Safe()){printf("同意分配请求\n");}else{printf("您的请求被拒绝！\n");for(i=0;i<n;i++){available[i]+=request[cusneed][i];allocation[cusneed][i]-=request[cusneed][i];need[cusneed][i]+=request[cusneed][i];}}for(i=0;i<m;i++){finish[i]=0;}}}int Safe(){int i,j,k,l=0;int Work[maxresource];for(i=0;i<n;i++){Work[i]=available[i];}for(i=0;i<m;i++){finish[i]==0;}for(i=0;i<m;i++){if(finish[i]==1){continue;}else{for(j=0;j<n;j++){if(need[i][j]>Work[j]){break;}}if(j==n){finish[i]=1;for(k=0;k<n;k++){Work[k]+=allocation[i][k];}p[l++]=i;i--;}else{continue;}}if(l==m){printf("系统是安全的\n");printf("安全序列：\n");for(i=0;i<l;i++){printf("%d ",p[i]);if(i!=l-1){printf("-->");}}return 1;}}printf("系统是不安全的\n");return 0;}要求：（1）实验报告名：班级名_完整学号_姓名_银行家算法的设计与实现（2）实验报告内容：实验要求、实验过程描述（主要算法或者流程、数据结构说明）、主要源代码注解、运行界面、问题分析和总结。

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; } } }

package bao1;import java.util.*;/*此类主要功能如下：* 1.初始化资源* 2.进行死锁避免* 3.检索进程请求资源是否可行* */class TestBanker{int m;int n;int[][] max;int[][] max1;int[][] allocation;int[][] allocation1;int[][] need;int[][]need1;int[] available;int[] availablebak;public TestBanker(){Scanner s = new Scanner(System.in);System.out.print("请依次输入系统中的进程数：");m = s.nextInt();System.out.print("请依次输入系统中的资源类型数：");n = s.nextInt();max =new int[m][n];max1 = new int[m][n];allocation = new int[m][n];allocation1 = new int[m][n];need = new int[m][n];need1 = new int[m][n];available = new int[n];availablebak = new int[n];for(int i=0;i<max.length;i++){//初始化向量MAX、ALLOCA TION、NEED、A V AILABLESystem.out.print("请依次输入第" + i + "进程所需的最大（max）的各资源数：");for(int j=0;j<max[i].length;j++){max[i][j] = s.nextInt();max1[i][j] = max[i][j];}}for(int i=0;i<allocation.length;i++){System.out.print("请依次输入第" + i + "进程中已分配(allocation)资源的数量：");for(int j=0;j<allocation[i].length;j++){allocation[i][j] = s.nextInt();allocation1[i][j] = allocation[i][j];}}for(int i=0;i<need.length;i++){System.out.println("请一次输入第"+i+"进程尚需的(need)资源数量");for(int j=0;j<need[i].length;j++){need[i][j] = max[i][j] - allocation[i][j];need1[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("初始化结果=============");init();}public void init(){//输出分配资源的状态System.out.println(" MAX ALLOCA TION NEED A V AILABLE");for(int i=0;i<m;i++){System.out.print("P" + i + ": ");for(int j=0;j<n;j++){if(max[i][j]>9){//如果是两位数，控制格式，在数字前少输出一个" "。

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

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

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

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

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

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

b)Request i=Need［i］。

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

c)Request i〉Need［i］。

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

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

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

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

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

操作系统课程设计（一号黑体加粗）银行家算法模拟（小二黑体加粗）院系：小二黑体加粗班级：学号：姓名：同组者：时间：目录（小二黑体加粗）一、题目 (3)二、设计目的 (3)三、总体设计思想概述 (3)四、设计要求 (3)五、设计方案 (3)六、说明 (4)七、流程图 (5)八、运行结果 (5)九、源程序 (7)十、总结 (12)十一、参考文献 (12)一、题目：（标题2，即三号黑体加粗）银行家算法模拟。

二、设计目的：通过此课程设计，进行的一次全面的综合训练，使之更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。

三、总体设计思想概述：安全状态下系统不会进入死锁，不安全状态可能进入死锁。

在进行资源分配之前，先计算分配的安全性，判断是否为安全状态。

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

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

设计完成后，要求写出一份详细的设计报告。

五、设计方案：编制银行家算法通用程序，并检测所给状态的系统安全性。

1）银行家算法中的数据结构假设有n个进程m类资源，则有如下数据结构：可利用资源向量Available。

这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。

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

最大需求矩阵Max。

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

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

分配矩阵Allocation。

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

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

银行家算法设计与实现摘要：解决死锁的方法有很多,一般可分为鸵鸟算法，预防，避免，检测与恢复。

银行家算法是一种最有代表性的避免死锁的算法。

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

在银行家算法中存在安全序列，则按安全序列申请资源不会导致死锁的发生。

若不存在安全序列并不是意味着系统一定会死锁，它只是说明若按此序列分配有可能会导致死锁，它是一种不安全的状态。

关键词：操作系统，银行家算法，Java语言程序设计，进程，死锁Design and implementation of banker's algorithmAbstract : There are many ways to solve the deadlock, which can be divided into ostrich algorithm, prevention, avoidance, detection and recovery. The banker's algorithm is one of the most representative algorithms to avoid deadlock. In the deadlock avoidance method, the process is allowed to dynamically apply for resources, but before the system is allocated, the safety of the allocated resource should be calculated first. If the distribution does not cause the system to enter the unsafe state, it will allocate or wait. There is a security sequence in the banker's algorithm, and the application of a security sequence does not lead to the occurrence of a deadlock. If there is no security sequence, it does not mean that the system will be deadlock. It means that if it is allocated according to this sequence, it may lead to deadlock. It is an unsafe state.Key Words: Operating System, Banker Algorithm, Java, Process, Deadlock一. 引言银行家算法是一种最有代表性的避免死锁的算法。

操作系统实验报告实验四：银行家算法的实现计科112 康岩岩2011008142202013/4/29实验四：银行家算法的实现一．实验目的（1）加深了解有关资源申请、避免死锁等概念。

（2）体会和了解死锁和避免死锁的具体实施方法。

二．实验属性该实验为设计性实验。

三．实验仪器设备及器材普通PC386以上微机四．实验要求本实验要求2学时完成。

本实验要求完成如下任务：（1）设计进程对各类资源最大申请表示及初值的确定。

（2）设定系统提供资源的初始状况。

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

（4）编制程序，依据银行家算法，决定其资源申请是否得到满足。

（5）显示资源申请和分配时的变化情况。

五．实验步骤（一）任务分析：实现银行家算法，首先需要构造四张链表表，如下：进程最大需求数量表：Max[m][n]进程以获取资源量表 Allocation[m][n]需求表 Need[m][n]可用资资源 Available[n]其中，m表示进程数目。

n表示资源数目。

对于银行家算的实现，我们可以先初始化一部分数据，模拟出某一状态下的资源分配情况。

并发出资源请求，然后判断请求是否可行，并寻找安全序列。

可以看出，本次试验会设计到大量的数据，所以为了简化步骤，并且能直观的得到算法运行结果，需要用到窗口来呈现数据变化情况。

（二）程序设计：（1）总体设计：本次试验语言为java。

程序分两大部分，一部分是核心的银行家算法，用来处理资源请求。

另一部分是界面，用来发出资源请求并显示处理结果。

利用java的swing编程和相关IDE，很容易初始化资源分布情况，下面是其截图：（2）具体实现：核心部分,银行家算法：算法的实现完全按照教材中的步骤来进行，具体实现如下：/**** @param processID 进程号* @param ra 请求A类资源数量* @param rb 请求A类资源数量* @param rc 请求C类资源数量*/public static List<Integer> checkEnable(int processID, int ra, int rb, int rc) {//得等到该进程对各类资源的需求量数组Integer need[] = Need.get(processID);//得等到该进程的各类资源的就绪量数组Integer allocation[] = Allocation.get(processID);//检测请求数量是否大于需求量if (ra > need[0] || rb > need[1] || rc > need[2]) {return null;}//检测请求量是否大于可用量if (ra > Available[0] || rb > Available[1] || rc > Available[2]) {return null;}//先根据需求修改各类数据，如果后来检测到不存在安全序列，这些数据还会复原Available[0] -= ra;Available[1] -= rb;Available[2] -= rc;need[0] -= ra;need[1] -= rb;need[2] -= rc;allocation[0] += ra;allocation[1] += rb;allocation[2] += rc;//获取安全序列List<Integer> list = findSaftyLine(processID);//如果安全序列为空，则恢复刚才修改的数据if (list == null) {Available[0] += ra;Available[1] += rb;Available[2] += rc;need[0] += ra;need[1] += rb;need[2] += rc;allocation[0] -= ra;allocation[1] -= rb;allocation[2] -= rc;}return list;}/*** 寻找安全序列* @param proceeeId* @return*/private static List<Integer> findSaftyLine(int proceeeId) {//得到进程数目int count = Max.size();//标示进程是否安全的数组boolean[] finish = new boolean[count];for (int i = 0; i < count; i++) {finish[i] = false;}//得到现有各类资源数目Integer work[] = new Integer[]{Available[0], Available[1], Available[2]};int curr = proceeeId;//安全序列List<Integer> saft = new ArrayList();//寻找满足条件”finish[i]=false And Need[i][j]<work[j]“（摘自课本）的进程while (curr < count) {if (finish[curr] == false) {Integer need[] = Need.get(curr);//检测需求量是否符合要求，如果符合，需要修改相应数值if ((need[0] <= work[0]) && (need[1] <= work[1]) && (need[2] <= work[2])) {Integer allocation[] = Allocation.get(curr);work[0] += allocation[0];work[1] += allocation[1];work[2] += allocation[2];saft.add(curr); //线程号加入安全序列finish[curr] = true; //标示完成curr = 0; //从头搜索数据} else {curr++;}} else {curr++;}}//检测是否有进程不安全for (int i = 0; i < count; i++) {if (finish[i] == false) {return null;}}return saft;}界面部分：虽然界面不是实验的关键，但在本次实验中，界面担当了很重要作用，银行家算法有可能涉及大量数据，所以这需要一个良好的界面来呈现数据。

System.out.println("**************************************************"); System.out.println("各进程的资源分配情况："); int size=this.process.size(); for(int i=0;i<size;i++) { Process pro=this.process.get(i); System.out.print("进程名称： "+pro.getName()+" ");
//输出资源 public void outputResource() {
int size=this.resource.size(); for(int i=0;i<size;i++)
System.out.print(this.resource.get(i)+" "); }
//输出安全序列 public void outputSquence() {
4、流程图：
2
1.系统主要过程流程图
3
2.银行家算法流程图
4
3.安全性算法流程图
三、 实验代码：
1.进程 public class Process {
//数据成员 private String name; private int[] Max; private int[] Allocation;
this.Max[i]=max[i]; this.Allocation[i]=allocation[i]; this.need[i]=this.Max[i]-this.Allocation[i]; } } else System.out.println("int[] max 和 int[] allocation 数据不合法。 "); }