操作系统实验报告银行家算法
《操作系统》课程实验报告银行家算法
《操作系统》课程实验报告实验名称:银行家算法姓名:学号:地点:指导老师:专业班级:一、实验目的:1)对死锁避免中的银行家算法做进一步的理解。
2)加深理解死锁的概念3)加深理解安全序列和安全状态的概念4)通过编程,掌握银行家算法分配资源的一步步实现过程二、实验内容:1)给出系统可用资源向量2)给出当前状态系统中各个进程的资源分配情况3)根据系统当前资源状态和各个进程的资源分配情况,判断系统是否处于安装状态,若系统处于安全状态,给出所有的安全序列和每一个安全序列所对应的资源分配图,若系统不处于安全序列,则发出死锁警告。
三、实验主要代码/**银行家算法(实现所有存在路径的查找)*///构造进程单位struct Process{string p_name; //进程的名称int Max[N]; //进程对于各个资源的最大需求数目int Allocation[N]; //进程已经得到的各个资源的数目int Need[N]; // 进程对各个资源所需要的数目};int p_num, s_num; // 进程数、资源种类static struct Process P[N];int Available[N]; //系统中各个资源可用的数目void dfs(int step){/**银行家算法(实现所有存在路径的查找)搜寻所有的安全序列 */for (int i = 0; i < p_num; i++){back_time++; // 找到当前安全序列的时间点int flag = 0;if (vis[i]) continue;//判断现有的系统资源是否满足该进程的需求for (int j = 0; j < s_num; j++){if (Available[j] < P[i].Need[j]){flag = 1;break;}}if (flag) continue;vis[i] = true;//该进程运行完毕ans[step] = i;//将这个可以运行的进程编号存入数组当中// 回收资源for (int j = 0; j < s_num; j++)Available[j] += P[i].Allocation[j];//如果所有的进程都全部执行完毕if (step == p_num)Print(ans, p_num);dfs(step + 1);vis[i] = false;for (int j = 0; j < s_num; j++)Available[j] -= P[i].Allocation[j];}}四、实验过程分析本次实验的主要任务是实现银行家算法,通过输入当前某一时刻系统的资源数目和所有进程相关的资源信息,然后通过算法的实现判断当前系统是否处于不安全状态,如果是处于安全状态那么找到所有的安全序列。
操作系统实验报告--银行家算法
操作系统实验报告二一:实验标题:实现死锁避免算法:银行家算法。
二:实验环境:操作系统:windows7编译器:Visual Studio 2010三:设计方案:1.实验目的通过程序模拟银行家算法,理解如何应用银行家算法避免死锁。
2.实验手段直接在C源程序定义整形进程数量、资源种类;用2维数组表示最大需求、已分配的资源。
从文件获取相关数量。
3.验证方式检验当前资源是否有安全序列,是的话输出安全序列。
四:实验代码:#include<stdio.h>#include<stdlib.h>#define P_num 5#define R_num 3int Allocation[P_num][R_num],Avaliable[R_num],Max[P_num][R_num]; int Need[P_num][R_num];int compare(int *a,int *b,int n){ int i;for(i = 0;i < n;i ++)if(a[i] < b[i])return 0;return 1;}void add(int *a,int *b,int n){ int i;for(i = 0;i < n;i++)a[i] += b[i];}void substract(int *a,int *b,int n){ int i;for(i = 0;i < n;i++)a[i] -= b[i];}void assign(int *a,int *b,int n){ int i;for(i = 0;i < n;i ++)a[i] = b[i];}void input(){FILE *fp;int i,j;if((fp = fopen("banker.txt","r")) == 0){ printf("cannot open the file");exit(0);}for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Allocation[i][j]);}for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Max[i][j]);}for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Avaliable[j]);}fclose(fp);for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){Need[i][j] = Max[i][j] - Allocation[i][j];}}int issafe(int *sp){int i;int count = 0;int n = 0;int work[R_num],finish[P_num];assign(work,Avaliable,R_num);for(i = 0;i < P_num;i ++)finish[i] = 0;n = P_num;while(n --){for(i = 0;i < P_num;i ++)if((finish[i] == 0) && compare(work,Need[i],R_num)){ add(work,Allocation[i],R_num);finish[i] = 1;sp[count] = i;count ++;}if(count >= P_num)return 1;}return 0;}int request(int pid,int *r,int n){int i;int sp[P_num];if(compare(Need[pid],r,n) == 1 && compare(Avaliable,r,n) == 1){ substract(Avaliable,r,n);add(Allocation[pid],r,n);substract(Need[pid],r,n);if(issafe(sp)){printf("Security Path:\n\t");for(i = 0;i < P_num;i ++)printf("p[%d] ",sp[i]);printf("\n");return 1;}else{add(Avaliable,r,n);substract(Allocation[pid],r,n);add(Need[pid],r,n);printf("no Security Parh on this request\n");return 0;}}else{printf("no Security Parh on this request\n");return 0;}}void main(){int id,i;int r[R_num],sp[P_num];input();if(issafe(sp)){printf("Security Path:\n\t");for(i = 0;i < P_num;i ++)printf("p[%d] ",sp[i]);printf("\n");}elseprintf("failed\n");printf("input the new request's id:");scanf("%d",&id);printf("input the new request:");for(i = 0;i < R_num;++ i)scanf("%d",&r[i]);request(id,r,R_num);}banker.txt文件内容:0 1 02 0 03 0 22 1 10 0 27 5 33 2 29 0 22 2 24 3 33 3 2所得结果:Security Path:P[1] p[3] p[4] p[0] p[2] Intput the new request's id:0Input the new request:0 2 0Security Path:p[3] p[1] p[2] p[0] p[4] 问题和想法:。
银行家算法操作系统实验报告
竭诚为您提供优质文档/双击可除银行家算法操作系统实验报告篇一:计算机操作系统银行家算法实验报告计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计:1、算法思路:先对用户提出的请求进行合法性检查,即检查请求是否大于需要的,是否大于可利用的。
若请求合法,则进行预分配,对分配后的状态调用安全性算法进行检查。
若安全,则分配;若不安全,则拒绝申请,恢复到原来的状态,拒绝申请。
2、银行家算法步骤:(1)如果Requesti<or=need,则转向步骤(2);否则,认为出错,因为它所需要的资源数已超过它所宣布的最大值。
(2)如果Request<or=Available,则转向步骤(3);否则,表示系统中尚无足够的资源,进程必须等待。
(3)系统试探把要求的资源分配给进程pi,并修改下面数据结构中的数值:Available=Available-Request[i];Allocation=Allocation+Request;need=need-Request;(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
3、安全性算法步骤:(1)设置两个向量①工作向量work。
它表示系统可提供进程继续运行所需要的各类资源数目,执行安全算法开始时,work=Allocation;②布尔向量Finish。
它表示系统是否有足够的资源分配给进程,使之运行完成,开始时先做Finish[i]=false,当有足够资源分配给进程时,令Finish[i]=true。
(2)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=false②need 如找到,执行步骤(3);否则,执行步骤(4)。
(3)当进程p获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:work=work+Allocation;Finish[i]=true;转向步骤(2)。
操作系统_银行家算法报告
实验四:银行家算法的实现一.实验目的(1)加深了解有关资源申请、避免死锁等概念。
(2)体会和了解死锁和避免死锁的具体实施方法。
二.实验属性该实验为设计性实验。
三.实验仪器设备及器材普通PC386以上微机四.实验要求本实验要求2学时完成。
本实验要求完成如下任务:(1)设计进程对各类资源最大申请表示及初值的确定。
(2)设定系统提供资源的初始状况。
(3)设定每次某个进程对各类资源的申请表示。
(4)编制程序,依据银行家算法,决定其资源申请是否得到满足。
(5)显示资源申请和分配时的变化情况。
五、实验设计及其思路数据结构:Available[m] 用来表示可利用资源的数目初始值是该类全部可用资源的数目。
MAX[n][m] 用来定义n个进程中的每一个进程对m类资源的最大需求Allocation[i][j] 用来表示i个进程中的每一个进程对j类资源已经拥有的数值Need[i][j] 用来表示i个进程中的每一个进程对j类资源还需要的数值在此程序中通过输入输出流从txt文档中读取数据进入以上数据数组中通过控控制台向request[i][j]数组输入值 此数组用来表示进程i 向j 资源请求申请资源个数 银行家算法流程图开始进程发出资源请求(request )所需要资源小于目前最大值Request<=need所需要资源小于可利用值Request<=avilable把资源分配给此进程并改变相关数值安全性算法 返回值是Y否出错(该系统无法执行此类进程)该进程暂时无法获得此资源 需等待还原相关数据是否分配成功结束是是否安全性算法流程图六 输出结果向其中输入三组数据1 p1发出请求向量request (1,0,2) 正确结果为分配资源2 p4发出请求向量request (3,3,0) 正确结果会产生安全问题要等待3 p0发出请求向量request (0,2,0)正确结果产生安全隐患需等待开始定义可以用的资源数目work 还有是否能在有限的资源条件下完成线程的标志finish ,并给他们所有的线程都可以顺利完成count 等于进程总数 尽可能多的找到满足(finish==false 和need<=work 这两个条件的线程)并对资源做相应的更改更改次数用count 计录 返回 N返回Y 结束是 否七、代码#include<iostream.h>#include<fstream.h>#include<stdio.h>int *avilable;//表示现在可利用的各类资源的数目int **max1;//用二维数组存储各给线程最多能够申请到个资源的数目int **allocation;//用二维数组存储目前各个线程已占用各类资源的数量int **need;//用二维数组存储目前每个进程还需要各类资源的数量方能完成工作int*xiancheng;//用来存储安全序列int m,n;//m用来记录资源的总数,n用来计算进程的总数void show();//用来向控制台输出allocation,needmax1,avilable的数据int correct();//安全性算法void createavilable();//为目前可利用资源赋初值void createmax();//为每一个进程对各类资源的最大需求赋初值void createallocation();//为目前各个进程已经申请到的资源赋初值void createneed();//为完成该进程所需要的各类资源数量赋初值int banker();//银行家算法int main(){ int choice=1;createavilable();createmax();createallocation();createneed();while(choice!=0){banker();cout<<"请输入你的选择(1继续,2重来 0 退出)"<<endl;cin>>choice;if(choice==1) show();if(choice==2){createavilable();createmax();createallocation();createneed(); }}return 0;}void createavilable(){ifstream inFile;int i;i=0;inFile.open("avilable.txt");//从txt文件中读取数据为其赋值inFile>>m;inFile.get();avilable=new int[m];cout<<"avilable:"<<endl;cout<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;while(inFile){inFile>>avilable[i];cout<<avilable[i]<<'\t';//显示到控制台上char c;inFile.get(c);//用来准确定读取时位真正的结束位置i++;}cout<<endl;}void createmax(){ifstream inFile1;inFile1.open("max.txt");inFile1>>n;inFile1.get();max1=new int*[n];//实现为二维数组动态分配内存for(int k=0;k<n;k++)max1[k]=new int[m];cout<<"max:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ if(inFile1) inFile1>>max1[i][j];cout<<max1[i][j]<<'\t';}cout<<endl;}}void createallocation(){ifstream inFile1;inFile1.open("allocation.txt");allocation=new int*[n];for(int k=0;k<n;k++)allocation[k]=new int[m];cout<<"allocation:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ if(inFile1) inFile1>>allocation[i][j]; cout<<allocation[i][j]<<'\t';}cout<<endl;}}void createneed(){need=new int*[n];for(int k=0;k<n;k++)need[k]=new int[m];cout<<"need:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ need[i][j]=max1[i][j]-allocation[i][j];//根据max allocation和need的关系为need赋值cout<<need[i][j]<<'\t';}cout<<endl;}}int correct(){int *work;//工作向量bool *finish,flag;//finish用来表示进程是否可以在特定的资源下完成工作,flag用来标记循环是否结束int i, k,count1,count;work=new int[m];xiancheng=new int[m];for( i=0;i<m;i++)work[i]=avilable[i];finish=new bool[n];//初值都为falsefor(k=0;k<n;k++)finish[k]=false;count=0;do{for(i=0;i<n;i++){flag=false;count1=0;for(k=0;k<m;k++)if(need[i][k]<=work[k]) count1++;//判断i个进程对各类资源的需要是小于该类资源的工作数量并记录小于的个数else break;if(count1==m&&finish[i]==false)//判断对每类资源来说都是所需小于工作数量并且该类线程并没有完成任务{ for(k=0;k<m;k++){work[k]=work[k]+allocation[i][k];finish[i]=true;flag=true;}xiancheng[count]=i;count++;}}}while(flag==true);//可能多的找到满足(finish==false和need<=work 这两个条件的线程)并对资源做相应的更改更改次数用count计录cout<<count<<endl;if(count==n)return 1;elsereturn 0;}int banker(){int *request,i,j,count;request=new int[m];//资源请求i=count=0;cout<<"哪个进程请求资源"<<endl;cin>>j;cout<<"请依次输入a,b,c资源的请求数"<<endl;while(i<m) {cin>>request[i]; i++;}for(i=0;i<m;i++)if(request[i]<=need[j][i]) count++;else break;if(count!=m) //判断所需要资源小于目前最大值Request<=need {cout<<"此操系统不能完成这个进程"<<endl;return 0;}count=0;for(i=0;i<m;i++)if(request[i]<=avilable[i]) count++;else break;if(count!=m)//所需要资源小于可利用值Request<=avilable {cout<<"现在可利用资源不能满足需要,需要等候"<<endl; return 0;}for(i=0;i<m;i++){avilable[i]=avilable[i]-request[i];allocation[j][i]=allocation[j][i]+request[i];need[j][i]=need[j][i]-request[i];}if(correct()==1)//安全性算法{cout<<"可以将资源分配给"<<"p"<<j<<"进程,其中安全序列可以是:"<<endl;for(i=0;i<n;i++)cout<<"p"<<xiancheng[i]<<'\t';cout<<endl;}else{cout<<"因为会造成系统不安全,所以不分配资源给"<<"p"<<j<<"进程"<<endl;for(i=0;i<m;i++){avilable[i]=avilable[i]+request[i];allocation[j][i]=allocation[j][i]-request[i];need[j][i]=need[j][i]+request[i];}}return 0;}void show(){ int i,j;cout<<"avilable:"<<endl;cout<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for( i=0;i<m;i++)cout<<avilable[i]<<'\t';cout<<endl;cout<<"max:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for( i=0;i<n;i++){ cout<<"p"<<i<<'\t';for( j=0;j<m;j++){cout<<max1[i][j]<<'\t';}cout<<endl;}cout<<"allocation:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl; for(i=0;i<n;i++){ cout<<"p"<<i<<'\t'; for( j=0;j<m;j++){cout<<allocation[i][j]<<'\t';}cout<<endl;}cout<<"need:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl; for( i=0;i<n;i++){cout<<"p"<<i<<'\t';for( j=0;j<m;j++){cout<<need[i][j]<<'\t';}cout<<endl;}}。
(完整word版)计算机操作系统银行家算法实验报告
计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计:1、算法思路:先对用户提出的请求进行合法性检查,即检查请求是否大于需要的,是否大于可利用的.若请求合法,则进行预分配,对分配后的状态调用安全性算法进行检查。
若安全,则分配;若不安全,则拒绝申请,恢复到原来的状态,拒绝申请。
2、银行家算法步骤:(1)如果Requesti<or =Need,则转向步骤(2);否则,认为出错,因为它所需要的资源数已超过它所宣布的最大值。
(2)如果Request<or=Available,则转向步骤(3);否则,表示系统中尚无足够的资源,进程必须等待.(3)系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值:Available=Available—Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态.3、安全性算法步骤:(1)设置两个向量①工作向量Work。
它表示系统可提供进程继续运行所需要的各类资源数目,执行安全算法开始时,Work=Allocation;②布尔向量Finish。
它表示系统是否有足够的资源分配给进程,使之运行完成,开始时先做Finish[i]=false,当有足够资源分配给进程时,令Finish[i]=true.(2)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=false②Need〈or=Work如找到,执行步骤(3);否则,执行步骤(4)。
(3)当进程P获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:Work=Work+Allocation;Finish[i]=true;转向步骤(2).(4)如果所有进程的Finish[i]=true,则表示系统处于安全状态;否则,系统处于不安全状态。
银行家算法实验报告绪论
一、实验背景在计算机系统中,资源分配和死锁问题是操作系统领域的重要研究课题。
在多进程环境下,进程之间会共享系统资源,如CPU、内存、磁盘等。
然而,当多个进程同时申请资源时,可能会出现死锁现象,导致系统瘫痪。
为了避免死锁,研究者提出了多种资源分配算法,其中最具代表性的就是银行家算法。
银行家算法最初由Edsger Dijkstra于1965年提出,旨在解决银行在贷款业务中可能出现的死锁问题。
该算法通过模拟银行家在贷款业务中的决策过程,对资源分配进行动态规划,以确保系统处于安全状态,从而避免死锁的发生。
二、实验目的本次实验旨在通过实现银行家算法,加深对资源分配、死锁和安全性概念的理解,并掌握以下内容:1. 了解资源分配的基本原理和死锁的概念。
2. 掌握银行家算法的原理和实现方法。
3. 能够运用银行家算法对系统资源进行动态分配,并确保系统处于安全状态。
4. 分析实验结果,验证银行家算法的有效性。
三、实验原理1. 资源分配资源分配是指操作系统将资源分配给进程的过程。
在多进程环境下,资源分配策略需要考虑以下因素:(1)资源的类型和数量。
(2)进程对资源的最大需求。
(3)进程当前已分配的资源。
(4)系统可利用的资源。
2. 死锁死锁是指多个进程在执行过程中,因争夺资源而相互等待,导致系统无法继续执行的现象。
产生死锁的必要条件包括:(1)互斥条件:资源不能被多个进程同时占用。
(2)请求和保持条件:进程在等待资源时,仍保持已占有的资源。
(3)不剥夺条件:进程不能被强制剥夺已占有的资源。
(4)循环等待条件:存在一个进程序列,其中每个进程都在等待前一个进程所持有的资源。
3. 安全状态安全状态是指系统可以按照某种顺序为每个进程分配资源,使得所有进程都可以顺利完成的状态。
判断系统是否处于安全状态的方法如下:(1)计算每个进程的最大需求。
(2)计算系统可利用的资源。
(3)从最大需求中减去已分配的资源,得到剩余需求。
(4)判断剩余需求是否小于等于系统可利用的资源。
操作系统实验项目银行家算法
实验四、银行家算法(一)目的和要求银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。
本实验要求用高级语言编写一个银行家的模拟算法。
通过本实验可以对预防死锁和银行家算法有更深刻的认识。
(二)实验内容1、设置数据结构包括可利用资源向量(Availiable),最大需求矩阵(Max),分配矩阵(Allocation),需求矩阵(Need)2、设计安全性算法设置工作向量Work 表示系统可提供进程继续运行可利用资源数目,Finish 表示系统是否有足够的资源分配给进程(三)实验环境1、pc2、vc++(四)、程序源代码:/*子函数声明*/int Isprocessallover(); //判断系统中的进程是否全部运行完毕void Systemstatus(); //显示当前系统中的资源及进程情况int Banker(int ,int *); //银行家算法void Allow(int ,int *); //若进程申请不导致死锁,用此函数分配资源void Forbidenseason(int ); //若发生死锁,则显示原因/*全局变量*/int Availiable[3]={3,3,2}; //初始状态,系统可用资源量int Max[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//各进程对各资源的最大需求量int Allocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//初始状态,各进程占有资源量int Need[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//初始状态时,各进程运行完毕,还需要的资源量int over[5]={0,0,0,0,0}; //标记对应进程是否得到所有资源并运行完毕#include <iostream.h>/*主函数*/void main(){int process=0; //发出请求的进程int decide=0; //银行家算法的返回值int Request[3]={0,0,0}; //申请的资源量数组int sourcenum=0; //申请的各资源量/*判断系统中进程是否全部运行完毕*/step1: if(Isprocessallover()==1){cout<<"系统中全部进程运行完毕!";return;}/*显示系统当前状态*/Systemstatus();/*人机交互界面*/step2: cout<<"\n输入发出请求的进程(输入“0”退出系统): ";cin>>process;if(process==0){cout<<"放弃申请,退出系统!";return;}if(process<1||process>5||over[process-1]==1){cout<<"系统无此进程!\n";goto step2;}cout<<"此进程申请各资源(A,B,C)数目:\n";for(int h=0;h<3;h++){cout<<char(65+h)<<"资源:";cin>>sourcenum;Request[h]=sourcenum;}/*用银行家算法判断是否能够进行分配*/decide=Banker(process,Request);if (decide==0){/*将此进程申请资源分配给它*/Allow(process,Request);goto step1;}else{/*不能分配,显示原因*/Forbidenseason(decide);goto step2;}}/*子函数Isprocessallover( )的实现*/int Isprocessallover(){int processnum=0;for(int i=0;i<5;i++){/*判断每个进程是否运行完毕*/if(over[i]==1)processnum++;}if(processnum==5)/*系统中全部进程运行完毕*/return 1;elsereturn 0;}/*子函数Systemstatus( )的实现*/void Systemstatus(){cout<<"此刻系统中存在的进程:\n";for(int i=0;i<5;i++){if(over[i]!=1)cout<<"P"<<i+1<<" ";}cout<<endl;cout<<"此刻系统可利用资源(单位:个):\n";cout<<"A B C\n";for(int a=0;a<3;a++){cout<<Availiable[a]<<" ";}cout<<endl;cout<<"此刻各进程已占有资源如下(单位:个): \n"<<" A B C\n";for(int b=0;b<5;b++){if(over[b]==1)continue;cout<<"P"<<b+1<<" ";for(int c=0;c<3;c++)cout<<Allocation[b][c]<<" ";cout<<endl;}cout<<"各进程运行完毕还需各资源如下(单位:个):\n"<<" A B C\n";for(int f=0;f<5;f++){if(over[f]==1)continue;cout<<"P"<<f+1<<" ";for(int g=0;g<3;g++)cout<<Need[f][g]<<" ";cout<<endl;}}/*子函数Banker(int ,int &)的实现*/int Banker(int p,int *R){int num=0; //标记各资源是否能满足各进程需要int Finish[5]={0,0,0,0,0}; //标记各进程是否安全运行完毕int work[5]={0,0,0,0,0}; //用于安全检查int AvailiableTest[3]; //用于试分配int AllocationTest[5][3]; //同上int NeedTest[5][3]; //同上/*判断申请的资源是否大于系统可提供的资源总量*/for(int j=0;j<3;j++){if(*(R+j)>Availiable[j])/*返回拒绝分配原因*/return 1;}/*判断该进程申请资源量是否大于初始时其申明的需求量*/for(int i=0;i<3;i++){if(*(R+i)>Need[p-1][i])/*返回拒绝原因*/return 2;}/*为检查分配的各数据结构赋初值*/for(int t=0;t<3;t++){AvailiableTest[t]=Availiable[t];}for(int u=0;u<5;u++){for(int v=0;v<3;v++){AllocationTest[u][v]=Allocation[u][v];}}for(int w=0;w<5;w++){for(int x=0;x<3;x++){NeedTest[w][x]=Need[w][x];}}/*进行试分配*/for(int k=0;k<3;k++)//修改NeedTest[]{AvailiableTest[k]-=*(R+k);AllocationTest[p-1][k]+=*(R+k);NeedTest[p-1][k]-=*(R+k);}/*检测进程申请得到满足后,系统是否处于安全状态*/ for(int l=0;l<3;l++){work[l]=AvailiableTest[l];}for(int m=1;m<=5;m++){for(int n=0;n<5;n++){num=0;/*寻找用此刻系统中没有运行完的进程*/if(Finish[n]==0&&over[n]!=1){for(int p=0;p<3;p++){if(NeedTest[n][p]<=work[p])num++;}if(num==3){for(int q=0;q<3;q++){work[q]=work[q]+AllocationTest[n][q];}Finish[n]=1;}}}}for(int r=0;r<5;r++){if(Finish[r]==0&&over[r]!=1)/*返回拒绝分配原因*/return 3;}return 0;}/*子函数Allow(int ,int &)的实现*/void Allow(int p,int *R){cout<<"可以满足申请!";static int overnum;/*对进程所需的资源进行分配*/for(int t=0;t<3;t++){Availiable[t]=Availiable[t]-*(R+t);Allocation[p-1][t]=Allocation[p-1][t]+*(R+t);Need[p-1][t]=Need[p-1][t]-*(R+t);}/*分配后判断其是否运行完毕*/overnum=0;for(int v=0;v<3;v++){if(Need[p-1][v]==0)overnum++;}if(overnum==3){/*此进程运行完毕,释放其占有的全部资源*/for(int q=0;q<3;q++)Availiable[q]=Availiable[q]+Allocation[p-1][q];/*标记该进程运行完毕*/over[p-1]=1;cout<<"进程P"<<p<<"所需资源全部满足,此进程运行完毕!\n";}}/*子函数Forbidenseason(int )的实现*/void Forbidenseason(int d){cout<<"不能满足申请,此进程挂起,原因为:\n";switch (d){case 1:cout<<"申请的资源量大于系统可提供的资源量!";break;case 2:cout<<"申请的资源中有某种资源大于其声明的需求量!";break;case 3:cout<<"若满足申请,系统将进入不安全状态,可能导致死锁!";}}。
操作系统银行家算法实验报告
操作系统银行家算法实验报告操作系统银行家算法实验报告引言:操作系统是计算机科学中的一个重要领域,它负责管理计算机的硬件和软件资源,以提供良好的用户体验。
在操作系统中,银行家算法是一种重要的资源分配和调度算法,它可以确保系统中的进程安全地访问资源,避免死锁的发生。
本实验旨在通过实践运用银行家算法,深入理解其原理和应用。
实验目的:1. 理解银行家算法的基本原理;2. 掌握银行家算法的实现方法;3. 分析银行家算法在资源管理中的应用。
实验过程:1. 实验环境的搭建在本次实验中,我们使用了一台运行Windows操作系统的计算机,并安装了Java开发环境。
同时,我们使用了一个模拟的资源管理系统,以便更好地理解和实践银行家算法。
2. 银行家算法的原理银行家算法是通过对系统中的资源进行合理分配,以避免死锁的发生。
它基于以下几个假设:- 每个进程对资源的最大需求量是已知的;- 系统中的资源数量是有限的;- 进程在请求资源时必须先声明其最大需求量;- 进程在释放资源后,不能再重新请求。
3. 银行家算法的实现银行家算法的实现主要包括以下几个步骤:- 初始化:获取系统中的资源总量和每个进程的最大需求量;- 安全性检查:通过模拟分配资源并检查系统是否处于安全状态,以确定是否可以满足进程的资源请求;- 资源分配:根据安全性检查的结果,决定是否分配资源给进程。
4. 银行家算法的应用银行家算法在实际应用中具有广泛的用途,尤其是在多任务操作系统中。
它可以用于资源的分配和调度,以确保系统中的进程能够安全地访问资源,避免死锁的发生。
结论:通过本次实验,我们深入了解了银行家算法的原理和应用。
银行家算法作为一种重要的资源管理和调度算法,可以有效地避免死锁的发生,提高系统的可靠性和稳定性。
在今后的学习和工作中,我们将继续深入研究操作系统相关的算法和原理,以提升自己在该领域的专业能力。
银行家算法实验报告
银行家算法实验报告引言:在计算机科学领域,由于资源的有限性,进程资源分配问题一直备受关注。
而银行家算法被广泛应用于操作系统中,用于确保资源的安全分配。
本文旨在介绍银行家算法的原理和应用,并通过实验报告来验证该算法的有效性和可行性。
1. 银行家算法简介银行家算法是由美国学者Dijkstra提出的一种资源分配和避免死锁的算法。
其基本思想是通过银行家的原则来避免系统陷入死锁状态,保证资源分配的安全性和可行性。
银行家算法适用于具有多个进程和多个资源的并发系统中。
2. 银行家算法原理银行家算法基于两个重要的概念:安全性和可分配性。
安全性表示在系统当前状态下,是否存在一种资源分配序列可以使系统避免死锁状态。
可分配性表示系统是否能够满足进程对资源的请求。
银行家算法的实现需要以下几个关键步骤:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。
(2) 效验:判断系统当前状态下资源是否满足所有进程的需求,即判断系统是否处于安全状态。
(3) 分配:若系统处于安全状态,则根据某种资源分配策略,为进程分配资源。
(4) 请求:进程请求资源。
(5) 回收:进程释放资源。
3. 银行家算法的实验验证为了验证银行家算法的有效性和可行性,我们设置了一个简单的实验环境,模拟一个有限的资源系统,包含3个进程和3种不同类型的资源。
实验过程如下:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。
设置3个进程的最大需求量分别为{5, 4, 3},已分配资源量分别为{1, 2, 2},需求资源量分别为{3, 2, 0}。
(2) 效验:判断系统当前状态下资源是否满足所有进程的需求。
经过实验验证,我们发现系统当前状态下资源无法满足进程2的资源需求。
为了保证系统的安全性和避免死锁,根据银行家算法原理,我们将不满足资源需求的进程2暂停,并回滚到初始状态。
重新调整资源分配后,系统进入了安全状态。
(3) 分配:为进程1和进程3分配资源。
银行家算法实验报告
操作系统实验报告1银行计算法的实现班级:计算机科学与技术082班级姓名:学号:老师:霍林实验目的:计算机科学与技术专业学生学习完《计算机操作系统》课程后,进行的一次全面的综合训练,其目的在于加深催操作系统基础理论和基本知识的理解,加强学生的动手能力.银行家算法是避免死锁的一种重要方法。
通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法实验环境:Windos XP系统,java编程实验分析:1.实验背景银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。
这时系统将该进程从进程集合中将其清除。
此时系统中的资源就更多了。
反复执行上面的步骤,最后检查进程的集合为空时就表明本次申请可行,系统处于安全状态,可以实施本次分配,否则,只要进程集合非空,系统便处于不安全状态,本次不能分配给他。
请进程等待2.算法描述1)如果Request[i] 是进程Pi的请求向量,如果Request[i,j]=K,表示进程Pi 需要K个Rj类型的资源。
当Pi发出资源请求后,系统按下述步骤进行检查:如果Requesti[j]<= Need[i,j],便转向步骤2;否则认为出错,因为它所需要的资源数已超过它所宣布的最大值。
2)如果Requesti[j]<=Available[j],便转向步骤3,否则,表示尚无足够资源,进程Pi须等待。
3)系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:Available[j]:=Available[j]-Requesti[j];Allocation[i,j]:=Allocation[i,j]+Requesti[j];Need[i,j]:=Need[i,j]-Requesti[j];4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
操作系统原理-银行家算法
广州大学学生实验报告一、实验目的1、掌握银行家算法二、实验器材1、计算机一台。
2、Linux三、实验内容1、运行银行家算法四、实验步骤、记录和结果实验七:银行家算法银行家算法代码如下:#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;//row为进程数,colum为资源种类数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("\n请输入系统资源的种类数:");scanf("%d",&colum);printf("请输入现时内存中的进程数:");scanf("%d",&row);printf("请输入已分配资源矩阵:\n");//生成进程已分配资源链表Allocationfor(i=0;i<row;i++){for (j=0;j<colum;j++){printf("请输入已分配给进程p%d 的%c 种系统资源:",i,'A'+j);//如果是第一次,创建头结点if(status==0){allochead=alloc1=alloc2=(struct allocation*)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("请输入最大需求矩阵:\n");//生成最大需求链表Maxfor(i=0;i<row;i++){for (j=0;j<colum;j++){printf("请输入进程p%d 种类%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=(struct available*)malloc(avalen);workhead=work1=work2=(struct available*)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=(struct need*)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;//初始化finsh默认值finsh=falsefor(i=0;i<row;i++){if(status==0){finihead=finish1=finish2=(struct finish*)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->next) 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=(struct path*)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{//恢复finish=false状态for(t=0;t<colum;t++)alloctemp=alloctemp->next;finishtemp->stat=0;}}else//安全性检测失败for(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");return0;}实验过程与结果使用如下表格数据进行测试:P3 00 2 06 4P4 00 1 06 5先列出Need表Allocation Max NeedA B C A B C A B CP0 00 3 00 4 00 1P1 100 17 5 07 5P2 13 5 23 5 100P3 00 2 06 4 06 2P4 00 1 06 5 06 4过程分析:当前系统中可用资源数为1,4,0,只能满足进程P2,所以P2获得资源,执行,释放资源,可用资源变为2,7,5;此时可满足P1,P2,P3,P4,假定P1获得资源,执行,释放资源,可用资源变为3,7,5;此时可满足P0,P3,P4,假定P0获得资源,执行,释放资源,可用资源变为3,7,8;此时可满足P3,P4,假定P3获得资源,执行,释放资源,可用资源变为3,7,10;最后P4运行。
操作系统实验报告 银行家算法
实验四银行家算法实习内容通过编程理解银行家算法,掌握进程安全性检查的方法及资源分配的方法,加深了解有关资源申请、避免死锁等概念,体会和了解死锁和避免死锁的具体实施方法。
实习目的银行家算法是避免死锁的代表性算法。
本实习旨在加深了解有关资源申请、避免死锁、状态安全性等概念,并体会和运用避免死锁的具体实施方法。
然后依照本实习,自行设计模拟程序。
实习原理算法思想:银行家算法操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。
安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。
安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。
不安全状态一定导致死锁。
实习编程思路和流程在避免死锁的方法中,如果施加的限制条件较弱,有可能获得令人满意的系统性能。
在该方法中把系统的状态分为安全状态和不安全状态,只要能使系统始终都处于安全状态,便可以避免发生死锁。
基本思想为:在分配资源之前,判断系统是否是安全的;若安全,才分配。
它是最具代表性的死锁算法,具体算法如下表示:假设进程P提出请求Request[i],则银行家算法按如下步骤进行判断:1)如果Request[i] <=Need[i],则转向2);否则出错。
2)如果Request[i] <=Available[i],则转向3);否则出错。
3)系统试探分配相关资源,修改相关数据:Available[i]=Available[i]-Request[i];Allocation[i]=Allocation[i]+Request[i];Need[i]=Need[i]-Request[i];4)系统执行安全性检查,如安全,则分配成立;否则试探性分配资源作废,系统恢复原状,进程进入等待状态。
实验报告_银行家算法
1. 题目分析1.1 设计目的●理解死锁产生的原因和必要条件●了解避免死锁的几种基本方法●掌握银行家算法及安全性算法1.2 设计内容设计内容包括银行家算法和安全性算法,以及用VC界面实现输出1.3 相关知识概述银行家算法是一种最有代表性的避免死锁的算法。
要解释银行家算法,必须先解释操作系统安全状态和不安全状态。
安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。
安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。
不安全状态一定导致死锁。
安全序列:一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
2. 概要设计2.1主要数据结构描述static int MAX[5][3]; //最大需求矩阵static int AVAILABLE[3]; //可利用资源矩阵static int ALLOCATION[5][3]; //分配矩阵static int NEED[5][3]; //需求矩阵因为数组成员MAX,AVAILABLE, ALLOCATION, NEED的值每次调用一次银行家算法,如果分配成功,都会改变,所以将他们设定为静态成员变量。
int Request[3]; //请求向量int Work[3]; //工作向量bool FINISH[5];//标记系统是否有足够的资源分配给进程2.2 流程图(1)银行家算法流程图单击“执行银行家算法”按钮时会调用OnButton1()函数,相当于银行家算法注:只要不按“退出”按钮退出程序,数组MAX,A V AILABLE, ALLOCATION, NEED中会保留上一次执行完后变化的值,不停的单击“进行银行家算法”按钮,程序会在上一次执行完后的基础上反复的执行银行家算法。
(2)安全性算法流程图3. 详细设计3.1 主要算法描述当进程pi提出资源申请时,系统执行下列步骤:(1)若Request≤Need,转(2);否则错误返回(2)若Request≤Available,转(3);否则进程等待(3)假设系统分配了资源,则有:Available:=Available-Request;Allocation:=Allocation+Request;Need:=Need-Request若系统新状态是安全的,则分配完成若系统新状态是不安全的,则恢复原状态,进程等待安全性检查的步骤:(1) Work:=Available;Finish:=false;(2) 寻找满足条件的i:Finish=false;Need≤Work;如果不存在,则转(4)(3) Work:=Work+Allocation;Finish:=true;转(2)(4) 若对所有i,Finish=true,则系统处于安全状态,否则处于不安全状态3.2 程序界面设计4. 编码实现4.1 开发工具简介Visual C++集成开发环境下下实现的4.2 部分程序源码int CSisuoDlg::MAX[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};int CSisuoDlg::AVAILABLE[3]={3,3,2};int CSisuoDlg::ALLOCATION[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}; int CSisuoDlg::NEED[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};int CSisuoDlg::safe(){int i,j,k,l=0;int Work[3];bool FINISH[5];int p[5];for(i=0;i<3;i++)Work[i]=AVAILABLE[i];for(i=0;i<5;i++){ FINISH[i]=false;}for(i=0;i<5;i++){if(FINISH[i]==true){ continue;}else{for(j=0;j<3;j++){if(NEED[i][j]>Work[j]){break;}}if(j==3)//找到满足要求的进程{FINISH[i]=true;for(k=0;k<3;k++){Work[k]+=ALLOCATION[i][k];}p[l++]=i;//记录安全序列i=-1;//每次都是从头开始找}else{continue;}}if(l==5){show+="经安全性检查,系统安全,本次分配成功。
实验三银行家算法实验报告
实验三银行家算法实验报告一、实验目的银行家算法是一种用于避免死锁的算法,本次实验旨在通过编程实现银行家算法,并通过模拟银行家算法的运行过程来加深对该算法的理解。
二、实验过程及结果1. 系统设计为了模拟银行家算法的运行过程,需要设计一个包含多个进程和资源的系统。
每个进程都有一定的最大需求资源数和已分配资源数。
系统中还有一定数量的可用资源,进程可以请求资源和释放资源。
2. 算法实现在程序中实现银行家算法需要以下几个关键的函数:(1)银行家算法的主函数:实现进程的请求资源和释放资源操作,并在此过程中判断是否产生死锁;(2)安全检查函数:用于判断系统状态是否安全,即是否存在一个安全序列,如果存在则表示系统处于安全状态,否则表示系统处于不安全状态;(3)资源请求函数:用于进程请求资源的操作,根据银行家算法的要求进行判断;(4)资源释放函数:用于进程释放资源的操作。
3. 算法运行通过对编写的程序进行多次运行测试,模拟不同进程对资源的请求和释放,观察系统是否能够始终处于安全状态。
在每次运行中,记录并输出系统的安全序列和进程的状态等信息。
4. 实验结果分析通过实验运行结果的分析,可以得出以下结论:(1)银行家算法能够有效地避免死锁的发生;(2)系统中资源的分配和释放过程需要合理,否则可能导致系统陷入死锁;(3)资源的分配策略对系统的安全状态有重要影响。
三、实验总结通过本次实验,深入了解了银行家算法的原理和实现过程,并通过编程实践加深了对该算法的理解。
银行家算法是一种重要的死锁避免算法,能够保证系统处于安全状态下运行,并且能够合理地分配系统资源,避免系统陷入死锁。
四、参考文献[1] 《操作系统概念》,Abraham Silberschatz,Peter B. Galvin,Greg Gagne,电子工业出版社,2014年五、附录(示例代码省略)以上是本次实验的实验报告,通过实验我们深入了解了银行家算法,了解了它在操作系统中的应用和重要性。
操作系统课程设计报告—银行家算法
操作系统课程设计报告题目:银行家算法院(系):专业:班级:学生:学号:指导教师:操作系统课程设计报告摘要Dijkstra提出的银行家算法,是最具代表性的避免死锁的算法。
本文对如何用银行家算法来处理操作系统给进程分配资源做了详细的说明,包括需求分析、概要设计、详细设计、测试与分析、总结、源程序清单。
首先做了需求分析,解释了什么是银行家算法,并指出它在资源分配中的重要作用。
然后给出了银行家算法的概要设计,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等。
在概要设计的基础上,又给出了详细的算法设计,实现概要设计中定义的所有函数,对每个函数写出核心算法,并画出了流程图。
接着对编码进行了测试与分析(并在最后附上Java编写的程序代码)。
最后对整个设计过程进行了总结。
关键词:安全状态;安全序列;银行家算法;安全性算法;安全序列;流程图。
目录摘要 (1)1绪论 (4)1.1前言 (5)1.2研究意义 (5)1.3结构安排 (5)2需求分析 (4)2.1题目描述 (5)2.2银行家算法 (5)2.3基本要求 (5)2.4目的 (5)3概要设计 (4)3.1基本思路 (5)3.2银行家算法步骤 (5)3.3安全型算法步骤 (5)3.4数据结构 (5)3.4.1主要用到的数据结构 (6)3.4.2程序模块 (6)3.4.3各模块间的调用关系 (6)4详细设计 (4)4.1主要函数的核心代码 (5)4.1程序流程图 (5)5测试 (4)5.1测试用例 (5)5.1测试结果分析和截图 (5)6总结 (4)参考文献 (4)附录:原程序清单 (4)1绪论1.1前言:Dijkstra (1965)提出了一种能够避免死锁的调度算法,称为银行家算法。
它的模型基于一个小城镇的银行家,他向一群客户分别承诺了一定的贷款额度,每个客户都有一个贷款额度,银行家知道不可能所有客户同时都需要最大贷款额,所以他只保留一定单位的资金来为客户服务,而不是满足所有客户贷款需求的最大单位。
操作系统实验报告--C语言实现银行家算法
实验报告附录3程序源代码:#include <stdio.h>#include <stdlib.h>#include <conio.h># define m 50int no1; //进程数int no2; //资源数int r;int allocation[m][m],need[m][m],available[m],max[m][m];char name1[m],name2[m]; //定义全局变量void main(){void check();void print();int i,j,p=0,q=0;char c;int request[m],allocation1[m][m],need1[m][m],available1[m];printf("**********************************************\n");printf("* 银行家算法的设计与实现 *\n");printf("**********************************************\n");printf("请输入进程总数:\n");scanf("%d",&no1);printf("请输入资源种类数:\n");scanf("%d",&no2);printf("请输入Max矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&max[i][j]); //输入已知进程最大资源需求量printf("请输入Allocation矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&allocation[i][j]); //输入已知的进程已分配的资源数for(i=0;i<no1;i++)for(j=0;j<no2;j++)need[i][j]=max[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值printf("请输入Available矩阵\n");for(i=0;i<no2;i++)scanf("%d",&available[i]); //输入已知的可用资源数print(); //输出已知条件check(); //检测T0时刻已知条件的安全状态if(r==1) //如果安全则执行以下代码{do{q=0;p=0;printf("\n请输入请求资源的进程号(0~4):\n");for(j=0;j<=10;j++){scanf("%d",&i);if(i>=no1){printf("输入错误,请重新输入:\n");continue;}else break;}printf("\n请输入该进程所请求的资源数request[j]:\n");for(j=0;j<no2;j++)scanf("%d",&request[j]);for(j=0;j<no2;j++)if(request[j]>need[i][j]) p=1;//判断请求是否超过该进程所需要的资源数if(p)printf("请求资源超过该进程资源需求量,请求失败!\n");else{for(j=0;j<no2;j++)if(request[j]>available[j]) q=1;//判断请求是否超过可用资源数if(q)printf("没有做够的资源分配,请求失败!\n");else //请求满足条件{for(j=0;j<no2;j++){available1[j]=available[j];allocation1[i][j]=allocation[i][j];need1[i][j]=need[i][j];//保存原已分配的资源数,仍需要的资源数和可用的资源数available[j]=available[j]-request[j];allocation[i][j]+=request[j];need[i][j]=need[i][j]-request[j];//系统尝试把资源分配给请求的进程}print();check(); //检测分配后的安全性if(r==0) //如果分配后系统不安全{for(j=0;j<no2;j++){available[j]=available1[j];allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];//还原已分配的资源数,仍需要的资源数和可用的资源数}printf("返回分配前资源数\n");print();}}}printf("\n你还要继续分配吗?Y or N ?\n");//判断是否继续进行资源分配c=getche();}while(c=='y'||c=='Y');}}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;do{for(i=0;i<no1;i++){if(finish[i]==false){f=1;for(j=0;j<no2;j++)if(need[i][j]>work[j])f=0;if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程{finish[i]=true;a[v++]=i; //记录安全序列号for(j=0;j<no2;j++)work[j]+=allocation[i][j]; //释放该进程已分配的资源}}}k--; //每完成一个进程分配,未完成的进程数就减1}while(k>0);f=1;for(i=0;i<no1;i++) //判断是否所有的进程都完成{if(finish[i]==false){f=0;break;}}if(f==0) //若有进程没完成,则为不安全状态{printf("系统处在不安全状态!");r=0;}else{printf("\n系统当前为安全状态,安全序列为:\n");for(i=0;i<no1;i++)printf("p%d ",a[i]); //输出安全序列}}void print() //输出函数{int i,j;printf("\n");printf("*************此时刻资源分配情况*********************\n");printf("进程名/号 | Max | Allocation | Need |\n"); for (i = 0; i < no1; i++){printf(" p%d/%d ",i,i);for (j = 0; j < no2; j++){printf("%d ",max[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",allocation[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",need[i][j]);}printf("\n");}printf("\n");printf("各类资源可利用的资源数为:");for (j = 0; j < no2; j++){printf(" %d",available[j]);}printf("\n");}(程序结束)附录 4程序运行调试结果:1、程序初始化2、检测系统资源分配是否安全结果。
操作系统实验2--银行家算法
操作系统实验2--银行家算法(总9页)--本页仅作为文档封面,使用时请直接删除即可----内页可以根据需求调整合适字体及大小--操作系统课程设计报告课程名称:银行家算法姓名:刘成启学号:149班级:计算机1008班指导老师:袁宁共享资源分配与银行家算法一、实验目的[问题描述]本题主要内容是模拟实现资源分配。
银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升。
二、实验内容[基本要求]具体用银行家算法实现资源分配。
要求如下:(1) 设计一个3个并发进程共享3类不同资源的系统,进程可动态地申请资源和释放资源,系统按各进程的申请动态地分配资源。
(2) 设计用银行家算法,实现资源分配,应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况。
(3) 确定一组各进程依次申请资源数的序列,输出运行结果。
[方案设计及开发过程]1银行家分配算法,顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。
在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其他进程使用资源。
如果资源分配不得到就会发生进程循环等待资源,每个进程都无法继续执行下去的死锁现象。
把个进程需要和已占有资源的情况记录在进程控制中,假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。
当进程在处于等待态时,表示系统不能满足该进程当前的资源申请。
“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。
显然,每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.2.算法描述银行家算法:设进程I提出请求Request[N],则银行家算法按如下规则进行判断。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
void change();当请求资源满足要求时,进行分配,系统资源发生改变;
int check();安全性算法,检查是否存在安全序列;
void outputsafe();输出安全序列的资源分配表。
4、检查代码,将编出的代码编译、链接,验证其正确性。
if (n==0)
printf("%6d%3d%3d\n",available[0],available[1],available[2]);
else
printf("\n");
}
line();
}
void change()//当Request[i,j]<=Available[j]时,系统把资源分配给进程P[i],Available[j]和Need[i,j]发生改变
line();
printf("资源情况Work Need Allocation Work+Allocation Finish\n");
printf("进程A B C A B C A B C A B C\n");
line();
for(n=0;n<5;n++)
printf("P%d%9d%3d%3d%5d%3d%3d%5d%3d%3d%6d%3d%3d%12s\n",safe[n],works[safe[n]][0],works[safe[n]][1],works[safe[n]][2],need[safe[n]][0],need[safe[n]][1],need[safe[n]][2],allocation[safe[n]][0],allocation[safe[n]][1],allocation[safe[n]][2],works[safe[n]][0]+allocation[safe[n]][0],works[safe[n]][1]+allocation[safe[n]][1],works[safe[n]][2]+allocation[safe[n]][2],finish[n]);
line();
}
void end()//表示银行家算法结束
{
line();
printf("银行家算法结束,谢谢使用\n");
line();
}
void input()//输入银行家算法起始各项数据
{
for (n=0;n<5;n++)
{
printf("请输入进程P%d的相关信息:\n",n);
printf("Max:");
int need[5][3];
int available[3];
int request[5][3];
char *finish[5];
int safe[5];
int n,i,m;
int k=0;
int j=0;
int work[3];
int works[5][3];
void line()//美化程序,使程序运行时更加明朗美观
{
printf("------------------------------------------------------------------\n");
}
void start()//表示银行家算法开始
{
line();
printf("银行家算法开始\n");
printf(" ——Designed by Zhang Hong\n");
{
for (m=0;m<3;m++)
{
available[m]-=request[i][m];
allocation[i][m]+=request[i][m];
need[i][m]-=request[i][m];
}
}
void outputsafe()//输出安全序列的资源分配表
{
printf("该安全序列的资源分配图如下:\n");
for (m=0;m<3;m++)
scanf("%d",&max[n][m]);
printf("Allocation:");
for (m=0;m<3;m++)
scanf("%d",&allocation[n][m]);
for (m=0;m<3;m++)
need[n][m]=max[n][m]-allocation[n][m];
}
printf("请输入系统可利用资源数Available:");
for (m=0;m<3;m++)
scanf("%d",&available[m]);
}
void output()//输ห้องสมุดไป่ตู้系统现有资源情况
{
line();
printf("资源情况Max Allocation Need Available\n");
三、实验要求
1、需写出设计说明;
2、设计实现代码及说明
3、运行结果;
四、主要实验步骤
1、分析银行家算法结构;
2、画出银行家算法的流程图,即设计说明;
3、根据画出的流程图使用C语言编写相应的代码(代码过长,放到最后);
程序主要由main函数和以下几个函数组成:
void input();用户输入银行家算法的初始数据;
printf("进程A B C A B C A B C A B C\n");
line();
for(n=0;n<5;n++)
{
printf("P%d%9d%3d%3d%5d%3d%3d%6d%3d%3d",n,max[n][0],max[n][1],max[n][2],allocation[n][0],allocation[n][1],allocation[n][2],need[n][0],need[n][1],need[n][2]);
七、参考资料
《计算机操作系统》
《C程序设计》
《C语言程序设计_现代方法》
八、实验代码
#include <stdio.h> //本实验中使用到的库函数
#include <stdlib.h>
#include <string.h>
int max[5][3]; //开始定义银行家算法中需要用到的数据
int allocation[5][3];
五、实验数据及处理结果
六、实验体会或对改进实验的建议
体会:编写银行家算法需要较好分析能力,C语言也要掌握的很好,而且需要细心和极大地耐心。我的程序在最开始编出来的第一份代码编译时大大小小一堆错误,有些是一个小错误导致了下面全错,这些小错误在一百多行里找起来非常费劲。然后小错误全部找出来以后,再编译,错误没有了,但是得到的结果却是错误的,这样又要开始一行一行分析,看是哪里出了问题。到最后得到了想要的结果以后,程序还需要修饰,至少要输出要简洁明朗,要让别人一运行这个程序就知道自己在什么时候该输入什么数据,数据是什么作用,而不是只有自己知道输进去的是什么东西。
南昌大学实验报告
---(3)编程实现银行家安全算法
学生姓名:张虹学号:6100409033专业班级:电Ⅲ091班
实验类型:□验证■综合□设计□创新实验日期:实验成绩:
一、实验目的
通过实验加强对银行家安全算法的理解和掌握。
二、实验内容
熟悉避免死锁发生的方法,死锁与安全序列的关系,编程实现银行家算法,要求输出进程的安全序列。