银行家算法-课程设计

合集下载

银行家算法课程设计

银行家算法课程设计

银行家算法课程设计1 银行家算法课程设计银行家算法(Banker's algorithm)是一种算法,用于保证系统中的进程能够访问临界资源,即保证系统的安全性和可行性。

银行家算法是一种基于资源分配图的安全性算法,它利用图形表示来检查系统状态,检查系统是否处在安全状态,并在资源分配时避免死锁。

银行家算法在许多计算机科学领域,如计算机系统分析,系统设计,系统编程,操作系统,数据库管理系统,计算机网络,复印设备管理系统等被广泛使用,因为它可以有效地开发高可用性系统,以及可靠的系统安全策略,用于解决资源分配的多个进程之间的相互问题。

因此,银行家算法在操作系统理论中具有重要的地位,是进行操作系统机制设计和实现时必不可少的一门课程设计,它具有较强的实际性和创造性,重要考点包括:理论基础介绍,实际运用,算法设计和实现,以及探究特定的资源调度问题,实现过程指导,进程同步互斥的实现,实验室相关实践,最后结论总结。

在设计银行家算法课程期间,在理论介绍和实际验证等不同阶段,需要按照教学大纲要求,结合教学案例,开展深入的针对性训练,增强学生数学解决问题、分析问题、建立数学模型和验证数学模型的思维能力。

同时,在引导学生完成银行家算法编程实践的各个阶段中,教师及时给予学生有效的反馈和指导,为学生的综合素质的发展提供必要的支持,保证学习效果。

银行家算法课程设计不仅要求学生有丰富的实践能力和创新能力,更重要的是,学生通过学习、实践,能够构建一个可靠的基于数学模型思想的资源分配和安全性模型,以及利用高效算法实现资源分配与安全性策略,从而获得实战技能。

只有通过丰富的数学建模思维能力和运算逻辑能力,才能逐步形成真正的技术依据,开发可靠的系统安全策略,更好地保障操作系统的安全性。

银行家算法课程设计报告

银行家算法课程设计报告

《计算机操作系统》课程设计报告——设计题目:银行家算法学院:计算机科学与工程专业:计算机科学与技术班级:学号:姓名:指导老师:目录1绪论--------------------------------------------2 1.1题目描述------------------------------------21.2设计目的------------------------------------21.3设计要求------------------------------------21.4目的----------------------------------------21.5有关概念的解释------------------------------3 2 概要设计---------------------------------------32.1算法思路------------------------------------32.2银行家算法步骤------------------------------3 2.3安全性算法步骤------------------------------4 2.4源程序结构分析------------------------------4 3 程序流程图-----------------------------------63.1系统主要过程流程图---------------------------6 3.2银行家算法流程图-----------------------------7 3.3安全性算法流程图-----------------------------84 测试-------------------------------------------95、设计心得-------------------------------------136、参考文献-------------------------------------137、实验代码-------------------------------------131绪论1.1题目描述:银行家算法是一种最具有代表性的避免死锁的算法。

银行家算法课程设计

银行家算法课程设计

课程设计(大作业)报告课程名称:操作系统设计题目:银行家算法院系:信息技术学院班级: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)设计函数完成功能:系统内资源总数已知、各进程对各类资源最大需求数目已知、已分配资源数目已知的前提下,某进程提出各类资源的需求量时能判断状态是否安全,以决定是否予以分配。

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

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

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

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

三、实验内容: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经测试,可为该进程分配资源。

操作系统课程设计任务书

操作系统课程设计任务书

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

银行家算法课程设计小结

银行家算法课程设计小结

银行家算法课程设计小结银行家算法课程设计小结一、引言近年来,计算机科学和金融领域的交叉发展逐渐成为研究和实践的热点。

其中,银行家算法作为一种重要的操作系统算法,对于保障系统稳定性和安全性具有至关重要的作用。

在本篇文章中,我将对我所参与的银行家算法课程设计进行全面评估,并分享我对该算法的个人观点和理解。

二、银行家算法的深度评估在我所参与的银行家算法课程设计中,我对该算法的深度和广度进行了全面评估,并按照从简到繁、由浅入深的方式展开探讨,以帮助自己更深入地理解。

1. 算法原理(此处可以详细解释银行家算法的原理,如资源分配和安全性检查等)2. 算法应用在我们的课程设计中,我们使用银行家算法来解决并发环境中资源的分配和安全性问题。

通过模拟银行家的行为,我们可以判断在系统中是否存在死锁,并可以采取相应的措施来解决或避免死锁的发生。

3. 算法实现我们在课程设计中使用了Java语言来实现银行家算法。

通过编写相应的代码,我们可以模拟系统中的进程、资源和请求,并通过银行家算法来判断资源是否能够安全分配,并进行相应的操作。

4. 算法优化除了基本的银行家算法外,我们还对其进行了优化,以提高算法的效率和性能。

我们使用了数据结构中的图来表示资源的分配情况,以便更快速地进行资源安全性检查。

我们还通过并行计算技术,提高了算法的并发处理能力,使其更适用于现代高性能计算环境。

三、银行家算法的个人观点和理解在参与课程设计的过程中,我对银行家算法产生了较深的兴趣,并对其产生了一些个人观点和理解。

1. 安全性与效率的平衡银行家算法在资源分配和安全性之间取得了一种平衡。

它通过对系统中的资源需求和可用资源进行合理的分析,以保证系统的安全性,同时又尽可能地提高系统的效率。

这种平衡在实际应用中具有重要的意义,因为我们既需要确保系统的安全性,又需要满足用户的实时需求。

2. 银行家角色的启示银行家算法的设计灵感来自银行家的行为,这给了我一些启示。

银行家算法课程设计

银行家算法课程设计

信息与计算科学操作系统原理课程设计报告题目:银行家算法程序设计班级:姓名:专业:银行家算法程序设计目录1.绪论 (2)2.需求分析 (2)2.1功能需求 (2)2.2数据需求 (2)3. 总体设计 (2)3.1功能模块设 (2)3.2系统设计方案 (3)3.3开发工具 (4)4. 详细设计 (4)4.1银行家算法中的数据结构 (4)4.2银行家算法 (5)4.3安全性算法 (6)5. 调试与测试 (8)6. 结论 (8)结束语 (8)参考文献 (9)附录1-用户手册 (10)附录2-源程序清单.................................................................................... 错误!未定义书签。

1.绪论20世纪末,随着计算机科学的发展,C语言的应用越来越广泛,很多程序都需要使用C语言来编写。

C语言使用方便快捷,它已经成为计算机编程中不可缺少的一部分,而且它也被用于各个方面。

例如:政府部门,银行,学校等等。

银行家算法是判断系统是否安全,并且允许其它进程来申请这里的资源,任何一个进程来申请资源时,必须先登记该进程对资源的申请要求然后由系统检查当前资源的状况,并用银行家算法和安全性算法来检查是否允许分配资源给进程。

通过课程设计,加深我们对利用银行家算法避免死锁的理解。

在设计中主要的难点是用语言编写银行家算法和安全性算法,使系统资源分配能安全进行,避免系统死锁。

2.需求分析2.1 功能需求1.添加进程的可用资源,最大资源,已分配资源;2.判断系统是否安全;3.申请资源;4.申请资源后如何分配;5.进行安全检查。

2.2 数据需求主要数据包括:可用资源,最大资源,已分配资源,申请资源数。

3. 总体设计3.1 功能模块设图1 功能模块图3.2 系统设计方案在程序中设计五个进程,分别为P0,P1,P2,P3,P4。

共享三类资源。

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

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

银行家算法课程设计实验报告摘要:本文主要介绍了一种新的实验方法——银行家算法课程设计实验,针对算法教学的实验设计,特别是在银行家算法这一领域,运用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++ 编程环境的熟悉、银行家算法的仿真实现及实验报告的编写。

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

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

《 操作系统 》课程设计报告系 别: 信息科学与技术系专业班级:学生姓名:指导教师:(课程设计时间:2010年7月5日——2010年7月9日)目 录一、课程设计目的和意义 (3)二、课程设计题目描述及算法 (3)三、课程设计报告内容 (3)1.算法描述 (3)2.数据结构 (4)3.主要函数说明 (4)4.算法流程图 (5)5.运行结果及说明 (7)6.附录清单及分析 (8)四、总结 (14)一、课程设计目的和意义了解掌握银行家算法,学会模拟实现资源分配,同时有要求编写和调试一个系统分配资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生二、课程设计题目描述及算法题目:银行家算法设计设计要求:编制银行家算法通用程序,并检测所给状态的系统安全性。

设进程I提出请求Request[N],则银行家算法按如下规则进行判断。

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

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

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

上述三个矩阵存在如下关系:Need[i,j]= Max[i,j]- Allocation[i,j]三、课程设计报告内容1.算法描述设Request[i] 是进程Pi的请求向量,如果Requesti[j]=K,表示进程Pi需要K 个Rj类型的资源,当Pi发出资源请求后,系统按下面步骤进行检查:,便转向步骤2;否则认为出错,因为它所需(1)如果Requesti[j]<=Need[i,j]要的资源数已超过它所宣布的最大值。

银行家算法课程设计报告

银行家算法课程设计报告

《计算机操作系统》课程设计报告书选题:银行家算法模拟姓名:包玉霞学号: 1班级:软件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.银行家算法在避免死锁的方法中,所施加的限制条件较弱,有可能获得令人满意的系统性能。

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

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

《操作系统--课程设计报告》银行家算法姓名:学号:专业:指导老师:目录一、设计目的 (1)二、设计要求 (1)三、设计内容和步骤 (1)四、算法描述 (6)五、实验结果 (12)六、实验心得 (12)一、设计目的银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。

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

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

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

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

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

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

三、设计内容和步骤设计内容银行家算法的思路:先对用户提出的请求进行合法性检查,即检查请求的是不大于需要的,是否不大于可利用的。

若请求合法,则进行试分配。

最后对试分配后的状态调用安全性检查算法进行安全性检查。

若安全,则分配,否则,不分配,恢复原来状态,拒绝申请。

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

假定系统中有M个进程,N类资源。

进程数和资源数由程序中直接定义#define M 5 //总进程数#define N 3 //总资源数银行家算法中使用的数据结构如下:(1)可利用资源Available。

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

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

(2)最大需求矩阵Max。

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

如果Max[i,j]=k,表示进程Pi对Rj类资源的最大需求数为k个。

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

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

//判断申请是否大于当前资源,若大于则 { cout<<"进程"<<i<<"申请的资源大于系统现在可利
用的资源"; cout<<" 分配出错,不予分配!"<<endl; ch='n'; break;
} } } if(ch=='y') { changdata(i); //根据进程需求量变换资源 showdata(); //根据进程需求量显示变换后的资源 safe(); //根据进程需求量进行银行家算法判断 } }
cout<<name[j]<<":"; cin>>Request[j]; //输入需要申请的资源 } for (j=0;j<N;j++) { if(Request[j]>Need[i][j]) //判断申请是否大于需求,若大于则出错 {
cout<<"进程 "<<i<<"申请的资源大于它需要的资源"; cout<<" 分配不合理,不予分配!"<<endl; ch='n'; break; } else { if(Request[j]>Avaliable[j])
cout<<"资源的数量:";
cin>>number;
Avaliable[i]=number;
}
cou程的数量:";
cin>>m;
M=m; cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵):" <<endl; for(i=0;i<m;i++)

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

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

课程设计报告课程设计名称:银行家算法模拟实现系:学生姓名:班级:学号:成绩:指导教师:开课时间:学年学期题目要求:一.设计题目银行家算法模拟实现二.主要内容设计目的1、了解多道程序系统中,多个进程并发执行的资源分配。

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

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

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

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

三.具体要求设计一个n个并发进程共享m个系统资源的系统,进程可动态申请资源和释放资源,系统按各进程的申请动态的分配资源。

要求采用银行家算法实现。

四.进度安排五.成绩评定考核方法:根据学生平时表现、测试检查、课程设计报告、运行演示和学生回答问题相结合的形式作为考核依据,考察学生的动手能力,独立分析解决问题的能力和创新精神,并根据学生的学习态度综合考评。

平时表现(占30%),课程设计报告(占40%),课程答辩(占30%)。

成绩评定:成绩分“优秀”、“良好”、“中等”、“及格”、“不及格”五个级别。

“优秀”为100分到90分,“良好”为89分到80分,“中等”为79分到70分,“及格”为69分到60分,“不及格”为60分以下。

目录1.需求分析 (4)2.概要设计 (4)3.详细设计 (6)4.调试分析 (12)5.总结 (16)6.参考文献 (16)1.需求分析1、始化这组进程的最大资源请求和一次申请的资源序列。

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

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

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

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

资源需求总量表示进程运行过程中对资源的总的需求量。

已占资源量表示进程目前已经得到但还为归还的资源量。

因此,进程在以后还需要的剩余资源量等于资源需要总量减去已占资源量。

课程设计银行家算法

课程设计银行家算法

操作系统课程设计题目:银行家算法学生姓名:学号:专业班级:指导教师:设计时刻:目录1.需求分析 (1)1.1、死锁概念: (1)1.2、关于死锁的一些结论: (1)1.3、资源分类: (1)1.4、产生死锁的四个必要条件: (2)1.5、死锁的解决方案 (2)1.5.1 产生死锁的例子 (2)1死锁预防: (3)1.6.平安状态与不平安状态 (4)2、算法的实现 (4)2.1、初始化 (4)2.2、银行家算法 (4)2.3、平安性检查算法 (4)2.4、程序模块划分 (5)2.5程序运行结果显示 (6)、源程序清单 (6)3、心得与体会: ......................... 错误!未定义书签。

4、参考文献 (14)二、需求分析2.一、死锁概念:在多道程序系统中,虽可借助于多个进程的并发执行,来改善系统的资源利用率,提高系统的吞吐量,但可能发生一种危险━━死锁。

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

一组进程中,每一个进程都无穷等待被该组进程中另一进程所占有的资源,因此永久无法取得的资源,这种现象称为进程死锁,这一组进程就称为死锁进程。

2.二、关于死锁的一些结论:a 参与死锁的进程最少是两个(两个以上进程才会显现死锁)b 参与死锁的进程至少有两个已经占有资源c 参与死锁的所有进程都在等待资源d 参与死锁的进程是当前系统中所有进程的子集注:若是死锁发生,会浪费大量系统资源,乃至致使系统崩溃。

2.3、资源分类:永久性资源:能够被多个进程多次利用(可再用资源)a 可抢占资源b 不可抢占资源临时性资源:只可利用一次的资源;如信号量,中断信号,同步信号等(可消耗性资源)“申请—分派—利用—释放”模式2.4、产生死锁的四个必要条件:1、互斥利用(资源独占)一个资源每次只能给一个进程利用2、不可侵占(不可剥夺)资源申请者不能强行的从资源占有者手中夺取资源,资源只能由占有者志愿释放3、请求和维持(部份分派,占有申请)一个进程在申请新的资源的同时维持对原有资源的占有(只有如此才是动态申请,动态分派)4、循环等待存在一个进程等待队列{P1 , P2 , … , Pn},其中P1等待P2占有的资源,P2等待P3占有的资源,…,Pn等待P1占有的资源,形成一个进程等待环路2.5、死锁的解决方案2.5.1 产生死锁的例子申请不同类型资源产生死锁P1:…申请打印机申请扫描仪利用释放打印机释放扫描仪…P2:…申请扫描仪申请打印机利用释放打印机释放扫描仪…申请同类资源产生死锁(如内存)设有资源R,R有m个分派单位,由n个进程P1,P2,…,Pn(n > m)共享。

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

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

一、课程设计的目的操作系统是计算机系统的核心系统软件,它负责控制和管理整个系统的资源并组织用户协调使用这些资源,使计算机高效的工作。

《操作系统课程设计》是《操作系统》理论课的必要补充,是复习和检验所学课程的重要手段,本课程设计的目的是综合应用学生所学知识,通过实验环节,加深学生对操作系统基本原理和工作过程的理解,提高学生独立分析问题、解决问题的能力,增强学生的动手能力。

二、课程设计的要求1.分析设计内容,给出解决方案(要说明设计实现的原理,采用的数据结构)。

2.画出程序的基本结构框图和流程图。

3.对程序的每一部分要有详细的设计分析说明。

4.源代码格式要规范。

5.设计合适的测试用例,对得到的运行结果要有分析。

6.设计中遇到的问题,设计的心得体会。

7.按期提交完整的程序代码、可执行程序和课程设计报告。

三、银行家算法1、银行家算法银行家算法是一种最有代表性的避免死锁的算法。

要解释银行家算法,必须先解释操作系统安全状态和不安全状态。

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

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

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

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

那么什么是安全序列呢?安全序列:一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。

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

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

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

银行家算法课程设计报告

银行家算法课程设计报告

课程设计题 目:银行家算法的设计与实现学生姓名:张海扬学 院:信息工程学院系 别:软件工程系专 业:软件工程班 级:软件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的银行家算法是最有代表性的避免死锁的算法,该算法由于能用于银行系统现金贷款的发放而得名。

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

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

银行家算法-课程设计

银行家算法-课程设计

银行家算法-课程设计1. 简介银行家算法(Banker’s Algorithm)是一种用于避免死锁的资源分配算法。

它最初由艾兹格·迪杰斯特拉(Edsger Dijkstra)于1965年提出,用于解决并发系统中的资源管理问题。

银行家算法可以预防死锁,即在执行过程中不会出现资源分配无法进行的情况。

在本次课程设计中,我们将深入研究银行家算法的原理和实现,并尝试在一个模拟的并发系统中应用该算法。

2. 算法原理银行家算法基于资源的可用性进行计算,以确保在给定的时刻,系统能够满足所有进程的资源需求,从而避免死锁的发生。

该算法通过以下几个关键步骤实现:2.1 系统资源初始化在系统启动之初,需要预先分配每种资源的总数和已被分配的数量。

这些信息将用于处理进程的资源请求和释放。

2.2 进程资源请求判断当一个进程提出资源请求时,银行家算法会判断是否能够满足该请求。

算法会检查当前的系统资源状态和进程的资源需求,以判断是否有足够的资源可供分配。

2.3 资源分配和回收如果银行家算法判断当前资源状态可以满足进程的资源请求,该算法将分配资源给该进程,并更新系统资源状态。

如果无法满足资源请求,进程将进入等待状态,直到系统有足够的资源可供分配。

2.4 进程资源回收和死锁检测当一个进程完成任务或者释放资源时,银行家算法会回收该进程所占用的资源,并检测是否可能发生死锁现象。

通过回收资源并重新分配,银行家算法可以避免死锁的发生。

3. 实现设计在本次课程设计中,我们将使用Python语言来实现银行家算法的模拟。

主要分为以下几个步骤:3.1 系统资源初始化首先,我们需要定义系统中每种资源的总量和已被分配数量。

这些数据可以使用一个二维矩阵来表示,其中每一行代表一种资源,每一列代表对应资源的数量。

3.2 进程资源请求判断当一个进程提出资源请求时,我们需要判断是否能够满足该请求。

可以通过比较进程的资源需求和系统资源状态来判断。

如果某个资源的需求量小于等于系统中该资源的可用数量,说明可以满足该请求。

银行家算法课程设计

银行家算法课程设计

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

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

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

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

二,银行家算法的数据结构1)可利用资源向量Available是个含有m个元素的数组,其中的每一个元素代表一类可利用的资源数目。

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

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

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

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

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

4)需求矩阵Need。

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

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

Need[i,j]=Max[i,j]-Allocation[i,j] 二,银行家算法流程图四,代码实现#include<stdio.h>#include<stdlib.h>#include<conio.h>#define true 1 //定义ture =1#define false 0 //定义false=0int Available[10]; //可使用资源向量int Max[10][10]; //最大需求矩阵int Allocation[10][10]={0}; //分配矩阵int Need[10][10]={0}; //需求矩阵int Work[10]; //工作向量int Finish[10]; //状态标志int Request[10][10]; //进程申请资源向量int Pause[10];int List[10];int i,j;int n; //系统资源总数int m; //总的进程数int a; //当前申请的进程号int l,e; //计数器int b=0,c=0,f=0,g; //计数器void enter()//输入部分{printf("请输入系统总共有的资源数:");scanf("%d",&n);printf("请输入总共有多少个进程:");scanf("%d",&m);for(i=1;i<=n;i++){printf("第%d类资源有的资源实例:",i);scanf("%d",&Available[i]);}for(i=1;i<=m;i++){for(j=1;j<=n;j++){printf("进程P[%d]对第%d类资源的最大需求量:",i,j);scanf("%d",&Max[i][j]);Need[i][j]=Max[i][j];}}}void request() //进程提出新申请{printf("请输入申请资源的进程:");scanf("%d",&a);for(i=1;i<=n;i++){printf("请输入进程P[%d]对%d类资源的申请量:",a,i);scanf("%d",&Request[a][i]);if(Request[a][i]>Need[a][i])printf("\n出错!进程申请的资源数多于它自己申报的最大量\n");if(Request[a][i]>Available[i])printf("\nP[%d]必须等待\n",a);//以下是试探性分配Available[i]=Available[i]-Request[a][i];Allocation[a][i]=Allocation[a][i]+Request[a][i];Need[a][i]=Need[a][i]-Request[a][i];Work[i]=Available[i];}for(i=1;i<=m;i++){Pause[i]=Available[i];//Pause[i]只是一个暂时寄存的中间变量,为防止在下面//安全性检查时修改到Available[i]而代替的一维数组Finish[i]=false;}for(g=1;g<=m;g++){for(i=1;i<=m;i++){b=0; //计数器初始化for(j=1;j<=n;j++){if(Need[i][j]<=Pause[j]){b=b+1;}if(Finish[i]==false&&b==n){for(l=1;l<=n;l++){Pause[l]=Pause[l]+Allocation[i][l];}Finish[i]=true;printf("$$ %d ",i);//依次输出进程安全序列之一中每个元素}}}}printf("\n");for(i=1;i<=m;i++){if(Finish[i]==true) f=f+1;//统计Finish[i]==true的个数}if (f==m){printf("safe static");f=0;//将计数器f重新初始化,为下一次提出新的进程申请做准备}else{printf(" unsafe static ");//以下代码为当系统被判定为不安全状态时//返回提出申请前的状态for(i=1;i<=n;i++){Available[i]=Available[i]+Request[a][i];Allocation[a][i]=Allocation[a][i]-Request[a][i];Need[a][i]=Need[a][i]+Request[a][i];}}}void print(){printf("当前的系统状态\n");printf(" 目前占有量最大需求量尚需要量\n进程");for(i=1;i<=n;i++)for(j=1;j<=n;j++){printf(" %d类",j);}for(i=1;i<=m;i++){printf("\nP[%d]",i);for(j=1;j<=n;j++){printf(" %d ",Allocation[i][j]);}for(j=1;j<=n;j++){printf(" %d ",Max[i][j]);}for(j=1;j<=n;j++){printf(" %d ",Need[i][j]);}}printf("\n\n系统剩余资源量:");for(i=1;i<=n;i++){printf(" %d ",Available[i]);}printf("\n");}void main(){ int k,h=1;while(h){ system("cls");{printf("\n\n 欢迎使用本程序\n");printf("\n\n 1**********输入系统的资源数、申请进程数、每个类资源的实例数");printf("\n 2:*********输入进程的资源申请");printf("\n 3:*********输出系统状态");printf("\n 4:*********退出程序");printf("\n\n please choose ");scanf("%d",&k);}switch(k){case 1:enter(); break;case 2:request(); break;case 3:print(); break;case 4:h=0; break;}printf("\n");system("pause");}}五,结果运行。

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

课程设计报告操作系统原理———银行家算法专业软件工程学生姓名陈鹏班级3班学号0810321306指导教师万方完成日期2011.06.24银行家算法一、银行家算法原理银行家算法是一种最有代表性的避免死锁的算法。

要解释银行家算法,必须先解释操作系统安全状态和不安全状态。

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

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

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

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

那么什么是安全序列呢?安全序列:一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i ) 我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

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

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

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

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

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

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

它是最具有代表性的避免死锁的算法。

二、算法的数据结构(1)可利用资源向量Available是个含有m个元素的数组,其中的每一个元素代表一类可利用的资源数目。

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

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

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

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

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

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

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

其中Need[i,j]=Max[i,j]-Allocation[i,j]三、程序流程图四、程序代码#include<iostream>using namespace std;#include<string.h>#include<stdio.h>#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;//资源的最大数为100void showdata()//显示资源矩阵{int i,j;cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<endl;for (j=0;j<N;j++)cout<<Avaliable[j]<<" ";//输出分配资源cout<<endl;cout<<" Max Allocation Need"<<endl;cout<<"进程名";for(j=0;j<3;j++){for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<" ";}cout<<endl;for(i=0;i<M;i++){cout<<" "<<i<<" ";for(j=0;j<N;j++)cout<<Max[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Allocation[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Need[i][j]<<" ";cout<<endl;}}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){cout<<"系统不安全"<<endl;//不成功系统不安全return -1;}}cout<<"系统是安全的!"<<endl;//如果安全,输出成功cout<<"分配的序列:";for(i=0;i<M;i++){//输出运行进程数组cout<<temp[i];if(i<M-1)cout<<"->";}cout<<endl;return 0;}void share()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch='y';cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";cin>>i;//输入须申请的资源号cout<<"请输入进程"<<i<<" 申请的资源:"<<endl;for(j=0;j<N;j++){cout<<name[j]<<":";cin>>Request[j];//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错{cout<<"进程"<<i<<"申请的资源大于它需要的资源";cout<<" 分配不合理,不予分配!"<<endl;ch='n';break;}else{if(Request[j]>Avaliable[j])//判断申请是否大于当前资源,若大于则{//出错cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";cout<<" 分配出错,不予分配!"<<endl;ch='n';break;}}}if(ch=='y'){changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}void addresources(){//添加资源int n,flag;cout<<"请输入需要添加资源种类的数量:";cin>>n;flag=N;N=N+n;for(int i=0;i<n;i++){cout<<"名称:";cin>>name[flag];cout<<"数量:";cin>>Avaliable[flag++];}showdata();safe();}void delresources(){//删除资源char ming;int i,flag=1;cout<<"请输入需要删除的资源名称:";do{cin>>ming;for(i=0;i<N;i++)if(ming==name[i]){flag=0;break;}if(i==N)cout<<"该资源名称不存在,请重新输入:";}while(flag);for(int j=i;j<N-1;j++){name[j]=name[j+1];Avaliable[j]=Avaliable[j+1];}N=N-1;showdata();safe();}void addprocess(){//添加作业int flag=M;M=M+1;cout<<"请输入该作业的最打需求量[Max]"<<endl;for(int i=0;i<N;i++){cout<<name[i]<<":";cin>>Max[flag][i];Need[flag][i]=Max[flag][i]-Allocation[flag][i];}showdata();safe();}int main()//主函数{int i,j,number,choice,m,n,flag;char ming;cout<<"*****************资源管理系统的设计与实现*****************"<<endl;cout<<"请首先输入系统可供资源种类的数量:";cin>>n;N=n;for(i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>ming;name[i]=ming;cout<<"资源的数量:";cin>>number;Avaliable[i]=number;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m;cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>Max[i][j];do{flag=0;cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j])flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)cout<<"申请的资源大于最大需求量,请重新输入!\n";}while(flag);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(true){cout<<"**************银行家算法演示***************"<<endl;cout<<" 1:增加资源"<<endl;cout<<" 2:删除资源"<<endl;cout<<" 3:分配资源"<<endl;cout<<" 4:增加作业"<<endl;cout<<"*******************************************"<<endl;cout<<"请选择功能号:";cin>>choice;switch(choice){case 1: addresources();break;case 2: delresources();break;case 3: share();break;case 4: addprocess();break;default: cout<<"请正确选择功能号(0-5)!"<<endl;break;}}return 1;}五、运行结果六、设计体会经过几天的自己动手练习,对操作系统的掌握又进了一步,收获了很多课堂上和书上未出现过的或老师未讲到的一些知识。

相关文档
最新文档