银行家算法及代码实现
银行家算法c语言流程图代码全
——银行家算法
院系 班级 学号 姓名
计算机与软件学院 08 软件工程 2 班
20081344066 何丽茗
一、实验目的
银行家算法是避免死锁的一种重要方法。通过编写一个模拟动态资源分配的银行家算法 程序�进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念�并掌握避免死锁 的具体实施方法。
四、实验代码以及运行示例
1. 源代码�
#include<iostream>
#include<string.h>
#include<stdio.h>
#define False 0
#define True 1
using namespace std;
intMax[100][100]={0};//各进程所需各类资源的最大需求
for(j=0;j<N;j++)
cout<<Allocation[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Need[i][j]<<" ";
cout<<endl;
}
}
intchangdata(inti)//进行资源分配 {
int j; for (j=0;j<M;j++) {
Y
i加1
提示 错误 重新 输入
所有进程运行 都结束
结束
初始化 need 矩阵 Y Need 矩阵为 0
N
任选一个进程作为当前进程
Need 向量为 0 N
银行家算法C语言代码
#include "malloc.h"#include "stdio.h"#include "stdlib.h"#define alloclen sizeof(struct allocation)#define maxlen sizeof(struct max)#define avalen sizeof(struct available)#define needlen sizeof(struct need)#define finilen sizeof(struct finish)#define pathlen sizeof(struct path)struct allocation{int value;struct allocation *next;};struct max{int value;struct max *next;};struct available /*¿ÉÓÃ×ÊÔ´Êý*/{int value;struct available *next;};struct need /*ÐèÇó×ÊÔ´Êý*/{int value;struct need *next;};struct path{int value;struct path *next;};struct finish{int stat;struct finish *next;};int main(){int row,colum,status=0,i,j,t,temp,processtest;struct allocation *allochead,*alloc1,*alloc2,*alloctemp;struct max *maxhead,*maxium1,*maxium2,*maxtemp;struct available *avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp ,*worktemp1;struct need *needhead,*need1,*need2,*needtemp;struct finish *finihead,*finish1,*finish2,*finishtemp;struct path *pathhead,*path1,*path2;printf("\nplease input the kinds of resourse:");scanf("%d",&colum);printf("please input the total number of the progress in the memory:");scanf("%d",&row);printf("please input the matrix of resourses that has allocated :\n"); for(i=0;i<row;i++){for (j=0;j<colum;j++){printf("Please input the number of system resources %c that has been allocated to process p%d:",'A'+j,i);if(status==0){allochead=alloc1=alloc2=(structallocation*)malloc(alloclen);alloc1->next=alloc2->next=NULL;scanf("%d",&allochead->value);status++;}else{alloc2=(struct allocation *)malloc(alloclen);scanf("%d,%d",&alloc2->value);if(status==1){allochead->next=alloc2;status++;}alloc1->next=alloc2;alloc1=alloc2;}}}alloc2->next=NULL;status=0;printf("please input the matrix of progress' maximumrequests:\n");for(i=0;i<row;i++){for (j=0;j<colum;j++){printf("Please input process p%d's maximum requests of system resources %c:",i,'A'+j);if(status==0){maxhead=maxium1=maxium2=(struct max*)malloc(maxlen); maxium1->next=maxium2->next=NULL;scanf("%d",&maxium1->value);status++;}else{maxium2=(struct max *)malloc(maxlen);scanf("%d,%d",&maxium2->value);if(status==1){maxhead->next=maxium2;status++;}maxium1->next=maxium2;maxium1=maxium2;}}}maxium2->next=NULL;status=0;printf("ÇëÊäÈëÏÖʱϵͳʣÓàµÄ×ÊÔ´¾ØÕó:\n");for (j=0;j<colum;j++){printf("ÖÖÀà %c µÄϵͳ×ÊÔ´Ê£Óà:",'A'+j);if(status==0){avahead=available1=available2=(structavailable*)malloc(avalen);workhead=work1=work2=(structavailable*)malloc(avalen);available1->next=available2->next=NULL;work1->next=work2->next=NULL;scanf("%d",&available1->value);work1->value=available1->value;status++;}else{available2=(struct available*)malloc(avalen); work2=(struct available*)malloc(avalen);scanf("%d,%d",&available2->value);work2->value=available2->value;if(status==1){avahead->next=available2;workhead->next=work2;status++;}available1->next=available2;available1=available2;work1->next=work2;work1=work2;}}available2->next=NULL;work2->next=NULL;status=0;alloctemp=allochead;maxtemp=maxhead;for(i=0;i<row;i++)for (j=0;j<colum;j++){if(status==0){needhead=need1=need2=(structneed*)malloc(needlen);need1->next=need2->next=NULL;need1->value=maxtemp->value-alloctemp->value; status++;}else{need2=(struct need *)malloc(needlen);need2->value=(maxtemp->value)-(alloctemp->value);if(status==1){needhead->next=need2;status++;}need1->next=need2;need1=need2;}maxtemp=maxtemp->next;alloctemp=alloctemp->next;}need2->next=NULL;status=0;for(i=0;i<row;i++){if(status==0){finihead=finish1=finish2=(structfinish*)malloc(finilen);finish1->next=finish2->next=NULL;finish1->stat=0;status++;}else{finish2=(struct finish*)malloc(finilen);finish2->stat=0;if(status==1){finihead->next=finish2;status++;}finish1->next=finish2;finish1=finish2;}}finish2->next=NULL; /*Initialization compleated*/ status=0;processtest=0;for(temp=0;temp<row;temp++){alloctemp=allochead;needtemp=needhead;finishtemp=finihead;worktemp=workhead;for(i=0;i<row;i++){worktemp1=worktemp;if(finishtemp->stat==0){for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->nex t)if(needtemp->value<=worktemp->value)processtest++;if(processtest==colum){for(j=0;j<colum;j++){worktemp1->value+=alloctemp->value;worktemp1=worktemp1->next;alloctemp=alloctemp->next;}if(status==0){pathhead=path1=path2=(structpath*)malloc(pathlen);path1->next=path2->next=NULL;path1->value=i;status++;}else{path2=(struct path*)malloc(pathlen);path2->value=i;if(status==1){pathhead->next=path2;status++;}path1->next=path2;path1=path2;}finishtemp->stat=1;}else{for(t=0;t<colum;t++)alloctemp=alloctemp->next;finishtemp->stat=0;}}elsefor(t=0;t<colum;t++){needtemp=needtemp->next;alloctemp=alloctemp->next; }processtest=0;worktemp=workhead;finishtemp=finishtemp->next;}}path2->next=NULL;finishtemp=finihead;for(temp=0;temp<row;temp++){if(finishtemp->stat==0){printf("\nϵͳ´¦ÓÚ·Ç°²È«×´Ì¬!\n"); exit(0);}finishtemp=finishtemp->next;}printf("\nϵͳ´¦ÓÚ°²È«×´Ì¬.\n");printf("\n°²È«ÐòÁÐΪ: \n");do{printf("p%d ",pathhead->value);}while(pathhead=pathhead->next);printf("\n");return 0;}。
银行家算法
操作系统银行家算法课后作业一、实验目的加深对多实例资源分配系统中死锁避免方法——银行家算法的理解，掌握Windows 环境下银行家算法的实现方法。
强调对于资源的管理、申请、比较来避免出现死锁的情况，保证系统的正常运行。
二、实验内容1.在Windows 操作系统上，利用DEVC++编写应用程序实现银行家算法。
2.创建n 个线程来申请或释放资源，只有保证系统安全，才会批准资源申请。
三、实验步骤（一）设计思路：银行家算法可分为个主要的功能模块，其描述如下：1.初始化由用户输入数据，分别对运行的进程数、总的资源种类数、总资源数、各进程所需要的最大资源数量（Max），已分配的资源数量赋值。
2.安全性检查算法(1)设置两个工作向量Work=AVAILABLE;FINISH=false;(2)从进程集合中找到一个满足下述条件的进程，FINISH==false;NEED<=Work;如找到，执行(3)；否则，执行(4)(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
Work+=ALLOCATION;Finish=true;(4).如所有的进程Finish= true，则表示安全；否则系统不安全。
3. 银行家算法在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。
在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。
银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。
它是最具有代表性的避免死锁的算法。
设进程j提出请求REQUEST [i]，则银行家算法按如下规则进行判断。
(1).如果REQUEST [j] [i]<= NEED[j][i]，则转(2)；否则，出错。
(2).如果REQUEST [j] [i]<= AVAILABLE[j][i]，则转(3)；否则，出错。
(3).系统试探分配资源，修改相关数据：AVAILABLE[i]-=REQUEST[j][i];ALLOCATION[j][i]+=REQUEST[j][i];NEED[j][i]-=REQUEST[j][i];用到的数据结构：实现银行家算法要有若干数据结构，它们用来表示资源分配系统的状态。
操作系统实验报告银行家算法
五邑大学实验报告操作系统课程实验报告2013~2014年度第1学期院系：计算机学院学号： 11080101姓名：宋蓓蕾任课教师：白明成绩评定：实验一：银行家算法完成日期：2013年12月20日1、实验目的银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
2、实验内容(1) 设计进程对各类资源最大申请表示及初值确定。
(2) 设定系统提供资源初始状况。
(3) 设定每次某个进程对各类资源的申请表示。
(4) 编制程序，依据银行家算法，决定其申请是否得到满足。
3、算法设计（全部代码）#include <STRING.H>#include <stdio.h>#include <stdlib.h>#include <CONIO.H> /*用到了getch()*/#define M 5 /*进程数*/#define N 3 /*资源数*/#define FALSE 0#define TRUE 1/*M个进程对N类资源最大资源需求量*/int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*系统可用资源数*/int AVAILABLE[N]={10,5,7};/*M个进程对N类资源最大资源需求量*/int ALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}}; /*M个进程已经得到N类资源的资源量*/int NEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*M个进程还需要N类资源的资源量*/int Request[N]={0,0,0};void main(){int i=0,j=0;char flag;void showdata();void changdata(int);void rstordata(int);int chkerr(int);showdata();enter:{printf("请输入需申请资源的进程号（从0到");printf("%d",M-1);printf("）:");scanf("%d",&i);}if(i<0||i>=M){printf("输入的进程号不存在，重新输入!\n");goto enter;}err:{printf("请输入进程");printf("%d",i);printf("申请的资源数\n");printf("类别: A B C\n");printf(" ");for (j=0;j<N;j++){scanf("%d",&Request[j]);if(Request[j]>NEED[i][j]){printf("%d",i);printf("号进程");printf("申请的资源数> 进程");printf("%d",i);printf("还需要");printf("%d",j);printf("类资源的资源量!申请不合理，出错!请重新选择!\n");goto err;}else{if(Request[j]>AVAILABLE[j]){printf("进程");printf("%d",i);printf("申请的资源数大于系统可用");printf("%d",j);printf("类资源的资源量!申请不合理，出错!请重新选择!\n");goto err;}}}}changdata(i);if(chkerr(i)){rstordata(i);showdata();}elseshowdata();printf("\n");printf("按'y'或'Y'键继续,否则退出\n");flag=getch();if (flag=='y'||flag=='Y'){goto enter;}else{exit(0);}}/*显示数组*/void showdata(){int i,j;printf("系统可用资源向量:\n");printf("***Available***\n");printf("资源类别: A B C\n");printf("资源数目:");for (j=0;j<N;j++){printf("%d ",AVAILABLE[j]);}printf("\n");printf("\n");printf("各进程还需要的资源量:\n"); printf("******Need******\n");printf("资源类别: A B C\n");for (i=0;i<M;i++){printf(" ");printf("%d",i);printf("号进程:");for (j=0;j<N;j++){printf(" %d ",NEED[i][j]);}printf("\n");}printf("\n");printf("各进程已经得到的资源量: \n"); printf("***Allocation***\n");printf("资源类别: A B C\n");for (i=0;i<M;i++){printf(" ");printf("%d",i);printf("号进程:");/*printf(":\n");*/for (j=0;j<N;j++){printf(" %d ",ALLOCATION[i][j]);}printf("\n");}printf("\n");}/*系统对进程请求响应，资源向量改变*/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 rstordata(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 chkerr(int s){int WORK,FINISH[M],temp[M];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;while(i<M){if (FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;temp[k]=i;k++;i=0;}else{i++;}}for(i=0;i<M;i++)if(FINISH[i]==FALSE){printf("\n");printf("系统不安全! 本次资源申请不成功!\n");printf("\n");return 1;}}printf("\n");printf("经安全性检查，系统安全，本次分配成功。
操作系统实验二：银行家算法
操作系统实验⼆：银⾏家算法实验⼆银⾏家算法⼀、实验⽬的1、了解什么是操作系统安全状态和不安全状态；2、了解如何避免系统死锁；3、理解银⾏家算法是⼀种最有代表性的避免死锁的算法，掌握其实现原理及实现过程。
⼆、实验内容根据银⾏家算法的基本思想，编写和调试⼀个实现动态资源分配的模拟程序，并能够有效避免死锁的发⽣。
三、实验原理进程申请资源时，系统通过⼀定的算法判断本次申请是否不可能产⽣死锁（处于安全状态）。
若可能产⽣死锁（处于不安全状态），则暂不进⾏本次资源分配，以避免死锁。
算法有著名的银⾏家算法。
1、什么是系统的安全状态和不安全状态？所谓安全状态，是指如果系统中存在某种进程序列＜P1，P2，…，Pn＞，系统按该序列为每个进程分配其所需要的资源，直⾄最⼤需求，则最终能使每个进程都可顺利完成，称该进程序列＜P1，P2，…，Pn，＞为安全序列。
如果不存在这样的安全序列，则称系统处于不安全状态。
2、银⾏家算法把操作系统看作是银⾏家，操作系统管理的资源相当于银⾏家管理的资⾦，进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。
为保证资⾦的安全，银⾏家规定:(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客;(2) 顾客可以分期贷款，但贷款的总数不能超过最⼤需求量;(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时,对顾客的贷款可推迟⽀付,但总能使顾客在有限的时间⾥得到贷款;(4) 当顾客得到所需的全部资⾦后,⼀定能在有限的时间⾥归还所有的资⾦。
操作系统按照银⾏家制定的规则设计的银⾏家算法为：（1）进程⾸次申请资源的分配：如果系统现存资源可以满⾜该进程的最⼤需求量，则按当前的申请量分配资源，否则推迟分配。
（2）进程在执⾏中继续申请资源的分配：若该进程已占⽤的资源与本次申请的资源之和不超过对资源的最⼤需求量，且现存资源能满⾜该进程尚需的最⼤资源量，则按当前申请量分配资源，否则推迟分配。
（3）⾄少⼀个进程能完成：在任何时刻保证⾄少有⼀个进程能得到所需的全部资源⽽执⾏到结束。
#操作系统课程设计-银行家算法(流程图 源代码 设计报告)
操作系统课程设计－银行家算法(流程图+源代码+设计报告)一、实验目的：熟悉银行家算法，理解系统产生死锁的原因及避免死锁的方法,加深记意。
二、实验要求：用高级语言编写和调试一个描述银行家算法的程序。
三、实验内容：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经测试，可为该进程分配资源。
java银行家算法代码实现
java银行家算法代码实现=================一、算法简介------银行家算法是一种用于避免系统发生死锁的算法，它通过分析系统资源分配情况，判断系统是否处于安全状态，从而避免死锁的发生。
Java银行家算法是一种基于Java语言的实现，它通过模拟系统资源分配情况，判断系统是否处于安全状态。
二、算法实现------以下是一个简单的Java银行家算法代码实现：```javapublicclassBankerAlgorithm{//资源数量和最大需求量privateint[]resource=newint[10];//例如：包括x，y，z三种资源，分别对应i-x1-x2-z...-xi-yi-zi...privateint[]maxDemand=newint[10];privateint[]available=newint[10];//当前可用资源数量privateint[]allocation=newint[10];//当前已分配资源数量privateint[]need=newint[10];//当前进程需求量privateint[]saved=newint[10];//已保存的安全序列中最后一个进程的资源需求量privateint[]process=newint[5];//进程集合，包括进程编号和进程所需资源量privateint[]processMax=newint[5];//进程最大需求量集合privateint[]systemSafe=0;//系统是否处于安全状态的标志位privateinttotalSystemSafe=0;//总共是否有足够资源可以安全运行的标志位//初始化资源分配信息publicvoidinitialize(int[][]allocationMatrix){for(inti=0;i<allocationMatrix.length;i++){process[i]=allocationMatrix[i][0];//进程编号processMax[i]=allocationMatrix[i][1];//进程最大需求量available[i]=allocationMatrix[i][2];//当前可用资源数量need[i]=allocationMatrix[i][3];//当前进程需求量maxDemand[i]=allocationMatrix[i][4];//当前进程最大需求量}systemSafe=true;//系统默认处于安全状态totalSystemSafe=true;//总共是否有足够资源可以安全运行的标志位默认设置为true}//检查系统是否处于安全状态，并返回检查结果和可能的执行序列（从开始到结束）publicboolean[]checkAndPrintSafePath(){intcurrentSystemSafe=false;//检查后的系统是否处于安全状态的标志位boolean[]safePath=newboolean[process.length];//安全序列for(inti=0;i<process.length;i++){if(need[i]<=available[i]){//如果当前进程需要的资源小于等于当前可用资源数量，则可以继续执行下去safePath[i]=true;//将当前进程标记为已执行过，并加入到安全序列中available[i]-=need[i];//将当前可用资源数量减去当前进程的已分配量，表示系统多出来的资源数量为已分配的减去需求的currentSystemSafe=true;//将当前系统的安全状态标记为true，因为已经有至少一个进程能够执行下去了}else{//如果当前进程需要的资源大于当前可用资源数量，则需要检查系统是否有足够的资源可以继续执行下去intavailableSum=0;//系统剩余的可用资源数量之和for(intj=0;j<process.length;j++){//将所有可用资源的数量累加起来availableSum+=available[j];}if(availableSum>=processMax[i]){//如果系统剩余的可用资源数量之和大于等于当前进程的最大需求量，则系统可以继续执行下去，否则需要重新分配资源并返回结果重新开始执行安全序列为null；如果为空说明不满足要求否则输出一个安全的执行序列，开始输出可执行的进程数以及所分配的资源和后续的系统安全状态标记等信息totalSystemSafe=false;//将当前系统安全状态的标志位置为false，因为此时不满足安全状态的要求，需要重新开始执行程序，且此次循环的完整性和执行性需要考虑已经完成过的安全序列重新考虑这些因素的修改可能会被重用）确保安全性序列不再更改）；再次输出完整的信息需要重新考虑这些因素以确保安全性序列不再更改）并返回结果；如果为true则说明系统已经处于安全状态并输出一个安全的执行序列；如果为false则说明。
银行家算法java代码
银行家算法java代码银行家算法是一种用于避免死锁的算法，它可以保证系统在分配资源时不会陷入死锁状态。
在操作系统中，银行家算法被广泛应用于进程调度和资源管理中。
本文将介绍银行家算法的原理和实现，并提供Java代码示例。
一、银行家算法原理银行家算法是基于资源分配图的理论基础上发展而来的。
资源分配图是描述进程和资源之间关系的一种图形表示方法。
在资源分配图中，每个进程和每个资源都表示为一个节点，进程需要的资源和已经被占用的资源之间连接一条边。
银行家算法通过模拟进程请求和释放资源的过程来判断是否会出现死锁。
当一个进程请求某些资源时，如果系统能够满足其请求，则该进程可以继续执行；否则，该进程必须等待直到有足够的资源可用。
当一个进程释放掉已经占用的某些资源时，系统会将这些资源重新分配给其他需要它们的进程。
为了避免死锁，银行家算法采取了预防措施：在分配任何一个新任务之前，先检查该任务所需求各类资料是否超过了系统现有的资料总量，如果超过了，则不予分配。
否则，再检查该任务所需求各类资料是否超过了系统现有的未分配资料总量，如果超过了，则不予分配。
二、银行家算法实现银行家算法的实现需要考虑以下几个方面：1.资源分配图的表示方法：可以使用邻接矩阵或邻接表来表示资源分配图。
2.进程请求和释放资源的模拟：可以使用数组来存储进程占用和需要的资源数量，并通过对数组的修改来模拟进程请求和释放资源的过程。
3.死锁检测：可以使用安全序列或银行家算法来判断是否会出现死锁。
下面是一个基于银行家算法实现的简单Java代码示例：public class BankerAlgorithm {// 进程数private int n;// 资源数private int m;// 各进程已占用资源数量private int[][] allocation;// 各进程尚需资源数量private int[][] need;// 系统剩余可用资源数量private int[] available;/*** 构造函数* @param n 进程数* @param m 资源数* @param allocation 各进程已占用资源数量* @param need 各进程尚需资源数量* @param available 系统剩余可用资源数量*/public BankerAlgorithm(int n, int m, int[][] allocation, int[][] need, int[] available) {this.n = n;this.m = m;this.allocation = allocation;this.need = need;this.available = available;}/*** 模拟进程请求资源* @param pid 进程ID* @param request 请求的资源数量* @return 是否满足请求*/public boolean requestResources(int pid, int[] request) { // 检查请求是否超过进程所需的资源数量for (int i = 0; i < m; i++) {if (request[i] > need[pid][i]) {return false;}}// 检查请求是否超过系统剩余的资源数量for (int i = 0; i < m; i++) {if (request[i] > available[i]) {return false;}}// 模拟进程占用资源的过程for (int i = 0; i < m; i++) {available[i] -= request[i];allocation[pid][i] += request[i];need[pid][i] -= request[i];}return true;}/*** 模拟进程释放资源* @param pid 进程ID* @param release 释放的资源数量*/public void releaseResources(int pid, int[] release) { // 模拟进程释放资源的过程for (int i = 0; i < m; i++) {available[i] += release[i];allocation[pid][i] -= release[i];need[pid][i] += release[i];}}/*** 判断系统是否安全* @return 是否安全*/public boolean isSafe() {// 初始化工作数组int[] work = new int[m];for (int i = 0; i < m; i++) {work[i] = available[i];}boolean[] finish = new boolean[n]; for (int i = 0; i < n; i++) {finish[i] = false;}// 查找可用的进程int count = 0;while (count < n) {boolean found = false;for (int i = 0; i < n; i++) {if (!finish[i]) {boolean canRun = true;for (int j = 0; j < m; j++) { if (need[i][j] > work[j]) { canRun = false;break;}}if (canRun) {finish[i] = true;found = true;count++;for (int j = 0; j < m; j++) {work[j] += allocation[i][j];}}}}if (!found) {return false;}}return true;}}三、总结银行家算法是一种重要的避免死锁的算法，它可以在系统分配资源时避免出现死锁状态。
操作系统银行家算法C语言代码
操作系统银行家算法C语言代码
银行家算法是保证系统安全的重要算法之一，它主要用于在多进程环境下避免死锁发生。
下面是银行家算法的C语言实现：
```c
#include <stdio.h>
#include <stdbool.h>
printf("请输入进程数和资源数，以空格分隔：");
scanf("%d%d", &m, &n);
printf("请输入各进程所需的最大资源数量：\n");
for (i = 0; i < m; i++)
{
printf("请输入第%d个进程的最大资源数量，以空格分隔：", i);
for (j = 0; j < n; j++)
scanf("%d", &max[i][j]);
}
for (i = 0; i < m; i++)
finish[i] = false;
printf("系统不是安全的，申请不能分配。
\n");
}
}
else
printf("申请不能满足，申请不能分配。
\n");
return 0;
}
```
该代码的输入包括：进程数、资源数、各进程所需的最大资源数、各进程已分配的资源数、系统中剩余的资源数，以及申请资源的进程编号和资源数量。
输出为判断系统是否安全以及申请资源是否成功分配的结果。
若系统是安全的，输出申请已经成功分配；若系统不是安全的，输出申请不能分配。
银行家算法C语言代码
for(int i=0;i<SMAX;++i)
{
cout<<Available[i]<<"\t";
}
cout<<"\n\n未执行进程目前已得到的资源[Allocation]:"<<endl;
for(i=0;i<PMAX;++i)
{
cout<<"\n进程["<<i<<"] : ";
void SourceRequest(); //资源请求
void FreeSource(); // 资源释放
void ShowProcess(); // 显示已执行进程的顺序
void GrantSource(int i); // 进程i资源分配
bool IsSafe();
bool FindS(int i); //进程i已经是false 现在需要确认每个资源 是不是满足Need[i][j] <= Work[j]
{
cout<<"需要的资源大于资源总量，请重新输入\n";
--j;
continue;
}
cout<<"输入进程["<<i<<"]已经拥有资源["<<j<<"]的数量 ：";
cin>>Allocation[i][j];
if(Allocation[i][j] > AvailableTemp[j])
#include <iostream>
银行家算法python实现代码
银行家算法python实现代码以下是银行家算法的Python实现代码：def banker_algorithm(available, max_resources, allocated_resources, need_resources):n_resources = len(available)n_processes = len(max_resources)safe_sequence = []work = available.copy()finish = [False] * n_processeswhile False in finish:is_safe = Falsefor i in range(n_processes):if not finish[i] and all(need_resources[i][j] <= work[j] for j in range(n_resources)):work = [work[j] + allocated_resources[i][j] for j in range(n_resources)]finish[i] = Trueis_safe = Truesafe_sequence.append(i)if not is_safe:return Nonereturn safe_sequence该函数的参数如下：- available: 一个列表，表示可用的各类资源数量- max_resources: 一个二维列表，max_resources[i][j]表示进程i请求第j类资源的最大数量- allocated_resources: 一个二维列表，allocated_resources[i][j]表示进程i 已分配第j类资源的数量- need_resources: 一个二维列表，need_resources[i][j]表示进程i还需要第j 类资源的数量返回值为一个列表，表示安全的执行顺序，如果不存在安全的执行顺序，则返回None。
实验二银行家算法
实验二银行家算法一、目的：加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效地防止和避免死锁的发生。
二、内容：银行家算法是避免死锁的一种重要方法，本实验要求编写和调试一个简单的银行家算法程序。
用银行家算法实现资源分配。
三、编程思想：首先分析银行家算法的数据结构，分析可利用资源向量Available、最大需求矩阵Max、分配矩阵Allocation、需求矩阵Need 、进程申请资源的关系，由所学知识可知；Need[i，j]=Max[I,j]-Allocation[i,j];当进程申请资源的时候；a)Requesti>Need[i]。
这种情况表示该进程的资源需求已超过系统所宣布的最大值，出错。
b)Requesti=Need[i]。
这种情况表示该进程现在对他所需的全部资源一次申请完成。
c)Requesti〉Need[i]。
这种情况表示该进程现在对它所需资源再进行部分的申请，剩余的资源以后再次申请。
当进程pi发出资源请求后；a)如果Requesti<=Need[i],转向步骤b，否则显示为出错，因为所需的资源数超过事先要求的最大值。
b)Requesti <=Available，便转向步骤三，否则则表示尚无足够资源，pi需等待。
c)假如系统将资源分配给pi则：Available=Available-RequestiAllocation[i]=Allocation[i]+RequestiNeed[i]=Need[i]-Request安全性算法检查(1)设置向量：工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work[]= Available[]。
Finish[]，它表示系统是否有足够的资源分配给每个进程，使之运行完成。
开始时先做Finish[i]=0；当有足够的资源分配给进程时，再令Finish[i]=1。
预防进程死锁的银行家算法
实验三预防进程死锁的银行家算法一、【实验目的】通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
二、【实验内容】问题描述：设计程序模拟预防进程死锁的银行家算法的工作过程。
假设系统中有n个进程P1, … ,P n，有m类可分配的资源R1, … ,R m，在T0时刻，进程P i分配到的j 类资源为Allocation ij个，它还需要j类资源Need ij个，系统目前剩余j类资源Work j个，现采用银行家算法进行进程资源分配预防死锁的发生。
三、【实验要求】程序要求：1）判断当前状态是否安全，如果安全给出安全序列；如果不安全给出理由。
2）对于下一个时刻T1，某个进程P k会提出请求Request(R1, … ,R m)，判断分配给P k进程请求的资源之后系统是否安全。
3）输入：进程个数n，资源种类m，T0时刻各个进程的资源分配情况（可以运行输入，也可以在程序中设置）；4）输出：如果安全，输出安全的进程序列，不安全则提示信息。
实现提示：用C++语言实现提示：1）程序中进程调度时间变量描述如下：int Available[MaxNumber];int Max[MaxNumber][MaxNumber];int Allocation[MaxNumber][MaxNumber];int Need[MaxNumber][MaxNumber];int Request[MaxNumber];int SafeOrder[MaxNumber];2）进程调度的实现过程如下：变量初始化；接收用户输入n，m，（输入或者默认的）Allocation ij，Need ij；按照银行家算法判断当前状态安全与否，安全给出安全序列，不安全给出提示；如果安全，提示用户输入下一时刻进程P k的资源请求Request(R1, … ,R m)；如果不安全或者无新请求则退出。
四、【实验代码】#include<iostream>using namespace std;#define MaxNumber 100int Available[MaxNumber];//可利用资源int Max[MaxNumber][MaxNumber];//最大需求矩阵int Allocation[MaxNumber][MaxNumber];//分配矩阵int Need[MaxNumber][MaxNumber];//需求矩阵int Request[MaxNumber];//请求资源int SafeOrder[MaxNumber];//安全序列int ProcessNumber;int TypeNumber;bool Finish[MaxNumber];int Work[MaxNumber];int i,j,go=1;void init();bool bank();bool IsSafe();void init(){cout<<"请输入进程的个数：";cin>>ProcessNumber;cout<<"请输入资源种类的个数：";cin>>TypeNumber;for(i=0;i<ProcessNumber;i++){cout<<endl<<"P"<<i<<"已经分配:";for(j=0;j<TypeNumber;j++){cin>>Allocation[i][j];}cout<<"P"<<i<<"还需分配:";for(j=0;j<TypeNumber;j++){cin>>Need[i][j];Max[i][j]=Allocation[i][j]+Need[i][j];}}cout<<"请输入各类可利用资源个数：";for(j=0;j<TypeNumber;j++){cin>>Available[j];}}bool bank(){cout<<"请输入请求资源下标:";cin>>i;cout<<"P"<<i<<"请求各类资源数分别是:";for(j=0;j<TypeNumber;j++){cin>>Request[j];if(Request[j]>Need[i][j]){cout<<"请求资源超过其需要这类资源的最大值，请求失败";return false;}else if(Request[j]>Available[j]){cout<<"没有足够的资源，P"<<i<<"必须等待";return false;}}//银行家算法for(j=0;j<TypeNumber;j++){Available[j]=Available[j]-Request[j];Allocation[i][j]=Allocation[i][j]+Request[j];Need[i][j]=Need[i][j]-Request[j];}return true;}bool IsSafe(){for(i=0;i<ProcessNumber;i++){Finish[i]=false;}for(j=0;j<TypeNumber;j++){Work[j]=Available[j];}int flag=0,k=0;//flag用来控制while循环，使得每个进程都能重新检测到while(flag!=-1){for(i=0;i<ProcessNumber;i++){flag=-1;if(Finish[i]==false){for(j=0;j<TypeNumber;j++){if(Need[i][j]>Work[j])break;}if(j==TypeNumber){for(j=0;j<TypeNumber;j++){Work[j]=Work[j]+Allocation[i][j];Finish[i]=true;}SafeOrder[k]=i;//入安全序列k++;flag=1;//再次进行进程循环break;}}}}for(i=0;i<ProcessNumber;i++){if(Finish[i]==true&&i==ProcessNumber-1){cout<<"系统处于安全状态,存在一个安全序列是：{";for(i=0;i<ProcessNumber;i++)cout<<"P"<<SafeOrder[i]<<",";cout<<"}"<<endl;return true;}else if(Finish[i]==false){cout<<"系统进入不安全状态"<<endl;return false;}}}void main(){init();if(IsSafe()){while(go==1){cout<<endl<<"是否继续为进程分配资源(Y/N): ";char a;cin>>a;if(a=='Y'||a=='y'){if(bank()){if(IsSafe())cout<<"系统处于安全状态，请求成功"<<endl;else{cout<<"请求失败"<<endl;break;}}}else if(a=='N'||a=='n'){cout<<"没有进程请求资源"<<endl;break;}}}elsecout<<"该请求不安全，没有安全序列"<<endl; }五、【实验结果】。
用C++实现银行家算法（代码）
⽤C++实现银⾏家算法（代码）#include <iostream>#include <vector>#include <algorithm>using namespace std ;void Max (vector <vector <int >>& max , const int m , const int n ) { cout << "请输⼊各进程最多还需要的资源数 按照" << m << "*" << n << "矩阵输⼊" << endl ; for (int i = 0; i < m ; i ++) { vector <int > b ;//每⼀个进程的还需资源数组 int resource ;//还需的资源 for (int j = 0; j < n ; j ++) { cin >> resource ; b .push_back (resource ); } max .push_back (b );//将资源数组放⼊所需资源素组 }}void Allocation (vector <vector <int >>& allocation , const int m , const int n ) { cout << endl <<"请输⼊各进程已分配的资源数 按照" << m << "*" << n << "矩阵输⼊" << endl ; for (int i = 0; i < m ; i ++) { vector <int > b ;//每⼀个进程的还需资源数组 int resource ;//还需的资源 for (int j = 0; j < n ; j ++) { cin >> resource ; b .push_back (resource ); } allocation .push_back (b );//将资源数组放⼊所需资源素组 }}void Available (vector <int > &available ,const int n ) { cout << endl << "请输⼊每个资源现有的数⽬ " << endl ; int resource ; for (int i = 0; i < n ; i ++) { cin >> resource ; available .push_back (resource ); }}void Need (vector <vector <int >> &max , vector <vector <int >> &allocation ,vector <vector <int >> &need ,int m ,int n ) { need .resize (m * n ); vector <int >t (n , 0); vector <vector <int >>T (m ,t ); need = T ; for (int i = 0; i < m ; i ++) { for (int j = 0; j < n ; j ++) { int f = max [i ][j ] - allocation [i ][j ]; need [i ][j ]; need [i ][j ] = max [i ][j ] - allocation [i ][j ]; } }}void safe (vector <int > &available , vector <vector <int >>& allocation , vector <vector <int >>& need , const int m , const int n ) { while (true ){ while (true ){1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162while (true ){ vector <int > work = available ; vector <bool >Finsh (m , false ); int mark1=0; int mark2=0; int mark3 = 0; int *route =new int [m ]; for (int z =0;z <m ;z ++){ for (int i = 0; i < m ; i ++) { if ( Finsh [i ]==true ){//判断是否需要资源 continue ; } mark1 = 0; for (int j = 0; j < n ; j ++) {//⽤于判断work 是否⼤于need if (work [j ] < need [i ][j ]) { continue ; } mark1 += 1; } if (mark1 == n ) {//当work ⼤于need Finsh [i ] = true ;//状态 for (int f = 0; f < n ; f ++) { work [f ] += allocation [i ][f ];//剩余资源增加 allocation [i ][f ] = 0; need [i ][f ] = 0;//该进程所需资源修改为零 } route [mark3] = i ;//记录路线 mark3 += 1; } } } for (int i = 0; i < m ; i ++) { if (Finsh [i ] == false ) { cout << endl << "线程不是安全的！ "; break ; } mark2 += 1; } if (mark2 == m ) { cout << endl << "线程是安全的！"<<endl ; cout << "系统安全序列是" << endl ; for (int i = 0; i < m ; i ++) { if (i == m - 1) { cout << route [i ]; break ; } cout << route [i ] << "----->"; } } int x ; cout <<endl <<"请输⼊要申请资源的进程号（从0开始,输⼊⼩于0结束）"<<endl ; cin >> x ; if (x < 0) { break ; } cout << "依次输⼊各个资源的数量"<<endl ; for (int i = 0; i < n ; i ++) { cin >> need [x ][i ];6263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127cin >> need [x ][i ]; }} char jud ; cout << "是否再次请求分配Y/N" << endl ;; cin >> jud ; if (jud != 'Y' || jud != 'y') { break ; } }}int main () { int m ;//进程数 int n ;//资源种类数 cout << "请输⼊进程数 "; cin >> m ; cout << endl <<"请输⼊资源种类数 "; cin >> n ; vector <vector <int >> max ;//所需资源素组 vector <vector <int >> allocation ;//已分配资源数组 vector <int > available ;//各个资源现有数⽬ vector <vector <int >> need ;//各个进程还需资源 Max (max , m , n );//输⼊max Allocation (allocation , m , n );//输⼊allocation Available (available , n );//输⼊available Need (max ,allocation ,need ,m ,n );//⽤于计算need safe (available ,allocation , need , m , n );}127128129130131132133134135136137138139140141142143144145146147148149150151152153154155。
银行家算法（安全序列）
银⾏家算法（安全序列）银⾏家算法银⾏家算法（Banker's Algorithm）是⼀个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的⼀种避免死锁产⽣的算法。
它以银⾏借贷系统的分配策略为基础，判断并保证系统的安全运⾏。
安全状态如果存在⼀个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。
安全状态⼀定是没有死锁发⽣。
不安全状态不存在⼀个安全序列。
不安全状态不⼀定导致死锁。
数据结构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]算法原理我们可以把操作系统看作是银⾏家，操作系统管理的资源相当于银⾏家管理的资⾦，进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。
为保证资⾦的安全，银⾏家规定：(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客；(2) 顾客可以分期贷款，但贷款的总数不能超过最⼤需求量；(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时，对顾客的贷款可推迟⽀付，但总能使顾客在有限的时间⾥得到贷款；(4) 当顾客得到所需的全部资⾦后，⼀定能在有限的时间⾥归还所有的资⾦.操作系统按照银⾏家制定的规则为进程分配资源，当进程⾸次申请资源时，要测试该进程对资源的最⼤需求量，如果系统现存的资源可以满⾜它的最⼤需求量则按当前的申请量分配资源，否则就推迟分配。
银行家算法全部代码
#include<iostream.h>#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;//作业的最大数为int N=100;//资源的最大数为//显示资源矩阵void 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 safe(){int k=0;int i,m,j;int Finish[100]={0};int pro;int pflag=0;//进程标志int Request[100];int rf=1;//请求标志//初始workWork[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];cout<<"输入请求资源的进程名："<<endl;do{pflag = 0;cin>>pro;cout<<"\n";if(pro<0&&pro>=M){pflag = 1;cout<<"输入的进程名有误，重新输入...[0..."<<M<<"]";}}while(pflag);cout<<"输入所各类资源请求的数量：例(2 3 4)"<<endl;for(int h=0;h<N;h++){cin>>Request[h];}/*在finish = false情况下request <= needrequest <= available*/int brf = 0; //第一次资源请求是否堵塞int count = 0; //记录已经进行了几次int apply =0;//记录进程被堵塞的次数int pass = 0;//进程通过的次数i=pro;while(count<M){rf = 1; //每次循环默认是能通过的//判断finish 若为false说明还没进行判断true 判断过了，if(Finish[i]==False){//若不是第一次则把请求的数变成是各个进程的NEED值if(count != 0){for(j=0;j<N;j++){Request[j] = Need[i][j];cout<<"Request["<<j<<"]"<<Request[j]<<endl;}}for(j=0;j<N;j++){int r = Request[j];int n = Need[i][j];int w = Work[j];if((r>n)||(r>w)){apply++;//堵塞一次+1rf = 0;cout<<"rf="<<rf<<endl;//请求资源的进程被堵塞了，直接跳出循环到等待。
银行家算法附代码
#include <iostream.h>#include <string.h>#define M 3 //资源的种类数#define N 5 //进程的个数int i ,j;void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]); //统一的输出格式bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);bool tr[N]={false,false,false,false,false};int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};int main(){//当前可用每类资源的资源数int iAvailable[M]={3,3,2};//系统中N个进程中的每一个进程对M类资源的最大需求//iNeed[N][M]每一个进程尚需的各类资源数//iAllocation[N][M]为系统中每一类资源当前已分配给每一进程的资源数int iNeed[N][M],iAllocation[N][M]={{0,1,1},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//进程名char cName[N]={'a','b','c','d','e'};bool bExitFlag=true; //退出标记char ch; //接收选择是否继续提出申请时传进来的值bool bSafe; //存放安全与否的标志//计算iNeed[N][M]的值for(i=0;i<N;i++)for(j=0;j<M;j++)iNeed[i][j]=iMax[i][j]-iAllocation[i][j];//输出初始值output(iMax,iAllocation,iNeed,iAvailable,cName);//判断当前状态是否安全bSafe=safety(iAllocation,iNeed,iAvailable,cName);//是否继续提出申请while(bExitFlag){cout<<"\n"<<"继续提出申请？\ny为是；n为否。
银行家算法-求所有安全序列
银⾏家算法-求所有安全序列银⾏家算法-求所有安全序列使⽤DFS（深度优先搜索）遍历求出所有的安全序列。
数据结构先上头⽂件说明，实现此算法⽤到的数据结构和命名。
#ifndef _DATA_STRUCTURE#define _DATA_STRUCTURE// 表⽰资源个数#define M (4)// 表⽰进程个数#define N (4)// 当前状态还剩多少可⽤的资源struct AvailableD;// 每个进程对每个资源的最⼤需求量struct MaxD;// 当前分配个每个进程的资源数⽬struct AllocationD;// 每个进程还需要多少资源数⽬（最⼤需求 - 当前分配）struct NeedD;// 当前状态每个进程请求的资源数量struct RequestD;// 存放安全序列的数据结构（名字叫 Queue 实际上是栈的实现【FILO先进后出】）struct QueueD;// 表明每个进程是否在安全序列中struct StatusD;typedef struct AvailableD *Available;typedef struct MaxD *Max;typedef struct AllocationD *Allocation;typedef struct NeedD *Need;typedef struct RequestD *Request;typedef struct QueueD *Queue;typedef struct StatusD *Status;Available create_available();Allocation create_allocation();Max create_max();Need create_need();Queue create_queue();int queue_full(Queue queue);int queue_empty(Queue queue);void queue_add(Queue queue, int data);int queue_get(Queue queue);void queue_display(Queue queue);Status create_status();void display_need(Need need);/* 更新 need 数组 */void update_need(Need need, Allocation allocation, Max max);/* 将 allocation 矩阵的第 row ⾏的值加(减)到 available ⾥ */void update_available(Allocation allocation, int row, Available available, int is_add);/* 检查 available 是否满⾜ need 的第 row ⾏的需求 */void check_available(Allocation allocation, Need need, Available available, int row, Queue queue, Status status);#endif算法步骤⾸先检查当前剩余的资源数⽬是否满⾜某个进程的需求量，也就是说判断 Available 向量中每⼀个资源数⽬是否⼤于等于 Need 矩阵中某⼀个进程的需求量；如果对于进程 row ，对每个资源数⽬的需求量⼩于当前可⽤的系统资源；⾸先检查当前进程是否已经在安全序列中，若存在就判断下⼀个进程；若当前进程 row 还没有处在安全序列，就开始深度优先搜索：将当前进程 row 已经分配到的系统资源数⽬加到当前可⽤的资源数⽬中，即 Allocation 矩阵中第row ⾏的所有数⽬加到 Available 向量中；然后将当前进程 row 添加到安全序列中（此安全序列是⼀个栈）；递归调⽤搜索的函数，向下⼀个进程开始搜索；在搜索的过程中需要判断所有的进程是否已经添加到安全序列中，即查看安全序列（栈）的⼤⼩是否等于当前系统的进程数⽬；若达到了就将安全序列输出并且开始回溯；此判断应该放在深度优先搜索函数的前⾯，⽤来作为递归出⼝；然后将最近加⼊到安全序列中的进程从安全队列中删除，即从栈中弹出⼀个元素，记为 row；然后修改此进程row未加在安全序列中的状态；将此进程row收回的资源数⽬归还，即从 Available 向量中减去 Allocation 矩阵中第 row ⾏的数⽬；然后向下⼀个进程搜索。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
available[j]=available[j]-request[j]; allocation[i][j]+=request[j]; need[i][j]=need[i][j]-request[j]; //系统尝试把资源分配给请求的进程 }
void check() //安全算法函数 { int k,f,v=0,i,j; int work[m],a[m]; bool finish[m]; r=1; for(i=0;i<no1;i++) finish[i]=false; // 初始化进程均没得到足够资 源数并完成 for(i=0;i<no2;i++) work[i]=available[i];//work[i]表示可提供进程继续 运行的各类资源数 k=no1;
}
while(k>0); f=1; for(i=0;i<no1;i++) //判断是否所有的进程都完成 { if(finish[i]==false) { f=0; break; } } if(f==0) //若有进程没完成，则为不安全状态 { printf("系统处在不安全状态！"); r=0; } else { printf("\n系统当前为安全状态，安全序列为：\n"); for(i=0;i<no1;i++) printf("p%d ",a[i]); //输出安全序列 } }
do{ for(i=0;i<no1;i++) { if(finish[i]==false) { f=1; for(j=0;j<no2;j++) if(need[i][j]>work[j]) f=0; if(f==1)//找到还没有完成且需求数小于可提供进程继续运行的资源数的进程 { finish[i]=true; a[v++]=i; //记录安全序列号 for(j=0;j<no2;j++) work[j]+=allocation[i][j]; //释放该进程已分配的资源 } } } k--; //每完成一个进程分配，未完成的进程数就减1
for(j=0;j<no2;j++) if(request[j]>need[i][j]) p=1; //判断请求是否超过该进程所需要的资源数 if(p) printf("请求资源超过该进程资源需求量，请求失败！\n"); else { for(j=0;j<no2;j++) if(request[j]>available[j]) q=1; //判断请求是否超过可用资源数 if(q) printf("没有做够的资源分配，请求失败！\n"); else //请求满足条件 { for(j=0;j<no2;j++) { available1[j]=available[j]; allocation1[i][j]=allocation[i][j]; need1[i][j]=need[i][j]; //保存原已分配的资源数，仍需要的资源数和可用的
//输入已知的可用资源数
print(); //输出已知条件 check(); //检测T0时刻已知条件的安全状态 if(r==1) //如果安全则执行以下代码 { do{ q=0;
p=0; printf("\n请输入请求资源的进程号(0~4)：\n"); for(j=0;j<=10;j++) { scanf("%d",&i); if(i>=no1) { printf("输入错误，请重新输入：\n"); continue; } else break; } printf("\n请输入该进程所请求的资源数request[j]:\n"); for(j=0;j<no2;j++) scanf("%d",&request[j]);
二．安全性检查算法（check()函数）
(1)设置两个向量： 工作向量Work，它表示系统可提供给进程继续运行所需的 各类资源数目，在执行安全性算法开始时，Work= Available。 工作向量Finish，它表示系统是否有足够的资源分配给进程， 使之运行完成。开始时先做Finish[i]=false；当有足够的资源 分配给进程时，再令Finish[i]=true。 (2)在进程中查找符合以下条件的进程： 条件1：Finish[i]=false； 条件2：need[i][j]<=Work[j] 若找到，则执行步骤(3)否则，执行步骤(4) (3)当进程获得资源后，可顺利执行，直至完成，并释放出分 配给它的资源，故应执行： Work[j]= Work[j]+ Allocation[i][j]； Finish[i]=true； goto step (2)； (4)如果所有的Finish[i]=true都满足，则表示系统处于安全状 态，否则，处于不安全状态。
银行家算法说明
小组成员：于鹏、张星、张旺 郝志超、杨泽平
张旺 制作，于鹏 修改完善
银行家算法原理
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家 管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。 为保证资金的安全,银行家规定: (1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可 接纳该顾客; (2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量; (3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的 贷款可推迟支付,但总能使顾客在有限的时间里得到贷款; (4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有 的资金. 操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源 时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足 它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程 在执行中继续申请资源时，先测试该进程本次申请的资源数是否超过了 该资源所剩余的总量。若超过则拒绝分配资源，若能满足则按当前的申 请量分配资源，否则也要推迟分配。
Байду номын сангаас
printf("请输入Max矩阵:\n"); for(i=0;i<no1;i++) for(j=0;j<no2;j++) scanf("%d",&max[i][j]); //输入已知进程最大资源需求量 printf("请输入Allocation矩阵:\n"); for(i=0;i<no1;i++) for(j=0;j<no2;j++) scanf("%d",&allocation[i][j]); //输入已知的进程已分配的 资源数 for(i=0;i<no1;i++) for(j=0;j<no2;j++) need[i][j]=max[i][j]-allocation[i][j]; //根据输入的两个数组 计算出need矩阵的值 printf("请输入Available矩阵\n"); for(i=0;i<no2;i++) scanf("%d",&available[i]);
流程图
银行家算法流程图：见附录1
安全性算法流程图：见附录2
程序源代码：
#include <stdio.h> #include <stdlib.h> #include <conio.h> # define m 50
int no1; //进程数 int no2; //资源数 int r;
void print() //输出函数 { int i,j; printf("\n"); printf("*************此时刻资源分配情况*********************\n"); printf("进程名/号 | Max | Allocation | Need |\n"); for (i = 0; i < no1; i++) { printf(" p%d/%d ",i,i); for (j = 0; j < no2; j++) {printf("%d ",max[i][j]);} for (j = 0; j < no2; j++) {printf(" %d ",allocation[i][j]);} for (j = 0; j < no2; j++) {printf(" %d ",need[i][j]);} printf("\n");
银行家算法所需要的数据结构
①可利用资源向量available, n个元素的数组, 每个元素代表一类可用资源的数目, available [ i ] = k 表示系统中有Rj 类资源k 个; ②最大需求矩阵 MAX, n3 m矩阵定义n 个进程时,m 类资源的最大 需求max ( i, j) = k 表示进程需要Rj类资源最大数目为k ; ③分配矩阵allocation, n3 m矩阵,表示n个 进程的每个进程已分配资源情况, alloction ( i, j) = k 表示进程i已分配Rj类资源k 个; ④需求矩阵 need, n3 m矩阵,表示各进程仍需要各类资源, need ( i, j) = k表示进程i仍需要资源Rj的数目为k. 由上述分析可知need i =max i - allocation i.