操作系统课设(模拟实现银行家算法实现死锁避免)

合集下载

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

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

操作系统课程设计(银行家算法的模拟实现)一、设计目的1、进一步了解进程的并发执行。

2、加强对进程死锁的理解。

3、用银行家算法完成死锁检测。

二、设计内容给出进程需求矩阵C、资源向量R以及一个进程的申请序列。

使用进程启动拒绝和资源分配拒绝(银行家算法)模拟该进程组的执行情况。

三、设计要求1、初始状态没有进程启动。

2、计算每次进程申请是否分配,如:计算出预分配后的状态情况(安全状态、不安全状态),如果是安全状态,输出安全序列。

3、每次进程申请被允许后,输出资源分配矩阵A和可用资源向量V。

4、每次申请情况应可单步查看,如:输入一个空格,继续下个申请。

四、算法原理1、银行家算法中的数据结构(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]2、银行家算法应用模拟实现Dijkstra的银行家算法以避免死锁的出现,分两部分组成:一是银行家算法(扫描);二是安全性算法。

(1)银行家算法(扫描)设Requesti是进程Pi的请求向量,如果Requesti[j]=K,表示进程Pi需要K个Ri类型的资源。

操作系统实验报告 预防进程死锁的银行家算法

操作系统实验报告 预防进程死锁的银行家算法

操作系统实验预防进程死锁的银行家算法一、需求分析:1、实验目的:通过这次实验,加深对进程死锁的理解,进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。

2、问题描述:设计程序模拟预防进程死锁的银行家算法的工作过程。

假设系统中有n个进程P1, … ,P n,有m类可分配的资源R1, … ,R m,在T0时刻,进程P i分配到的j类资源为Allocation ij个,它还需要j类资源Need ij个,系统目前剩余j类资源Work j个,现采用银行家算法进行进程资源分配预防死锁的发生。

3、程序要求:1)判断当前状态是否安全,如果安全给出安全序列;如果不安全给出理由。

2)对于下一个时刻T1,某个进程P k会提出请求Request(R1, … ,R m),判断分配给P k进程请求的资源之后系统是否安全。

3)输入:进程个数n,资源种类m,T0时刻各个进程的资源分配情况(可以运行输入,也可以在程序中设置);4)输出:如果安全,输出安全的进程序列,不安全则提示信息。

二、概要设计:1、进程调度的实现过程2、程序中的变量及数据结构struct ResItem{string Name;int Number;}; //资源项typedef vector<ResItem> Resource;struct Progress{string Name;Resource Max; //最大需求Resource Allocation; //分配Resource Need; //需求}; //进程vector <Progress> Progresses; //所有进程vector <ResItem> Available; //可利用资源向量vector <Progress> SafeOrder; //安全序列3、主要函数//初始化数据void InitData(int &n);//判断rs1是否小于等于rs2,是返回true,否则返回falseinline bool LessThan(Resource rs1,Resource rs2);//安全性算法bool SafeAlg();//银行家算法bool BankerAlg(Resource request,Progress &pro);4、主函数int main(){int n;InitData(n);cout<<"\n\n=============================================\n ";if(SafeAlg()){cout<<"由安全性检查可知:可以找到一个安全序列为:{";for(int i = 0 ; i < SafeOrder.size(); i++)cout<<SafeOrder[i].Name<<",";cout<<"}。

避免死锁银行家算法的模拟实现

避免死锁银行家算法的模拟实现

避免死锁银行家算法的模拟实现实验题目:机时:4实验一避免死锁银行家算法的模拟实现目的与任务银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

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

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

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

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

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

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

设计内容(原理图以及相关说明、调试过程、结果设requesti为进程p[i]的请求向量,如果requesti[j]=K,表示进程p[i]需要K 个Rj资源。

当系统发出请求后,系统按下述步骤开始检查:(1)、如果requesti[j]=need[i][j],转向步骤2;否则报告出错,申请的资源已经大于它需要的最大值。

(2)、如果requesti[j]=available[j],转向步骤3;否则报告出错,尚无足够的资源。

(3)、系统试探着把资源分配给p[i],并修改下列数据结构中的值:available[j]=available[j]-request[j]allocation[i][j]=allocation[i][j]+request[j]need[i][j]=need[i] [j]-request[j](4)、系统进行安全性算法,检查此次分配后,系统是否还处于安全状态,若安全,把资源分配给进程p[i];否则,恢复原来的资源分配状态,让进程p[i]等待。

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

假定系统中有m个进程,n类资源进程数和资源数由程序中直接定义,#define m5//总进程数#define n4//总资源数对于不同规模的进程和资源数,在程序中直接修改m和n值即可。

操作系统课程设计实验报告用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; }}}}。

操作系统课程设计任务书

操作系统课程设计任务书

操作系统集中上机实验1:银行家算法一、目的和要求银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

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

二、实验内容1.设计进程对各类资源最大申请表示及初值确定。

2.设定系统提供资源初始状况。

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

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

三、算法描述银行家可以把一定数量的资金供多个用户周转使用,为保证资金的安全银行家规定:1.当一个用户对资金的最大需求量不超过银行家现有的资金就要接纳该用户;2.用户可以分期贷款,但贷的总数不能超过最大需求量;3.当银行家现有的资金不能满足用户的沿需贷数时,对用户的贷款可推迟支付,但总能使用户在有限的时间里得到贷款;4.当用户得到所需的全部资金后,一定能在有限的时间里归还所有的资金。

实验2:时间片轮转法基本思想:将CPU的处理时间划分成一个个时间片,就绪队列中的诸进程轮流运行一个时间片,当时间片结束时,就强迫运行进程让出CPU,该进程进入就绪队列,等待下一次调度,同时,进程调度又去选择就绪队列中的一个进程,分配给它一个时间片,以投入运行。

在轮转法中,时间片长度的选择非常重要,将宜接影响系统开销和响应时间。

如果时间片长度很小,则调度程序剥夺处理机的次数频繁,加重系统开销;反之,如果时间片长度选择过长,比方说一个时间片就能保证就绪队列中所有进程都执行完毕,则轮转法就退化成先进先出算法。

实验3-4:抢占式(或非抢占式)优先级调度算法基本思想:该算法的基本思想是进程优先级高者优先调度,是一种常用的进程调度算法。

该算法的关键是如何确定优先数。

通常确定优先数的方法有两种,即静态法和动态法。

(1)静态优先权是在创建进程时确定的,其运行特征是优先数确定之后在整个进行运行期间不再改变。

确定静态优先权的依据有进程的类型、进程所使用的资源、进程的估计运行时间等因素。

计算机操作系统课程设计避免死锁预习报告

计算机操作系统课程设计避免死锁预习报告

计算机操作系统课程设计预习报告设计题目:死锁避免——银行家算法的模拟实现思路和算法思想一、思路本题目的简化假设是:1、程序运行开始时,资源全部可用。

资源种类约10种,每种资源数目为1~10。

2、不断随机产生或手工输入新的“进程资源需求向量”,并填写到最大需求矩阵。

3、在各进程的最大需求数量范围内(因此需作是否超出范围的检验),为各进程随机生成或手工输入资源请求。

经银行家算法后输出系统是否安全的信息。

当一个进程的资源请求全部发完后,认为它结束。

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

要求如下:(1)模拟一个银行家算法;(2)初始化时让系统拥有一定的资源,资源种类约10种,每种资源数目为1~10;(3)用键盘输入的方式申请资源;(4)如果预分配后,系统处于安全状态,则修改系统的资源分配情况;(5)如果预分配后,系统处于不安全状态,则提示不能满足请求,设计的主要内容是模拟实现动态资源分配。

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

二、算法思想银行家算法.顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。

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

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

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

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

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

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

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

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

操作系统课设(模拟实现银行家算法实现死锁避免)

计算机与信息工程系《计算机系统与系统软件》课程设计报告题目:模拟实现银行家算法实现死锁避免专业:信息管理与信息系统班级:信管082班学号:姓名:指导老师:2010年9 月9 日一、实验题目模拟实现银行家算法实现死锁避免二、目的:1、了解进程产生死锁的原因,了解为什么要进行死锁的避免。

2、掌握银行家算法的数据结构,了解算法的执行过程,加深对银行家算法的理解。

三、内容:模拟实现银行家算法实现死锁避免。

要求:初始数据(如系统在T0时刻的资源分配情况、每一种资源的总数量)从文本文件读入,文件中给出最大需求矩阵Max、分配矩阵Allocation,在程序中求得需求矩阵Need和可利用资源向量Available。

四、实验提示:1、整个银行家算法的思路。

先对用户提出的请求进行合法性检查,再进行预分配,利用安全性检查算法进行安全性检查。

2、算法用到的主要数据结构和C语言说明。

(1)、可利用资源向量INT A V AILABLE[M] M为资源的类型。

(2)、最大需求矩阵INT MAX[N][M] N为进程的数量。

(3)、已分配矩阵INT ALLOCA TION[N][M](4)、还需求矩阵INT NEED[N][N](5)、申请各类资源数量int Request[x]; //(6)、工作向量int Work[x];(7)、int Finish[y]; //表示系统是否有足够的资源分配给进程,0为否,非0为是3、银行家算法(主程序)(1)、系统初始化。

输入进程数量,资源种类,各进程已分配、还需求各资源数量,各资源可用数量等(2)、输入用户的请求三元组(I,J,K),为进程I申请K个J类资源。

(3)、检查用户的请求是否小于还需求的数量,条件是K<=NEED[I,J]。

如果条件不符则提示重新输入,即不允许索取大于需求量(4)、检查用户的请求是否小于系统中的可利用资源数量,条件是K<=A V ALIABLE[I,J]。

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

《 操作系统 》课程设计报告系 别: 信息科学与技术系专业班级:学生姓名:指导教师:(课程设计时间: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: 在多道程序系统中, 虽然借助于多个进程的并发执行来改善系统的运用率, 提高系统的吞吐量, 但也许发生一种危险—死锁。

死锁就是多个进程在运营过程中因争夺资源而导致的一种僵局, 当进程处在这种僵局状态时, 如无外力作用, 他们将无法再向前进行, 如再把信号量作为同步工具时, 多个Wait和Signal操作顺序不妥, 会产生进程死锁。

然而产生死锁的必要条件有互斥条件, 请求和保持条件, 不剥夺条件和环路等待条件。

在防止死锁的几种方法中, 都施加了较强的限制条件, 在避免死锁的方法中, 所施加的条件较弱, 有也许获得令人满意的系统性能。

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

2:实验目的:让学生独立的使用编程语言编写和调试一个系统分派资源的简朴模拟程序, 了解死锁产生的因素及条件。

采用银行家算法及时避免死锁的产生, 进一步理解课堂上老师讲的相关知识点。

银行家算法是从当前状态出发, 逐个按安全序列检查各客户中谁能完毕其工作, 然后假定其完毕工作且归还所有贷款, 再进而检查下一个能完毕工作的客户。

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

二: 银行家算法中的数据结构1:可运用资源向量Available。

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

假如Available[j]=k, z则表达系统中现有Rj类资源K 个。

2: 最大需求矩阵Max。

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

假如Max[i,j]=k, 表达第i个进程需要第Rj类资源的最大数目k个.3: 分派矩阵Allocation,也是n*m的矩阵, 若Allocation[i,j]=k,表达第i个进程已分派Rj类资源的数目为k个。

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

计算机与信息工程系《计算机系统与系统软件》
课程设计报告
题目:模拟实现银行家算法实现死锁避免专业:信息管理与信息系统
班级:信管082班
学号:
姓名:
指导老师:
2010年9 月9 日
一、实验题目
模拟实现银行家算法实现死锁避免
二、目的:
1、了解进程产生死锁的原因,了解为什么要进行死锁的避免。

2、掌握银行家算法的数据结构,了解算法的执行过程,加深对银行家算法的理解。

三、内容:
模拟实现银行家算法实现死锁避免。

要求:初始数据(如系统在T0时刻的资源分配情况、每一种资源的总数量)从文本文件读入,文件中给出最大需求矩阵Max、分配矩阵Allocation,在程序中求得需求矩阵Need和可利用资源向量Available。

四、实验提示:
1、整个银行家算法的思路。

先对用户提出的请求进行合法性检查,再进行预分配,利用安全性检查算法进行安全性检查。

2、算法用到的主要数据结构和C语言说明。

(1)、可利用资源向量INT A V AILABLE[M] M为资源的类型。

(2)、最大需求矩阵INT MAX[N][M] N为进程的数量。

(3)、已分配矩阵INT ALLOCA TION[N][M]
(4)、还需求矩阵INT NEED[N][N]
(5)、申请各类资源数量int Request[x]; //
(6)、工作向量int Work[x];
(7)、int Finish[y]; //表示系统是否有足够的资源分配给进程,0为否,非0为是
3、银行家算法(主程序)
(1)、系统初始化。

输入进程数量,资源种类,各进程已分配、还需求各资源数量,各资源可用数量等
(2)、输入用户的请求三元组(I,J,K),为进程I申请K个J类资源。

(3)、检查用户的请求是否小于还需求的数量,条件是K<=NEED[I,J]。

如果条件不符则提示重新输入,即不允许索取大于需求量
(4)、检查用户的请求是否小于系统中的可利用资源数量,条件是K<=A V ALIABLE[I,J]。

如果条件不符则申请失败,阻塞该进程,重新进行进程动态资源申请(使用goto语句)
(5)、进行资源的预分配,语句如下:
A V ALIBLE[I][J]= A V ALIBLE[I][J]-K;
ALLOCATION[I][J]= ALLOCATION[I][J]+K;
NEED[I][J]=NEED[I][J]-K;
(6)、系统调用安全性检查算法(safe()函数)进行检查,如果检查通过,则不用回收,否则进行回收,进程资源申请失败进入等待。

4、安全性检查算法(safe()子函数)
(1)、设置两个临时变量。

FINISH[N]记录进程模拟执行的结束状态,初值为0,如果可以模拟执行结束,则可
设为1,也可设为其它非零值以表示执行的先后次序。

WORK[M]记录模拟执行中资源的回收情况,初值为A V AILABLE[M]的值。

(2)、在进程中查找符合以下条件的进程。

条件1:FINISH[I]=0
条件2:NEED[I][J]〈=WORK[J]
(3)、如果查找成功则进行资源的模拟回收,语句如下:
WORK[J]=WORK[J]+ALLOCA TION[I][J];
FINISH[I]=1 或查找到的顺序号
(4)、如果查找不成功,则检查所有进程的FINISH[],如果有一个为0,则系统不为0,返回不成功标志。

否则返回成功标志。

五、程序源代码
六、程序运行结果及分析
1、示例数据
(1)初始化文件内容,见运行结果中第一个数据框。

(2)P1发出请求向量Request1( 1 ,0 ,2 )
2、运行结果
3、出现问题及解决方案
本程序考虑了程序功能实现、格式显示合理化、输入错误异常处理等各个方面的设计,尽可能使程序设计的更加完美。

在长期的设计调试过程中遇到过许多问题,通过网上搜索、查询资料、调试试验等方法一一解决。

下面大致罗列一些主要问题:
(1)、关于某些判断算法优劣问题:
在程序中很多地方都会用到循环判断是否符合条件的算法,在设计这些算法时有很多方法,而有的算法可以更节省时间。

如下安全性算法中寻找寻找符合Finish[i]==0条件的进程的例子:
/* 算法一:
for (j=0; j<m; j++)
if (Work[j]>=Need[i][j]) counter=counter+1;//记数
if(counter==m){…
*/ //算法二:
for (j=0; j<m; j++)
if (Work[j]>=Need[i][j]); //可用大于等于需求
else{
counter=1;
break;
}
if(counter!=1){…
显然算法二要优于算法一。

本程序中还有很多类似的地方。

这里主要考虑的是一个程序的优化设计问题。

(2)、关于某些系统函数调用时的执行顺序:
在调用一些系统函数如getch() 、system("pause")等时发现其执行顺序的一些问题。

如类似:
cout<<" =================================="<<endl;
cout<<" \n\n\n"<<endl;
system("pause");//暂停
调试时发现此时:在Microsoft Visual C++ 6.0中先执行system("pause") 再输出显示,而在调试器Bloodshed Dev-C++中则顺序执行;但当把cout<<" \n\n\n"<<endl; 改为cout<<endl<<endl<<endl; 其他不变时,则在两中调试器中均为顺序执行,即先显示后暂停。

查找了一下相关帮助:
在OSTREAM.H中有这样的一个inline函数:
inline _CRTIMP ostream& __cdecl endl(ostream& _outs) { return _outs << '\n' << flush; }。

也就是说
endl= return _outs << '\n' << flush;
endl除了写'\n'进外,还调用flush函数,刷新缓冲区,把缓冲区里的数据写入文件或屏幕。

如果考虑效率就用'\n'
(3)、关于设置暂停的方法:
在有些地方需要暂停一下以便于用户查看信息等,总结了下大致可用以下几中方法:
方法一:
#include <stdlib.h>
system("pause");//暂停一下并显示“输入任意键继续…”
方法二:
#include <stdio.h>
getchar();//须按回车键结束,不是任意键
方法三:
#include <conio.h>
getch();//等待键盘输入,不返回任何值,无任何显示
方法四:
使用char* tt=new char; cin>>tt; 方式,要求键盘输入一个与程序无关的变量
七、心得体会
“银行家算法的模拟实现”是本学期操作系统课程唯一的课程设计。

在设计此程序的过程中,我遇到过许多问题,也学到了很多东西。

本程序的设计实现主要是用C++语言实现,通过对程序算法的设计优化、输出显示的格式设计、输入过程中的异常处理等一些设计过程中的问题的考虑解决,在C++学习上也有了很大的进步。

程序设计过程中开始遇到的最大的问题是算法的结构设计问题,课本上只给了设计要求及简单的算法,要真正实现还需要考虑很多方面。

在算法的数据结构设计上考虑了很长时间。

在程序设计中先后参考了很多网络资料,也参考了一些别人写的的程序,综合这些算法思想和自己的思路对程序做了很好的设计方式,对一些算法的优越性等也作了一些考虑。

此外考虑最多的就是异常错误处理的设计。

一个好的程序必须能在各种环境下都有其相应的处理方式,至少能应对一些常见的可能发生的错误。

比如一般的要求输入为数字时,如果输入了一个非数字字符,程序就会立即出错无法继续运行,本程序针对这个问题设计了一个shuzi();函数进行处理,处理方式为:接受键盘输入的字符为字符串,然后对字符串的每个字符进行判断是否为数字,如果有非数字字符出现则提示出错并要求重新输入。

又如在判断是否继续时要求输入Y/N时,按一般的方式,如果输入为多个字符,则多余的字符会保存在缓冲区,到下次要求输入时输入而导致出错,对此问题设计处理方式为接受输入字符保存为串然后只取其首字符进行判断。

还有很多类似的错误处理。

还有在设置程序的显示优化时,发现暂停函数在不同的情况下执行顺序不同,如此等等。

在课程设计过程中遇到了许多问题,也向同宿舍的同学做了一些请教一起讨论,也因此从他们身上学到了许多东西。

相关文档
最新文档