计算机操作系统 课程设计报告 银行家算法

合集下载

《操作系统》课程实验报告银行家算法

《操作系统》课程实验报告银行家算法

《操作系统》课程实验报告实验名称:银行家算法姓名:学号:地点:指导老师:专业班级:一、实验目的:1)对死锁避免中的银行家算法做进一步的理解。

2)加深理解死锁的概念3)加深理解安全序列和安全状态的概念4)通过编程,掌握银行家算法分配资源的一步步实现过程二、实验内容:1)给出系统可用资源向量2)给出当前状态系统中各个进程的资源分配情况3)根据系统当前资源状态和各个进程的资源分配情况,判断系统是否处于安装状态,若系统处于安全状态,给出所有的安全序列和每一个安全序列所对应的资源分配图,若系统不处于安全序列,则发出死锁警告。

三、实验主要代码/**银行家算法(实现所有存在路径的查找)*///构造进程单位struct Process{string p_name; //进程的名称int Max[N]; //进程对于各个资源的最大需求数目int Allocation[N]; //进程已经得到的各个资源的数目int Need[N]; // 进程对各个资源所需要的数目};int p_num, s_num; // 进程数、资源种类static struct Process P[N];int Available[N]; //系统中各个资源可用的数目void dfs(int step){/**银行家算法(实现所有存在路径的查找)搜寻所有的安全序列 */for (int i = 0; i < p_num; i++){back_time++; // 找到当前安全序列的时间点int flag = 0;if (vis[i]) continue;//判断现有的系统资源是否满足该进程的需求for (int j = 0; j < s_num; j++){if (Available[j] < P[i].Need[j]){flag = 1;break;}}if (flag) continue;vis[i] = true;//该进程运行完毕ans[step] = i;//将这个可以运行的进程编号存入数组当中// 回收资源for (int j = 0; j < s_num; j++)Available[j] += P[i].Allocation[j];//如果所有的进程都全部执行完毕if (step == p_num)Print(ans, p_num);dfs(step + 1);vis[i] = false;for (int j = 0; j < s_num; j++)Available[j] -= P[i].Allocation[j];}}四、实验过程分析本次实验的主要任务是实现银行家算法,通过输入当前某一时刻系统的资源数目和所有进程相关的资源信息,然后通过算法的实现判断当前系统是否处于不安全状态,如果是处于安全状态那么找到所有的安全序列。

操作系统课设-银行家算法

操作系统课设-银行家算法

《计算机操作系统》课程设计报告题目:银行家算法设计与实现专业:软件工程班级: 09级(2)班姓名: XXX 学号: XXX 指导老师: XXX 完成时间: 2012年2月20日目录一、课设题目要求二、算法设计思路三、主要数据结构及其说明四、程序流程图五、源程序代码六、结果及数据分析七、实验心得八、参考资料一、课设题目要求模拟一个银行家算法,要求如下:输入:1.系统中各类资源表2.每个进程需要各类资源总数系统分配给各个进程各类资源数输出:1.判断T0时刻的安全性2.如果系统是安全的,任意给出某个进程的一个资源请求方式并判断系统能否接受此请求,如果可以接受,其输出全部安全序列,反之,不予分配。

二、算法设计思路银行家算法是一种最具代表性的避免死锁的算法。

要解释银行家算法,必须先解释操作系统的安全状态和不安全状态。

安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,P n,则系统处于安全状态。

安全状态一定没有死锁发生。

不安全状态:不存在一个安全序列。

不安全状态不一定导致死锁。

安全序列:一个进程序列{P1,…,P n}是安全的,如果对于每个进程Pi (0≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj(j<i)当前占有资源量之和。

先对系统从源文件中读取的数据进行安全性判断,然后对用户提出的请求进行合法性检查,即检查请求的是不大于需要的,不大于系统可利用的资源。

若请求合法,则进行试分配,最后对试分配状态调用安全性算法进行安全性检查。

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

三、主要数据结构及其说明进程数 i、M资源种类数 j、N最大需求矩阵 int Max[i][j];分配矩阵 int Allocation[i][j];需求矩阵 int Need[i][j]=Max[i][j]-Allocation[i][j];工作向量 int Work[N];可利用资源矩阵 int Available[N];进程的数目 int n_pro=0;标记安全序列 int flag[M]={-1};安全序列的个数 int w=0;表示系统是否有足够的资源分配给进程 bool finish[M];安全性检查算法Safe()函数只要求出了一种安全序列就可以说明系统是处于安全状态的,故:①设置了两个向量:工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目,在执行安全性算法开始时,Work =Available 。

计算机操作系统课程设计报告《Linux下C编程实现银行家算法》

计算机操作系统课程设计报告《Linux下C编程实现银行家算法》

《计算机操作系统》课程设计题目:Linux下C编程实现银行家算法专业:软件工程年级:小组成员:指导教师:时间:地点:2014年12 月摘要Dijkstra(艾兹格·迪科斯彻) 的银行家算法是最有代表性的避免死锁的算法,该算法由于能用于银行系统现金贷款的发放而得名。

银行家算法是在确保当前系统安全的前提下推进的。

对进程请求先进行安全性检查,来决定资源分配与否,从而确保系统的安全,有效的避免了死锁的发生。

该论文在理解和分析了银行家算法的核心思想以及状态的本质涵义的前提下,对算法的实现在总体上进行了设计,包括在对算法分模块设计,并对各个模块的算法思想通过流程图表示,分块编写代码,并进行测试,最后进行程序的测试,在设计思路上严格按照软件工程的思想执行,确保了设计和实现的可行,可信。

代码实现采用C语言。

目录目录1.概述 (4)2.课程设计任务及要求 (4)2.1 设计任务 (4)2.2设计要求 (5)3.算法及数据结构 (5)3.1算法的总体思想 (5)3.2 安全算法模块 (6)3.2.3 算法(流程图表示,或伪C表示) (7)4. 程序设计与实现 (9)4.1程序流程图 (9)4.2程序代码(部分代码) (9)4.3实验结果 (11)5 结论 (13)6 收获、体会和建议。

(14)7 参考文献。

(14)1.概述银行家算法是一种最有代表性的避免死锁的算法。

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

为实现银行家算法,系统必须设置若干数据结构。

要解释银行家算法,必须先解释操作系统安全状态和不安全状态。

安全序列是指一个进程序列{P1,…,Pn}是安全的,即对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。

安全状态如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。

操作系统课程设计 银行家算法报告

操作系统课程设计 银行家算法报告

操作系统课程设计报告院(系):计算机工程学院专业:计算机科学与技术专业学生姓名:__班级:__计算073 _学号:题目:仿真模拟银行家算法对死锁的避免起迄日期:__2010-7-6至2010-7-16_设计地点: 2号实验楼402指导教师:2009—2010年度第 2 学期完成日期: 2010 年 7 月 16 日一、课程设计目的《操作系统》是一门重要的专业基础课,是涉及较多硬件知识的计算机系统软件课程。

在计算机软硬件课程的设置上,它起着承上启下的作用。

操作系统对计算机系统资源实施管理,是所有其他软件与计算机硬件的唯一接口,所有用户在使用计算机时都要得到操作系统提供的服务。

操作系统课程设计的主要任务是研究计算机操作系统的基本原理和算法,掌握操作系统的进程管理、存储管理、文件管理和设备管理的基本原理与主要算法。

目的是使学生掌握常用操作系统(如DOS、Windows或Linux)的一般管理方法,了解它是如何组织和运作的,对操作系统的核心概念和算法有一个透彻的理解,并对系统运行的机制有一个全面的掌握,从而充分理解系统调用与程序设计之间的关系。

二、课程设计内容仿真模拟银行家算法对死锁的避免。

对于进程死锁的避免问题,分为两种状态:安全状态和非安全状态。

在避免死锁的方法中,允许进程动态地申请资源分配之前,应先计算此次资源分配的安全性。

若此次分配不会导致系统进入不安全状态,则将资源分配给进程;否则,令进程等待。

所谓安全状态是指系统能按某种进程顺序,来为每个进程pi分配所需的资源,直至满足每个进程对资源的最大需求,使每个进程都可顺利地完成。

如果系统无法找到这样一个序列,则系统处于不安全状态。

只要系统处于安全状态,系统便可避免进入死锁状态。

因此避免死锁的实质在于:系统在进行资源分配时,如何使系统不进入不安全状态。

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

三、系统分析与设计1、系统分析系统分析的主要任务是将在系统详细调查中所得到的文档资料集中到一起,对组织内部整体管理状况和信息处理过程进行分析。

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

(完整word版)操作系统课程设计银行家算法

(完整word版)操作系统课程设计银行家算法

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

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

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

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

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

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

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

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

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

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

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

三、问题分析与设计: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)。

操作系统课程设计实验报告用C实现银行家算法

操作系统课程设计实验报告用C实现银行家算法

操作系统实验报告2学院:计算机科学与技术学院班级:计091学号:姓名:时间:2011/12/30目录1.实验名称 (3)2.实验目的 (3)3.实验内容 (3)4.实验要求 (3)5.实验原理 (3)6.实验环境 (4)7.实验设计 (4)数据结构设计 (4)算法设计 (6)功能模块设计 (7)8.实验运行结果 (8)9.实验心得 (9)附录:源代码部分 (9)一、实验名称:用C++实现银行家算法二、实验目的:通过自己编程来实现银行家算法,进一步理解银行家算法的概念及含义,提高对银行家算法的认识,同时提高自己的动手实践能力;各种死锁防止方法能够阻止发生死锁,但必然会降低系统的并发性并导致低效的资源利用率;死锁避免却与此相反,通过合适的资源分配算法确保不会出现进程循环等待链,从而避免死锁;本实验旨在了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生;三、实验内容:利用C++,实现银行家算法四、实验要求:1.完成银行家算法的设计2.设计有n个进程共享m个系统资源的系统,进程可动态的申请和释放资源,系统按各进程的申请动态的分配资源;五、实验原理:系统中的所有进程放入进程集合,在安全状态下系统收到进程的资源请求后,先把资源试探性的分配给它;之后,系统将剩下的可用资源和进程集合中的其他进程还需要的资源数作比较,找出剩余资源能够满足的最大需求量的进程,从而保证进程运行完毕并归还全部资源;这时,把这个进程从进程集合中删除,归还其所占用的所有资源,系统的剩余资源则更多,反复执行上述步骤;最后,检查进程集合,若为空则表明本次申请可行,系统处于安全状态,可以真正执行本次分配,否则,本次资源分配暂不实施,让申请资源的进程等待;银行家算法是一种最有代表性的避免的算法;在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待;为实现银行家算法,系统必须设置若干;要解释银行家算法,必须先解释操作系统安全状态和不安全状态;安全序列是指一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi1≤i≤n,它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj j < i 当前占有资源量之和;安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态;安全状态一定是没有死锁发生;不安全状态:不存在一个安全序列;不安全状态不一定导致死锁;我们可以把看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款;为保证资金的安全,银行家规定:1 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;2 顾客可以分期贷款,但贷款的总数不能超过最大需求量;3 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;4 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金.操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配;当进程在执行中继续申请资源时,先测试该进程本次申请的资源数是否超过了该资源所剩余的总量;若超过则拒绝分配资源,若能满足则按当前的申请量分配资源,否则也要推迟分配;六、实验环境:Win-7系统Visual C++七、实验设计:1.数据结构设计定义结构体:struct Process0, 0, 0;}}};class DataInit法设计class FindSafeListdb->available; db->pdb->ruleri.currentAvail db->pdb->ruleri-1.currentAvail;db->pdb->ruleri-1.allocation;db->pdb->ruleri.currentAvail{ return false; }db->sum{ return false; }}return true; laim_allocation{ return 1; }Source sdb->pi.allocation; db->ask;db->pi.db->ask;ifexsitSafeListdb db->ask;db->pi.db->ask;return 2;}db->0,0,0; 能模块设计class Data0, 0, 0;}}};class DataInitr1,r2,r3;cout<<'p'<<i<<" max allocationclaimR1,R2,R3: ";r1,r2,r3;r1=db->pi.>pi.;pi.;r3=db->pi.>pi.;db->pi.r1, r2, r3;}}};class Displaylaim;cout<<"\t\t";displaySourcepi.allocation;cout<<endl;}cout<<endl;}void displaySafeListData db urrentAvail;cout<<" ";displaySourcedb->pdb->ruleri.claim;cout<<" ";displaySourcedb->pdb->ruleri.allocation;cout<<" ";displaySourcedb->pdb->ruleri.claim_allocation;cout<<" true";cout<<endl;}}void displayAskResultData db,int n db->available;db->pdb->ruleri.currentAvail db->pdb->ruleri-1.currentAvail;db->pdb->ruleri-1.allocation;db->pdb->ruleri.currentAvail{ return false; }db->sum{ return false; }}return true; laim_allocation{ return 1; }Source sdb->pi.allocation; db->ask;db->pi.db->ask;ifexsitSafeListdb db->ask;db->pi.db->ask;return 2;}db->0,0,0; //找到安全序列,将请求资源置零,返回3return 3;}};void main{Data db;db=new Data;ifdb{ cout<<"errorno enough memory space"; return; } DataInit dataInit;db; //设置进程个数db; //设置系统总资源量db; //设置当前系统可获得资源量db; //设置t0时刻进程基本状态Display display;FindSafeList findSafeList;int r1=0,r2=0,r3=0;int c;db->r1,r2,r3; //设置请求资源为0,即无请求c=db,0; //寻找安全序列,返回结果ifc=3{ cout<<"t0时刻的进程组不存在安全序列\n"; return; }int choice=1;int pi;whilechoice{cout<<"\n 选择操作:\n 1 查看进程情况\n 2 请求分配资源\n 0 退出\n ";cin>>choice;switchchoice{case 1:{cout<<"当前资源量availableR1,R2,R3:\n ";db->available;cout<<endl;cout<<"\n当前进程资源分配情况piR1,R2,R3: \n";cout<<" 进程\tclaim\t\tallocation\n";db->p,db->pLength;break;}case 2:{cout<<"输入请求资源进程序号:";cin>>pi;cout<<"输入请求资源R1,R2,R3: 0,0,0表示当前进程组无请求\n";cin>>r1>>r2>>r3;db->r1,r2,r3;c=db,pi;db,c;cout<<endl;break;}case 0:{ break; }default:{ cout<<"input errortry again\n"; break; }}}}。

操作系统课程设计报告 银行家算法

操作系统课程设计报告 银行家算法

操作系统课程设计报告题目:银行家算法操作系统课程设计报告题目:银行家算法摘要在多道操作系统中,可以利用多个进程并发执行来改善系统资源利用率,提高系统的吞吐量,但也可能发生人们不想看到的危险——死锁。

为了解决这个问题,人们引入了多种机制处理死锁问题。

本文主要介绍了操作系统如何运用银行家算法和安全性算法避免死锁的产生。

同时运用Java编程语言模拟计算机内部资源分配的过程。

让读者对银行家算法有更深刻的认识。

关键字:死锁银行家算法安全性算法资源分配IAbstractIn much road OS, improve the systematic handling capacity, but also may people happened not thinking of dangerous dead lock seeing that to come to improve system resource utilization ratio being able to make use of many course concurrency to carry out. Have led into various mechanism for problem , people resolving this handle lock fast problem. The main body of a book has been introduced mainly how to apply the banker algorithm and the security algorithm to avoid lock fast creation. Wield Java programming language analog computer inside resource assignment process at the same time. Let reader have deeper cognition to banker algorithm.Key words: Algorithmic algorithmic security of dead lock banker resource assignmentII目录中文摘要 (I)英文摘要 (II)1绪论 (1)2需求分析 (2)3概要设计 (3)4详细设计 (4)5测试与分析 (6)6总结 (11)7参考文献 (12)附录 (13)1绪论银行家算法诞生的背景:操作系统作为裸机上安装的第一层软件,起着控制和管理计算机内部软硬件资源,合理组织计算机工作流程,提高计算机工作效率,用户和计算机硬件接口的重要作用。

操作系统课程设计银行家算法参考

操作系统课程设计银行家算法参考

3 课程设计三银行家算法(参考1)1设计目的(1)了解多道程序系统中,多个进程并发执行的资源分配。

(2)掌握死锁产生的原因、产生死锁的必要条件和处理死锁的基本方法。

(3)掌握预防死锁的方法,系统安全状态的基本概念。

(4)掌握银行家算法,了解资源在进程并发执行中的资源分配策略。

(5)理解避免死锁在当前计算机系统不常使用的原因。

2.算法描述Dijkstra(1965年)提出了一种能够避免死锁的调度方法,称为银行家算法,它的模型基于一个小城镇的银行家,现将该算法描述如下:假定一个银行家拥有资金,数量为Σ,被N个客户共享。

银行家对客户提出下列约束条件:(1)每个客户必须预先说明自已所要求的最大资金量;(2)每个客户每次提出部分资金量申请各获得分配;(3)如果银行满足了客户对资金的最大需求量,那么,客户在资金动作后,应在有限时间内全部归还银行。

只要每个客户遵守上述约束,银行家将保证做到:若一个客户所要求的最大资金量不超过Σ,则银行一定接纳该客户,并可处理他的资金需求;银行在收到一个客户的资金申请时,可能因资金不足而让客户等待,但保证在有限时间内让客户获得资金。

在银行家算法中,客户可看做进程,资金可看做资源,银行家可看做操作系统。

3. 环境操作系统Windows XP SP2,开发工具VC++6.0或者BCB6.0。

4 功能模块说明1.银行家所能够提供的资源typedef struct node{int a;int b;int c;int remain_a;int remain_b;int remain_c;}bank;2.进程所占用的资源typedef struct node1{char name[20];int a;int b;int c;int need_a;int need_b;int need_c;}process;main()函数:完成对系统运行环境的初始化,定义了简单的选择菜单,调用各功能函数。

操作系统课程设计(银行家算法设计)

操作系统课程设计(银行家算法设计)

《 操作系统 》课程设计报告系 别: 信息科学与技术系专业班级:学生姓名:指导教师:(课程设计时间:2010年7月5日——2010年7月9日)目 录一、课程设计目的和意义 (3)二、课程设计题目描述及算法 (3)三、课程设计报告内容 (3)1.算法描述 (3)2.数据结构 (4)3.主要函数说明 (4)4.算法流程图 (5)5.运行结果及说明 (7)6.附录清单及分析 (8)四、总结 (14)一、课程设计目的和意义了解掌握银行家算法,学会模拟实现资源分配,同时有要求编写和调试一个系统分配资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生二、课程设计题目描述及算法题目:银行家算法设计设计要求:编制银行家算法通用程序,并检测所给状态的系统安全性。

设进程I提出请求Request[N],则银行家算法按如下规则进行判断。

(1)如果Request[N]<=NEED[I,N],则转(2);否则,出错。

(2)如果Request[N]<=AVAILABLE,则转(3);否则,出错。

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

上述三个矩阵存在如下关系:Need[i,j]= Max[i,j]- Allocation[i,j]三、课程设计报告内容1.算法描述设Request[i] 是进程Pi的请求向量,如果Requesti[j]=K,表示进程Pi需要K 个Rj类型的资源,当Pi发出资源请求后,系统按下面步骤进行检查:,便转向步骤2;否则认为出错,因为它所需(1)如果Requesti[j]<=Need[i,j]要的资源数已超过它所宣布的最大值。

操作系统课程设计银行家算法模拟实现

操作系统课程设计银行家算法模拟实现

操作系统课程设计银行家算法模拟实现操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导老师完成日期信息工程学院题目:银行家算法的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进展的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统根底理论和重要算法的理解,加强学生的动手才能。

二、设计内容 1〕概述用C或C++语言编制银行家算法通用程序,并检测所给状态的系统平安性。

1.算法介绍:数据构造:1〕可利用资向量 Available;2〕最大需求矩阵Max;3〕分配矩阵Allocation;4〕需求矩阵Need 2.功能介绍模拟实现Dijkstra的银行家算法以防止死锁的出现,分两局部组成:第一局部:银行家算法〔扫描〕;第二局部:平安性算法。

2〕设计原理一.银行家算法的根本概念 1、死锁概念。

在多道程序系统中,虽可借助于多个进程的并发执行,来改善系统的资利用率,进步系统的吞吐量,但可能发生一种危险━━死锁。

所谓死锁(Deadlock),是指多个进程在运行中因争夺资而造成的一种僵局(Deadly_Embrace),当进程处于这种僵持状态时,假设无外力作用,它们都将无法再向前推进。

一组进程中,每个进程都无限等待被该组进程中另一进程所占有的资,因此永远无法得到的资,这种现象称为进程死锁,这一组进程就称为死锁进程。

2、关于死锁的一些结论:Ø参与死锁的进程最少是两个Ø〔两个以上进程才会出现死锁〕Ø参与死锁的进程至少有两个已经占有资Ø参与死锁的所有进程都在等待资Ø参与死锁的进程是当前系统中所有进程的子集注:假如死锁发生,会浪费大量系统资,甚至导致系统崩溃。

3、资分类。

永久性资:可以被多个进程屡次使用〔可再用资〕l 可抢占资 l 不可抢占资临时性资:只可使用一次的资;如信号量,中断信号,同步信号等〔可消耗性资〕“申请--分配--使用--释放”形式 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设计目的银行家算法是一种最有代表性的避免死锁的算法。

银行家算法课程设计报告

银行家算法课程设计报告

《计算机操作系统》课程设计报告书选题:银行家算法模拟姓名:包玉霞学号: 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.银行家算法在避免死锁的方法中,所施加的限制条件较弱,有可能获得令人满意的系统性能。

操作系统课程设计(银行家算法)

操作系统课程设计(银行家算法)

操作系统课程设计说明书题目: 银行家算法模拟院系:计算机科学与工程学院专业班级:计算机10-5班学号: 2010303157学生姓名:张绪磊指导教师:刘惠临2013年 1月 9日安徽理工大学课程设计(论文)任务书计算机科学与工程学院计算机科学与技术系2013年 1月 9日安徽理工大学课程设计(论文)成绩评定表摘要银行家算法是一个用来预防系统进入死锁状态的算法,用它可以判断系统的安全性,如果系统当前处于安全状态,则可以为申请资源的进程分配资源;如果不是安全状态,则不能为申请资源的进程分配资源。

银行家算法执行过程中,首先判断申请资源的进程所申请的资源数目是否合法,若是合法的,则可以为其进行试分配,再利用安全性算法求出安全序列,如果存在安全序列,则说明可以给申请资源的进程分配资源,分配成功,继续为其它进程服务。

如果找不到安全序列,则说明为该进程分配资源后系统会进入不安全状态,所以不能为该进程分配资源,使该进程进入阻塞状态。

若申请资源的进程申请的资源数目不合法,则不需要进行试分配,直接使其进入阻塞状态,处理其他申请资源的进程。

关键词:可用资源,最大需求矩阵,分配矩阵,需求矩阵,安全性算法,安全序列目录1.绪论 (1)1.1系统分工 (1)1.2课题背景 (1)1.3死锁 (1)1.4安全性 (2)1.5算法设计思想 (2)2.需求分析 (3)2.1基本要求 (3)2.2模块划分 (3)3.总体设计 (4)3.1算法设计 (4)3.2模块设计 (5)4.详细设计 (6)4.1程序流程图 (6)4.2主要函数的核心代码 (6)5.程序测试 (12)5.1界面设计 (12)5.2数据测试 (13)5.3操作提示 (14)6.总结 (16)参考文献 (17)1.绪论1.1系统分工1.2课题背景在多道程序系统中,虽可以借助多个进程的并发执行来改善系统的资源利用率,提高系统吞吐量,但可能发生一种危险——死锁,即多个进程在运行过程中因争夺资源而造成的一种僵局,若无外力作用,将无法再向前推进。

操作系统课程设计银行家算法

操作系统课程设计银行家算法

《操作系统--课程设计报告》银行家算法姓名:学号:专业:指导老师:目录一、设计目的 (1)二、设计要求 (1)三、设计内容和步骤 (1)四、算法描述 (6)五、实验结果 (12)六、实验心得 (12)一、设计目的银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

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

二、设计要求在了解和掌握银行家算法的基础上,能熟练的处理课本例题中所给状态的安全性问题,能编制银行家算法通用程序,将调试结果显示在计算机屏幕上。

具体程序的功能要求:1.设定进程对各类资源最大申请表示及初值确定。

2.设定系统提供资源初始状况(已分配资源、可用资源)。

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

4.编制程序,依据银行家算法,决定其申请是否得到满足。

三、设计内容和步骤设计内容银行家算法的思路:先对用户提出的请求进行合法性检查,即检查请求的是不大于需要的,是否不大于可利用的。

若请求合法,则进行试分配。

最后对试分配后的状态调用安全性检查算法进行安全性检查。

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

设计步骤1、为实现银行家算法,系统中需要设置若干数据结构,用来表示系统中各进程的资源分配及需求情况。

假定系统中有M个进程,N类资源。

进程数和资源数由程序中直接定义#define M 5 //总进程数#define N 3 //总资源数银行家算法中使用的数据结构如下:(1)可利用资源Available。

这是一个含有m个元素的数组,其中的每一个元素代表一类资源的空闲资源数目,其初值是系统中所配置的该类资源的数目,其数值随该类资源的分配和回收而动态的改变。

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

(2)最大需求矩阵Max。

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

如果Max[i,j]=k,表示进程Pi对Rj类资源的最大需求数为k个。

操作系统课程设计报告――银行家算法

操作系统课程设计报告――银行家算法

操作系统课程设计报告――银行家算法中原工学院信息商务学院操作系统课程设计报告操作系统课程设计报告课程设计名称:银行家算法的模拟实现专业:计算机科与技术(软件工程方向)班级:软件***班学号:*** *学生姓名:锦超 9817 指导教师:杨**2021 年 6 月 26 日星期六中原工学院信息商务学院操作系统课程设计报告目录一、实验目的...........................................................................2 二、实验内容...........................................................................2 三、实验步骤...........................................................................3 (1)需求分析...............................................................................3 (2)概要设计...............................................................................3 (3)详细设计...............................................................................3 (4)调试分析..............................................................................11 (5)测试结果..............................................................................11 (6)使用说明:............................................................................15 四、实验总结...........................................................................15 五、附录:程序清单...............................................................15 六、参考资料. (26)- 1 -中原工学院信息商务学院操作系统课程设计报告银行家算法的模拟实现一、实验目的( 1)了解进程产生死锁的原因,了解为什么要进行死锁的避免。

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

《计算机操作系统》课程设计报告题目:银行家算法班级: XXXXXXXXXXXXXXXX 姓名: XXM 学号: XXXXXXXXXXXX 指导老师: XXXXXXXXXXXXXX 设计时间: XXXXXXXXXXXXXXX一.设计目的1、掌握死锁概念、死锁发生的原因、死锁产生的必要条件;2、掌握死锁的预防、死锁的避免;3、深刻理解死锁的避免:安全状态和银行家算法;二.银行家算法1.简介银行家算法是一种最有代表性的避免死锁的算法。

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

为实现银行家算法,系统必须设置若干数据结构。

2.数据结构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].3.算法原理操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

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

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

三.算法实现1.初始化由用户输入数据,分别对可利用资源向量矩阵A V AILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。

2.银行家算法在避免死锁的方法中,所施加的限制条件较弱,有可能获得令人满意的系统性能。

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

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

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

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

(2)如果REQUEST [cusneed] [i]<= A V AILABLE[cusneed][i],则转(3);否则,出错。

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

3.安全性检查算法(1)设置两个工作向量Work=A V AILABLE;FINISH(2)从进程集合中找到一个满足下述条件的进程,FINISH==false;NEED<=Work;如找到,执行(3);否则,执行(4)(3)设进程获得资源,可顺利执行,直至完成,从而释放资源。

Work+=ALLOCATION;Finish=true;GOTO 2(4)如所有的进程Finish= true,则表示安全;否则系统不安全。

4.算法流程图1)初始化算法流程图2)银行家算法流程图:3)安全性算法流程图:4.代码(C语言)#include <STRING.H>#include <stdio.h>#include <stdlib.h>#include <CONIO.H> /*用到了getch()*/ #define M 5 /*进程数*/#define N 3 /*资源数*/#define FALSE 0#define TRUE 1/*M个进程对N类资源最大资源需求量*/ intMAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2 ,2,2},{4,3,3}};/*系统可用资源数*/int AVAILABLE[N]={10,5,7};/*M个进程对N类资源最大资源需求量*/ intALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};/*M个进程已经得到N类资源的资源量 */ intNEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{ 2,2,2},{4,3,3}};/*M个进程还需要N类资源的资源量*/int Request[N]={0,0,0};void main(){int i=0,j=0;char flag;void showdata();void changdata(int);void rstordata(int);int chkerr(int);showdata();enter:{printf("请输入需申请资源的进程号(从0到");printf("%d",M-1);printf("):");scanf("%d",&i);}if(i<0||i>=M){printf("输入的进程号不存在,重新输入!\n");goto enter;}err:{printf("请输入进程");printf("%d",i);printf("申请的资源数\n");printf("类别: A B C\n");printf(" ");for (j=0;j<N;j++){scanf("%d",&Request[j]);if(Request[j]>NEED[i][j]){printf("%d",i);printf("号进程");printf("申请的资源数 > 进程");printf("%d",i);printf("还需要");printf("%d",j);printf("类资源的资源量!申请不合理,出错!请重新选择!\n");goto err;}else{if(Request[j]>AVAILABLE[j]){printf("进程");printf("%d",i);printf("申请的资源数大于系统可用");printf("%d",j);printf("类资源的资源量!申请不合理,出错!请重新选择!\n");goto err;}}}}changdata(i);if(chkerr(i)){rstordata(i);showdata();}elseshowdata();printf("\n");printf("按'y'或'Y'键继续,否则退出\n");flag=getch();if (flag=='y'||flag=='Y'){goto enter;}else{exit(0);}}/*显示数组*/void showdata(){int i,j;printf("系统可用资源向量:\n");printf("***Available***\n");printf("资源类别: A B C\n");printf("资源数目:");for (j=0;j<N;j++){printf("%d ",AVAILABLE[j]);}printf("\n");printf("\n");printf("各进程还需要的资源量:\n");printf("******Need******\n");printf("资源类别: A B C\n");for (i=0;i<M;i++){printf(" ");printf("%d",i);printf("号进程:");for (j=0;j<N;j++){printf(" %d ",NEED[i][j]);}printf("\n");}printf("\n");printf("各进程已经得到的资源量: \n");printf("***Allocation***\n");printf("资源类别: A B C\n");for (i=0;i<M;i++){printf(" ");printf("%d",i);printf("号进程:");/*printf(":\n");*/for (j=0;j<N;j++){printf(" %d ",ALLOCATION[i][j]);}printf("\n");}printf("\n");}/*系统对进程请求响应,资源向量改变*/ void changdata(int k){int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request [j];ALLOCATION[k][j]=ALLOCATION[k][j] +Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}/*资源向量改变*/void rstordata(int k){int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]+Request [j];ALLOCATION[k][j]=ALLOCATION[k][j] -Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}/*安全性检查函数*/int chkerr(int s){int WORK,FINISH[M],temp[M];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){WORK=AVAILABLE[j];i=s;while(i<M){if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;temp[k]=i;k++;i=0;}else{i++;}}for(i=0;i<M;i++)if(FINISH[i]==FALSE){printf("\n");printf("系统不安全! 本次资源申请不成功!\n");printf("\n");return 1;}}printf("\n");printf("经安全性检查,系统安全,本次分配成功。

相关文档
最新文档