实验四银行家算法

合集下载

银行家算法的实现

银行家算法的实现

实验四银行家算法的实现1、实验目的通过编写和调试银行家算法的模拟程序以加深对避免死锁方案的理解。

熟悉银行家算法的分配思想。

2、实验要求设计一个银行家方案。

并编写模拟程序实现之。

已知系统总共的资源数、进程名、进程已分配的资源、进程运行完毕最大最资源的需求量,以书上例题为例,分析某一时刻系统是否会产生死锁。

3、算法描述银行家算法中数据结构如下:n :系统中的进程个数;m :系统中的资源类数。

1)Available(m):现有资源向量。

Available(j)=k表示k个未分配的j类资源2)Max(n,m):资源最大申请量矩阵。

Max(i,j)=k表示第i个进程在运行过程中对第j类资源的最大申请量为k。

3)Allocation(n,m):资源分配矩阵。

Allocation(i,j)=k表示进程i已占有k个j类资源。

4)Need(n,m):进程以后还需要的资源矩阵。

Need(i,j)=k表示进程i以后还需要k个第j类资源。

显然有Need[i,j]=Max[i,j]-Allocation[i,j]。

5)Request(n,m):进程申请资源矩阵。

Request(i,j)=k表示进程i申请k个第j类资源。

银行家算法思想如下:若进程i申请资源,申请资源向量为Request(i),则有如下资源分配过程:1)如果Request(i)〉Need(i),则报错返回。

2)如果Request(i)〉Avaliable,则进程i进入等待资源状态,返回。

3)假设进程进程i的申请已获批准,于是修改系统状态:Avaliable=Avaliable-Request(i)Allocation(i)=Allocation(i)+Request(i)Need(i)=Need(i)-Request(i)4)调用安全状态检查算法。

设Work(m)为临时工作向量。

初始时Work=Available。

令N={1,2,……n}。

寻求j∈N 使其满足:Need(j)<=Work,若不存在这样的j则转至3)。

银行家算法实验报告总结

银行家算法实验报告总结

银行家算法实验报告总结一、实验目的与背景银行家算法是一种用于避免死锁和保证系统稳定运行的算法。

通过模拟银行贷款行为的策略,银行家算法可以有效地避免系统的资源枯竭,从而保证系统的正常运行。

在本实验中,我们通过使用银行家算法对实际的系统进行模拟,验证其有效性。

二、算法原理与流程银行家算法的主要原理是:将系统中的所有资源按照类型进行分类,并对每种资源设置一个最大值和最小值,分别表示该资源的最大需求量和最小剩余量。

同时,对于每个进程,需要定义其最大需求量、已分配资源和需求量,并根据这些信息来决定是否分配资源。

具体流程如下:初始化:将所有资源的最大值和最小值进行初始化,并给每个进程分配一个唯一的标识符。

请求资源:每个进程在执行过程中,如果需要更多的资源,则向系统发送请求。

分配资源:系统根据银行家算法的原理,将资源分配给满足条件的进程。

更新资源:系统更新已分配给进程的资源,并检查是否满足每个进程的最大需求量。

重复执行:如果存在多个进程需要资源,则重复执行步骤2-4,直到所有进程都满足其最大需求量或系统中的资源不足以为更多的进程分配资源为止。

三、实验数据与结果在本实验中,我们使用了10个进程,每个进程的需求量和已分配资源均随机生成。

实验结果表明,在满足了每个进程的最大需求量后,系统中仍有剩余资源,证明了银行家算法可以有效地避免资源的浪费。

四、结果分析通过对实验结果进行分析,我们发现银行家算法可以有效地保证系统的稳定性,避免出现死锁和资源枯竭等问题。

同时,该算法需要较少的系统开销,因为只需要对每个进程的请求进行处理和更新,不需要进行额外的检查和管理。

五、性能对比分析为了进一步验证银行家算法的性能,我们将其与其他常见的资源管理算法进行了比较。

在同等条件下,与其他算法相比,银行家算法具有更高的系统吞吐量和更低的响应时间。

银行家算法在系统吞吐量和响应时间方面均优于其他常见算法,而在死锁发生率上,银行家算法则表现出了更高的稳定性。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告银行家算法实验报告引言:在计算机科学领域中,银行家算法是一种用于避免死锁的资源分配算法。

它是由荷兰计算机科学家艾兹赫尔·迪科斯彻在1965年提出的。

银行家算法通过合理的资源分配和安全性检查,确保系统中的进程能够安全地执行,避免了资源竞争和死锁的发生。

本篇文章将详细介绍银行家算法的原理、实验设计和结果分析。

一、银行家算法的原理银行家算法基于资源的最大需求和可用性进行资源分配。

它将系统中的资源分为若干类别,并为每个类别分配一个初始数量。

当进程请求资源时,银行家算法会检查该请求是否能够满足,如果满足则分配资源,否则将进程置于等待状态。

算法的核心思想是避免分配资源后导致系统无法满足其他进程的资源需求,从而避免死锁的发生。

二、实验设计为了验证银行家算法的有效性,我们设计了一个模拟实验。

实验中,我们创建了一个包含多个进程和资源的系统,并模拟了进程对资源的请求和释放。

每个进程都有自己的资源需求和最大需求量,系统中的资源总量也是有限的。

首先,我们初始化系统的资源数量和每个进程的最大需求量。

然后,模拟进程的请求和释放过程。

当一个进程请求资源时,银行家算法会检查该请求是否能够满足,如果满足则分配资源,否则将进程置于等待状态。

当一个进程释放资源时,系统将回收该资源并重新分配给其他进程。

实验的关键是设计合理的资源分配策略和进程请求顺序,以模拟不同的场景。

我们通过调整进程的最大需求量和资源数量,观察系统的运行情况和死锁的发生情况。

三、实验结果分析通过多次实验,我们得出了以下结论:1. 资源数量的合理分配对避免死锁非常重要。

如果资源数量过少,无法满足进程的最大需求量,系统容易发生死锁。

如果资源数量过多,系统的资源利用率低,效率低下。

因此,需要根据系统的实际需求合理分配资源数量。

2. 进程的最大需求量与资源数量的关系也是影响死锁的重要因素。

当进程的最大需求量超过系统资源数量的一半时,系统容易发生死锁。

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

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

银行家算法实验报告一、实验题目为了了解系统的资源分配情况,假定系统的任何一种资源在任一种资源在任意时刻只能被一个进程使用。

任何进程已经占用的资源只能由进程自己释放,而不能任由其他进程抢占。

当进程申请的资源不能满足时,必须等待。

因此,只要资源分配算法能保证进程的资源请求,且不出现循环等待,则系统不会出现死锁。

而银行家算法是避免死锁的一种重要方法。

通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法二、实验要求要求编写系统进行资源调度的程序,模拟进程的资源分配算法,了解死锁的产生和避免的办法。

一个是随机动态地进行资源分配的模拟程序,即只要系统当前剩余资源满足进程的当前要求,就立即将资源分配给进程,以观察死锁产生情况;一个是采用银行家算法,有效地避免死锁的产生。

要求用银行家算法和随机算法实现资源分配。

1.设计3-4个并发进程,共享系统的10个同类不可抢占的资源。

各进程动态进行资源的申请和释放。

2.用银行家算法和随机算法分别设计一个资源分配程序,运行这两个程序,观察系统运行情况,并对系统运行的每一步情况进行显示。

二、总的设计思想及语言环境、工具等1.算法设计思路银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。

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

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

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

2.语言环境、工具计算机基本配置要求:操作系统:WIN 98/2000/XP/2003 等Windows平台内存:256MB及以上主存64KB(Memory)(以KB为单位分配)开发语言:Visual C++ 6.0四、数据结构与模块说明(功能与框图)五、源程序(指导老师验收通过)#include<string.h>#include<iostream.h>#define FALSE 0#define TRUE 1#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20int M ;int N ;int ALL_RESOURCE[W];int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void inputdata(); //数据输入void showdata(); //数据显示void changdata(int k);//进程请求资源数据改变void restoredata(int k); //数据恢复int chksec(int s); //系统安全性的检测int chkmax(int s); //检测最大需求void bank(); //检测分配的资源是否合理void main(){ int i,j;inputdata();for(i=0;i<M;i++){ j=chksec(i);if (j==0) break;}if (i>=M)cout<<"错误提示:经安全性检查发现,系统的初始状态不安全\n"<<endl;else{ cout<<"提示:经安全性检查发现,系统的初始状态安全!"<<endl;bank();}}void inputdata(){ int i=0,j=0,p;cout<<"请输入总进程数:"<<endl;do{cin>>M;if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数,请重新输入:"<<endl;}while (M>W);cout<<endl;cout<<"请输入资源的种类数:"<<endl;do {cin>>N;if (N>R)cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数,请重新输入:"<<endl; }while (N>R);cout<<endl;cout<<"请依次输入各类资源的总数量,即设置向量all_resource:"<<endl;for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];cout<<endl;cout<<"请依次输入各进程所需要的最大资源数量,即设置矩阵max:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do { cin>>MAX[i][j];if (MAX[i][j]>ALL_RESOURCE[j])cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);}}cout<<endl;cout<<"请依次输入各进程已经占据的各类资源数量,即设置矩阵allocation:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do{ cin>>ALLOCATION[i][j];if (ALLOCATION[i][j]>MAX[i][j])cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;}while (ALLOCATION[i][j]>MAX[i][j]);}}cout<<endl;for (i=0;i<M;i++)for(j=0;j<N;j++)NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];for (j=0;j<N;j++){ p=ALL_RESOURCE[j];for (i=0;i<M;i++){ p=p-ALLOCATION[i][j];AVAILABLE[j]=p;if(AVAILABLE[j]<0)AVAILABLE[j]=0;}}}void showdata(){ int i,j;cout<<"各种资源的总数量,即向量all_resource为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];cout<<endl<<endl;cout<<"当前系统中各类资源的可用数量,即向量available为:"<<endl; cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<AVAILABLE[j];cout<<endl<<endl;cout<<"各进程还需要的资源数量,即矩阵need为:"<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<NEED[i][j]<<" ";cout<<endl;}cout<<endl;cout<<"各进程已经得到的资源量,即矩阵allocation为: "<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<" ";cout<<endl;} cout<<endl;}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 restoredata(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 chksec(int s){int WORK,FINISH[W];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;do{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++;}}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){ return 1;}} return 0;}int chkmax(int s){ int j,flag=0;for(j=0;j<N;j++){if (MAX[s][j]==ALLOCATION[s][j]){ flag=1;AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];MAX[s][j]=0;}} return flag;}c{int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){i=-1;while(i<0||i>=M){ cout<<"请输入需申请资源的进程号(从P0到P"<<M-1<<",否则重新输入!):"; cout<<"p";cin>>i;if(i<0||i>=M)cout<<"输入的进程号不存在,重新输入!"<<endl;}cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;for (j=0;j<N;j++){ cout<<" 资源"<<j<<": ";cin>>Request[j];if(Request[j]>NEED[i][j]){ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}else{ if(Request[j]>AVAILABLE[j]){ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}}}if(flag=='Y'||flag=='y'){ changdata(i);if(chksec(i)){ cout<<endl;cout<<"该分配会导致系统不安全本次资源申请不成功,不予分配"<<endl;cout<<endl;restoredata(i);}else{ cout<<endl;cout<<"经安全性检查,系统安全,本次分配成功,且资源分配状况如下所示:"<<endl;cout<<endl;showdata();if(chkmax(i)){cout<<"在资源分配成功之后,由于该进程所需的某些资源的最大需求量已经满足,"<<endl;cout<<"因此在进程结束后系统将回收这些资源!"<<endl;cout<<"在资源收回之后,各进程的资源需求和分配情况如下所示:"<<endl;showdata();}}}cout<<endl;cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";cin>>flag; }}六、运行结果分析1.输入进程数、资源种类数、各类资源总数量、各进程所需要的最大资源数量、各进程所已经占据的各类资源数量2.经安全性检验,系统状态安全,进程P0申请资源3.经安全性检验,系统状态安全,进程P0获得所申请资源4.进程P3申请资源5.经安全性检验,系统状态安全,进程P3获得所申请资源6.进程P1申请资源7.经安全性检验,系统状态安全,进程P1获得所申请资源8.进程P2申请资源9.经安全性检验,系统状态安全,进程P2获得所申请资源5.进程P1申请资源6.经安全性检验,系统状态安全,进程P1获得所申请资源七、总结这次实验中我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

实验四银行家算法

实验四银行家算法

操作系统实验实验四银行家算法学号 1115102002姓名蔡凤武班级 11电子A华侨大学电子工程系实验目的1、理解银行家算法。

2、掌握进程安全性检查的方法与资源分配的方法。

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

现在系统中A、B、C、D 4类资源分别还剩1、5、2、0个,请按银行家算法回答:1、现在系统是否处于安全状态?2、如果现在进程P1提出需要(0、4、2、0)个资源的请求,系统能否满足它的请求?1、银行家算法和安全性检查算法原理。

操作系统的银行家算法:当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

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

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

1、程序流程描述。

银行家算法:(1) 步骤:1如果Request [j]<=Need[i],转向步骤(2),否则认为出错,因为他所需要的资源数已经超过它所宣布的最大值。

(2) 步骤2;如果:Request [i]<=Available[i],转向步骤(3),否则提示尚无足够资源,进程i需等待。

(3) 步骤3:系统试探分配相关资源,并修改下面数据:Available[i]= Available[i]- Request [j];Allocation[i]= Allocat ion[i]+ Request [i];Need[i]= Need[i]- Request [i];(4) 步骤4:执行安全性检查,如安全,则分配成立;否则本次试探分配作废,恢复原来的资源分配状态,让该进程等待。

安全性检查算法:安全性检查算法主要是根据银行家算法进行资源分配后,检查资源分配后的系统状态之中。

具体算法如下:(1) 步骤1:设置两个向量: Work= Available,Finish[i]=false;说明:Finish(它表示系统是否有足够的资源分配给进程)Work(它表示系统可提供给进程继续运行所需的各类资源数目)(2) 步骤2:在进程中查找符合以下条件的进程:Finish[i]=false,need<=Work 若能找到,则执行步骤(3),否则,执行步骤(4)(3) 步骤3:当进程获得资源后,可顺利执行,直至完成,从而释放资源:Work= Work+ Allocation; Finish=true; goto step (2);(4) 步骤4:如果所有进程的Finish=true都满足,则表示系统处于安全状态,否则,系统不安全状态。

银行家算法

银行家算法

实验四银行家算法一、实验学时2 学时二、实验目的与要求(1)了解多道程序系统中,多个进程并发执行的资源分配。

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

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

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

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

三、实验内容在多道程序系统中,虽可借助于多个进程的并发执行来改善系统的资源利用率,提高系统的吞吐量,但可能发生一种危险——死锁。

死锁是指多个进程在运行中因争夺资源而造成的一种僵局,当进程处于这种僵持状态时,若无外力作用,他们都将无法再向前推进。

银行家算法是最具代表性的避免死锁的算法,它的基本思想是分配资源之前,判断系统是否是安全的,若是才分配资源。

设计一个n个并发进程共享m个系统资源的程序实现银行家算法。

要求包含:1、一个简单的界面。

2、显示或修改当前系统资源情况。

3、添加进程对资源的需求。

4、判断是否存在死锁,若无死锁则显示其安全序列。

5、若产生死锁,制定策略,以最小的代价解决死锁问题。

四、实验重点、难点银行家算法的实现、解除死锁的策略。

五、实验教学方法集中讲授,讨论需求,由学生独立完成六、运行结果分析1、给出一组初始数据。

2、根据给出的数据得出运行结果。

3、分析结果是否符合原理。

4、产生死锁时你采用的策略是什么?为什么?5、分析所写程序还有什么可以改进的地方。

七、关键数据结构及源代码1、带注释的源代码。

实验四 银行家算法模拟

实验四 银行家算法模拟

实验四银行家算法模拟【实验目的】(1)进一步理解利用银行家算法避免死锁的问题;(2)在了解和掌握银行家算法的基础上,编制银行家算法通用程序,将调试结果显示在计算机屏幕上,再检测和笔算的一致性。

(3)理解和掌握安全序列、安全性算法【实验要求】(1)了解和理解死锁;(2)理解利用银行家算法避免死锁的原理;(3)会使用某种编程语言。

【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。

二、银行家算法假设在进程并发执行时进程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等待。

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

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

银行家算法实验报告

银行家算法实验报告

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

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

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告实验目的:了解和掌握银行家算法,进一步熟悉进程和如何避免死锁。

实验内容:1、主要程序结构(a)resource allocation algorithm如果要求的资源量+占有的资源总的资源需求量可以carry out allocation(b) test for safety algorithm注:《--- 》中的内容为未具体写明但说明其功能的程序段bool safe(struct state new ){bool possible = true,found=false;process rest[n];//正在执行的进程号int p=n;// 正在执行的进程数量int currentavail[m];//可用资源的一个副本《---为rest和currentavail赋值---》while(possible==true&&p>0){int g=0;《---寻找可以执行完成的进程---》if(found==true){int c=0;《---假设可以执行完的进程以完成,及currentavail[*]=currentavail[*]+new.alloc[g][*];---》rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}2、实验步骤1)设计结构体#ifndef STATE_H_#define m 3#define n 5struct state{int resource[m];int available[m];int claim[n][m];int alloc[n][m];} ;#define STATE_H_#endif /* STATE_H_ */2)设计实现程序的结构的具体程序Safe算法的具体代码bool safe(struct state new ){bool possible = true,found=false;process rest[n]; //正在执行的进程号int f=0,p=n;// 正在执行的进程数量do{rest[f]=f;++f;}while(f<n);int currentavail[m]; //可用资源的一个副本int i=0;do{currentavail[i]=new.available[i];++i;}while(i<m);while(possible==true&&p>0){int g=0;/*------------------寻找可以执行完成的进程------------------------------------------*/ while(g<n){int h = 0;/*while(h<m){if((new.claim[g][h]-new.alloc[g][h])<=currentavail[h]&&rest[g]!=(-1)){if(h==m-1){found=true;}}++h;}if(found==true)break;++g;}/*-------------------------------------------------------------------------------------*/ if(found==true){int c=0;while(c<m){currentavail[c]=currentavail[c]+new.alloc[g][c];c++;}rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}实验代码:/*============================================================================ Name : pre.cAuthor :Version :Copyright : Your copyright noticeDescription : Hello World in C, Ansi-style============================================================================ */#include <stdio.h>#include <stdlib.h>#include"state.h"#define bool int#define process int#define false 0#define true 1int main(void) {bool alloc(int,int[],struct state );struct state sta1={{10,5,7},{3,3,2},{{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}},{{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}};int request[m];int k=0;while(k>=0){puts("输入要改变资源的进程号");scanf("%d",&k);puts("输入要改变的资源");int i =0;while(i<m){scanf("%d",&request[i]);i++;}if(alloc(k,request,sta1)==true){i=0;puts("输出个进程占用的资源");while(i<n){int j=0;printf("%d ",i);while(j<m){if(i==k){sta1.alloc[k][j]=request[j]+sta1.alloc[k][j];sta1.available[j]=sta1.available[j]-request[j];}printf("%d ",sta1.alloc[i][j]);j++;}printf("\n");++i;}}puts("银行家算法");}return 0;}bool alloc(int l,int request[m],struct state nest){bool safe(struct state news);bool t = false;int i=0;while(i<m){if(nest.alloc[l][i]+request[i]>nest.claim[l][i]){puts("!!resource request error!!");return false;}else if(request[i]>nest.available[i]){puts("suspend process");return false;}else{if(i==m-1){int f=0;while(f<m){nest.alloc[l][f]=nest.alloc[l][f]+request[f];nest.available[f]=nest.available[f]-request[f];f++;}if(safe(nest)==true){t=true;}else{puts(" no safe suspend process");t=false;}}}i++;}return t;}bool safe(struct state new ){bool possible = true,found=false;process rest[n];int f=0,p=n;do{rest[f]=f;++f;}while(f<n);int currentavail[m];int i=0;do{currentavail[i]=new.available[i];++i;}while(i<m);while(possible==true&&p>0){int g=0;while(g<n){int h = 0;while(h<m&&(new.claim[g][h]-new.alloc[g][h])<=currentavail[h]&&rest[g]!=(-1)){if(h==m-1){found=true;}++h;}if(found==true)break;++g;}if(found==true){int c=0;while(c<m){currentavail[c]=currentavail[c]+new.alloc[g][c];c++;}rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}。

实验四 银行家算法

实验四 银行家算法

银行家算法的模拟实现一.实验目的1.了解进程产生死锁原因,了解为什么要防止死锁。

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

二.实验内容:采用银行家算法来实现一个n 个并发进程共享m 个系统资源的系统。

进程可以申请和释放资源,系统可以按照各进程的申请计算是否可以分配给其资源。

三.实验原理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]申请各类资源数量int Request i[j] i进程申请j资源的数量工作向量int Work[x]int Finish[y]3.银行家算法bank()进程i发出请求申请k个j资源,Request i[j]=k(1)检查申请量是否不大于需求量:Request i[j]<=need[i,j],假设条件不符重新输入,不允许申请大于需求量。

(2)检查申请量是否小于系统中的可利用资源数量:Request i[j]<=available[i,j],假设条件不符就申请失败,阻塞该进程,用goto语句跳转到重新申请资源。

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

武汉轻工大学——实验四模拟实现银行家算法实验

武汉轻工大学——实验四模拟实现银行家算法实验

武汉轻工大学数学与计算机学院《操作系统》实验报告题目:模拟实现银行家算法专业:数学与计算机学院班级:计算机类1303班学号: 1305110050 姓名:刘文斌指导老师:黄川2015年05月26日1、目的和要求在熟练掌握死锁发生原理和解决死锁问题的基础上,利用一种程序设计语言模拟实现利用银行家算法实现死锁避免,一方面加深对原理的理解,另一方面提高学生通过编程根据已有原理解决实际问题的能力,为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。

2、实验内容模拟实现银行家算法对系统资源进行分配,以防止死锁的出现。

本课题肯定不可能实现对实际操作系统的资源管理,而是通过对模拟资源数据的处理,检测银行家算法在防止死锁出现的作用。

银行家算法描述:第一部分:银行家算法(扫描)1.如果Request<=Need,则转向2;否则,出错2.如果Request<=Available,则转向3,否则等待3.系统试探分配请求的资源给进程4.系统执行安全性算法第二部分:安全性算法1.设置两个向量(1).工作向量:Work=Available(表示系统可提供给进程继续运行所需要的各类资源数目)(2).Finish:表示系统是否有足够资源分配给进程(True:有;False:没有).初始化为False2.若Finish[i]=False&&Need<=Work,则执行3;否则执行4(i为资源类别)3.进程P获得第i类资源,则顺利执行直至完成,并释放资源:Work=Work+Allocation;Finish[i]=true;3、实验环境Windows操作系统、VC++6.0C语言4、设计思想当进程pi提出资源申请时,系统执行下列步骤:(1)若Request[i]≤Need[i],转(2);否则错误返回(2)若Request[i]≤Available,转(3);否则进程等待(3)假设系统分配了资源,则有:Available:=Available-Request[i];Allocation[i]:=Allocation[i]+Request[i];Need[i]:=Need[i]-Request[i]若系统新状态是安全的,则分配完成若系统新状态是不安全的,则恢复原状态,进程等待模拟实现Dijkstra的银行家算法以避免死锁的出现.分两部分组成:5、源程序#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();}void Init() /*初始化算法*/{int i,j;cout<<"\t---------------------------------------------------"<<endl; cout<<"\t||||"<<endl;cout<<"\t|| 银行家算法||"<<endl;cout<<"\t||||"<<endl;cout<<"\t|| XXXXXXXXXXXXXXXXXXXX ||"<<endl;cout<<"\t||||"<<endl;cout<<"\t|| 2004024031 2004024054||"<<endl;cout<<"\t---------------------------------------------------"<<endl;cout<<"请输入进程的数目:";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]; }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;}6、实例运行结果7、总结操作系统的基本特征是并发与共享。

操作系统实验项目银行家算法

操作系统实验项目银行家算法

实验四、银行家算法(一)目的和要求银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。

本实验要求用高级语言编写一个银行家的模拟算法。

通过本实验可以对预防死锁和银行家算法有更深刻的认识。

(二)实验内容1、设置数据结构包括可利用资源向量(Availiable),最大需求矩阵(Max),分配矩阵(Allocation),需求矩阵(Need)2、设计安全性算法设置工作向量Work 表示系统可提供进程继续运行可利用资源数目,Finish 表示系统是否有足够的资源分配给进程(三)实验环境1、pc2、vc++(四)、程序源代码:/*子函数声明*/int Isprocessallover(); //判断系统中的进程是否全部运行完毕void Systemstatus(); //显示当前系统中的资源及进程情况int Banker(int ,int *); //银行家算法void Allow(int ,int *); //若进程申请不导致死锁,用此函数分配资源void Forbidenseason(int ); //若发生死锁,则显示原因/*全局变量*/int Availiable[3]={3,3,2}; //初始状态,系统可用资源量int Max[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//各进程对各资源的最大需求量int Allocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//初始状态,各进程占有资源量int Need[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//初始状态时,各进程运行完毕,还需要的资源量int over[5]={0,0,0,0,0}; //标记对应进程是否得到所有资源并运行完毕#include <iostream.h>/*主函数*/void main(){int process=0; //发出请求的进程int decide=0; //银行家算法的返回值int Request[3]={0,0,0}; //申请的资源量数组int sourcenum=0; //申请的各资源量/*判断系统中进程是否全部运行完毕*/step1: if(Isprocessallover()==1){cout<<"系统中全部进程运行完毕!";return;}/*显示系统当前状态*/Systemstatus();/*人机交互界面*/step2: cout<<"\n输入发出请求的进程(输入“0”退出系统): ";cin>>process;if(process==0){cout<<"放弃申请,退出系统!";return;}if(process<1||process>5||over[process-1]==1){cout<<"系统无此进程!\n";goto step2;}cout<<"此进程申请各资源(A,B,C)数目:\n";for(int h=0;h<3;h++){cout<<char(65+h)<<"资源:";cin>>sourcenum;Request[h]=sourcenum;}/*用银行家算法判断是否能够进行分配*/decide=Banker(process,Request);if (decide==0){/*将此进程申请资源分配给它*/Allow(process,Request);goto step1;}else{/*不能分配,显示原因*/Forbidenseason(decide);goto step2;}}/*子函数Isprocessallover( )的实现*/int Isprocessallover(){int processnum=0;for(int i=0;i<5;i++){/*判断每个进程是否运行完毕*/if(over[i]==1)processnum++;}if(processnum==5)/*系统中全部进程运行完毕*/return 1;elsereturn 0;}/*子函数Systemstatus( )的实现*/void Systemstatus(){cout<<"此刻系统中存在的进程:\n";for(int i=0;i<5;i++){if(over[i]!=1)cout<<"P"<<i+1<<" ";}cout<<endl;cout<<"此刻系统可利用资源(单位:个):\n";cout<<"A B C\n";for(int a=0;a<3;a++){cout<<Availiable[a]<<" ";}cout<<endl;cout<<"此刻各进程已占有资源如下(单位:个): \n"<<" A B C\n";for(int b=0;b<5;b++){if(over[b]==1)continue;cout<<"P"<<b+1<<" ";for(int c=0;c<3;c++)cout<<Allocation[b][c]<<" ";cout<<endl;}cout<<"各进程运行完毕还需各资源如下(单位:个):\n"<<" A B C\n";for(int f=0;f<5;f++){if(over[f]==1)continue;cout<<"P"<<f+1<<" ";for(int g=0;g<3;g++)cout<<Need[f][g]<<" ";cout<<endl;}}/*子函数Banker(int ,int &)的实现*/int Banker(int p,int *R){int num=0; //标记各资源是否能满足各进程需要int Finish[5]={0,0,0,0,0}; //标记各进程是否安全运行完毕int work[5]={0,0,0,0,0}; //用于安全检查int AvailiableTest[3]; //用于试分配int AllocationTest[5][3]; //同上int NeedTest[5][3]; //同上/*判断申请的资源是否大于系统可提供的资源总量*/for(int j=0;j<3;j++){if(*(R+j)>Availiable[j])/*返回拒绝分配原因*/return 1;}/*判断该进程申请资源量是否大于初始时其申明的需求量*/for(int i=0;i<3;i++){if(*(R+i)>Need[p-1][i])/*返回拒绝原因*/return 2;}/*为检查分配的各数据结构赋初值*/for(int t=0;t<3;t++){AvailiableTest[t]=Availiable[t];}for(int u=0;u<5;u++){for(int v=0;v<3;v++){AllocationTest[u][v]=Allocation[u][v];}}for(int w=0;w<5;w++){for(int x=0;x<3;x++){NeedTest[w][x]=Need[w][x];}}/*进行试分配*/for(int k=0;k<3;k++)//修改NeedTest[]{AvailiableTest[k]-=*(R+k);AllocationTest[p-1][k]+=*(R+k);NeedTest[p-1][k]-=*(R+k);}/*检测进程申请得到满足后,系统是否处于安全状态*/ for(int l=0;l<3;l++){work[l]=AvailiableTest[l];}for(int m=1;m<=5;m++){for(int n=0;n<5;n++){num=0;/*寻找用此刻系统中没有运行完的进程*/if(Finish[n]==0&&over[n]!=1){for(int p=0;p<3;p++){if(NeedTest[n][p]<=work[p])num++;}if(num==3){for(int q=0;q<3;q++){work[q]=work[q]+AllocationTest[n][q];}Finish[n]=1;}}}}for(int r=0;r<5;r++){if(Finish[r]==0&&over[r]!=1)/*返回拒绝分配原因*/return 3;}return 0;}/*子函数Allow(int ,int &)的实现*/void Allow(int p,int *R){cout<<"可以满足申请!";static int overnum;/*对进程所需的资源进行分配*/for(int t=0;t<3;t++){Availiable[t]=Availiable[t]-*(R+t);Allocation[p-1][t]=Allocation[p-1][t]+*(R+t);Need[p-1][t]=Need[p-1][t]-*(R+t);}/*分配后判断其是否运行完毕*/overnum=0;for(int v=0;v<3;v++){if(Need[p-1][v]==0)overnum++;}if(overnum==3){/*此进程运行完毕,释放其占有的全部资源*/for(int q=0;q<3;q++)Availiable[q]=Availiable[q]+Allocation[p-1][q];/*标记该进程运行完毕*/over[p-1]=1;cout<<"进程P"<<p<<"所需资源全部满足,此进程运行完毕!\n";}}/*子函数Forbidenseason(int )的实现*/void Forbidenseason(int d){cout<<"不能满足申请,此进程挂起,原因为:\n";switch (d){case 1:cout<<"申请的资源量大于系统可提供的资源量!";break;case 2:cout<<"申请的资源中有某种资源大于其声明的需求量!";break;case 3:cout<<"若满足申请,系统将进入不安全状态,可能导致死锁!";}}。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告引言:在计算机科学领域,由于资源的有限性,进程资源分配问题一直备受关注。

而银行家算法被广泛应用于操作系统中,用于确保资源的安全分配。

本文旨在介绍银行家算法的原理和应用,并通过实验报告来验证该算法的有效性和可行性。

1. 银行家算法简介银行家算法是由美国学者Dijkstra提出的一种资源分配和避免死锁的算法。

其基本思想是通过银行家的原则来避免系统陷入死锁状态,保证资源分配的安全性和可行性。

银行家算法适用于具有多个进程和多个资源的并发系统中。

2. 银行家算法原理银行家算法基于两个重要的概念:安全性和可分配性。

安全性表示在系统当前状态下,是否存在一种资源分配序列可以使系统避免死锁状态。

可分配性表示系统是否能够满足进程对资源的请求。

银行家算法的实现需要以下几个关键步骤:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。

(2) 效验:判断系统当前状态下资源是否满足所有进程的需求,即判断系统是否处于安全状态。

(3) 分配:若系统处于安全状态,则根据某种资源分配策略,为进程分配资源。

(4) 请求:进程请求资源。

(5) 回收:进程释放资源。

3. 银行家算法的实验验证为了验证银行家算法的有效性和可行性,我们设置了一个简单的实验环境,模拟一个有限的资源系统,包含3个进程和3种不同类型的资源。

实验过程如下:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。

设置3个进程的最大需求量分别为{5, 4, 3},已分配资源量分别为{1, 2, 2},需求资源量分别为{3, 2, 0}。

(2) 效验:判断系统当前状态下资源是否满足所有进程的需求。

经过实验验证,我们发现系统当前状态下资源无法满足进程2的资源需求。

为了保证系统的安全性和避免死锁,根据银行家算法原理,我们将不满足资源需求的进程2暂停,并回滚到初始状态。

重新调整资源分配后,系统进入了安全状态。

(3) 分配:为进程1和进程3分配资源。

c语言银行家算法实验报告

c语言银行家算法实验报告

c语言银行家算法实验报告C语言银行家算法实验报告引言:计算机科学领域中,操作系统的资源管理是一个十分重要的课题。

在多任务处理系统中,多个进程同时竞争有限的资源,如何合理地分配和调度资源,以保证系统的稳定性和效率,是一个关键问题。

银行家算法(Banker's Algorithm)是一种经典的资源分配算法,它通过分析系统的资源状态和进程的资源需求,来判断是否能够安全地分配资源,从而避免产生死锁。

一、实验目的本次实验旨在通过C语言编程实现银行家算法,加深对资源管理和死锁问题的理解,并通过实际案例验证银行家算法的有效性。

二、实验环境本次实验使用C语言进行编程,并在Linux操作系统下进行测试。

三、实验过程1. 设计数据结构在开始编写代码之前,我们需要先设计适合的数据结构来表示系统资源和进程的状态。

在银行家算法中,我们需要记录系统中的可用资源数量、各个进程的最大需求资源数量、已分配资源数量和需要资源数量等信息。

通过定义合适的数据结构,我们可以方便地进行资源的分配和回收。

2. 实现银行家算法根据银行家算法的原理,我们可以将其分为两个步骤:安全性检查和资源分配。

在安全性检查中,我们需要判断当前系统状态下是否存在安全序列,即是否能够满足所有进程的资源需求,避免死锁的发生。

在资源分配中,我们需要根据当前系统状态和进程的资源需求,动态地分配和回收资源。

3. 编写测试用例为了验证银行家算法的正确性和有效性,我们需要编写一些测试用例。

测试用例应该包括各种不同的进程资源需求和系统资源状态,以覆盖不同情况下的资源分配和回收。

4. 运行测试用例在编写完测试用例后,我们可以运行程序,观察输出结果。

通过比较实际输出与预期结果,我们可以判断银行家算法的正确性和有效性。

四、实验结果与分析通过运行多个测试用例,我们可以得出以下结论:1. 银行家算法能够有效地避免死锁的发生。

在安全性检查过程中,如果存在安全序列,那么系统可以继续分配资源,否则需要阻塞等待。

黄天实验四银行家算法实验报告

黄天实验四银行家算法实验报告

操作系统实验实验四学号 1415251011 姓名黄天班级 14集成1班华侨大学电子工程系实验目的1、理解银行家算法。

2、掌握进程安全性检查的方法与资源分配的方法。

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

现在系统中A、B、C、D 4类资源分别还剩1、5、2、0个,请按银行家算法回答:1、现在系统是否处于安全状态?答:系统是安全的。

2、如果现在进程P1提出需要(0、4、2、0)个资源的请求,系统能否满足它的请求?答:可以满足。

实验报告内容1、银行家算法和安全性检查算法原理。

银行家算法:银行家算法最初级原为银行系统设计,以确保银行在发放现金贷款时,不会发生不能满足所有客户需要的情况。

在OS设计中,也可以用它来避免死锁。

为实现银行家算法,每个新进程在进入系统时它必须申明在运行过程中,可能需要的每种资源类型的最大单元数目,其数目不应超过系统所拥有的资源总量。

当某一进程请求时,系统会自动判断请求量是否小于进程最大所需,同时判断请求量是否小于当前系统资源剩余量。

若两项均满足,则系统试分配资源并执行安全性检查算法。

安全性检查算法:安全性检查算法用于检查系统进行资源分配后是否安全,若安全系统才可以执行此次分配;若不安全,则系统不执行此次分配。

安全性检查算法原理为:在系统试分配资源后,算法从现有进程列表寻找出一个可执行的进程进行执行,执行完成后回收进程占用资源;进而寻找下一个可执行进程。

当进程需求量大于系统可分配量时,进程无法执行。

当所有进程均可执行,则产生一个安全执行序列,系统资源分配成功。

若进程无法全部执行,即无法找到一条安全序列,则说明系统在分配资源后会不安全,所以此次分配失败。

2、程序流程图。

3、程序及注释。

4、运行结果以及结论。

(1)、按照题给例子验证所编写的程序的正确性如下:如上图所示,编写的程序基本正确。

假如现在系统中A、B、C、D 4类资源分别还剩1、5、2、0个,如图所示,系统是安全的,安全序列为0 -2-1-3-4.假如现在要申请的资源的进程号为P1。

银行家算法实验报告c语言

银行家算法实验报告c语言

银行家算法实验报告c语言银行家算法实验报告引言:计算机科学中的银行家算法是一种资源分配和避免死锁的算法。

它是由艾德加·戴克斯特拉(Edsger Dijkstra)在1965年提出的。

银行家算法通过判断一个系统是否处于安全状态来决定是否分配资源给进程。

本实验旨在使用C语言实现银行家算法,并通过一系列的实例来验证其有效性。

一、实验背景银行家算法是为了解决资源分配中的死锁问题而提出的。

在多进程系统中,每个进程都需要一定数量的资源来完成任务。

然而,如果资源分配不当,可能会导致死锁的发生,即所有进程都陷入无法继续执行的状态。

银行家算法通过合理地分配资源,避免了死锁的发生。

二、实验目的本实验的主要目的是通过C语言实现银行家算法,并通过实例验证其正确性和有效性。

具体而言,我们将模拟一个系统中的多个进程,并为每个进程分配资源。

然后,我们将使用银行家算法来判断系统是否处于安全状态,从而决定是否继续分配资源。

三、实验过程1. 创建进程和资源我们首先创建了5个进程和3种资源。

每个进程需要的资源数量是随机生成的,以模拟真实情况下的资源需求。

2. 分配资源根据银行家算法的原则,我们按照以下步骤来分配资源:- 首先,检查每个进程的资源需求是否小于等于系统当前可用的资源数量。

- 如果满足条件,将资源分配给该进程,并更新系统剩余资源数量。

- 如果不满足条件,暂时不分配资源给该进程,继续检查下一个进程。

3. 判断系统状态在每次资源分配后,我们需要判断系统是否处于安全状态。

为此,我们使用银行家算法的核心原则:只有当系统能够为每个进程提供所需的资源时,系统才是安全的。

我们通过遍历所有进程来检查其资源需求是否小于等于系统剩余资源数量,如果满足条件,说明系统是安全的。

4. 实例验证我们进行了多个实例验证,以确保银行家算法的正确性。

在每个实例中,我们模拟了不同的进程和资源需求,并观察系统的状态。

通过比较实验结果和预期结果,我们验证了银行家算法的有效性。

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

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

实验四银行家算法实习内容通过编程理解银行家算法,掌握进程安全性检查的方法及资源分配的方法,加深了解有关资源申请、避免死锁等概念,体会和了解死锁和避免死锁的具体实施方法。

实习目的银行家算法是避免死锁的代表性算法。

本实习旨在加深了解有关资源申请、避免死锁、状态安全性等概念,并体会和运用避免死锁的具体实施方法。

然后依照本实习,自行设计模拟程序。

实习原理算法思想:银行家算法操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

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

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

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

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

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

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

实习编程思路和流程在避免死锁的方法中,如果施加的限制条件较弱,有可能获得令人满意的系统性能。

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

基本思想为:在分配资源之前,判断系统是否是安全的;若安全,才分配。

它是最具代表性的死锁算法,具体算法如下表示:假设进程P提出请求Request[i],则银行家算法按如下步骤进行判断:1)如果Request[i] <=Need[i],则转向2);否则出错。

2)如果Request[i] <=Available[i],则转向3);否则出错。

3)系统试探分配相关资源,修改相关数据:Available[i]=Available[i]-Request[i];Allocation[i]=Allocation[i]+Request[i];Need[i]=Need[i]-Request[i];4)系统执行安全性检查,如安全,则分配成立;否则试探性分配资源作废,系统恢复原状,进程进入等待状态。

银行家算法实验报告

银行家算法实验报告

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

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

实验四银行家算法

实验四银行家算法

.操作系统实验实验四银行家算法学号 1115102002姓名蔡凤武班级 11电子A华侨大学电子工程系实验目的1、理解银行家算法。

2、掌握进程安全性检查的方法与资源分配的方法。

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

现在系统中A、B、C、D 4类资源分别还剩1、5、2、0个,请按银行家算法回答:1、现在系统是否处于安全状态?2、如果现在进程P1提出需要(0、4、2、0)个资源的请求,系统能否满足它的请求?1、银行家算法和安全性检查算法原理。

操作系统的银行家算法:当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

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

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

1、程序流程描述。

银行家算法:(1) 步骤:1如果Request[j]<=Need[i],转向步骤(2),否则认为出错,因为他所需要的资源数已经超过它所宣布的最大值。

(2) 步骤2;如果:Request[i]<=Available[i],转向步骤(3),否则提示尚无足够资源,进程i需等待。

(3) 步骤3:系统试探分配相关资源,并修改下面数据:Available[i]=Available[i]-Request[j];Allocation[i]=Allocation[i]+ Request[i];Need[i]=Need[i]-Request[i];(4) 步骤4:执行安全性检查,如安全,则分配成立;否则本次试探分配作废,恢复原来的资源分配状态,让该进程等待。

安全性检查算法:安全性检查算法主要是根据银行家算法进行资源分配后,检查资源分配后的系统状态之中。

具体算法如下:(1) 步骤1:设置两个向量: Work= Available,Finish[i]=false;说明:Finish(它表示系统是否有足够的资源分配给进程)Work(它表示系统可提供给进程继续运行所需的各类资源数目)(2) 步骤2:在进程中查找符合以下条件的进程:Finish[i]=false,need<=Work 若能找到,则执行步骤(3),否则,执行步骤(4)(3) 步骤3:当进程获得资源后,可顺利执行,直至完成,从而释放资源:Work= Work+ Allocation; Finish=true; goto step (2);(4) 步骤4:如果所有进程的Finish=true都满足,则表示系统处于安全状态,否则,系统不安全状态。

操作系统:银行家算法的实现

操作系统:银行家算法的实现

操作系统实验报告实验四:银行家算法的实现计科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;}界面部分:虽然界面不是实验的关键,但在本次实验中,界面担当了很重要作用,银行家算法有可能涉及大量数据,所以这需要一个良好的界面来呈现数据。

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

操作系统实验实验四银行家算法学号 1115102002姓名蔡凤武班级 11电子A华侨大学电子工程系实验目的1、理解银行家算法。

2、掌握进程安全性检查的方法与资源分配的方法。

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

现在系统中A、B、C、D 4类资源分别还剩1、5、2、0个,请按银行家算法回答:1、现在系统是否处于安全状态?2、如果现在进程P1提出需要(0、4、2、0)个资源的请求,系统能否满足它的请求?1、银行家算法和安全性检查算法原理。

操作系统的银行家算法:当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

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

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

1、程序流程描述。

银行家算法:(1) 步骤:1如果Request [j]<=Need[i],转向步骤(2),否则认为出错,因为他所需要的资源数已经超过它所宣布的最大值。

(2) 步骤2;如果:Request [i]<=Available[i],转向步骤(3),否则提示尚无足够资源,进程i需等待。

(3) 步骤3:系统试探分配相关资源,并修改下面数据:Available[i]= Available[i]- Request [j]; Allocation[i]= Allocation[i]+ Request [i];Need[i]= Need[i]- Request [i];(4) 步骤4:执行安全性检查,如安全,则分配成立;否则本次试探分配作废,恢复原来的资源分配状态,让该进程等待。

安全性检查算法:安全性检查算法主要是根据银行家算法进行资源分配后,检查资源分配后的系统状态之中。

具体算法如下:(1) 步骤1:设置两个向量:Work= Available,Finish[i]=false;说明:Finish (它表示系统是否有足够的资源分配给进程)Work(它表示系统可提供给进程继续运行所需的各类资源数目)(2) 步骤2:在进程中查找符合以下条件的进程:Finish[i]=false,need<=Work 若能找到,则执行步骤(3),否则,执行步骤(4)(3) 步骤3:当进程获得资源后,可顺利执行,直至完成,从而释放资源:Work= Work+ Allocation;Finish=true;goto step (2);(4) 步骤4:如果所有进程的Finish=true都满足,则表示系统处于安全状态,否则,系统不安全状态。

流程图:主函数:2、程序及注释。

#include <stdio.h>#include <stdlib.h>#include <conio.h># define m 50# define false 0# define true 1int no1; //进程数int no2; //资源数int r;int allocation[m][m], max[m][m],need[m][m], available[m];char name1[m], name2[m]; //定义全局变量void main(){void check();void print();void shoudon();int i,j,p=0,q=0;char c;int s;int request[m],allocation1[m][m],need1[m][m],available1[m],f[m];int mx[5][4]={{0,0,1,2},{1,7,5,0},{2,3,5,6},{0,6,5,2},{0,6,5,6}};int an[5][4]={{0,0,1,2},{1,0,0,0},{1,3,5,4},{0,6,3,2},{0,0,1,4}};int ann[5][4]={{0,0,1,2},{1,4,2,0},{2,3,5,6},{0,6,5,2},{0,6,5,6}};printf("**********************************************\n");printf("*** sf银行家算法演示***\n");printf("**********************************************\n");printf("\n1.演示报告给定系统1.");printf("\n2.演示报告给定系统2.(P1提出需要(0、4、2、0)个资源)"); printf("\n3.演示手动输入系统.");printf("\n0.退出程序.");printf("\n请选择(0~3):");scanf("%d",&s);switch(s){case 1:{no1=5; no2=4;for(i=0;i<no1;i++)for(j=0;j<no2;j++){max[i][j]=mx[i][j];allocation[i][j]=an[i][j];}}break;case 2:{no1=5; no2=4;for(i=0;i<no1;i++)for(j=0;j<no2;j++){max[i][j]=mx[i][j];allocation[i][j]=ann[i][j];}}break;case 3:shoudon();break;case 0:printf("\n thanks for you watching! \n");exit(0); /*退出程序*/default:printf("\n请输入有效指令\n"); break; /*提示输入无效提示*/}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]; //系统尝试把资源分配给请求的进程}check(); //检测分配后的安全性if(r==1)for(j=0;j<no2;j++){ f[j]=allocation1[i][j]+request[j];if(f[j]==max[i][j])allocation[i][j]=0;else allocation[i][j]=f[j];available[j]=available1[j]+allocation1[i][j]-allocation[i][j]; // 改写(已分配的资源数、仍需要的资源数、可用的资源数)need[i][j]=need1[i][j]-request[j];}else //如果分配后系统不安全{for(j=0;j<no2;j++){available[j]=available1[j];allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j]; // 还原(已分配的资源数、仍需要的资源数、可用的资源数)}}print(); //显示相关信息printf("返回分配前资源数\n");}}printf("\n你还要继续分配吗?Y or N ?\n"); //判断是否继续进行资源分配c=getche();}while(c=='y'||c=='Y');}}//手动输入void shoudon(){int i,j;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]); //输入已知的进程已分配的资源数return;}//安全算法函数void check(){int k,f,v=0,i,j;int work[m],a[m];int 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");}3、运行结果以及结论。

相关文档
最新文档