(完整word版)操作系统银行家算法实验报告-(1)
《操作系统》课程实验报告银行家算法
《操作系统》课程实验报告实验名称:银行家算法姓名:学号:地点:指导老师:专业班级:一、实验目的: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];}}四、实验过程分析本次实验的主要任务是实现银行家算法,通过输入当前某一时刻系统的资源数目和所有进程相关的资源信息,然后通过算法的实现判断当前系统是否处于不安全状态,如果是处于安全状态那么找到所有的安全序列。
操作系统实验报告-银行家算法5页word
南昌大学实验报告---(3)编程实现银行家安全算法学生姓名:张虹学号:6100409033 专业班级:电Ⅲ091班实验类型:□验证■综合□设计□创新实验日期:实验成绩:一、实验目的通过实验加强对银行家安全算法的理解和掌握。
二、实验内容熟悉避免死锁发生的方法,死锁与安全序列的关系,编程实现银行家算法,要求输出进程的安全序列。
三、实验要求1、需写出设计说明;2、设计实现代码及说明3、运行结果;四、主要实验步骤1、分析银行家算法结构;2、画出银行家算法的流程图,即设计说明;3、根据画出的流程图使用C语言编写相应的代码(代码过长,放到最后);程序主要由main函数和以下几个函数组成:void input();用户输入银行家算法的初始数据;void output();输出当前系统资源分配情况;void change();当请求资源满足要求时,进行分配,系统资源发生改变;int check();安全性算法,检查是否存在安全序列;void outputsafe();输出安全序列的资源分配表。
4、检查代码,将编出的代码编译、链接,验证其正确性。
五、实验数据及处理结果六、实验体会或对改进实验的建议体会:编写银行家算法需要较好分析能力,C语言也要掌握的很好,而且需要细心和极大地耐心。
我的程序在最开始编出来的第一份代码编译时大大小小一堆错误,有些是一个小错误导致了下面全错,这些小错误在一百多行里找起来非常费劲。
然后小错误全部找出来以后,再编译,错误没有了,但是得到的结果却是错误的,这样又要开始一行一行分析,看是哪里出了问题。
到最后得到了想要的结果以后,程序还需要修饰,至少要输出要简洁明朗,要让别人一运行这个程序就知道自己在什么时候该输入什么数据,数据是什么作用,而不是只有自己知道输进去的是什么东西。
七、参考资料《计算机操作系统》《C程序设计》《C语言程序设计_现代方法》八、实验代码#include <stdio.h> //本实验中使用到的库函数#include <stdlib.h>#include <string.h>int max[5][3]; //开始定义银行家算法中需要用到的数据int allocation[5][3];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");line();void end() //表示银行家算法结束line();printf(" 银行家算法结束,谢谢使用\n");line();void input() //输入银行家算法起始各项数据for (n=0;n<5;n++)printf("请输入进程P%d的相关信息:\n",n);printf("Max:");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");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]);if (n==0)printf("%6d%3d%3d\n",available[0],available[1],available[2]);elseprintf("\n");line();void change() //当Request[i,j]<=Available[j]时,系统把资源分配给进程P[i],Available[j]和Need[i,j]发生改变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");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();int check() //安全性算法printf("开始执行安全性算法……\n");for (m=0;m<3;m++) //数组work和finish初始化work[m]=available[m];for (n=0;n<5;n++)finish[n]="false";safe[n]=0;k=0;for (m=0;m<5;m++)for (n=0;n<5;n++)if(strcmp(finish[n],"false")==0 && need[n][0]<=work[0] && need[n][1]<=work[1] && need[n][2]<=work[2]) //查找可以分配资源但尚未分配到资源的进程safe[k]=n; //以数组safe[k]记下各个进程得到分配的资源的顺序works[safe[k]][0]=work[0];works[safe[k]][1]=work[1];works[safe[k]][2]=work[2];work[0]+=allocation[n][0]; //进程执行后释放出分配给它的资源work[1]+=allocation[n][1];work[2]+=allocation[n][2];finish[n]="ture"; //finish[n]变为1以示该进程完成本次分k++;for (m=0;m<5;m++) //判断是否所有进程分配资源完成if (strcmp(finish[m],"false")==0)printf("找不到安全序列,系统处于不安全状态。
民大-银行家算法-操作系统实验报告
银行家算法实验报告一、实验题目为了了解系统的资源分配情况,假定系统的任何一种资源在任一种资源在任意时刻只能被一个进程使用。
任何进程已经占用的资源只能由进程自己释放,而不能任由其他进程抢占。
当进程申请的资源不能满足时,必须等待。
因此,只要资源分配算法能保证进程的资源请求,且不出现循环等待,则系统不会出现死锁。
而银行家算法是避免死锁的一种重要方法。
通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法二、实验要求要求编写系统进行资源调度的程序,模拟进程的资源分配算法,了解死锁的产生和避免的办法。
一个是随机动态地进行资源分配的模拟程序,即只要系统当前剩余资源满足进程的当前要求,就立即将资源分配给进程,以观察死锁产生情况;一个是采用银行家算法,有效地避免死锁的产生。
要求用银行家算法和随机算法实现资源分配。
1.设计3-4个并发进程,共享系统的10个同类不可抢占的资源。
各进程动态进行资源的申请和释放。
2.用银行家算法和随机算法分别设计一个资源分配程序,运行这两个程序,观察系统运行情况,并对系统运行的每一步情况进行显示。
二、总的设计思想及语言环境、工具等1.算法设计思路银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。
这时系统将该进程从进程集合中将其清除。
此时系统中的资源就更多了。
反复执行上面的步骤,最后检查进程的集合为空时就表明本次申请可行,系统处于安全状态,可以实施本次分配,否则,只要进程集合非空,系统便处于不安全状态,本次不能分配给他,请进程等待。
2.语言环境、工具计算机基本配置要求:操作系统:WIN 98/2000/XP/2003 等Windows平台内存:256MB及以上主存64KB(Memory)(以KB为单位分配)开发语言:Visual C++ 6.0四、数据结构与模块说明(功能与框图)五、源程序(指导老师验收通过)#include<string.h>#include<iostream.h>#define FALSE 0#define TRUE 1#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20int M ;int N ;int ALL_RESOURCE[W];int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void inputdata(); //数据输入void showdata(); //数据显示void changdata(int k);//进程请求资源数据改变void restoredata(int k); //数据恢复int chksec(int s); //系统安全性的检测int chkmax(int s); //检测最大需求void bank(); //检测分配的资源是否合理void main(){ int i,j;inputdata();for(i=0;i<M;i++){ j=chksec(i);if (j==0) break;}if (i>=M)cout<<"错误提示:经安全性检查发现,系统的初始状态不安全\n"<<endl;else{ cout<<"提示:经安全性检查发现,系统的初始状态安全!"<<endl;bank();}}void inputdata(){ int i=0,j=0,p;cout<<"请输入总进程数:"<<endl;do{cin>>M;if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数,请重新输入:"<<endl;}while (M>W);cout<<endl;cout<<"请输入资源的种类数:"<<endl;do {cin>>N;if (N>R)cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数,请重新输入:"<<endl; }while (N>R);cout<<endl;cout<<"请依次输入各类资源的总数量,即设置向量all_resource:"<<endl;for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];cout<<endl;cout<<"请依次输入各进程所需要的最大资源数量,即设置矩阵max:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do { cin>>MAX[i][j];if (MAX[i][j]>ALL_RESOURCE[j])cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);}}cout<<endl;cout<<"请依次输入各进程已经占据的各类资源数量,即设置矩阵allocation:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do{ cin>>ALLOCATION[i][j];if (ALLOCATION[i][j]>MAX[i][j])cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;}while (ALLOCATION[i][j]>MAX[i][j]);}}cout<<endl;for (i=0;i<M;i++)for(j=0;j<N;j++)NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];for (j=0;j<N;j++){ p=ALL_RESOURCE[j];for (i=0;i<M;i++){ p=p-ALLOCATION[i][j];AVAILABLE[j]=p;if(AVAILABLE[j]<0)AVAILABLE[j]=0;}}}void showdata(){ int i,j;cout<<"各种资源的总数量,即向量all_resource为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];cout<<endl<<endl;cout<<"当前系统中各类资源的可用数量,即向量available为:"<<endl; cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<AVAILABLE[j];cout<<endl<<endl;cout<<"各进程还需要的资源数量,即矩阵need为:"<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<NEED[i][j]<<" ";cout<<endl;}cout<<endl;cout<<"各进程已经得到的资源量,即矩阵allocation为: "<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<" ";cout<<endl;} cout<<endl;}void changdata(int k){ int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}void restoredata(int k){int j;for (j=0;j<N;j++){ AVAILABLE[j]=AVAILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}int chksec(int s){int WORK,FINISH[W];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){ WORK=AVAILABLE[j];i=s;do{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++;}}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){ return 1;}} return 0;}int chkmax(int s){ int j,flag=0;for(j=0;j<N;j++){if (MAX[s][j]==ALLOCATION[s][j]){ flag=1;AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];MAX[s][j]=0;}} return flag;}c{int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){i=-1;while(i<0||i>=M){ cout<<"请输入需申请资源的进程号(从P0到P"<<M-1<<",否则重新输入!):"; cout<<"p";cin>>i;if(i<0||i>=M)cout<<"输入的进程号不存在,重新输入!"<<endl;}cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;for (j=0;j<N;j++){ cout<<" 资源"<<j<<": ";cin>>Request[j];if(Request[j]>NEED[i][j]){ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}else{ if(Request[j]>AVAILABLE[j]){ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}}}if(flag=='Y'||flag=='y'){ changdata(i);if(chksec(i)){ cout<<endl;cout<<"该分配会导致系统不安全本次资源申请不成功,不予分配"<<endl;cout<<endl;restoredata(i);}else{ cout<<endl;cout<<"经安全性检查,系统安全,本次分配成功,且资源分配状况如下所示:"<<endl;cout<<endl;showdata();if(chkmax(i)){cout<<"在资源分配成功之后,由于该进程所需的某些资源的最大需求量已经满足,"<<endl;cout<<"因此在进程结束后系统将回收这些资源!"<<endl;cout<<"在资源收回之后,各进程的资源需求和分配情况如下所示:"<<endl;showdata();}}}cout<<endl;cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";cin>>flag; }}六、运行结果分析1.输入进程数、资源种类数、各类资源总数量、各进程所需要的最大资源数量、各进程所已经占据的各类资源数量2.经安全性检验,系统状态安全,进程P0申请资源3.经安全性检验,系统状态安全,进程P0获得所申请资源4.进程P3申请资源5.经安全性检验,系统状态安全,进程P3获得所申请资源6.进程P1申请资源7.经安全性检验,系统状态安全,进程P1获得所申请资源8.进程P2申请资源9.经安全性检验,系统状态安全,进程P2获得所申请资源5.进程P1申请资源6.经安全性检验,系统状态安全,进程P1获得所申请资源七、总结这次实验中我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
银行家算法操作系统实验报告
竭诚为您提供优质文档/双击可除银行家算法操作系统实验报告篇一:计算机操作系统银行家算法实验报告计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计: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)。
(完整word版)操作系统课程设计银行家算法
操作系统课程设计报告题目:银行家算法院(系):专业:班级:学生:学号:指导教师:2010年12月操作系统课程设计报告题目:银行家算法院(系):专业:班级:学生:学号:指导教师:2010年12月银行家算法摘要本次的课程设计内容是银行家算法,在操作系统当中,由于竞争非剥夺性资源和进程推进的不当,对系统的安全造成威胁,所以,银行家算法就是为了避免对系统产生死锁而存在的.银行家算法包括对请求资源的试分配和对安全性的考量,当系统的安全性不能够满足的时候,则对系统进行保护。
在编写银行家算法的时候需要定义Need(需求矩阵),Allocation(分配矩阵),Max(最大需求矩阵)以及Available(可利用资源量)。
在实现一系列的功能的时候使用的数组的结构,便于进行矩阵的加减运算,可以提高程序的运行效率.通过编写可以基本上实现银行家算法所要达到的基本目的,在输入正确的情况下能够输出正确的安全序列,在不安全的情况下可以做出提醒,并且恢复原有输入数据。
关键字:银行家算法最大需求矩阵分配矩阵需求矩阵可利用资源量目录摘要 (i)1 绪论 (1)2需求分析.................................................................。
(2)2.1 问题描述.........................................................。
. (2)2.2 产生条件..........................................................。
(2)2.3 运行环境.........................................................。
. (2)2.4 程序功能.........................................................。
(完整word版)《银行家算法的模拟实现》—实验报告
《银行家算法的模拟实现》 --实验报告题目: 银行家算法的模拟实现专业:班级:组员:指导老师:一、实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。
本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序,了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生,以加深对课堂上所讲授的知识的理解。
二、实验内容模拟实现银行家算法实现死锁避免。
要求:初始数据(如系统在T0时刻的资源分配情况、每一种资源的总数量)从文本文件读入,文件中给出最大需求矩阵Max、分配矩阵Allocation,在程序中求得需求矩阵Need和可利用资源向量Available。
三、实验分析过程1、整个银行家算法的思路。
先对用户提出的请求进行合法性检查,再进行预分配,利用安全性检查算法进行安全性检查。
1)进程一开始向系统提出最大需求量.2)进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.3)若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待2、算法用到的主要数据结构和C语言说明。
(1)、可利用资源向量INT A V AILABLE[M] M为资源的类型。
(2)、最大需求矩阵INT MAX[N][M] N为进程的数量。
(3)、已分配矩阵INT ALLOCA TION[N][M](4)、还需求矩阵INT NEED[N][N](5)、申请各类资源数量int Request[x]; //(6)、工作向量int Work[x];(7)、int Finish[y]; //表示系统是否有足够的资源分配给进程,0为否,非0为是3、银行家算法(主程序)(1)、系统初始化。
输入进程数量,资源种类,各进程已分配、还需求各资源数量,各资源可用数量等(2)、输入用户的请求三元组(I,J,K),为进程I申请K个J类资源。
(3)、检查用户的请求是否小于还需求的数量,条件是K<=NEED[I,J]。
操作系统_银行家算法报告
实验四:银行家算法的实现一.实验目的(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,则表示系统处于安全状态;否则,系统处于不安全状态。
(完整word版)操作系统银行家算法实验报告 (1)
银行家算法实验报告【实验目的】(1)根据设计题目的要求,充分地分析和理解题目,叙述系统的要求,明确程序要求实现的功能以及限制条件。
(2)明白自己需要用代码实现的功能,清楚编写每部分代码的目的,做到有的放矢,有条理不遗漏的用代码实现银行家算法。
【实验要求】(1)了解和理解死锁;(2)理解利用银行家算法避免死锁的原理;(3)会使用某种编程语言。
【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。
二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。
系统按下述步骤进行安全检查:(1)如果Request i≤Need i则继续以下检查,否则显示需求申请超出最大需求值的错误。
(2)如果Request i≤Available则继续以下检查,否则显示系统无足够资源,Pi阻塞等待。
(3)系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:Available[j]∶=Available[j]-Request i[j];Allocation[i,j]∶=Allocation[i,j]+Request i[j];Need[i,j]∶=Need[i,j]-Requesti[j];(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。
三、安全性算法(1)设置两个向量:①工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程,使之运行完成。
开始时先做Finish[i]∶=false; 当有足够资源分配给进程时,再令Finish [i]∶=true。
操作系统银行家算法实验报告
操作系统银行家算法实验报告操作系统银行家算法实验报告引言:操作系统是计算机科学中的一个重要领域,它负责管理计算机的硬件和软件资源,以提供良好的用户体验。
在操作系统中,银行家算法是一种重要的资源分配和调度算法,它可以确保系统中的进程安全地访问资源,避免死锁的发生。
本实验旨在通过实践运用银行家算法,深入理解其原理和应用。
实验目的: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分配资源。
操作系统 银行家算法实验报告
《计算机操作系统》课程设计题目银行家算法分析学院计算机与软件学院专业网络工程班级2012级1班学号20121346001姓名方锡指导教师岳键起止时间2014.5.20~2014.6.3一、实验报告设计背景1.1. 产生死锁的原因:我们知道,多个进程在运行的时候因为争夺资源会产生死锁的情况,当进程出浴照这种情况的时候,若无外力作用,他们将处于无法再向前推进的状态,而根据课本知识可知,预知,可以通过预防死锁或者避免死锁的方法来解决这一问题,通过使产生死锁的四个必要条件的第2、3、4个条件之一不能成立来避免死锁的发生。
1.2. 产生的死锁的必要条件:(1)互斥条件;(2)请求和保持条件;(3)不可剥夺条件;(4)环路等待。
1.3.银行家算法介绍通过实践可以看出,预防死锁虽然可以预防死锁的发生,但是牺牲了进程的执行效率,同时,在预防死锁的过程中需要考虑到对用户的资料的安全性,所以就需要考虑到利用一些特别的算法来避免死锁,其中最具代表性的算法就是Dijkstra的银行家算法,这是由于该算法能用于银行系统现金贷款的发放而得名的。
它通过自己特有的算法,在每次分配进程系统资源时候会先试探性的假设分配资源给进程,然后通过安全性算法检测此次分配是否会导致系统进入不安全状态,如果安全则直接进行资源分配,如果不安全则暂不分配。
所以本次试验报告就是要深入了解银行家算法的原理和运行过程。
二.银行家算法的原理2.1 银行家算法的思路算法会先对用户提出的请求进行合法性检查,即检查请求的是不大于需要的,是否不大于可利用的。
若请求合法,则进行试分配。
最后对试分配后的状态调用安全性检查算法进行安全性检查。
若安全,则分配,否则,不分配,恢复原来状态,拒绝申请。
2.2 银行家算法中的数据结构可利用资源向量int Available[j] j为资源的种类。
最大需求矩阵int Max[i][j] i为进程的数量。
分配矩阵int Allocation[i][j]需求矩阵int need[i][j]= Max[i][j]- Allocation[i][j]申请各类资源数量int Request i[j] i进程申请j资源的数量工作向量int Work[x] int Finish[y]2.3银行家算法设Request i是进程P i的请求向量,如果Request i[j]=K,表示进程P i需要k个Rj类型的资源,当P i发出资源请求后,系统按照下述步骤进行检查:(1)如果Request i[j]≤Need[j],便转向步骤(2);否则认为出错,因为它所需要的资源数已经超过它所宣布的最大值。
银行家算法(操作系统实验报告)
privateButtonbutton1;
privateTextlistText;//输出文本框
privateCompositecomposite4;
privateLabellabel_3;
privateTextkindNumbers;//资源数量输入框
privateButtonbutton2;
composite2.setBackgroundMode(SWT.INHERIT_FORCE);
composite2.setForeground(SWTResourceManager.getColor(SWT.COLOR_BLUE));
composite2.setBackground(SWTResourceManager.getColor(0, 255, 0));
composite4=newComposite(composite3, SWT.BORDER);
composite4.setBackground(SWTResourceManager.getColor(SWT.COLOR_DARK_GREEN));
composite4.setData("name","composite4");
importorg.eclipse.swt.custom.StackLayout;
importorg.eclipse.swt.events.SelectionAdapter;
importorg.eclipse.swt.events.SelectionEvent;
importorg.eclipse.swt.widgets.Button;
shell.setBackground(SWTResourceManager.getColor(SWT.COLOR_WIDGET_BACKGROUND));
银行家算法实验报告电子版
else
{
prin tf("error");
j=1;
}
}
if(j==0) //满足调用银行家算法
yhjsf(y,a,x);
}
运行结果:
7120¥02£4-R源P漏圧源3'®;M澜佛最督駆賢曾甌耶鬣需分需分需分需为需分所伊已所已所己誓-—I.■/-■1■--.1■-—I.---1.■-7---11■--11■进齐逵1£进壬l£^^4yIl•11工、一工・=1-、-A、1!—*•AT^T^T^T^T^iB011223344fMUSIA-AAJAJAJAiAJAJAx-丿nJ"JM丿丿1JM丿a丿丿m丿
另帛另另DRPRDR另另另
八R^<F<R^<^<R<[^XP
諫卑王"聲电璋源 戏分配资源 需要貸源
0753RIB
1322209
Z爭村23OZ
3222211
|4433Q02
帆入每环贪源可用教量辺5
Lnuut reauest-[N];
for(i=0;i<M;i++) //初始化max,allocation,need
{
x[i]. num=i;
x[i].fi nish=0;
printf("分别输入第%c个进程所需最大资源",i);
for(j=0;j<N;j++)
{
scan f("%d", &x[i].max[j]);
福州大学数学与计算机科学学院
银行家算法实践报告.doc
一、实验概述1. 实验名称通过银行家算法2. 实验目的用银行家算法判断系统是否处于安全序列,它的安全序列怎样。
3. 实验内容实现银行家算法二、实验环境xx大学机房,Visual C++6.0三、实验过程1. 设计思路我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。
2.所需变量1.主要的常量变量n:系统中进程的总数m:资源类总数Available: ARRAY[1..m] of integer;Max: ARRAY[1..n,1..m] of integer;Allocation: ARRAY[1..n,1..m] of integer;Need: ARRAY[1..n,1..m] of integer;Request: ARRAY[1..n,1..m] of integer;符号说明:Available 可用剩余资源Max 最大需求Allocation 已分配资源Need 需求资源Request 请求资源3.主要数据结构、实现代码及其说明当进程pi提出资源申请时,系统执行下列步骤:(“=”为赋值符号,“==”为等号)step(1)若Request<=Need, goto step(2);否则错误返回step(2)若Request<=Available, goto step(3);否则进程等待step(3)假设系统分配了资源,则有:Available=Available-Request;Allocation=Allocation+Request;Need=Need-Request若系统新状态是安全的,则分配完成若系统新状态是不安全的,则恢复原状态,进程等待为进行安全性检查,定义数据结构:Work:ARRAY[1..m] of integer;Finish:ARRAY[1..n] of Boolean;安全性检查的步骤:step (1):Work=Available;Finish=false;step (2) 寻找满足条件的i:a.Finish==false;b.Need<=Work;如果不存在,goto step(4)step(3)Work=Work+Allocation;Finish=true;goto step(2)step (4) 若对所有i,Finish=true,则系统处于安全状态,否则处于不安全状态/* 银行家算法,操作系统概念(OS concepts Six Edition)reedit by Johnny hagen,SCAU,run at vc6.0*/5. 源程序并附上注释#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("\n请输入系统资源的种类数:");scanf("%d",&colum);printf("请输入现时内存中的进程数:");scanf("%d",&row);printf("请输入已分配资源矩阵:\n");for(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");for(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;for(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++;}elsepath2=(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");{printf("p%d ",pathhead->value);}while(pathhead=pathhead->next);printf("\n");return 0;}6. 程序运行时的初值和运行结果四、实验体会个进程同时运行时,系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列,使得系统能快速且安全地运行进程,不至发生死锁。
操作系统银行家算法实验报告
实验报告四实验名称:一、编程实现银行家算法二、测试算法日期:2015-11-24 班级:13级计科学号:姓名:一、实验目的银行家算法是操作系统中避免死锁的典型算法,本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。
二、实验内容用java语言编写一个简单的银行家算法模拟程序,用银行家算法实现资源分配。
程序能模拟多个进程共享多种资源的情形。
进程可以动态地申请资源,系统按照各个进程的申请动态地分配资源。
要求程序具有显示和打印各个进程的某一时刻的资源分配和安全序列;显示和打印各个进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。
三、项目要求与分析1.要找出某一状态下所有的安全序列,程序该如何实现?要找出这个状态下的所有的安全序列,前提是要使这个系统先处于安全状态,而系统的状态可以通过以下来描述:(1)进程剩余申请数=最大申请数-占有数;(2)可分配资源数=总数-占有数之和;2.银行家算法的局限性有哪些?银行家算法是一个最具有代表性的避免死锁的算法。
银行家算法把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求资源相当于用户向银行家贷款。
当进程执行继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求数。
若超过则拒绝分配资源,若没有超过则再检测系统现存的资源数能否满足该进程尚需的最大资源数,若能满足则按当前的申请量分配资源,否则也要推迟分配。
但任何一种算法都存在其缺点,对各种进程的资源分配要求严格,经常使其处于不安全状态,银行家算法的主要局限是过于谨慎和检查各申请者对各类资源的最大需求量开销较大。
四、具体实现1.资源类代码:// 资源类假设一共三类资源;class Sources {private int A;private int B;private int C;public Sources(int a, int b, int c) {super();this.B = b;this.A = a;this.C = c;}public Sources(Sources sources) {super();this.B = sources.getB();this.A = sources.getA();this.C = sources.getC();}public int getB() {return B;}public void setB(int B) {this.B = B;}public int getA() {return A;}public void setA(int A) {this.A = A;}public int getC() {return C;}public void setC(int C) {this.C = C;}2.进程类代码://进程类,包进程使用最大内存,当前已分配内存,和需要分配内存class Processor {private String name;private Sources maxSources;private Sources allSources;private Sources needSources;public String getName() {return name;}public void setName(String name) { = name;}public Sources getMaxSources() {return maxSources;}public void setMaxSources(Sources maxSources) {this.maxSources = maxSources;}public Sources getNeedSources() {return needSources;}public void setNeedSources(Sources needSources) {this.needSources = needSources;}public Sources getAllSources() {return allSources;}public void setAllSources(Sources allSources) {this.allSources = allSources;}3.相关显示测试代码// 显示当前系统和各个进程的资源使用情况public void showdata(Processor[] processors) {// 显示当前可用资源System.out.print("当前系统可分配资源为:");showSources(allSources);System.out.println("-----------------进程状态-------------"); System.out.println("进程号 Max Allocation Need ");System.out.println(" A B C A B C A B C");for (int i = 0; i < processors.length; i++) {System.out.print(processors[i].getName() + " "+ processors[i].getMaxSources().getA() + " "+ processors[i].getMaxSources().getB() + " "+ processors[i].getMaxSources().getC() + " "); System.out.print(processors[i].getAllSources().getA() + " "+ processors[i].getAllSources().getB() + " "+ processors[i].getAllSources().getC() + " "); System.out.println(processors[i].getNeedSources().getA()+ " "+ processors[i].getNeedSources().getB() + " "+ processors[i].getNeedSources().getC() + " ");}System.out.println("-----------------------------------");}4.运行结果:五、所遇问题与解决方法这个银行家算法只有申请资源的相应操作,没有其他的添加资源,删除资源等的操作,但由于水平有限,没来得及解决。
实验三银行家算法实验报告
实验三银行家算法实验报告一、实验目的银行家算法是一种用于避免死锁的算法,本次实验旨在通过编程实现银行家算法,并通过模拟银行家算法的运行过程来加深对该算法的理解。
二、实验过程及结果1. 系统设计为了模拟银行家算法的运行过程,需要设计一个包含多个进程和资源的系统。
每个进程都有一定的最大需求资源数和已分配资源数。
系统中还有一定数量的可用资源,进程可以请求资源和释放资源。
2. 算法实现在程序中实现银行家算法需要以下几个关键的函数:(1)银行家算法的主函数:实现进程的请求资源和释放资源操作,并在此过程中判断是否产生死锁;(2)安全检查函数:用于判断系统状态是否安全,即是否存在一个安全序列,如果存在则表示系统处于安全状态,否则表示系统处于不安全状态;(3)资源请求函数:用于进程请求资源的操作,根据银行家算法的要求进行判断;(4)资源释放函数:用于进程释放资源的操作。
3. 算法运行通过对编写的程序进行多次运行测试,模拟不同进程对资源的请求和释放,观察系统是否能够始终处于安全状态。
在每次运行中,记录并输出系统的安全序列和进程的状态等信息。
4. 实验结果分析通过实验运行结果的分析,可以得出以下结论:(1)银行家算法能够有效地避免死锁的发生;(2)系统中资源的分配和释放过程需要合理,否则可能导致系统陷入死锁;(3)资源的分配策略对系统的安全状态有重要影响。
三、实验总结通过本次实验,深入了解了银行家算法的原理和实现过程,并通过编程实践加深了对该算法的理解。
银行家算法是一种重要的死锁避免算法,能够保证系统处于安全状态下运行,并且能够合理地分配系统资源,避免系统陷入死锁。
四、参考文献[1] 《操作系统概念》,Abraham Silberschatz,Peter B. Galvin,Greg Gagne,电子工业出版社,2014年五、附录(示例代码省略)以上是本次实验的实验报告,通过实验我们深入了解了银行家算法,了解了它在操作系统中的应用和重要性。
银行家算法实习报告
青岛农业大学学生实习报告实习名称:软件系统课程设计实习时间: -- 年第 2学期专业班级:姓名(学号):同组成员:***师:***年 3 月 22 日(一)编译原理部分一、实习题目将词法分析器设计成单独旳程序或供语法分析器调用旳子程序,功能涉及:规定可以辨认数字、标记符、核心字、运算符等。
二、设计思路及算法描述词法分析程序旳功能:输入源程序,输出单词符号,如图所示:源程序单词符号解决过程:在扫描源程序字符串时,一旦辨认出核心字、分隔符、标记符、无符号常数中之一,即以单词形式(各类单词均采用相似旳构造,即二元式编码形式)输出。
每次调用词法分析程序,它均能自动继续扫描下去,形成下一种单词,直至整个源程序所有扫描完毕,并形成相应旳单词串形式旳源程序。
本程序规定:(1)核心字"begin","end","if","then","else","while","write","read","do", "call","const","char","until","procedure","repeat"(2)运算符:"+","-","*","/","="(3)界符:"{","}","[","]",";",",",".","(",")",":"(4)其他标记如字符串,表达以字母开头旳标记符。
银行家算法实验报告
xx大学操作系统实验报告姓名:学号:班级:实验日期:实验名称:预防进程死锁的银行家算法实验三预防进程死锁的银行家算法1.实验目的:通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。
理解银行家算法的运行原理,进一步掌握预防进程死锁的策略及对系统性能的评价方法。
:2. 需求分析(1) 输入的形式和输入值的范围;输入:首先输入系统可供资源种类的数量n 范围:0<n<=100资源1的名称:资源的数量:资源2的名称:资源的数量:。
输入作业的数量m 范围:0<m<=100输入个进程的最大需求量<m*n矩阵>[Max]:输入个进程已经申请的资源量<m*n矩阵>[Allocation]:(2) 输出的形式系统目前可用的资源[Avaliable]:(显示系统是否安全)分配序列:(3)程序所能达到的功能通过手动输入资源种类数量和各进程的最大需求量、已经申请的资源量,运用银行家算法检测系统是否安全,若安全则给出安全序列,并且当用户继续输入某进程的资源请求时,能够继续判断系统的安全性。
(4) 测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果。
正确输入输入参数(已申请资源数)错误3、概要设计所有抽象数据类型的定义:int Max[100][100]; //各进程所需各类资源的最大需求int Avaliable[100]; //系统可用资源char name[100] };//资源的名称int Allocation[100][100]; //系统已分配资源int Need[100][100] }; //还需要资源int Request[100]; //请求资源向量int temp[100]; //存放安全序列int Work[100];//存放系统可提供资源int M=100; //作业的最大数为100int N=100; //资源的最大数为100主程序的流程:* 变量初始化;* 接收用户输入n,m,Max ij,Allocation ij;* 按照银行家算法判断当前状态安全与否,安全给出安全序列,不安全给出提示;* 如果安全,提示用户输入下一时刻进程P k的资源请求Request(R1, … ,R m);* 如果不安全或者无新请求则退出。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
银行家算法实验报告【实验目的】(1)根据设计题目的要求,充分地分析和理解题目,叙述系统的要求,明确程序要求实现的功能以及限制条件。
(2)明白自己需要用代码实现的功能,清楚编写每部分代码的目的,做到有的放矢,有条理不遗漏的用代码实现银行家算法。
【实验要求】(1)了解和理解死锁;(2)理解利用银行家算法避免死锁的原理;(3)会使用某种编程语言。
【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。
二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。
系统按下述步骤进行安全检查:(1)如果Request i≤Need i则继续以下检查,否则显示需求申请超出最大需求值的错误。
(2)如果Request i≤Available则继续以下检查,否则显示系统无足够资源,Pi阻塞等待。
(3)系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:Available[j]∶=Available[j]-Request i[j];Allocation[i,j]∶=Allocation[i,j]+Request i[j];Need[i,j]∶=Need[i,j]-Requesti[j];(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。
三、安全性算法(1)设置两个向量:① 工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程,使之运行完成。
开始时先做Finish[i]∶=false; 当有足够资源分配给进程时,再令Finish [i]∶=true。
(2)从进程集合中找到一个能满足下述条件的进程:① Finish[i]=false;② Need[i,j]≤Work[j];若找到,执行步骤(3),否则,执行步骤(4)。
(3)当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:Work[j]∶=Work[i]+Allocation[i,j];Finish[i]∶=true;go to step 2;(4)如果所有进程的Finish[i]=true都满足,则表示系统处于安全状态;否则,系统处于不安全状态。
【实验步骤】参考实验步骤如下:(1)参考图1-1所示流程图编写安全性算法。
(2)银行家算法流程图(3)编写统一的输出格式。
每次提出申请之后输出申请成功与否的结果。
如果成功还需要输出变化前后的各种数据,并且输出安全序列。
(4)参考图1-2所示流程图编写银行家算法。
(5)编写主函数来循环调用银行家算法。
【参考代码】部分参考代码如下:#include <>#include <>#define M 3 //资源的种类数#define N 5 //进程的个数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]); void main(){int i,j;//当前可用每类资源的资源数int iAvailable[M]={3,3,2};//系统中N个进程中的每一个进程对M类资源的最大需求int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//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为否。
\n";cin>>ch;switch(ch){case 'y'://cout<<"调用银行家算法";bSafe=banker(iAllocation,iNeed,iAvailable,cName);if (bSafe) //安全,则输出变化后的数据output(iMax,iAllocation,iNeed,iAvailable,cName);break;case 'n':cout<<"退出。
\n";bExitFlag=false;break;default:cout<<"输入有误,请重新输入:\n";}}}//输出void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]){int i,j;cout<<"\n\t Max \tAllocation\t Need \t Available"<<endl;cout<<"\tA B C\tA B C\tA B C\t A B C"<<endl;for(i=0;i<N;i++){cout<<cName[i]<<"\t";for(j=0;j<M;j++)cout<<iMax[i][j]<<" ";cout<<"\t";for(j=0;j<M;j++)cout<<iAllocation[i][j]<<" ";cout<<"\t";for(j=0;j<M;j++)cout<<iNeed[i][j]<<" ";cout<<"\t";cout<<" ";//Available只需要输出一次if (i==0)for(j=0;j<M;j++)cout<<iAvailable[j]<<" ";cout<<endl;}}//安全性算法,进行安全性检查;安全返回true,并且输出安全序列,不安全返回false,并输出不安全的提示;bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]){int i,j,flag,x=0;char num[5];int Work[M];bool Finish[N]; //定义基本变量for(j=0;j<3;j++)Work[j]=iAvailable[j]; //将iAvailable的值赋给Work for(i=0;i<5;i++) //将Finish全部置为FalseFinish[i]=false;while(true) //执行无限循环,满足条件时跳出{flag=0; //每次循环开始时将记录本次循环中是否有使有满足条件iAllocation的标志置为0,若为0表示不存在,若不为0表示存在for(i=0;i<5;i++) //执行循环,看有没有满足条件的iAllocation{if(Finish[i]==false&&Work[0]>=iNeed[i][0]&&Work[1]>=iNeed[i][1]&&Work[2]>=i Need[i][2]){for(j=0;j<3;j++){Work[j]+= iAllocation[i][j] ; //Work[j]+= Work[j]+iAllocation[i][j]}Finish[i]=true; //将Finish置trueflag++; //标志加1num[x++]=cName[i]; //将该序列名赋给数组num[]}}if(flag==0){cout<<"无安全序列"; //标志为0,证明已无满足条件iAllocation ,退出循环,返回falsereturn false;}if(Finish[0]==true&&Finish[1]==true&&Finish[2]==true&&Finish[3]==true&&Fini sh[4]==true) //若所有Finish置为true,输出安全数列,返回True{cout<<"\n";cout<<"安全序列为:";for(x=0;x<5;x++)cout<<num[x]<<" ";cout<<"\n";return true;}}return true;}//安全返回true,不安全返回falsebool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]) {int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};int t,i,Request[3],check_1[3];char x; //定义变量cout<<"请输入进程名:"; //输入进程名cin>>x;if(x=='a')i=0;if(x=='b')i=1;if(x=='c')i=2;if(x=='d')i=3;if(x=='e')i=4;cout<<"请输入各资源数量:"; //输入变量名for(t=0;t<3;t++)cin>>Request[t];for(t=0;t<3;t++) //检查数值{check_1[t]=Request[t]+iAllocation[i][t];}for(t=0;t<3;t++){if((iMax[i][t]-check_1[t])<0){cout<<"\n资源申请超过最大需求量!!!\n";return false;}}for(t=0;t<3;t++) //检查数值{if((iAvailable[t]-Request[t])<0){cout<<"\n不能满足进程!!!\n";return false;}}for(t=0;t<3;t++) //将该变量的iAvailable、iAllocation、iNeed重新赋值{iAvailable[t]-=Request[t];iAllocation[i][t]+=Request[t];iNeed[i][t]-=Request[t];}safety(iAllocation,iNeed,iAvailable,cName); //执行安全数列算法return true;return true;}实验结果【实验小结】通过这次实验,让我更深的了解了银行家算法,银行家算法是避免死锁的主要方法,其思路在很多方面都非常值得我们来学习借鉴。