操作系统实验2银行家算法

合集下载

操作系统实验二:银行家算法

操作系统实验二:银行家算法

操作系统实验⼆:银⾏家算法实验⼆银⾏家算法⼀、实验⽬的1、了解什么是操作系统安全状态和不安全状态;2、了解如何避免系统死锁;3、理解银⾏家算法是⼀种最有代表性的避免死锁的算法,掌握其实现原理及实现过程。

⼆、实验内容根据银⾏家算法的基本思想,编写和调试⼀个实现动态资源分配的模拟程序,并能够有效避免死锁的发⽣。

三、实验原理进程申请资源时,系统通过⼀定的算法判断本次申请是否不可能产⽣死锁(处于安全状态)。

若可能产⽣死锁(处于不安全状态),则暂不进⾏本次资源分配,以避免死锁。

算法有著名的银⾏家算法。

1、什么是系统的安全状态和不安全状态?所谓安全状态,是指如果系统中存在某种进程序列<P1,P2,…,Pn>,系统按该序列为每个进程分配其所需要的资源,直⾄最⼤需求,则最终能使每个进程都可顺利完成,称该进程序列<P1,P2,…,Pn,>为安全序列。

如果不存在这样的安全序列,则称系统处于不安全状态。

2、银⾏家算法把操作系统看作是银⾏家,操作系统管理的资源相当于银⾏家管理的资⾦,进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。

为保证资⾦的安全,银⾏家规定:(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客;(2) 顾客可以分期贷款,但贷款的总数不能超过最⼤需求量;(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时,对顾客的贷款可推迟⽀付,但总能使顾客在有限的时间⾥得到贷款;(4) 当顾客得到所需的全部资⾦后,⼀定能在有限的时间⾥归还所有的资⾦。

操作系统按照银⾏家制定的规则设计的银⾏家算法为:(1)进程⾸次申请资源的分配:如果系统现存资源可以满⾜该进程的最⼤需求量,则按当前的申请量分配资源,否则推迟分配。

(2)进程在执⾏中继续申请资源的分配:若该进程已占⽤的资源与本次申请的资源之和不超过对资源的最⼤需求量,且现存资源能满⾜该进程尚需的最⼤资源量,则按当前申请量分配资源,否则推迟分配。

(3)⾄少⼀个进程能完成:在任何时刻保证⾄少有⼀个进程能得到所需的全部资源⽽执⾏到结束。

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

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

江南大学理学院实验报告课程名称:计算机操作系统实验名称:银行家算法实验日期:2013.11.29 班级:信计1103 姓名:陈鹭学号:1301110301实验报告要求:1.实验目的 2.实验内容与要求 3.流程图与模块调用 4.实验分析5.运行情况6.实验体会1.实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。

本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序,了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生,以加深对课堂上所讲授的知识的理解。

2.实验内容与要求内容:银行家算法流程安全算法流程要求:设计有n个进程共享m个系统资源的系统,进程可动态的申请和释放资源,系统按各进程的申请动态的分配资源。

系统能显示各个进程申请和释放资源,以及系统动态分配资源的过程,便于用户观察和分析;3.流程图与模块调用数据结构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。

Allocation 表示进程i的分配向量,有矩阵Allocation的第i行构成。

i4.需求矩阵Need,这是一个n×m的矩阵,用以表示每个进程还需要的各类资源的数目。

如果Need (i,j)=k,表示进程i还需要Rj类资源k个,才能完成其任务。

操作系统第二次银行家算法

操作系统第二次银行家算法

软件学院上机实验报告课程名称:操作系统原理实验项目:实验二银行家算法实验室:耘慧402 姓名:王欣鸿学号: 1320010724专业班级:软件13-7班实验时间: 2015-12-12一、实验目的及要求1.进一步理解利用银行家算法避免死锁的问题;2.在了解和掌握银行家算法的基础上,编制银行家算法通用程序,将调试结果显示在计算机屏幕上,再检测和笔算的一致性;3.理解和掌握安全序列、安全性算法。

二、实验性质验证性三、实验学时4学时四、实验环境Linux系统开发环境五、实验内容及步骤内容:1. 了解和理解死锁;2. 理解利用银行家算法避免死锁的原理;3. 会使用某种编程语言。

步骤:1.安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。

2. 银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。

系统按下述步骤进行安全检查:(1)如果Requesti≤Needi则继续以下检查,否则显示需求申请超出最大需求值的错误。

(2)如果Requesti≤Available则继续以下检查,否则显示系统无足够资源,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)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。

若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。

3.安全性算法(1)设置两个向量:① 工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程,使之运行完成。

银行家算法实验报告

银行家算法实验报告

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

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

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

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

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()函数:完成对系统运行环境的初始化,定义了简单的选择菜单,调用各功能函数。

操作系统实验报告-C语言实现银行家算法参考模板

操作系统实验报告-C语言实现银行家算法参考模板

实验报告附录3程序源代码:#include <stdio.h>#include <stdlib.h>#include <conio.h># define m 50int no1; //进程数int no2; //资源数int r;int allocation[m][m],need[m][m],available[m],max[m][m];char name1[m],name2[m]; //定义全局变量void main(){void check();void print();int i,j,p=0,q=0;char c;int request[m],allocation1[m][m],need1[m][m],available1[m];printf("**********************************************\n");printf("* 银行家算法的设计与实现 *\n");printf("**********************************************\n");printf("请输入进程总数:\n");scanf("%d",&no1);printf("请输入资源种类数:\n");scanf("%d",&no2);printf("请输入Max矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&max[i][j]); //输入已知进程最大资源需求量printf("请输入Allocation矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&allocation[i][j]); //输入已知的进程已分配的资源数for(i=0;i<no1;i++)for(j=0;j<no2;j++)need[i][j]=max[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值printf("请输入Available矩阵\n");for(i=0;i<no2;i++)scanf("%d",&available[i]); //输入已知的可用资源数print(); //输出已知条件check(); //检测T0时刻已知条件的安全状态if(r==1) //如果安全则执行以下代码{do{q=0;p=0;printf("\n请输入请求资源的进程号(0~4):\n");for(j=0;j<=10;j++){scanf("%d",&i);if(i>=no1){printf("输入错误,请重新输入:\n");continue;}else break;}printf("\n请输入该进程所请求的资源数request[j]:\n");for(j=0;j<no2;j++)scanf("%d",&request[j]);for(j=0;j<no2;j++)if(request[j]>need[i][j]) p=1;//判断请求是否超过该进程所需要的资源数if(p)printf("请求资源超过该进程资源需求量,请求失败!\n");else{for(j=0;j<no2;j++)if(request[j]>available[j]) q=1;//判断请求是否超过可用资源数if(q)printf("没有做够的资源分配,请求失败!\n");else //请求满足条件{for(j=0;j<no2;j++){available1[j]=available[j];allocation1[i][j]=allocation[i][j];need1[i][j]=need[i][j];//保存原已分配的资源数,仍需要的资源数和可用的资源数available[j]=available[j]-request[j];allocation[i][j]+=request[j];need[i][j]=need[i][j]-request[j];//系统尝试把资源分配给请求的进程}print();check(); //检测分配后的安全性if(r==0) //如果分配后系统不安全{for(j=0;j<no2;j++){available[j]=available1[j];allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];//还原已分配的资源数,仍需要的资源数和可用的资源数}printf("返回分配前资源数\n");print();}}}printf("\n你还要继续分配吗?Y or N ?\n");//判断是否继续进行资源分配c=getche();}while(c=='y'||c=='Y');}}void check() //安全算法函数{int k,f,v=0,i,j;int work[m],a[m];bool finish[m];r=1;for(i=0;i<no1;i++)finish[i]=false; // 初始化进程均没得到足够资源数并完成for(i=0;i<no2;i++)work[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数k=no1;do{for(i=0;i<no1;i++){if(finish[i]==false){f=1;for(j=0;j<no2;j++)if(need[i][j]>work[j])f=0;if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程{finish[i]=true;a[v++]=i; //记录安全序列号for(j=0;j<no2;j++)work[j]+=allocation[i][j]; //释放该进程已分配的资源}}}k--; //每完成一个进程分配,未完成的进程数就减1}while(k>0);f=1;for(i=0;i<no1;i++) //判断是否所有的进程都完成{if(finish[i]==false){f=0;break;}}if(f==0) //若有进程没完成,则为不安全状态{printf("系统处在不安全状态!");r=0;}else{printf("\n系统当前为安全状态,安全序列为:\n");for(i=0;i<no1;i++)printf("p%d ",a[i]); //输出安全序列}void print() //输出函数{int i,j;printf("\n");printf("*************此时刻资源分配情况*********************\n");printf("进程名/号| Max | Allocation | Need |\n");for (i = 0; i < no1; i++){printf(" p%d/%d ",i,i);for (j = 0; j < no2; j++){printf("%d ",max[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",allocation[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",need[i][j]);}printf("\n");}printf("\n");printf("各类资源可利用的资源数为:");for (j = 0; j < no2; j++){printf(" %d",available[j]);}printf("\n");}(程序结束)附录 4程序运行调试结果:1、程序初始化2、检测系统资源分配是否安全结果友情提示:范文可能无法思考和涵盖全面,供参考!最好找专业人士起草或审核后使用,感谢您的下载!。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验二银行家算法实验报告一、实验目的通过本次实验,主要学习了解了银行家算法的原理和实现方式,掌握银行家算法的应用场景,了解了安全序列的概念和判断方法,并通过代码实现加深对银行家算法的理解和掌握。

二、实验过程1、阅读银行家算法的相关理论知识。

2、编写银行家算法的代码实现。

3、根据实验要求,设置不同的初始资源分配和不同的进程请求资源情况,分别计算是否存在安全序列。

三、实验结果与分析1、首先按照实验要求设置一个初始的资源分配情况:可用的资源数目:4 4 4进程数目:4各进程对三种资源的最初需要数目:Max:7 5 33 2 29 0 22 2 2已分配资源数目:Allocation:0 1 02 0 03 0 22 1 1剩余资源数目:Need: 7 4 31 2 26 0 00 1 1根据上述数据,计算出该初试分配情况下的安全序列为:1 -> 3 -> 4 -> 2。

2、然后设置一个进程请求资源的情况:进程 1 请求资源 [3,3,0],进程 2 请求资源 [1,0,1],进程 3 请求资源 [2,2,0],进程 4 请求资源 [0,0,2]。

根据银行家算法,先进行安全性检测,发现该系统不存在安全序列,因此不满足银行家算法的要求,请求不被满足。

3、接着修改初始的资源分配情况和请求的资源情况,进行比较:通过以上的实验操作,得出结论:只有当请求的资源不会导致系统不再安全时,才会满足请求。

银行家算法基于这个假设进行运算,它管理着一个可以分配的表格,该表格显示系统的各种资源已经分配和未分配的情况,并确定哪些进程可以分配资源,哪些不可以。

四、实验总结本次实验通过对银行家算法的概念、原理和应用场景的了解,对该算法有了更深的认识和理解,并通过代码实现和实验操作,进一步巩固和掌握了该算法的应用方法。

在实验过程中,也有一些需要注意的问题:如需要按照一定的顺序输入原数据,正确地计算资源分配和剩余情况;核实每个请求的资源数目是否足够,才进行安全性检测;注意计算过程中数值的准确性和解题思路的正确性等。

操作系统实验2--银行家算法

操作系统实验2--银行家算法

共享资源分配与银行家算法[问题描述]本题主要内容是模拟实现资源分配。

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

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

通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升。

[基本要求]具体用银行家算法实现资源分配。

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

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

(3) 确定一组各进程依次申请资源数的序列,输出运行结果。

[方案设计及开发过程]1银行家分配算法,顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。

在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其他进程使用资源。

如果资源分配不得到就会发生进程循环等待资源,每个进程都无法继续执行下去的死锁现象。

把个进程需要和已占有资源的情况记录在进程控制中,假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。

当进程在处于等待态时,表示系统不能满足该进程当前的资源申请。

“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。

显然,每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.2.算法描述银行家算法:设进程I提出请求Request[N],则银行家算法按如下规则进行判断。

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

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

计算机操作系统-实验二:银行家算法

计算机操作系统-实验二:银行家算法
Available[j]:=Available[j]-Requesti[j]; Allocation[i,j]:=Allocation[i,j]+Requesti[j]; Need[i,j]:=Need[i,j]-Requesti[j]; (4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。若安全,才正式将资源 分配给进程 Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态, 让进程 Pi 等待。
for (i = 0; i < no1; i++) { printf(" p%d/%d
",i,i);
for (j = 0; j < no2; j++) {printf("%d ",max[i][j]);}
for (j = 0; j < no2; j++) {printf(" %d ",allocation[i][j]);}
1、在多道程序系统中,虽可借助与多个进程的并发执行,来改善系统的资源利用率,提高系统的吞吐 量,但可能发生一种危险---死琐。产生死锁的原因可归结为两点:
1:竞争资源。当系统中供多个进程共享的资源如打印机、公用队列等,其数目不足以满足诸进程 的需要时,会引起诸进程对资源的竞争而产生死锁。
2:进程间推进顺序非法。进程在运行过程中,请求和释放资源的顺序不当,也同样会导致产生进 程死锁。
计算机操作系统-实验二:银行家算法
void check() //安全算法函数
{
int k,f,v=0,i,j;
int work[m],a[m];
bool finish[m];
r=1;

操作系统大作业-银行家算法

操作系统大作业-银行家算法

编程验证银行家算法一、实验目的银行家算法是避免死锁的一种重要方法,本设计要求编程实现银行家算法程序。

了解银行家算法运行的规律币,加深对银行家算法的了解。

二、实验原理银行家算法的思路:1)、进程一开始向系统提出最大需求量.2)、进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.3)、若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待.银行家算法的数据结构.1)、系统剩余资源量A[n],其中A[n]表示第I类资源剩余量.2)、各进程最大需求量,B[m][n],其中B[j][i]表示进程j对i类资源最大需求.3)、已分配资源量C[m][n],其中C[j][i]表示系统j程已得到的第i资源的数量.4)、剩余需求量.D[m][n],其中D[j][i]对第i资源尚需的数目.银行家算法流程:当某时刻,某进程时,提出新的资源申请,系统作以下操作:1)、判定E[n]是否大于D[j][n],若大于,表示出错.2)、判定E[n]是否大于系统剩余量A[n],若大于,则该进程等待.3)、若以上两步没有问题,尝试分配,即各变量作调整.4)、按照安全性推测算法,判断,分配过后,系统是否安全,若安全,则实际分配,否则,撤消分配,让进程等待."安全性检测"算法1)、先定义两个变量,用来表示推算过程的数据.F[n]=A[n],表示推算过程中,系统中剩余资源量的变化.J[n]=False表示推算过程中各进程是否假设"已完成"2)、流程:在"剩余"的进程中(在推算)过程中,一些进程假设已完成,查找D[j][n]<=F[n]的进程,找到后令J[j]=True(假设该进程完成),F[n]+D[j][n](该进程所占资源释放),如此循环执行.若最后,所有的F[n]=True(在推算过程中,所有进程均可以完成),则表示(分配过后)系统是安全的,否则系统是不安全的.三、实验内容在codeblock编译器下编写代码首先现编写一个库文件‘’,定义一个结构体:typedef struct {int A;int B;int C;}RESOURCE;结构体里面的三个域分别表示三种资源的数量。

实验二银行家算法

实验二银行家算法

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

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

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

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

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

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

b)Requesti=Need[i]。

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

c)Requesti〉Need[i]。

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

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

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

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

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

开始时先做Finish[i]=0;当有足够的资源分配给进程时,再令Finish[i]=1。

操作系统实验二-银行家算法02

操作系统实验二-银行家算法02

实验二银行家算法一、实验目的:运用高级语言编写和调试一个系统动态分配资源的简单模拟程序,了解死锁产生的条件和原因,并采用银行家算法有效地避免死锁的发生,以加深对课堂上所讲授的知识的理解。

二、实验内容:完成银行家算法的模拟实现:设计有m个进程共享n个系统资源的系统,进程可动态的申请和释放资源。

系统按各进程的申请动态的分配资源时,采用银行家算法有效地避免死锁的发生。

三、实验准备:1.相关理论知识:(1)银行家算法的思路对进程的资源请求进行合法性检查;若请求合法,则进行试分配。

试分配后,调用安全性检查算法进行安全性检查。

若安全,则满足该进程请求,分配资源;若不安全,则拒绝该进程申请,不分配资源,并恢复系统试分配前的资源状态。

(2)银行家算法中用到的主要数据结构可利用资源向量 int Available[j] // j为资源的种类。

最大需求矩阵 int Max[i][j] // i为进程的数量。

分配矩阵 int Allocation[i][j]需求矩阵 int Need[i][j]= Max[i][j]- Allocation[i][j][j] //i进程申请j资源的数量申请各类资源数量 int Requesti工作向量 int Work[x] int Finish[y](3)银行家算法Bank()[j]=k进程i发出请求申请k个j资源,Requesti①检查申请量是否小于等于需求量:[j]<=Need[i,j],若条件不符重新输入,不允许申请大于需求量。

Requesti②检查申请量是否小于等于系统中的可利用资源量:Request[j]<=Available[j],若条件不符就申请失败,阻塞该进程,用gotoi语句跳转至重新申请资源。

③若以上两个条件都满足,则系统试探着将资源分配给申请的进程,并修改下面数据结构中的数值:Available[j]= Available[j]- Request[j];i[j];Allocation[i][j]= Allocation[i][j]+ RequestiNeed[i][j]= Need[i][j]- Request[j];i④试分配后,执行安全性检查,调用Safe()函数检查此次资源分配后系统是否处于安全状态。

实验2 银行家算法

实验2 银行家算法

实验2 银行家算法(2学时)一、实验目的理解银行家算法,掌握进程安全性检查的方法及资源分配的方法。

二、实验内容编写程序实现银行家算法,并验证程序的正确性。

三、实验要求编制模拟银行家算法的程序,并以下面给出的例子验证所编写的程序的正确性。

例子:某系统有A、B、C、D 4类资源共5个进程(P0、P1、P2、P3、P4)共享,各进程对资源的需求和分配情况如下表所示。

现在系统中A、B、C、D 4类资源分别还剩1、5、2、0个,请按银行家算法回答下列问题:(1)现在系统是否处于安全状态?(2)如果现在进程P1提出需求(0、4、2、0)个资源的请求,系统能否满足它的请求?#include <stdio.h>//#include <tchar.h>#include <iostream>using namespace std;#define Maxprocess 50 /*最大进程数*/#define Maxresource 100 /*最大资源数*/int Available[Maxresource]; /*可用资源数组*/int MAX[ Maxprocess][Maxresource]; /*最大需求矩阵*/int Allocation[ Maxprocess][Maxresource]; /*分配矩阵*/int need [Maxprocess][Maxresource]; /*需求矩阵*/int Request[Maxprocess][Maxresource]; /*进程需要资源数*/bool finish[Maxprocess]; /*系统是否有足够的资源分配*/int p[Maxprocess]; /*记录序列*/int m,n; /*m个进程,n个资源*/void Init();/*初始化算法*/bool Safe(); /*安全性算法*/void Bank(); /*银行家算法*/int main(){Init();Safe();Bank();return 1;}void Init() /*初始化算法*/{int i,j;cout<<"请输入进程的数目:"; /*m个进程,n个资源*/cin>>m;cout<<"请输入资源的种类数:";cin>>n;cout<<"请输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>MAX[i][j];cout<<"请输入每个进程已分配的各资源数,也按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++){for(j=0;j<n;j++){cin>>Allocation[i][j];need[i][j]=MAX[i][j]-Allocation[i][j];if(need[i][j]<0){cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl;j--;continue;}}}cout<<"请输入各个资源现有的数目:"<<endl;for(i=0;i<n;i++){cin>>Available[i];}}void Bank() /*银行家算法*/{int i,cusneed;char again;while(1){cout<<"请输入要申请资源的进程号(注:第1个进程号为0,依次类推)"<<endl;cin>>cusneed;cout<<"请输入进程所请求的各资源的数量"<<endl;for(i=0;i<n;i++){cin>>Request[cusneed][i];}for(i=0;i<n;i++){if(Request[cusneed][i]>need[cusneed][i]){cout<<"您输入的请求数超过进程的需求量!请重新输入!"<<endl;continue;}if(Request[cusneed][i]>Available[i]){cout<<"您输入的请求数超过系统有的资源数!请重新输入!"<<endl;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()){cout<<"同意分配请求!"<<endl;}else{cout<<"您的请求被拒绝!"<<endl;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]=false;}cout<<"您还想再次请求分配吗?是请按y/Y,否请按其它键"<<endl;cin>>again;if(again=='y'||again=='Y'){continue;}break;}}bool 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]=false;}for(i=0;i<m;i++){if(finish[i]==true){continue;}else{for(j=0;j<n;j++){if(need[i][j]>Work[j]){break;}}if(j==n){finish[i]=true;for(k=0;k<n;k++){Work[k]+=Allocation[i][k];cout<<Work[k];}p[l++]=i;i=-1;}else{continue;}}if(l==m){cout<<"系统是安全的"<<endl;cout<<"安全序列:"<<endl;for(i=0;i<l;i++){cout<<p[i];if(i!=l-1){cout<<"-->";}}cout<<""<<endl;return true;}}cout<<"系统是不安全的"<<endl;return false;}。

实验二(3)银行家算法

实验二(3)银行家算法

实验二(3)银行家算法一、实验目的1)掌握死锁的产生的原因、产生死锁的必要条件和处理死锁的基本方法。

2)了解多道程序系统中,多个进程并发执行的资源分配。

3)掌握预防死锁的方法,系统安全状态的基本概念4)掌握银行家算法,了解资源在进程并发执行中的资源分配策略。

二、实验内容设计一个n个并发进程共享m个系统资源的系统。

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

用银行家算法设计实现。

三、实验原理我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

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

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

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

- 1 -四、算法实现(1)初始化这组进程的最大资源请求和依次申请的资源序列。

把各进程已占用和需求资源情况记录在进程控制块中。

假定进程控制块的内容包括:进程名,状态,当前申请量,资源需求总量,已占资源量,能执行完标志。

其中,进程的状态有:就绪、等待和完成。

当系统不能满足进程的资源请求时,进程处于等待态。

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

操作系统课程设计报告课程名称:银行家算法姓名:刘成启学号:20101221149班级:计算机1008班指导老师:袁宁共享资源分配与银行家算法一、实验目的[问题描述]本题主要内容是模拟实现资源分配。

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

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

通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升。

二、实验内容[基本要求]具体用银行家算法实现资源分配。

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

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

(3) 确定一组各进程依次申请资源数的序列,输出运行结果。

[方案设计及开发过程]1银行家分配算法,顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。

在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其他进程使用资源。

如果资源分配不得到就会发生进程循环等待资源,每个进程都无法继续执行下去的死锁现象。

把个进程需要和已占有资源的情况记录在进程控制中,假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。

当进程在处于等待态时,表示系统不能满足该进程当前的资源申请。

“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。

显然,每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.2.算法描述银行家算法:设进程I提出请求Request[N],则银行家算法按如下规则进行判断。

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

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

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

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

WORK=WORK+ALLOCATIONFINISH=TRUEGO TO 2(4)如所有的进程Finish[M]=true,则表示安全;否则系统不安全。

3.数据结构假设有M个进程N类资源,则有如下数据结构:#define W 10#define R 20int M ; //总进程数int N ; //资源种类int ALL_RESOURCE[W]; //各种资源的数目总和int MAX[W][R]; //M个进程对N类资源最大资源需求量int A V AILABLE[R]; //系统可用资源数int ALLOCATION[W][R]; //M个进程已经得到N类资源的资源量int NEED[W][R]; //M个进程还需要N类资源的资源量int Request[R]; //请求资源个数三、程序及运行情况#include<stdio.h>#define false 0#define true 1#define W 10 //进程的最大个数#define R 20 //初始化资源的最大种类个数int M=2 ; //总进程数int N=3 ; //资源种类char name[R]; //各资源的名称int MAX[W][R]; //M个进程对N类资源最大资源需求量int A V AILABLE[R]; //系统可用资源数int ALLOCATION[W][R]; //M个进程已经得到N类资源的资源量int NEED[W][R]; //M个进程还需要N类资源的资源量int Request[R]; //请求资源个数//int Work[R]; //存放系统可提供资源void Show() //显示资源矩阵{int i,j;printf("\n进程\t已占有的资源\t还需要的资源\t 可用的资源\t最大资源需求量\n");printf(" ");for(i=0;i<4;i++){for(j=0;j<N;j++){printf("%3c ",name[j]);}printf(" ");}printf("\n");for(i=0;i<M;i++){printf(" %d ",i);for(j=0;j<N;j++){printf("%3d ",ALLOCATION[i][j]);}printf(" ");for(j=0;j<N;j++){printf("%3d ",NEED[i][j]);}printf(" ");for(j=0;j<N;j++){printf("%3d ",A V AILABLE[j]);}printf(" ");for(j=0;j<N;j++){printf("%3d ",MAX[i][j]);}printf("\n");}}bool check()//安全性检查{//int WORK[R];int SAFE[W];static int P = 0;int i =0, j= 0;//循环控制bool FINISH[W] = {false,false,false,false,false,false,false,false,false,false};for(i = 0; i < M; i++)//外层循环:无论能否运行完毕,从零开始检查,直到都运行完毕或无法都无法执行{if(FINISH[i]){continue;}for(j = 0; j < N; j++){if(NEED[i][j]!=0) //>A V AILABLE[j]{break;}}SAFE[P++] = i;if(N == j) //i进程可以执行完毕,WORK = WORK + ALLOCATION,外层从零开始检查{FINISH[i] = true;//SAFE[P++] = i;for(int k = 0; k < N; k++){A V AILABLE[k]+= ALLOCATION[i][k];ALLOCATION[i][k]=0;}printf("第%d进程已经执行完毕",&i);}else{continue;}i = -1;}for(int k = 0; k < M; k++)//判断是否所有进程都运行完毕{if(!FINISH[k]){return false;}}printf("\n安全序列:{");for(i = 0; i < M; i++){printf(" %d",SAFE[i]);}printf(" }");P = 0;return true;}void main(){int i,j,flag;char ch='y';printf("===========================银行家算法============================\n\n");printf("*****************一、请分别输入%d个资源信息***********************\n",N);printf("\n");for(i=0;i<N;i++){printf("请输入第%d个资源的名称:",i);scanf("%s",&name[i]);printf("请输入第%d个资源的资源量(小于20的数):",i);scanf("%d",&A V AILABLE[i]);printf("\n");}printf("*****************二、请分别输入%d个进程信息***********************\n",M);printf("\n");do{flag=0;for(i=0;i<M;i++){for(j=0;j<N;j++){printf("请输入第%d个进程对%c类资源的最大需求量:",i,name[j]);scanf("%d",&MAX[i][j]);printf("请输入第%d个进程已分配的%c类资源的数量:",i,name[j]);scanf("%d",&ALLOCATION[i][j]);}}for(i=0;i<M&&flag!=1;i++){for(j=0;j<N&&flag!=1;j++){if(MAX[i][j]>A V AILABLE[j]||ALLOCATION[i][j]>MAX[i][j]){printf("sorry!您所输入的最大需求量超过系统的资源总量,或者申请的资源大于最大需求量!请重新输入!\n");flag=1;}else{NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];//需求的数目=最大需求-已分配A V AILABLE[j]=A V AILABLE[j]-ALLOCATION[i][j];//可分配的数目减去已经分配的数目}}}}while(flag);Show();while(ch=='y'||ch=='Y'){printf("*****************三、请输入请求资源的进程:***********************\n");scanf("%d",&i);do{flag=0;for(j=0;j<N;j++){printf("请输入请求资源%c的数量",name[j]);scanf("%d",&Request[j]);if(Request[j]>NEED[i][j]||Request[j]>A V AILABLE[j]){flag=1;printf("申请该类资源大于需求量,请重新输入!\n");}else{ALLOCATION[i][j]+=Request[j];NEED[i][j]-=Request[j];A V AILABLE[j]-=Request[j];}}check();Show();}while(flag);printf("是否继续请求资源(y/n)?");scanf("%s",&ch);}}四、实验过程中出现的问题及解决方法安全序列生成方面还要改进,是乱码。

相关文档
最新文档