大作业 银行家算法课程设计报告

合集下载

大作业 银行家算法课程设计报告

大作业    银行家算法课程设计报告

《操作系统》课程设计报告设计题目:银行家算法的实现姓名:梅济民学号: 2012015014 同组人姓名:赵宇昊学号: 2012012962班级: 2012级信息与计算科学完成日期: 2015年 11 月 12 日银行家算法分析、设计与实现一、理论描述银行家算法要求每个进程的最大资源需求,其基本思想是:始终保持系统处于安全状态,当设计进程提出资源请求时,系统先进行预分配,再判断系统分配后是否仍然处于安全状态。

如果仍然处于安全状态,就进行实际分配;如果处于不安全状态,则拒绝该进程的资源请求。

二、算法描述及数据结构模型#define False 0#define True 1int Max[100][100]={0};//各进程所需各类资源的最大需求int Avaliable[100]={0};//系统可用资源char name[100]={0};//资源的名称int Allocation[100][100]={0};//系统已分配资源int Need[100][100]={0};//还需要资源int Request[100]={0};//请求资源向量int temp[100]={0};//存放安全序列int Work[100]={0};//存放系统可提供资源int M=100;//作业的最大数为100int N=100;//资源的最大数为10三、源代码void showdata()//显示资源矩阵{int i,j;printf(”系统目前可用的资源[Avaliable]:\n”);for(i=0;i〈N;i++)printf("%c ”,name[i]);printf("\n”);for (j=0;j<N;j++)printf(”%d ",Avaliable[j]);//输出分配资源printf(”\n");printf(" Max Allocation Need \n"); printf("进程名”);for(j=0;j<3;j++){for(i=0;i〈N;i++)printf(”%c ”,name[i]);printf(” ");}printf(”\n”);for(i=0;i〈M;i++){printf(” %d ",i);for(j=0;j〈N;j++)printf("%d ",Max[i][j]);printf(” ”);for(j=0;j〈N;j++)printf(”%d ",Allocation[i][j]);printf(” ”);for(j=0;j〈N;j++)printf("%d ",Need[i][j]);printf(”\n");}}int changdata(int i)//进行资源分配{int j;for (j=0;j<M;j++){Avaliable[j]=Avaliable[j]—Request[j];Allocation[i][j]=Allocation[i][j]+Request[j];Need[i][j]=Need[i][j]—Request[j];}return 1;}int safe()//安全性算法{int i,k=0,m,apply,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){apply=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==N){for(m=0;m〈N;m++)Work[m]=Work[m]+Allocation[i][m];//变分配数Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i〈M;i++){if(Finish[i]==False){printf("系统不安全\n");//不成功系统不安全return -1;}}printf(”系统是安全的!\n”);//如果安全,输出成功printf("分配的序列:”);for(i=0;i<M;i++){//输出运行进程数组printf(”%d",temp[i]);if(i<M-1)printf(”—〉");}printf(”\n");return 0;}void share()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch=’y';printf("请输入要求分配的资源进程号(0-%d):”,M—1);scanf(”%d”,&i);//输入须申请的资源号printf("请输入进程%d 申请的资源:\n",i);for(j=0;j〈N;j++){printf("%c:”,name[j]);scanf(”%d”,&Request[j]);//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错{printf(”进程%d申请的资源大于它需要的资源,分配不合理,不予分配!\n”,i);ch='n’;break;}else {if(Request[j]〉Avaliable[j])//判断申请是否大于当前资源,若大于则出错{printf("进程%d申请的资源大于系统现在可利用的资源\n",i);printf(”分配出错,不予分配!\n");ch='n’;break;}}}if(ch==’y’) {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}int main()//主函数{int i,j,q,choice,m,n,flag;char ming;printf("请首先输入系统可供资源种类的数量:");scanf(”%d”,&n);N=n;for(i=0;i〈n;i++){printf("资源%d的名称:",i+1);scanf(”%s",&ming);name[i]=ming;printf(”资源%d的数量:",i+1);scanf("%d",&q);Avaliable[i]=q;}// printf("\n");printf(”请输入作业的数量:”);scanf("%d",&m);M=m;printf(”请输入各进程的最大需求量%d*%d矩阵[Max]:\n",m,n);for(i=0;i〈m;i++){for(j=0;j〈n;j++)scanf("%d”,&Max[i][j]);//printf(”\n”);}do{flag=0;printf("请输入各进程已经申请的资源量(%d*%d矩阵)[Allocation]:\n”,m,n);for(i=0;i<m;i++)for(j=0;j〈n;j++){scanf("%d”,&Allocation[i][j]);if(Allocation[i][j]〉Max[i][j]) flag=1;Need[i][j]=Max[i][j]—Allocation[i][j];}if(flag)printf(”申请的资源大于最大需求量,请重新输入!\n”);}while(flag);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){printf(”\n");printf(”0:离开\n”);printf(”1:分配资源\n");printf(”请选择功能号:");scanf("%d”,&choice);switch(choice){case 1: share();break;case 0:break;default:printf("请正确选择功能号(0-1)!\n");break;}}return 1;四、程序运行结果及分析时刻的资源分配表(各种资源的数量分别为:10、5、7)T运行结果五、课程设计心得与体会通过这次实验,我了解了银行家算法的原理,在编写和调试程序过程中,我的算法和编程能力提高了很多六。

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

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

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

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

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

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

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

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

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

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

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获得所申请资源七、总结这次实验中我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

银行家算法课程设计

银行家算法课程设计

课程设计(大作业)报告课程名称:操作系统设计题目:银行家算法院系:信息技术学院班级:2011级1班设计者:111学号:201111010111111指导教师:11111设计时间:12.22——12.27昆明学院昆明学院课程设计(大作业)任务书一、题目分析银行家算法基本原理:操作系统在每一次分配之前都要进行以下操作,判断当前的资源请求是否安全,如果安全则实施分配,否则不予分配。

第1步:操作系统对提出资源请求的进程按所请求的资源数目实施预分配,修改剩余资源数组、资源分配矩阵和剩余资源请求矩阵;第2步:将剩余资源数组代入剩余需求矩阵中与各元素进行比较,找到可以满足其所有资源需求的某个进程将它加入到安全序列中;第3步:将该进程运行结束后释放的资源累加到剩余资源数组中;第4步:再重复第2、3两步。

若所有进程都能够进入安全序列<Pi,Pj,……>,则此次分配可以实施,否则系统将会处于不安全状态,因而不能实施分配。

如果不能实施分配,则将系统还原到预分配之前的状态。

2.设计步骤和方法(1)设计数据结构:剩余资源数组available,如available[j] = k表示资源Rj现有k个。

(2)设计数据结构:最大资源请求矩阵max,如max [i][j] = k表示进程Pi 最多可申请k个类型为Rj的资源。

(3)设计数据结构:资源分配矩阵allocation,定义每个进程现在所分配的各种资源类型的数量,如allocation [i][j] = k表示进程Pi现在分配了k个类型为Rj的资源。

(4)设计数据结构:剩余资源请求矩阵claim,定义每个进程还需要的剩余的资源数,如claim [i][j] = k表示进程Pi还需要申请k个类型Rj的资源。

其中,claim [i][j] = max[i][j] - allocation[i][j]。

(5)设计函数完成功能:系统内资源总数已知、各进程对各类资源最大需求数目已知、已分配资源数目已知的前提下,某进程提出各类资源的需求量时能判断状态是否安全,以决定是否予以分配。

银行家算法课程设计报告

银行家算法课程设计报告

中南大学软件技术课程设计报告课程名称:模拟银行家算法原理班级:学号:姓名:指导老师:2009年5月2日一设计目的模拟实现银行家算法,用银行家算法实现资源分配。

二问题描述在死锁的避免中,银行家算法把系统状态分为安全状态和不安全状态,只要能使系统始终处于安全状态,便可以避免发生死锁。

所谓安全状态,是指系统能按某种顺序为每个进程分配所需资源,直到最大需求,使每一个进程都可以顺利完成,即可找到一个安全资源分配序列。

模拟实现这个工作过程。

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

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

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

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

四详细设计1、初始化由用户输入数据,分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。

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

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

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

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

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

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

银行家算法课程设计报告

银行家算法课程设计报告

操作系统课程实训报告选题名称:进程创建模拟实现系(院):专业:计算机科学与技术班级:姓名:学号:姓名:学号:姓名:学号:指导教师:学年学期:2012 ~ 2013 学年第一学期2013 年12 月20 日实训任务书指导教师(签章):年月日摘要:银行家算法是一种最有代表性的避免死锁的算法。

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

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

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

银行算法进行资源分配可以避免死锁。

在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待实现银行家算法,系统必须设置若干数据结构。

关键词:银行家,死锁,资源,分配目 录需求分析1.1功能需求分析 错误!未定义书签。

1需求分析1.1 设计任务及要求银行家算法是避免死锁的一种重要方法。

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

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

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

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

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

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

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

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

三、实验内容: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 NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源(〉2)*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外,对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ #include "string.h"#include "stdio.h"#include "dos.h"#include "conio.h"#define MOVEIN 1#define GUIYUE 2#define ACC 3#define OK 1#define ERROR 0#define MAXSH 7#define MAXSHL 10#define MAXINPUT 50#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;struct time now;typedef struct{int data[maxsize];int top;}stack;int emptystack(stack *S){if(S->top==48&&S->data[S->top]==35)return(1); /*35 is '#'*/ 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);music(1,60);}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);delay(200);}nosound();}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){case 3:case 43:case 63:case 73:act=4;return MOVEIN;case 0:case 40:case 60:case 70:act=5;return MOVEIN;case 11:case 81: act=6;return MOVEIN;case 92:case 22:act=7;return MOVEIN;case 84:act=11;return MOVEIN;/*-------------------------------------------*/ case 91:case 94:case 95:act=1;return GUIYUE;case 21:case 24:case 25:act=2;return GUIYUE;case 101:case 102:case 104:case 105:act=3;return GUIYUE;case 31:case 32:case 34:case 35:act=4;return GUIYUE;case 111:case 112:case 114:case 115:act=5;return GUIYUE;case 51:case 52:case 54:case 55:act=6;return GUIYUE;/*+++++++++++++++++*/case 15:return ACC;/*******************************/case 6:return 1;case 7:case 47:return 2;case 8:case 48:case 68:return 3;case 46:return 8;case 67:return 9;case 78:return 10;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");if(fp==0){printf("\nwrite error!!");writeok=0;}else{if(a==-1){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); fprintf(fp," 测试时间:%02d:%02d:%02d",now.ti_hour,now.ti_min,now.ti_sec);}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';initstack(st);push(st,48); /* (int)0 进栈*/writefile(-1,"\n------------------------SLR(1)词法分析器-------------------------");writefile(-1,"\n 计本003 安完成于2003.01.12 14: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=4 int =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经测试,可为该进程分配资源。

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

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

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

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

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

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

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

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

银行家算法课程设计实验报告

银行家算法课程设计实验报告

滁州学院课程设计报告课程名称:操作系统设计题目:银行家算法的设计与实现系别:计算机与信息工程学院专业:计算机科学与技术组别:第二组起止日期: 2012年5月14日~ 2012年6月19日指导教师:马丽生课程设计题目银行家算法的设计和实现组长张震学号2010211148 班级10计科2班系别计算机专业计算机科学与技术组员李梦 2010211102马岩 2010211109蒋路路 2010211095严路路 2010211132指导教师马丽生课程设计目的熟练掌握银行家算法课程设计所需环境Vc++,windows xp课程设计任务要求编写带有界面的银行家算法程序课程设计工作进度计划序号起止日期工作内容分工情况1 2012/5/14~2012/5/21 查询相关资料,了解银行家算法的主要目的及编写方式张震负责对银行家算法的整体思想过程以及了解函数总体编写李梦、严路路负责查找银行家算法的输出算法的实现编写过程马岩、蒋路路负责对安全性检测的方式的实现查找2 2011/5/22~2011/6/5 进行代码设计各个组员对各自部分的代码编写3 2011/6/6~2011/6/13 调试程序共同解决程序中的相应错误4 2011/6/13~2011/6/19 文档编写及最终修订编写word文档,仔细检查发现各类问题指导教师签字:年月日教研室审核意见:教研室主任签字:年月日目录1. 引言 (4)2. 设计要求 (4)2.1.问题描述 (4)2.2.基本要求 (4)3.设计分析 (5)3.1.安全性算法的算法思想 (5)3.1.1.设置向量 (5)3.1.2.安全性检测流程图 (6)3.2.银行家算法的算法思想 (7)3.2.1.银行家算法的思路 (7)3.2.2. 银行家算法 (7)3.2.3. 银行家算法流程图 (8)4.详细设计 (10)4.1.银行家算法中用到的主要数据结构设计 (10)4.2.算法整体设计与调用 (10)4.3.模块设计 (11)4.3.1.安全性算法 (11)4.3.2.输出算法 (13)4.3.3.整体函数设计 (14)5.调试与操作说明 (19)5.1运行程序 (19)6.课程设计的总结与体会 (21)6.1.总结 (21)6.2.体会 (21)1.引言银行家算法是一个用来预防系统进入死锁状态的算法,用它可以判断系统的安全性,如果系统当前处于安全状态,则可以为申请资源的进程分配资源,如果不是安全状态,则不能为申请资源的进程分配资源。

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

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

第一章设计内容1.1 设计目的通过银行家算法设计与实现,可以加深学生对死锁的理解,掌握死锁的预防、避免、检测和解除的基本原理,重点掌握死锁的避免方法—银行家算法。

使学生初步具有研究、设计、编制和调试操作系统模块的能力。

1.2 设计要求1.问题描述系统在进行资源分配的过程中,允许进程动态的申请资源,为了避免发生死锁,在分配资源前要进行安全性检查,若此次分配不会导致系统进入不安全状态,便将资源分配给进程,否则,进程等待。

2.基本要求设计一个进程动态请求资源的模拟系统,实现随机产生进程请求资源的数量;资源安全性检查算法;资源的分配算法;以及输出显示每次请求的结果和系统资源的状态。

1.3 程序设计思想首先输入进程的数目和系统中的资源数目,根据输入的进程数目创建相应数目的数据结构作为进程的PCB,然后初始化每个进程对每种资源的最大需求量、每种资源的已分配量、系统每种资源的可利用量,进行初始化安全性检查;如果是不安全状态,重新初始化系统;否则,从等待队列中提取一个等待进程,让该进程动态申请所需的各种资源,使用银行家算法进行检测,如果是安全状态,则输出系统的一个安全序列和系统当前资源的使用情况,如果是不安全状态则继续从等待队列中提取进程进行随机申请资源;一直循环到把等待队列清空为止,系统中申请资源的进程全部进入等待队列等候处理。

第二章数据结构、算法和程序流程图2.1 数据结构数据结构说明:本程序中所运用的数据结构主要为进程的说明信息,即进程控制块PCB,如下:struct PCB //进程控制块PCB的数据结构{int pid; //进程编号int Max[MaxResource]; //进程对资源的最大需求矩阵int Allocation[MaxResource]; //进程已分配的资源矩阵int Need[MaxResource]; //进程对资源的需求矩阵int Request[MaxResource]; //进程本次对资源的申请矩阵};2.2 银行家算法银行家算法的基本思想是在分配资源之前,判断系统是否是安全的;若安全,才分配。

银行家算法课程设计实验报告

银行家算法课程设计实验报告

银行家算法课程设计实验报告摘要:本文主要介绍了一种新的实验方法——银行家算法课程设计实验,针对算法教学的实验设计,特别是在银行家算法这一领域,运用Visual C++ 语言,给出了一种实验实现及其相应的实验报告。

实验的通过对 Visual C++ 的开发环境及语法的掌握,实验证明了银行家算法的可行性和实际应用的安全性。

关键词:银行家算法;Visual C++;实验设计;实验报告1. 绪论随着网络技术的不断发展和深化,如今网络系统的仿真实验,尤其是银行家算法的仿真实验的需求量日益增大,该实验将把网络系统设计中的概念、原理以及运用的方法用于系统的实际应用,更直观地表达出网络实验中的概念。

本实验希望通过对 Visual C++语言的开发环境及语法的掌握,实现银行家算法在计算机系统中的运用,实现这种算法的可行性和实际应用的安全性,从而使网络系统仿真实验更加简单有效的实现。

2. 实验目的(1)熟悉 Visual C++ 语言的开发环境及语法;(2)了解银行家算法基本原理及其实现;(3)验证银行家算法的可行性及实际应用的安全性;(4)为网络系统仿真实验提供一种新的实验方法。

3. 实验内容(1)Visual C++编程环境的熟悉;(2)实现银行家算法的仿真实验;(3)验证银行家算法的可行性和实际应用的安全性;(4)实验报告的编写。

4. 实验环境实验环境主要包括实验平台、操作系统、语言编程工具和文本编辑器。

实验平台:实验所使用的计算机硬件平台为:Intel 酷睿i5-8400 处理器、 DDR4 8G 内存及 GTX 1050TI 4G 显卡;操作系统:实验所使用的操作系统为 Windows 10 家庭版;语言编程工具:实验所使用的语言编程工具为 Visual Studio 2017;文本编辑器:实验所使用的文本编辑器为 Notepad。

5. 实验过程实验过程主要包括 Visual C++ 编程环境的熟悉、银行家算法的仿真实现及实验报告的编写。

银行家算法实验设计报告

银行家算法实验设计报告

实验三银行家算法班级:xxxxxxxxxxxxxx姓名:xxxx 学号:xxxxxxxxxxxxxxxxxxxxxxxxx上级日期:2018年10月成绩:___________________________一、实验目的:银行家算法是避免死锁的一种重要方法,通过一个简单的银行家算法程序加深了解有关资源申请,避免死锁等概念,并体会和了解死锁以及避免死锁的具体实施方法。

二、实验内容1、程序流程图系统主要运行过程流程图银行家算法流程图安全性算法流程图2、程序源码1.//#define M 52.//#define N 33.#include <stdio.h> //本实验中使用到的库函数4.#include <stdlib.h>5.#include <string.h>6.7.int max[5][1]; //开始定义银行家算法中需要用到的数据8.int allocation[5][1];9.int need[5][1];10.int available[1];11.int request[5][1];12.char *finish[5];13.int safe[5];14.int n,i,m;15.int k=0;16.int j=0;17.int work[1];18.int works[5][1];19.20.void line() //美化程序,使程序运行时更加明朗美观21.{22. printf("------------------------------------------------\n");23.}24.25.void start() //表示银行家算法开始26.{27. line();28. printf(" 银行家算法开始\n");29. printf(" -- 死锁避免方法 \n");30. line();31.}32.33.void end() //表示银行家算法结束34.{35. line();36. printf(" 银行家算法结束,谢谢使用\n");37. line();38.}39.40.void input() //输入银行家算法起始各项数据41.{42.for (n=0;n<5;n++)43. {44. printf("请输入进程P%d的相关信息:\n",n);45. printf("Max:");46.for (m=0;m<1;m++)47. scanf("%d",&max[n][m]);48. printf("Allocation:");49.for (m=0;m<1;m++)50. scanf("%d",&allocation[n][m]);51.for (m=0;m<1;m++)52. need[n][m]=max[n][m]-allocation[n][m];53. }54. printf("请输入系统可利用资源数Available:");55.for (m=0;m<1;m++)56. scanf("%d",&available[m]);57.}58.59.void output() //输出系统现有资源情况60.{61. line();62. printf("资源情况 Max Allocation Need Available\n");63. printf("进程 A A A A \n");64. line();65.for(n=0;n<5;n++)66. {67. printf("P%d%3d%3d%3d",n,max[n][0],allocation[n][0],need[n][0]);68.if (n==0)69. printf("%3d%3d\n",available[0]);70.else71. printf("\n");72. }73. line();74.}75.76.void change() //当Request[i,j]<=Available[j]时,系统把资源分配给进程P[i],Available[j]和Need[i,j]发生改变77.{78.for (m=0;m<1;m++)79. {80. available[m]-=request[i][m];81. allocation[i][m]+=request[i][m];82. need[i][m]-=request[i][m];83. }84.}85.86.void outputsafe() //输出安全序列的资源分配表87.{88. printf("该安全序列的资源分配图如下:\n");89. line();90. printf("资源情况 Work Need Allocation Work+Allocation Finish\n");91. printf("进程 A A A A \n");92. line();93.for(n=0;n<5;n++)94. printf("P%d%9d%3d%3d%5d%12s\n",safe[n],works[safe[n]][0],need[safe[n]][0],allocation[safe[n]][0],works[safe[n]][0]+allocation[safe[n]][0],finish [n]);95. line();96.}97.98.int check() //安全性算法99.{100. printf("开始执行安全性算法……\n");101.for (m=0;m<1;m++) //数组work和finish初始化102. work[m]=available[m];103.for (n=0;n<5;n++)104. {105. finish[n]="false";106. safe[n]=0;107. }108. k=0;109.for (m=0;m<5;m++)110.for (n=0;n<5;n++)111.if(strcmp(finish[n],"false")==0 && need[n][0]<=work[0] ) //查找可以分配资源但尚未分配到资源的进程112. {113. safe[k]=n; //以数组safe[k]记下各个进程得到分配的资源的顺序114. works[safe[k]][0]=work[0];115.116.117. work[0]+=allocation[n][0]; //进程执行后释放出分配给它的资源118.119.120. finish[n]="ture"; //finish[n]变为1以示该进程完成本次分121. k++;122. }123.for (m=0;m<5;m++) //判断是否所有进程分配资源完成124. {125.if (strcmp(finish[m],"false")==0)126. {127. printf("找不到安全序列,系统处于不安全状态。

银行家算法设计报告

银行家算法设计报告

基于银行家算法的研究摘要1.研究的目的和意义加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

死锁的产生,必须同时满足四个条件,即一个资源每次只能由一个进程占用:第二个为等待条件,即一个进程请求资源不能满足时,它必须等待,但它仍继续保持已得到的所有其他资源:第四个为循环等待条件,系统中存在若干个循环等待的进程,即其中每一个进程分别等待它前一个进程所持有的资源。

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

通过这个算法可用解决生活中的实际问题,如银行贷款等.2.研究的内容及方法银行家算法是最有代表性的避免死锁的算法,由于该算法能用于银行系统现金贷款的发放而得名。

其实现思想是:允许进程动态地申请资源,系统在每次实施资源分配之前,先计算资源分配的安全性,若此次资源分配安全(即资源分配后,系统能按某种顺序来为每个进程分配其所需的资源,直至最大需求,使每个进程都可以顺利地完成),便将资源分配给进程,否则不分配资源,让进程等待。

关键词:银行家算法安全死锁目录摘要 (i)1绪论 (1)1.1前言 (1)1.2本文主要研究内容 (1)2需求分析 (2)2.1死锁的概念 (2)2.2关于死锁的一些概念 (2)2.3资源分类 (2)2.4产生死锁的必要条件 (2)2.5死锁预防 (3)2.6银行家算法 (3)3概要设计 (4)3.1设计思路 (4)3.2 数据结构 (4)3.3主要函数说明 (5)4详细设计 (6)4.1算法描述 (6)4.1.1银行家算法 (6)4.1.2 安全性检查算法 (7)4.2函数的实现过程 (7)4.3程序流程图 (9)5测试结果 (10)6结果分析 (12)7总结 (13)源程序清单 (14)1绪论1.1前言银行家算法是避免死锁的一种重要方法。

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

银行家算法课程设计报告

银行家算法课程设计报告

《计算机操作系统》课程设计报告1、概述一、设计目的银行家算法是一种最有代表性的避免死锁的算法。

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

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

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

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

本次课程设计通过用C语言编写和调试实现银行家算法的程序,达到进一步掌握银行家算法,理解系统产生死锁的原因以及系统避免死锁的方法,增强理论联系实际的能力的目的。

二、开发环境操作系统:Windows XP编译环境:Microsoft visual C++生成文件:Terrence.exe2、需求分析一、死锁概念:死锁就是指多个进程在运行中因争夺资源而造成的一种僵局,当进程出于这种僵持状态时,若无外力作用,它们都将无法再向前推进。

二、关于死锁的一些结论:产生死锁的原因是:竞争资源和进程间推进顺序非法。

处理死锁的基本方法是:①预防死锁②避免思索③检测死锁④解除死锁三、资源分类:1.可剥夺性资源,某些进程在获得此类资源后,该资源可以再被其他进程或系统剥夺。

CPU和内存均属于可剥夺性资源。

2.非剥夺性资源,当系统把这类资源分配给进程后,再不能强行回收,只能在进程用完后自动释放,如磁带机,打印机。

3.临时性资源,有一个进程产生,被另一个进程使用一短暂时间后便无用。

四、产生死锁的四个必要条件:1.互斥条件:进程对它所分配到的资源进行排他性使用,即在一段时间内某资源由一个进程占有。

如果此时还有其它进程请求该资源,则请求者只能等待,直至占有该资源的进程用毕释放。

银行家算法课程设计报告

银行家算法课程设计报告

《计算机操作系统》课程设计报告书选题:银行家算法模拟姓名:包玉霞学号: 1班级:软件1001指导老师:徐向英2012年6月目录一. 课程设计目的二. 课题内容三. 设计思路四. 源代码五. 运行与测试六. 心得体会1.设计目的计算机系统中有很多资源,在多道程序设计环境中,若干程序往往要共享这些资源,而一个进程所需的资源不止一个,这样,系统就会容易发生死锁现象。

然而系统产生死锁不仅浪费大量的系统资源,甚至导致整个系统的崩溃,带来灾难性的后果。

而银行家算法是最具有代表性的避免死锁的一种重要方法,如果在并发执行的进程中能够寻找一个安全序列,则系统按照此序列分配资源,系统就不会产生死锁现象。

2.课题内容1.复习银行家算法,设计一个具有若干(不少于3种)资源和若干(不少于5个)进程的系统。

2.定义系统的初始状态,即进程获得的资源数,还需要的资源数以及系统可用的资源数。

3.以用户输入的方式提出资源请求,并用银行家算法避免可能发生的死锁,若系统安全,允许用户继续申请资源。

4.设计的系统要求结构清晰,与用户的交互界面友好,能动态地实现资源的申请和分配。

3.设计思路银行家算法可分为几个主要的功能模块,其描述如下:1.初始化由用户输入数据,分别对运行的进程数、总的资源种类数、总资源数、各进程所需要的最大资源数量(Max),已分配的资源数量赋值。

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

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

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

银行家算法课程设计报告

银行家算法课程设计报告

课程设计题 目:银行家算法的设计与实现学生姓名:张海扬学 院:信息工程学院系 别:软件工程系专 业:软件工程班 级:软件10—1班指导教师:马志强 副教授刑红梅 讲师20013年1月9日学校代码: 10128学 号: 20102020205062内蒙古工业大学课程设计任务书(二)学院(系):信息学院软件工程系课程名称:操作系统课程设计指导教师(签名):专业班级:软件 10-1 学生姓名:张海扬学号: 201020205062一、课程设计题目银行家算法的设计与实现二、课程设计的目的通过银行家算法设计与实现,可以加深学生对死锁的理解,掌握死锁的预防、避免、检测和解除的基本原理,重点掌握死锁的避免方法—银行家算法。

使学生初步具有研究、设计、编制和调试操作系统模块的能力。

三、课程设计的主要内容和要求(包括原始数据、技术参数、设计要求、工作量要求等)技术参数:Windows XP系统,VC++6.0开发工具。

设计要求:1.设计银行家算法的核心数据结构、安全性检查算法;2.画出银行家算法流程图;3.编程实现算法功能;4.编写课程设计说明书。

工作量要求:完成以上设计要求中的所有算法功能。

四、工作进度安排周一:布置、讲解题目,收集资料;周二:系统分析,算法设计;周三:编制、调试程序;周四:测试系统,形成设计结论,编写课设报告;周五:系统及材料验收,课设答辩。

五、主要参考文献[1] 张尧学编.计算机操作系统教程(第三版)习题解答与实验指导.北京:清华大学出版社,2006[2] 汤子瀛主编.计算机操作系统(第三版).西安:西安电子科技大学出版社,2001[3] 张坤等编.操作系统实验教程.北京:清华大学出版社,2008审核批准意见系(教研室)主任(签字)摘要Dijkstra的银行家算法是最有代表性的避免死锁的算法,该算法由于能用于银行系统现金贷款的发放而得名。

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

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

银行家算法(用C语言实现)课程设计报告

银行家算法(用C语言实现)课程设计报告

课程设计报告题目银行家算法程序设计课程名称操作系统课程设计院部名称信息技术学院专业计算机科学与技术班级学生姓名* *学号**********课程设计地点课程设计学时20指导教师* ********教务处制操作系统课程设计报告摘要Dijkstra提出的银行家算法,是最具代表性的避免死锁的算法。

本文对如何用银行家算法来处理操作系统给进程分配资源做了详细的说明,包括需求分析、概要设计、详细设计、测试与分析、总结、源程序清单。

首先做了需求分析,解释了什么是银行家算法,并指出它在资源分配中的重要作用。

然后给出了银行家算法的概要设计,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等。

在概要设计的基础上,又给出了详细的算法设计,实现概要设计中定义的所有函数,对每个函数写出核心算法,并画出了流程图。

接着对编码进行了测试与分析(并在最后附上Java编写的程序代码)。

最后对整个设计过程进行了总结。

关键词:安全状态;安全序列;银行家算法;安全性算法;安全序列;流程图。

目录摘要 (1)目录 (2)1.绪论 (3)1.1前言 (3)1.2研究意义 (4)1.3结构安排 (4)2.需求分析 (5)2.1题目描述 (5)2.2银行家算法 (5)2.3基本要求 (5)2.4目的 (6)3.概要设计 (7)3.1设备环境 (7)3.2算法思路 (7)3.3银行家算法步骤 (7)3.4安全性算法步骤 (8)3.5数据结构 (9)3.6系统结构图 (12)4.详细设计 (13)4.1主要函数的核心代码 (13)4.2程序流程图 (13)5.测试 (16)5.1测试用例 (16)5.2测试结果截图 (17)6.总结 (22)参考文献 (24)致谢 (25)附录 (26)1绪论1.1前言:Dijkstra (1965)提出了一种能够避免死锁的调度算法,称为银行家算法。

它的模型基于一个小城镇的银行家,他向一群客户分别承诺了一定的贷款额度,每个客户都有一个贷款额度,银行家知道不可能所有客户同时都需要最大贷款额,所以他只保留一定单位的资金来为客户服务,而不是满足所有客户贷款需求的最大单位。

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

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

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

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

《操作系统》课程设计报告设计题目:银行家算法的实现姓名:梅济民学号: 2012015014 同组人姓名:赵宇昊学号: 2012012962班级: 2012级信息与计算科学完成日期: 2015年 11 月 12 日银行家算法分析、设计与实现一、理论描述银行家算法要求每个进程的最大资源需求,其基本思想是:始终保持系统处于安全状态,当设计进程提出资源请求时,系统先进行预分配,再判断系统分配后是否仍然处于安全状态。

如果仍然处于安全状态,就进行实际分配;如果处于不安全状态,则拒绝该进程的资源请求。

二、算法描述及数据结构模型#define False 0#define True 1int Max[100][100]={0};//各进程所需各类资源的最大需求int Avaliable[100]={0};//系统可用资源char name[100]={0};//资源的名称int Allocation[100][100]={0};//系统已分配资源int Need[100][100]={0};//还需要资源int Request[100]={0};//请求资源向量int temp[100]={0};//存放安全序列int Work[100]={0};//存放系统可提供资源int M=100;//作业的最大数为100int N=100;//资源的最大数为10三、源代码void showdata()//显示资源矩阵{int i,j;printf("系统目前可用的资源[Avaliable]:\n");for(i=0;i<N;i++)printf("%c ",name[i]);printf("\n");for (j=0;j<N;j++)printf("%d ",Avaliable[j]);//输出分配资源printf("\n");printf(" Max Allocation Need \n"); printf("进程名");for(j=0;j<3;j++){for(i=0;i<N;i++)printf("%c ",name[i]);printf(" ");}printf("\n");for(i=0;i<M;i++){printf(" %d ",i);for(j=0;j<N;j++)printf("%d ",Max[i][j]);printf(" ");for(j=0;j<N;j++)printf("%d ",Allocation[i][j]);printf(" ");for(j=0;j<N;j++)printf("%d ",Need[i][j]);printf("\n");}}int changdata(int i)//进行资源分配{int j;for (j=0;j<M;j++) {Avaliable[j]=Avaliable[j]-Request[j];Allocation[i][j]=Allocation[i][j]+Request[j];Need[i][j]=Need[i][j]-Request[j];}return 1;}int safe()//安全性算法{int i,k=0,m,apply,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){apply=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==N){for(m=0;m<N;m++)Work[m]=Work[m]+Allocation[i][m];//变分配数Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){printf("系统不安全\n");//不成功系统不安全return -1;}}printf("系统是安全的!\n");//如果安全,输出成功printf("分配的序列:");for(i=0;i<M;i++){//输出运行进程数组printf("%d",temp[i]);if(i<M-1) printf("->");}printf("\n");return 0;}void share()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch='y';printf("请输入要求分配的资源进程号(0-%d):",M-1);scanf("%d",&i);//输入须申请的资源号printf("请输入进程%d 申请的资源:\n",i);for(j=0;j<N;j++){printf("%c:",name[j]);scanf("%d",&Request[j]);//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错{printf("进程%d申请的资源大于它需要的资源, 分配不合理,不予分配!\n",i);ch='n';break;}else {if(Request[j]>Avaliable[j])//判断申请是否大于当前资源,若大于则出错{printf("进程%d申请的资源大于系统现在可利用的资源\n",i);printf(" 分配出错,不予分配!\n");ch='n';break;}}}if(ch=='y') {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}int main()//主函数{int i,j,q,choice,m,n,flag;char ming;printf("请首先输入系统可供资源种类的数量:");scanf("%d",&n);N=n;for(i=0;i<n;i++){printf("资源%d的名称:",i+1);scanf("%s",&ming);name[i]=ming;printf("资源%d的数量:",i+1);scanf("%d",&q);Avaliable[i]=q;}// printf("\n");printf("请输入作业的数量:");scanf("%d",&m);M=m;printf("请输入各进程的最大需求量%d*%d矩阵[Max]:\n",m,n);for(i=0;i<m;i++){for(j=0;j<n;j++)scanf("%d",&Max[i][j]);//printf("\n");}do{flag=0;printf("请输入各进程已经申请的资源量(%d*%d矩阵)[Allocation]:\n",m,n);for(i=0;i<m;i++)for(j=0;j<n;j++){scanf("%d",&Allocation[i][j]);if(Allocation[i][j]>Max[i][j]) flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)printf("申请的资源大于最大需求量,请重新输入!\n");}while(flag);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){printf("\n");printf(" 0:离开\n");printf(" 1:分配资源\n");printf("请选择功能号:");scanf("%d",&choice);switch(choice){case 1: share();break;case 0: break;default: printf("请正确选择功能号(0-1)!\n");break;}}return 1;四、程序运行结果及分析时刻的资源分配表(各种资源的数量分别为:10、5、7) T运行结果五、课程设计心得与体会通过这次实验,我了解了银行家算法的原理,在编写和调试程序过程中,我的算法和编程能力提高了很多六.参考文献:《计算机操作系统》第四版,《C 程序设计教程》谭浩强。

相关文档
最新文档