实验二-银行家算法讲课教案

合集下载

计算机操作系统之银行家算法

计算机操作系统之银行家算法

淮海工学院计算机工程学院实验报告书课程名:《计算机操作系统》题目:实验二银行家算法班级: ^ ^ 姓名: ^ ^实验二银行家算法实验目的和要求应用银行家算法验证进程安全性检查及分配资源编制模拟银行家算法的程序,并以以下例子验证程序的正确性。

实验环境1.PC微机。

2.Windows 操作系统。

3.C/C++/VB开发集成环境。

实验学时2学时,必做实验实验内容和步骤1)依照算法流程图编制可执行程序2)用以下两个例子验证程序的正确性。

3)按照上述两个例子,输出执行的结果。

算法流程图银行家算法:安全性算法:【例1】某系统有A、B、C、D这4类资源供5个进程共享,进程对资源的需求和分配情况如下表所示。

现在系统中A、B、C、D类资源分不还剩1、5、2、0个,请按银行家算法回答下列问题:(1) 现在系统是否处于安全状态?(2) 假如现在进程P2提出需要(0,4,2,0)个资源的请求,系统能否满足它的请求?【例2】用银行家算法考虑下列系统状态:进程分配矩阵最大需求矩阵资源总数矩阵A 3 0 1 1 4 1 1 16 3 4 2B 0 1 0 0 0 2 1 2C 1 1 1 0 4 2 1 0D 1 1 0 1 1 1 1 1E 0 0 0 0 2 1 1 0问系统是否安全?若进程B请求(0,0,1,0),可否立即分配?此后进程E也请求(0,0,1,0),可否分配给它?通过运行程序发觉,例1当中的系统处于不安全状态,进程P2提出的请求无法实现;例2当中的系统处于安全状态,进程B提出的请求能实现,此后进程E的请求也能实现。

源代码#include<iostream>#define N 20#define M 20using namespace std;int f(int a[N][M],int b[N][M],int m,int k) {int j;for(j=0;j<m;j++)if(a[k-1][j]>b[k-1][j])return 0;return 1;}int g(int a[N][M],int b[],int m,int k) {int j;for(j=0;j<m;j++)if(a[k][j]>b[j])return 0;return 1;}int h(int a[],int n){for(int i=0;i<n;i++)if(!a[i])return 0;return 1;}int p(int a[],int b[N][M],int m,int k){int j;for(j=0;j<m;j++)if(a[j]>b[k-1][j])return 0;return 1;}int q(int a[],int b[],int m){int j;for(j=0;j<m;j++)if(a[j]>b[j])return 0;return 1;}int safe(int Finish[N],int Work[M],int Need[N][M],int Allocation[N][M],int n,int m){ int i,j,k;int t[N];for(i=0;i<n;i++)t[i]=1;cout<<"安全性检查!"<<endl;for(i=0;i<n;)// 首先找到一个满足条件的进程 {if((Finish[i]==0)&&g(Need,Work,m,i)){k=i;t[i]=0;cout<<"p("<<k+1<<"):"<<endl;cout<<"Work["<<m<<"]:";for(j=0;j<m;j++){cout<<Work[j]<<" ";Work[j]=Work[j]+Allocation[i][j]; Finish[i]=1;}cout<<endl;cout<<"Need["<<m<<"]:";for(j=0;j<m;j++)cout<<Need[i][j]<<" ";cout<<endl;cout<<"Allocation["<<m<<"]:";for(j=0;j<m;j++)cout<<Allocation[i][j]<<" ";cout<<endl;cout<<"(Work+Allocation)["<<m<<"]:"; for(j=0;j<m;j++)cout<<Work[j]<<" ";cout<<endl;cout<<"Finish["<<k+1<<"]:";cout<<Finish[i]<<" ";cout<<endl;break;}else{i++;}}if(g(Need,Work,m,k))//依次找到满足条件的后面几个进程 {for(i=0;i<n;i++){if(t[i]){if(g(Need,Work,m,i)){cout<<"p("<<i+1<<"):"<<endl;cout<<"Work["<<m<<"]:";for(j=0;j<m;j++){cout<<Work[j]<<" ";Work[j]=Work[j]+Allocation[i][j];Finish[i]=1;cout<<endl;cout<<"Need["<<m<<"]:";for(j=0;j<m;j++)cout<<Need[i][j]<<" ";cout<<endl;cout<<"Allocation["<<m<<"]:";for(j=0;j<m;j++)cout<<Allocation[i][j]<<" ";cout<<endl;cout<<"(Work+Allocation)["<<m<<"]:"; for(j=0;j<m;j++)cout<<Work[j]<<" ";cout<<endl;cout<<"Finish["<<i+1<<"]:";cout<<Finish[i]<<" ";cout<<endl;t[i]=0;}}}else {return 0;}if(h(Finish,n))return 1;//系统处于安全状态else return 0;//系统处于不安全状态}void r(int Finish[N],int Work[M],int Available[M],int Need[N][M],int Allocation[N][M],int Max[N][M],int n,int m) {int Request[M];char b;int i,j,k;cout<<"\n要申请资源,请按'y'或'Y',否则按'n'或'N'"<<endl;//是立即进行安全性检查,依旧进行资源申请cin>>b;if(b!='y'&&b!='Y')if(safe(Finish,Work,Need,Allocation,n,m)){cout<<"现在刻系统安全!\n";}else{cout<<"现在刻系统不安全!\n";}}else{{cout<<"\n请输入申请资源的进程编号(1,2,…,"<<n<<"):"<<endl;cin>>k;while(k>n){cout<<"您输入了错误的进程号,请核查后重新输入:"<<endl;cin>>k;}cout<<"\n请输入进程p("<<k<<")申请各类资源的数量:"<<endl;for (j=0; j<m; j++)cin>>Request[j];if(p(Request,Need,m,k)){if(q(Request,Available,m)){for(j=0;j<m;j++){Available[j]=Available[j]-Request[j];Allocation[k-1][j]=Allocation[k-1][j]+Request[j]; Need[k-1][j]=Need[k-1][j]-Request[j];Work[j]=Available[j];}cout<<"试分配!"<<endl;cout<<"各种资源可利用的数量Available["<<m<<"]: "<<endl;for (j=0; j<m; j++){cout<<Available[j]<<" ";}cout<<endl;cout<<"\n已分配资源Allocation["<<m<<"]: "<<endl;for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Allocation[i][j]<<" ";}cout<<endl;}cout<<"\n最大需求矩阵Max["<<n<<"]["<<m<<"]: "<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Max[i][j]<<" ";}cout<<endl;}cout<<"\n需求矩阵Need["<<n<<"]["<<m<<"]: "<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Need[i][j]<<" ";}cout<<endl;}if (safe(Finish,Work,Need,Allocation,n,m)){//推断当前状态的安全性cout<<"系统处于安全状态!";cout<<"\n申请资源成功!!!"<<endl;}else{cout<<"\n当前状态不安全!!!!!!";//恢复数据for (j=0; j<m; j++){Available[j]=Available[j]+Request[j];Allocation[k-1][j]=Allocation[k-1][j]-Request[j];Need[k-1][j]=Need[k-1][j]+Request[j];Work[j]=Available[j];}for(i=0; i<n; i++)Finish[i]=0;cout<<"\n恢复数据:"<<endl;//显示输入各数组的值cout<<"各种资源可利用的数量Available["<<m<<"]: "<<endl;for (j=0; j<m; j++){cout<<Available[j]<<" ";}cout<<endl;cout<<"\n已分配资源Allocation["<<m<<"]: "<<endl;for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Allocation[i][j]<<" ";}cout<<endl;}cout<<"\n最大需求矩阵Max["<<n<<"]["<<m<<"]: "<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Max[i][j]<<" ";}cout<<endl;}cout<<"\n需求矩阵Need["<<n<<"]["<<m<<"]: "<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cout<<Need[i][j]<<" ";}cout<<endl;}cout<<"系统中尚无足够的资源满足进程p["<<k<<"]的申请,p["<<k<<"]必须等待!"<<endl;}}else cout<<"系统中尚无足够的资源满足进程p["<<k<<"]的申请,p["<<k<<"]必须等待!"<<endl;}else cout<<"出错,进程所需要的资源数目已超过它所宣布的最大值!"<<endl;}}}void main(){cout<<"---------------------------------------------------------"<<endl;cout<<"------------------模拟银行家算法------------------"<<endl;cout<<"---------------------------------------------------------"<<endl;cout<<"--------------------江之风海之韵-------------------"<<endl;cout<<"------------------------QuQu-------------------------"<<endl;cout<<"---------------------------------------------------------"<<endl;int Available[M];int Max[N][M];int Allocation[N][M];int Need[N][M];int Work[M];int Finish[N];int i,j,n,m;//定义全局变量cout<<"输入进程的数量: ";//从此开始输入有关数据cin>>n;cout<<"输入资源种类数: ";cin>>m;cout<<"输入各种资源可利用的数量Available["<<m<<"]: "<<endl;for (j=0; j<m; j++){cin>>Available[j];Work[j]=Available[j];//初始化Work[j]}cout<<"\n输入各进程对各类资源的最大需求数Max["<<n<<"]["<<m<<"]: "<<endl;cout<<"\n请严格按照("<<n<<"×"<<m<<")的距阵输入:"<<endl;for (i=0; i<n; i++){for (j=0; j<m; j++)cin>>Max[i][j];}cout<<"\n请输入各进程当前已分配的资源数量Allocation["<<n<<"]["<<m<<"]: "<<endl;cout<<"\n请严格按照("<<n<<"×"<<m<<")的距阵输入:"<<endl; for (i=0; i<n; i++){for (j=0; j<m; j++){cin>>Allocation[i][j];Need[i][j] = Max[i][j]-Allocation[i][j];}}r(Finish,Work,Available,Need,Allocation,Max,n,m); for(i=0;i<n;i++)Finish[i]=0;r(Finish,Work,Available,Need,Allocation,Max,n,m); for(i=0;i<n;i++)Finish[i]=0;r(Finish,Work,Available,Need,Allocation,Max,n,m); for(i=0;i<n;i++)Finish[i]=0;r(Finish,Work,Available,Need,Allocation,Max,n,m); for(i=0;i<n;i++)}实验结果实验体会银行家算法在计算机操作系统中是一个特不重要的算法,这次我编制模拟银行家算法的程序,来验证了程序的正确性。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

淮海工学院计算机学院实验报告书课程名:《操作系统原理A》题目:银行家算法班级:Z计121学号:2014140093姓名:薛慧君操作系统原理实验——银行家算法实验报告1目的与要求:1)本实验目的是通过使用银行家算法实现系统资源的分配和安全性检查模拟,提高学生对操作系统资源分配功能的深刻理解,并培养学生对操作系统开发的兴趣与应用能力。

2)实验前必须认真阅读和理解银行家算法的基本原理和实现方法。

3)独立使用C或VC++编程语言编写银行家算法模拟程序。

4)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)5)于2015年5月10日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。

2实验内容或题目1)设计五个进程{P0,P1,P2,P3,P4}共享三类资源{A,B,C}的系统,{A,B,C}的资源总数量分别为10,5,7。

(参考书上用例)2)并行进程可动态地申请资源和释放资源(程序交互输入申请或释放资源数量),系统按各进程的申请动态地分配资源。

3)每当进程动态申请资源或释放资源时,模拟程序应能及时显示或打印各个进程在此时刻的资源分配表、系统可用资源量和安全序列等资源分配信息和安全检查信息。

4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。

3实验步骤与源程序4 测试数据与实验结果(可以抓图粘贴)(1)程序运行时选择1 ,输入进程pr1的请求向量(1,0,2)经过程序计算,资源分配成功。

资源具体分配过程如下图所示。

得出一个安全序列为pr1,pr3,pr0,pr2,pr4。

(2)进程pr0请求资源:pr0发出请求向量(2,2,2),由于Request0不大于Need0,Request0不大于Available0。

系统试探着为它分配资源。

由结果可知,系统不安全。

则系统不分配资源,并回收系统预分配给pr0的资源。

(3)程序运行时选择1,进行系统资源的分配。

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

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

目录第一章功能需求描述 (2)1.1功能列表与说明 (2)1.2操作界面和操作方法 (2)第二章设计描述 (3)2.1任务分解说明 (3)2.2主要数据结构设计说明 (3)2.3主要函数接口设计说明 (3)第三章算法描述 (5)第四章开发过程描述 (14)4.1程序代码 (14)4.2设计中的问题和解决方法 (23)4.3测试用例和测试方法 (24)第五章设计心得体会 (32)计算机科学与技术学院课程设计任务书第一章功能需求描述1.1功能列表与说明(1)添加进程:规定现在操作系统中运行的进程数。

(2)添加资源:规定当前需要资源的种类数和各种类资源的数目。

(3)分配资源:给各进程分配资源。

(4)安全性检查:检查资源分配后是否会发生死锁,若发生则不这样进行分配。

(5)资源释放:当一个进程结束后释放其所占有的各类资源。

(6)得到安全序列:当资源分配能够保证各进程顺利结束,则得到进程的安全序列。

(7)删除资源:即取消某资源1.2操作界面和操作方法*************银行家算法演示****************请首先输入系统可供资源种类的数量:资源*的名称:资源的数量:请输入作业的数量:请输入各进程的最大需求量:请输入各进程已经申请的资源量:系统目前可用资源:系统是否安全?分配的序列:********银行家算法演示***********1:增加资源2:删除资源3:修改资源4:分配资源5:增加作业0:离开在如上的操作界面中分别按照提示进行输入,按回车键表示当前输入完毕,然后进行下个步骤的输入或者得到最终结果。

第二章设计描述2.1任务分解说明银行家算法的实现过程主要分为以下几个部分:为实现银行家算法,系统中必须设置若干数据结构。

其中有allocation,记录已经分配的系统资源;max,记录每个进程的资源最大需求;available,记录剩余资源;need用来记录现在每个进程需要多少资源,need=max-allocation;request 请求资源;temp,记录路径,即输出的顺序;finish,用来实现循环,以判断是否安全,这也就是安全性检查。

精品课程银行家算法的模拟实现共22页

精品课程银行家算法的模拟实现共22页

1 课设简介:1.1 课程设计题目银行家算法的模拟实现1.2 课程设计目的通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。

1.3 课程设计内容模拟实现动态资源分配。

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

2 实验原理分析:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

死锁的产生,必须同时满足四个条件,即一个资源每次只能由一个进程张勇;第二个为等待条件,即一个进程请求资源不能满足时,它必须等待,单它仍继续宝石已得到的所有其他资源;第三个为非剥夺条件,即在出现死锁的系统中一定有不可剥夺使用的资源;第四个为循环等待条件,系统中存在若干个循环等待的进程,即其中每一个进程分别等待它前一个进程所持有的资源。

防止死锁的机构只能确保上述四个条件之一不出现,则系统就不会发生死锁。

通过这个算法可以用来解决生活中的实际问题,如银行贷款等。

3 程序结构分析:3.2 程序模块划分3.2.1.银行家算法:设进程i提出请求Request[n],则银行家算法按如下规则进行判断。

(1)如果Request[n]>Need[i,n],则报错返回。

(2)如果Request[n]>Available,则进程i进入等待资源状态,返回。

(3)假设进程i的申请已获批准,于是修改系统状态:Available=Available-RequestAllocation=Allocation+RequestNeed=Need-Request(4)系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待。

3.2.2.安全性检查(1)设置两个工作向量Work=Available;Finish[M]=False(2)从进程集合中找到一个满足下述条件的进程,Finish [i]=FalseNeed<=Work如找到,执行(3);否则,执行(4)(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个,才能完成其任务。

#操作系统课程设计-银行家算法(流程图 源代码 设计报告)

#操作系统课程设计-银行家算法(流程图 源代码 设计报告)

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

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

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

包括:进程名——name[5],要求资源数目——command[m](m类资源),还需要资源数目——need[m],已分配资源数目——allo[m]。

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

(动态完成)四、程序流程图五、源程序:最新版本:bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源(〉2)*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外,对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*//*四、程序流程图:五、源程序:最新版本:bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改#define NP10*//* #define NS5*//*资源种类*//*bk3.c::可以继续分配资源(〉2)*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外,对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ #include "string.h"#include "stdio.h"#include"dos.h"#include"conio.h"#define MOVEIN1#define GUIYUE2#define ACC3#define OK1#define ERROR0#define MAXSH7#define MAXSHL10#define MAXINPUT50#define maxsize 100int act;int ip=0;int line=0; /*line为要写的行号,全局变量*/int writeok;int right;char wel[30]={"Welcome To Use An_Li System"};char ente[76]={" 警告:未经作者同意不得随意复制更改!"};char rights[40]={"Copyright (c)2002"};struct date today;sssssssssssss;ttttttttttttt{int data[maxsize];int top;}stack;int emptystack(stack*S){if(S->top==48&&S->data[S->top]==35)return(1); /*35is'#'*/else return(0);}int push(stack*S,int x){if(S->top>=maxsize-1)return(-1);else{S->top++;S->data[S->top]=x;return(0);}int gettop(stack*S){return S->data[S->top];}int pop(stack*S){if(emptystack(S)){printf("the stack is empty\n");exit(1);}else S->top--;return S->data[S->top+1];}void initstack(stack*S){int i;S->top=0;S->data[S->top]=35;}/*****模拟打字机的效果*********/delay_fun(){int i;void music();for(i=0;;i++){if(wel!='\0'){delay(1000);textcolor(YELLOW);gotoxy(26+i,8);cprintf("%c",wel);printf("谢谢");printf("网络");music(1,60);}else break;}delay(500000);for(i=0;;i++){if(ente!='\0'){delay(1000);textcolor(RED);/*显示警告及版权*/gotoxy(2+i,11);cprintf("%c",ente);}else break;}delay(40000);for(i=0;;i++){if(rights!='\0'){delay(1000);textcolor(YELLOW);gotoxy(30+i,14);cprintf("%c",rights);music(1,60);}elsebreak;}getch();}/*********登陆后的效果**********/ logined(){int i;clrscr();gotoxy(28,10);textcolor(YELLOW);cprintf("程序正在载入请稍候....."); gotoxy(35,12);for(i=0;i<=50;i++){gotoxy(40,12);delay(8000);cprintf("%02d%已完成",i*2);gotoxy(i+15,13);cprintf("\n");cprintf("|");}main0();}/*********对PC扬声器操作的函数****/void music(int loop,int f)/*f为频率*/ {int i;for(i=0;i<30*loop;i++){sound(f*20);}int analys(int s,int a){int hh,pos;switch(a){case(int)'i':hh=0;break;case(int)'+':hh=1;break;case(int)'*':hh=2;break;case(int)'(':hh=3;break;case(int)')':hh=4;break;case(int)'#':hh=5;break;case(int)'E':hh=6;break;case(int)'T':hh=7;break;case(int)'F':hh=8;break;default:{printf("\n analys()分析发现不该有的字符%c!(位置:%d)",a,ip+1); writeerror('0',"\n............分析出现错误!!!");writeerror(a,"\n 错误类型: 不该有字符");printf("谢谢");printf("网");return ERROR;}}pos=(s-48)*10+hh;switch(pos){case3:case43:case63:case73:act=4;return MOVEIN;case0:case40:case60:case70:act=5;return MOVEIN;case11:case81:act=6;return MOVEIN;case92:case22:act=7;return MOVEIN;case84:act=11;return MOVEIN;/*-------------------------------------------*/case91:case94:case95:act=1;return GUIYUE;case21:act=2;return GUIYUE;case101:case102:case104:case105:act=3;return GUIYUE;case31:case32:case34:case35:act=4;return GUIYUE;case111:case112:case114:case115:act=5;return GUIYUE;case51:case52:case54:case55:act=6;return GUIYUE;/*+++++++++++++++++*/case15:return ACC;/*******************************/case6:return1;case7:case47:return2;case8:case48:case68:return3;case46:return8;case67:return9;case78:return10;default:{if(a=='#')printf("");else printf("\n analys() 分析发现字符%c 不是所期望的!(位置:%d)",a,ip+1);writeerror('0',"\n...........分析出现错误!!!");writeerror(a,"\n 错误类型: 字符");writeerror('0'," 不是所期望的!");printf("谢谢");printf("网");return ERROR;}}}int writefile(int a,char*st){FILE*fp;fp=fopen("an_slr.txt","a");{fprintf(fp,"%s",st); /*若a==-1则为添加的注释*/}else if(a==-2){getdate(&today);gettime(&now);fprintf(fp,"\n测试日期:%d-%d-%d",today.da_year,today.da_mon,today.da_day);测试时间:%02d:%02d:%02d",now.ti_hour,now.ti_min,now.ti_sec); fprintf(fp,"}else if(a>=0)fprintf(fp,"\n step:%02d,%s",a,st);writeok=1;fclose(fp);}return writeok;}int writeerror(char a,char*st) /*错误类型文件*/{FILE*fpp;fpp=fopen("an_slr.txt","a");if(fpp==0){printf("\nwrite error!!");writeok=0;}else{if(a=='0')fprintf(fpp,"%s",st); /*若a=='0' 则为添加的注释*/else fprintf(fpp,"%s\'%c\'(位置:%d)",st,a,ip+1);writeok=1;fclose(fpp);}return writeok;}/*^^^^^^^^^^^^^^^^^^^^^^*/main0(){int an,flag=1,action,lenr;char a,w[MAXINPUT];int len,s,ss,aa,ana;stack*st;char r[MAXSH][MAXSHL];/*初始化产生式*/strcpy(r[0],"S->E");strcpy(r[1],"E->E+T");strcpy(r[2],"E->T");strcpy(r[3],"T->T*F");strcpy(r[4],"T->F");strcpy(r[5],"F->(E)");strcpy(r[6],"F->i");clrscr();printf("\nplease input analyse string:\n");gets(w);len=strlen(w);w[len]='#';w[len+1]='\0';push(st,48); /*(int)0 进栈*/writefile(-1,"\n------------------------SLR(1)词法分析器-------------------------"); writefile(-1,"\n计本003 安完成于2003.01.1214:04"); writefile(-1,"\n谢谢");writefile(-1,"网");writefile(-1,"\n 以下为串");writefile(-1,w);writefile(-1,"('#'为系统添加)的分析结果:");writefile(-2,"");do{s=gettop(st);aa=(int)w[ip];action=analys(s,aa);if(action==MOVEIN){ss=48+act;push(st,aa);push(st,ss); /*if ss=4int=52*/ip++;}else if(action==GUIYUE){lenr=strlen(r[act])-3;for(an=0;an<=2*lenr-1;an++)pop(st); /*#0 */s=gettop(st); /*s=0*/push(st,(int)r[act][0]);/*将产生式左端F 进栈*/ana=analys(s,(int)r[act][0])+48;if(ana>59)printf("\分析出错:ana>59!!!");push(st,ana);/*analys(s,aa)即为goto(s',aa)*/if((line+1)%20==0){printf("\nThis screen is full,press any key to continue!!!");getche();clrscr();}printf("step%02d: %s\n",line++,r[act]);writefile(line,r[act]);}else if(action==ACC){flag=0;right=1;}else if(action==ERROR){flag=0;right=0;}/*接受成功*/else{flag=0;right=0;}/* 出错*/}while(flag==1);if(right==1)printf("\nok,输入串%s 为可接受串!!",w);if(right==0)printf("\nsorry,输入串%s 分析出错!!",w);if(writeok==1){printf("\nAnWin soft have wrote a file an_slr.txt");if(right==1)writefile(-1,"\n最终结果:输入串为可接受串!");}}main() /*主函数*/{clrscr();delay_fun();logined();}六、测试报告-操作系统课程设计-银行家算法(流程图+源代码+设计报告)六、测试报告:(测试结果保存于系统生成的an.txt 文件中)以下为课本上的实例::-------------------------------------------------------------------------------------========================银行家算法测试结果=========================-------------------------------------------------------------------------------------T0 时刻可用资源(Available)A:3,B:3,C:2测试日期:2003-6-28请求分配时间:14:07:29经测试,可为该进程分配资源。

(完整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 程序功能.........................................................。

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

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

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

(word完整版)实验二银行家算法

(word完整版)实验二银行家算法

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

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

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

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

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

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

b)Request i=Need[i]。

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

c)Request i〉Need[i]。

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

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

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

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

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

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

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

操作系统实验2--银行家算法(总9页)--本页仅作为文档封面,使用时请直接删除即可----内页可以根据需求调整合适字体及大小--操作系统课程设计报告课程名称:银行家算法姓名:刘成启学号:149班级:计算机1008班指导老师:袁宁共享资源分配与银行家算法一、实验目的[问题描述]本题主要内容是模拟实现资源分配。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

内容摘要本课设要完成的是编写一程序,能够模拟银行家算法和安全算法来避免死锁的问题。

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

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

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

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

关键词银行家算法C语言数据结构课程设计任务书目录:第一章绪论 (4)1.1 综述 (4)1.2设计内容与要求 (5)1.3 设计目的 (5)1.4设计地点 (5)1.5设计环境 (5)第二章程序设计与实现 (6)2 .1详细设计 (6)2.1 .1银行家算法数据结构设计描述 (6)2.1.2银行家算法实现描述 (6)2.1.3 程序流程图 (7)第三章程序调试与运行 (8)3.1运行结果 (8)第四章实验体会 (10)参考文献 (11)附录: (11)第一章绪论1.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;}。

实验二-银行家算法讲课教案

实验二-银行家算法讲课教案

实验二-银行家算法实验四银行家算法一、实验目的1.理解死锁避免相关内容;2.掌握银行家算法主要流程;3.掌握安全性检查流程。

操作系统中的死锁避免部分的理论进行实验。

要求实验者设计一个程序,该程序可对每一次资源申请采用银行家算法进行分配。

二、实验设备PC机、windows 操作系统、VC++6.0三、实验要求本实验要求3学时完成。

1.设计多个资源(≥3);2.设计多个进程(≥3);3.设计银行家算法相关的数据结构;4.动态进行资源申请、分配、安全性检测并给出分配结果。

5.撰写实验报告,并在实验报告中画出银行家算法和和安全性检查算法流程图。

四、预备知识死锁避免定义:在系统运行过程中,对进程发出的每一个资源申请进行动态检查,并根据检查结果决定是否分配资源:若分配后系统可能发生死锁,则不予分配,否则予以分配。

由于在避免死锁的策略中,允许进程动态地申请资源。

因而,系统在进行资源分配之前预先计算资源分配的安全性。

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

其中最具有代表性的避免死锁算法是银行家算法。

1 系统安全状态1)安全状态所谓系统是安全的,是指系统中的所有进程能够按照某一种次序分配资源,并且依次地运行完毕,这种进程序列{ P1 ,P2 …Pn}就是安全序列。

如果存在这样一个安全序列,则系统是安全的。

并非所有的不安全状态都会转为死锁状态,但当系统进入不安全状态后,便有可能进入死锁状态;反之,只要系统处于安全状态,系统便可避免进入死锁状态。

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

2)安全状态之例假设系统有三个进程,共有12台磁带机。

各进程的最大需求和T0时刻已分配情况如下表:答:T0时刻是安全的,因为存在安全序列:P2 →P1→ P3不安全序列:P1→…P3→…P2→P3→P13)由安全状态向不安全状态的转换如果不按照安全序列分配资源,则系统可能会由安全状态进入不安全状态。

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

实验二-银行家算法
实验四银行家算法
一、实验目的
1.理解死锁避免相关内容;
2.掌握银行家算法主要流程;
3.掌握安全性检查流程。

操作系统中的死锁避免部分的理论进行实验。

要求实验者设计一个程序,该程序可对每一次资源申请采用银行家算法进行分配。

二、实验设备
PC机、windows 操作系统、VC++6.0
三、实验要求
本实验要求3学时完成。

1.设计多个资源(≥3);
2.设计多个进程(≥3);
3.设计银行家算法相关的数据结构;
4.动态进行资源申请、分配、安全性检测并给出分配结果。

5.撰写实验报告,并在实验报告中画出银行家算法和和安全性检查算法流程图。

四、预备知识
死锁避免定义:在系统运行过程中,对进程发出的每一个资源申请进行动态检查,并根据检查结果决定是否分配资源:若分配后系统可能发生死锁,则不予分配,否则予以分配。

由于在避免死锁的策略中,允许进程动态地申请资源。

因而,系统在进行资源分配之前预先计算资源分配的安全性。

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

其中最具有代表性的避免死锁算法是银行家算法。

1 系统安全状态
1)安全状态
所谓系统是安全的,是指系统中的所有进程能够按照某一种次序分配资源,并且依次地运行完毕,这种进程序列{ P1 ,P2 …Pn}就是安全序列。

如果存在这样一个安全序列,则系统是安全的。

并非所有的不安全状态都会转为死锁状态,但当系统进入不安全状态后,便有可能进入死锁状态;反之,只要系统处于安全状态,系统便可避免进入死锁状态。

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

2)安全状态之例
假设系统有三个进程,共有12台磁带机。

各进程的最大需求和T0时刻已分配情况如下表:
答:T0时刻是安全的,因为存在安全序列:P2 →P1→ P3
不安全序列:P1→…
P3→…
P2→P3→P1
3)由安全状态向不安全状态的转换
如果不按照安全序列分配资源,则系统可能会由安全状态进入不安全状态。

例如,在T0时刻以后,P3又请求1台磁带机,若此时系统把剩余3台中的1台分配给P3,则系统便进入不安全状态。

因为,此时也无法再找到一个安全序列,例如,把其余的2台分配给P2,这样,在P2完成后只能释放出4台,既不能满足P1尚需5台的要求,也不能满足P3尚需6台的要求,致使它
们都无法推进到完成,彼此都在等待对方释放资源,即陷入僵局,结果导致死锁。

2 利用银行家算法避免死锁
1)银行家算法中的数据结构
①可利用资源向量Available。

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

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

②最大需求矩阵Max。

最大需求矩阵Max。

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

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

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

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

④需求矩阵Need
这也是一个n×m的矩阵,用以表示每一个进程尚需的各类资源数。

如果Need[i,j]=K,则表示进程i还需要Rj类资源K个,方能完成其任务。

Need[i,j]=Max[i,j]-Allocation[i,j]2)银行家算法
设Requesti是进程Pi的请求向量,如果Requesti[j]=K,表示进程Pi 需要K个Rj类型的资源。

当Pi发出资源请求后,系统按下述步骤进行检查:
(1) 如果Requesti[j]≤Need[i,j],便转向步骤2;否则认为出错,因为它所需要的资源数已超过它所宣布的最大值。

(2) 如果Requesti[j]≤Available[j],便转向步骤(3);否则,表示尚无足够资源,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: 它表示系统是否有足够的资源分配给进程,使之运行完成。

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

(2) 从进程集合中找到一个能满足下述条件的进程:
① Finish[i]=false;
② Need[i,j]≤Work[j];若找到,执行步骤(3),否则,执行步骤
(4)。

(3) 当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:
Work[j]∶=Work[i]+Allocation[i,j];
Finish[i]∶=true;
go to step (2);
(4) 如果所有进程的Finish[i]=true都满足,则表示系统处于安全状态;否则,系统处于不安全状态。

安全性算法的参考流程图如下:
五、实验步骤
1.设计并编写银行家算法模拟程序。

2.在上机环境中输入程序,调试,编译。

3.设计输入数据,写出程序的执行结果。

4.根据具体实验要求,撰写好实验报告,提交到天空教室。

相关文档
最新文档