实验三 银行家算法
银行家算法实验报告
银行家算法实验报告银行家算法是为了实现避免出现死锁的状态而采取的一种算法，本实验则是用C语言实现。
一、银行家算法数据结构1、可利用资源数量Avail。
这是一个含M个元素的数组，其中每一个元素代表一类可用的资源数目，定义为int型，Avail[m]。
2、最大需求矩阵Max。
这是一个nxm的二维矩阵，它定义了系统中n个进程的每一个进程对m类资源的最大需求，定义为int型，Max[n][m]。
3、分配矩阵Alloc。
这是一个nxm的二维矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。
定义为int型，Alloc[n][m]。
4、需求矩阵Need。
这也是一个nxm的二维矩阵，用以表示每一个进程尚需的各类资源数。
定义为int型，Need[n][m]。
5、请求资源数目Request。
这是一个含M个元素的数组，它表示进程请求的资源数目，定义为int型，Request[m]。
6、系统当前可用的资源矩阵Work，这是一个含M个元素的数组，表示系统还可以分配的资源数目，用于对安全算法的检测。
定义为int型，Work[m]。
7、记录安全序号的数组sequence，用于记录系统的安全信号，便于在后面输出。
定义为int型，sequence[n].二、银行家算法过程步骤如下：1、判断请求的资源是否超过他所宣布需要的最大值，即如果request[j]>need[i][j],则判断出错，否则继续执行。
2、判断请求的资源是否超过系统可分配的数目，即如果request[j]>Avail[j],则判断出错，否则继续执行。
3、系统试探着把资源分配给进程Pi。
并修改其中的数据Avail、Alloc、Need。
4、系统进行安全性算法的检查。
三、安全性算法其中有两个信号量，Work和Finish。
分别用于表示系统可提供给进程的继续运行所需的各类资源的数目，含m个int型的元素。
而Finish用于标识系统是否有足够的资源分配给进程，使之运行完成，默认为1（不能）,从而只有在finish都为0时才能表示安全算法成功。
操作系统实验3 银行家算法附代码
《操作系统》实验三内容要求09软一 0925114047 杨秦香【实验题目】：预防进程死锁的银行家算法【实验学时】：4学时【实验目的】通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
【实验内容】问题描述：设计程序模拟预防进程死锁的银行家算法的工作过程。
假设有系统中有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)；➢如果不安全或者无新请求则退出。
计算机操作系统银行家算法实验报告
计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要办法，通过编写一种简朴的银行家算法程序，加深理解有关资源申请、避免死锁等概念，并体会和理解死锁和避免死锁的具体实施办法。
三、问题分析与设计：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）。
实验三 银行家算法
实验三银行家算法一、实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。
本实验的目的在于使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。
二、实验要求设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；三、数据结构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。
Allocation i表示进程i的分配向量，有矩阵Allocation的第i行构成。
4．需求矩阵Need，这是一个n×m的矩阵，用以表示每个进程还需要的各类资源的数目。
如果Need（i，j）=k，表示进程i还需要Rj类资源k个，才能完成其任务。
Need i表示进程i的需求向量，由矩阵Need 的第i行构成。
上述三个矩阵间存在关系：Need（i，j）=Max（i，j）-Allocation（i，j）；四、银行家算法Request i是进程Pi 的请求向量。
Request i（j）=k表示进程Pi请求分配Rj类资源k个。
操作系统实验2时间片轮转和实验3银行家算法
实验二时间片轮转【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的时间片轮转RR调度过程。
假设有n个进程分别在T1, …,Tn时刻到达系统, 它们需要的服务时间分别为S1, …,Sn。
分别利用不同的时间片大小q, 采用时间片轮转RR进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n个进程的平均周转时间和平均带权周转时间。
程序要求如下:1）进程个数n；每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n；输入时间片大小q。
2）要求时间片轮转法RR调度进程运行, 计算每个进程的周转时间, 带权周转时间, 并且计算所有进程的平均周转时间, 带权平均周转时间；3）输出: 要求模拟整个调度过程, 输出每个时刻的进程运行状态, 如“时刻3: 进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间, 带权周转时间, 所有进程的平均周转时间, 带权平均周转时间。
源程序在VisualC++6.0中实现//RR算法#include<iostream.h>#include<iomanip.h>#include<stdio.h>#include<conio.h>#include<malloc.h>#include<stdlib.h>typedef int QElemType;#define OK 1#define ERROR 0#define OVERFLOW -1typedef int Status;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;Status InitQueue(LinkQueue &Q);Status DestroyQueue(LinkQueue &Q);Status EnQueue(LinkQueue &Q,QElemType e);int DeQueue(LinkQueue &Q,QElemType e);bool QueueEmpty(LinkQueue &Q);static const int MaxNum=100;intn,q,ArrivalTime[MaxNum],ServiceTime[MaxNum],FinishedTime[MaxNum],WholeTime[MaxNu m];double WeightWholeTime[MaxNum],Average_WT=0,Average_WWT=0;LinkQueue Q;void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q);void main(){cout<<"请输入进程总数n的值(0<n<=100):"<<endl;cin>>n;while(n<0||n>100){cout<<"你输入的n的值不正确, 请重新输入！"<<endl;cin>>n;}cout<<"请依次输入各个进程的到达时间: "<<endl;for(int i=0;i<n;i++)cin>>ArrivalTime[i];cout<<"请依次输入各个进程的服务时间: "<<endl;for( i=0;i<n;i++)cin>>ServiceTime[i];cout<<"请输入时间片q的值(0<q<=200):"<<endl;cin>>q;while(q<0||q>200){cout<<"你输入的q值不正确, 请重新输入！"<<endl;cin>>q;}RR(ArrivalTime,ServiceTime,n,q,Q);//调用RR算法}//RR算法的具体实现void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q){int countTime=0,e;int STime[MaxNum],pushed[MaxNum];for(int i=0;i<n;i++){STime[i]=ServiceTime[i];pushed[i]=0;}InitQueue(Q);EnQueue(Q,0);pushed[0]=1;int time=0;while(QueueEmpty(Q)==false){e=DeQueue(Q,e);if(STime[e]>q){STime[e]=STime[e]-q;countTime+=q;}else{countTime+=STime[e];STime[e]=0;FinishedTime[e]=countTime;}while(time<countTime){if(STime>0){cout<<"时刻"<<setw(2)<<time<<":进程"<<e<<"正在运行"<<endl;}time++;}for(i=1;i<n;i++){if(STime!=0&&i!=e&&ArrivalTime[i]<countTime&&pushed[i]==0||STime!=0&&i!=e&&A rrivalTime[i]==countTime){EnQueue(Q,i);pushed[i]=1;}}if(STime[e]>0)//判断进程e是否已执行完{EnQueue(Q,e);}}for(i=0;i<n;i++){//求周转时间和带权周转时间WholeTime[i]=FinishedTime[i]-ArrivalTime[i];WeightWholeTime[i]=(double)(WholeTime[i]*1.000000/ServiceTime[i]);Average_WT+=WholeTime[i];Average_WWT+=WeightWholeTime[i];}Average_WT/=n;//求平均周转时间Average_WWT/=n;//求平均带权周转时间//----------------输出----------------cout<<"完成:"<<" ";for(i=0;i<n;i++)cout<<setw(8)<<FinishedTime[i]<<" ";cout<<endl;cout<<"周转:"<<" ";for(i=0;i<n;i++)cout<<setw(8)<<WholeTime[i]<<" ";cout<<endl;cout<<"带权: "<<" ";for(i=0;i<n;i++)cout<<setw(8)<<setiosflags(ios::fixed)<<setprecision(2)<<WeightWholeTime[i]<<" "; cout<<endl;cout<<"平均周转时间为: "<<Average_WT<<endl;cout<<"平均带权周转时间为:"<<Average_WWT<<endl;DestroyQueue(Q);}//初始化链队列QStatus InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next=NULL;return OK;}//销毁链队列QStatus DestroyQueue(LinkQueue &Q){while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}//入队Status EnQueue(LinkQueue &Q,QElemType e){QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}//出队, 并用e返回出队节点的元素值int DeQueue(LinkQueue &Q,QElemType e){ QueuePtr p;if(Q.front==Q.rear) return ERROR;p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p) {Q.rear=Q.front;}free(p);return e;}//判断链队列Q是否为空bool QueueEmpty(LinkQueue &Q){if(Q.front==Q.rear)return true;else return false;}实例运行截图实验三银行家算法【实验目的】通过这次实验, 加深对进程死锁的理解, 进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
操作系统实验三银行家算法
实验三银行家算法一、实验内容运用某种高级语言（如C或C++）模拟银行家算法的处理过程。
二、实验目的银行家算法是避免死锁的代表性算法。
本实验旨在加深了解有关资源申请、避免死锁、状态安全性等概念，并体会和运用避免死锁的具体实施方法。
然后依照本实验，自行设计模拟程序。
三、实验题目银行家算法的模拟。
[提示]：(1) 我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
(2) 安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。
安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。
不安全状态一定导致死锁。
安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j <i )当前占有资源量之和。
(3) 设requesti为进程p[i]的请求向量，如果requesti[j]=K，表示进程p[i]需要K个Rj 资源。
当系统发出请求后，系统按下述步骤开始检查：1）如果requesti[j]<=need[i][j],转向步骤2；否则报告出错，申请的资源已经大于它需要的最大值。
2）如果requesti[j]<=available[j],转向步骤3；否则报告出错，尚无足够的资源。
银行家算法实验报告
2011-2012学年第一学期计算机操作系统实验报告专业：计算机科学与技术班级：学号：姓名：提交日期：实验三银行家算法模拟【开发语言及实现平台或实验环境】C++/C#Microsoft Visual Studio 6.0/ Microsoft V isual Studio .NET 2003【实验目的】（1）进一步理解利用银行家算法避免死锁的问题；（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。
（3）理解和掌握安全序列、安全性算法【实验要求】（1）了解和理解死锁；（2）理解利用银行家算法避免死锁的原理；（3）会使用某种编程语言。
【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列)，为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。
二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后，表示为Requesti[j]=k。
系统按下述步骤进行安全检查：（1）如果Request i≤Need i则继续以下检查，否则显示需求申请超出最大需求值的错误。
（2）如果Request i≤A vailable则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。
（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：A vailable［j］∶=A vailable［j］-Request i[j］;Allocation［i,j］∶=Allocation［i,j］+Request i［j］;Need［i,j］∶=Need［i,j］-Requesti［j］;（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
银行家算法实验设计报告
实验三银行家算法班级：xxxxxxxxxxxxxx姓名：xxxx 学号：xxxxxxxxxxxxxxxxxxxxxxxxx上级日期：2018年10月成绩：___________________________一、实验目的:银行家算法是避免死锁的一种重要方法，通过一个简单的银行家算法程序加深了解有关资源申请，避免死锁等概念，并体会和了解死锁以及避免死锁的具体实施方法。
二、实验内容1、程序流程图系统主要运行过程流程图银行家算法流程图安全性算法流程图2、程序源码1.//#define M 52.//#define N 33.#include <stdio.h> //本实验中使用到的库函数4.#include <stdlib.h>5.#include <string.h>6.7.int max[5][1]; //开始定义银行家算法中需要用到的数据8.int allocation[5][1];9.int need[5][1];10.int available[1];11.int request[5][1];12.char *finish[5];13.int safe[5];14.int n,i,m;15.int k=0;16.int j=0;17.int work[1];18.int works[5][1];19.20.void line() //美化程序，使程序运行时更加明朗美观21.{22. printf("------------------------------------------------\n");23.}24.25.void start() //表示银行家算法开始26.{27. line();28. printf(" 银行家算法开始\n");29. printf(" -- 死锁避免方法 \n");30. line();31.}32.33.void end() //表示银行家算法结束34.{35. line();36. printf(" 银行家算法结束，谢谢使用\n");37. line();38.}39.40.void input() //输入银行家算法起始各项数据41.{42.for (n=0;n<5;n++)43. {44. printf("请输入进程P%d的相关信息：\n",n);45. printf("Max:");46.for (m=0;m<1;m++)47. scanf("%d",&max[n][m]);48. printf("Allocation:");49.for (m=0;m<1;m++)50. scanf("%d",&allocation[n][m]);51.for (m=0;m<1;m++)52. need[n][m]=max[n][m]-allocation[n][m];53. }54. printf("请输入系统可利用资源数Available:");55.for (m=0;m<1;m++)56. scanf("%d",&available[m]);57.}58.59.void output() //输出系统现有资源情况60.{61. line();62. printf("资源情况 Max Allocation Need Available\n");63. printf("进程 A A A A \n");64. line();65.for(n=0;n<5;n++)66. {67. printf("P%d%3d%3d%3d",n,max[n][0],allocation[n][0],need[n][0]);68.if (n==0)69. printf("%3d%3d\n",available[0]);70.else71. printf("\n");72. }73. line();74.}75.76.void change() //当Request[i,j]<=Available[j]时，系统把资源分配给进程P[i]，Available[j]和Need[i,j]发生改变77.{78.for (m=0;m<1;m++)79. {80. available[m]-=request[i][m];81. allocation[i][m]+=request[i][m];82. need[i][m]-=request[i][m];83. }84.}85.86.void outputsafe() //输出安全序列的资源分配表87.{88. printf("该安全序列的资源分配图如下：\n");89. line();90. printf("资源情况 Work Need Allocation Work+Allocation Finish\n");91. printf("进程 A A A A \n");92. line();93.for(n=0;n<5;n++)94. printf("P%d%9d%3d%3d%5d%12s\n",safe[n],works[safe[n]][0],need[safe[n]][0],allocation[safe[n]][0],works[safe[n]][0]+allocation[safe[n]][0],finish [n]);95. line();96.}97.98.int check() //安全性算法99.{100. printf("开始执行安全性算法……\n");101.for (m=0;m<1;m++) //数组work和finish初始化102. work[m]=available[m];103.for (n=0;n<5;n++)104. {105. finish[n]="false";106. safe[n]=0;107. }108. k=0;109.for (m=0;m<5;m++)110.for (n=0;n<5;n++)111.if(strcmp(finish[n],"false")==0 && need[n][0]<=work[0] ) //查找可以分配资源但尚未分配到资源的进程112. {113. safe[k]=n; //以数组safe[k]记下各个进程得到分配的资源的顺序114. works[safe[k]][0]=work[0];115.116.117. work[0]+=allocation[n][0]; //进程执行后释放出分配给它的资源118.119.120. finish[n]="ture"; //finish[n]变为1以示该进程完成本次分121. k++;122. }123.for (m=0;m<5;m++) //判断是否所有进程分配资源完成124. {125.if (strcmp(finish[m],"false")==0)126. {127. printf("找不到安全序列，系统处于不安全状态。
银行家算法实验报告c语言
银行家算法实验报告c语言银行家算法实验报告引言：计算机科学中的银行家算法是一种资源分配和避免死锁的算法。
它是由艾德加·戴克斯特拉（Edsger Dijkstra）在1965年提出的。
银行家算法通过判断一个系统是否处于安全状态来决定是否分配资源给进程。
本实验旨在使用C语言实现银行家算法，并通过一系列的实例来验证其有效性。
一、实验背景银行家算法是为了解决资源分配中的死锁问题而提出的。
在多进程系统中，每个进程都需要一定数量的资源来完成任务。
然而，如果资源分配不当，可能会导致死锁的发生，即所有进程都陷入无法继续执行的状态。
银行家算法通过合理地分配资源，避免了死锁的发生。
二、实验目的本实验的主要目的是通过C语言实现银行家算法，并通过实例验证其正确性和有效性。
具体而言，我们将模拟一个系统中的多个进程，并为每个进程分配资源。
然后，我们将使用银行家算法来判断系统是否处于安全状态，从而决定是否继续分配资源。
三、实验过程1. 创建进程和资源我们首先创建了5个进程和3种资源。
每个进程需要的资源数量是随机生成的，以模拟真实情况下的资源需求。
2. 分配资源根据银行家算法的原则，我们按照以下步骤来分配资源：- 首先，检查每个进程的资源需求是否小于等于系统当前可用的资源数量。
- 如果满足条件，将资源分配给该进程，并更新系统剩余资源数量。
- 如果不满足条件，暂时不分配资源给该进程，继续检查下一个进程。
3. 判断系统状态在每次资源分配后，我们需要判断系统是否处于安全状态。
为此，我们使用银行家算法的核心原则：只有当系统能够为每个进程提供所需的资源时，系统才是安全的。
我们通过遍历所有进程来检查其资源需求是否小于等于系统剩余资源数量，如果满足条件，说明系统是安全的。
4. 实例验证我们进行了多个实例验证，以确保银行家算法的正确性。
在每个实例中，我们模拟了不同的进程和资源需求，并观察系统的状态。
通过比较实验结果和预期结果，我们验证了银行家算法的有效性。
实验三 银行家算法
浙江工业大学计算机科 学与技术学院 何玲娜
实验三 进程的死锁避免算法 （银行家算法实现）
实验目的：
根据银行家算法的思想，编写程序，解 决并发进程的死锁问题。
背景知识
本实验要求设计并实现银行家算法。银行家算法
是死锁避免的经典算法，其核心思想是：进程动
态地申请资源，每次申请资源时系统都执行安全
利用VC++6.0实现上述程序设计和调试操作，
根据提示输入相应的资源请求，对于算法操
作的成功与否提供一定的提示框。
通过阅读和分析实验程序，熟悉进程的死锁 问题。
工具/准备工作
在开始本实验之前，请回顾教科书的相关内容
需要做以下准备：
– 一台运行Windows 2000 /XP 操作系统的计算机
– 计算机中需安装Visual C++ 6.0专业版或企业版
死锁避免算法
实验报告
每人独立一组，需要上交实验报告 实验报告包括实验目的、实验内容、主要程序 结构（附注释）、实验步骤、实验中遇到的问 题及解决方法等。 上交程序源代码。 源代码和实验报告一并打包后上交，其命名方 式为：班级_学号_姓名.rar （注：只需上交源代码，不需要上交生成的目标 文件及可执行文件。） 通过EMAIL地址上交：coignhln@
状态检查算法判断本次申请是否会造成系统处于 不安全状态，如果不安全则阻塞进程；如果安全 状态，则完成资源分配。
安全状态检查算法的思想是找到一个安为不安全状态。
实验内容与步骤
进程的死锁避免算法。编写一段程序，模拟
银行家算法，解决进程的死锁问题。
实验三 银行家算法
实验三银行家算法
一、实验内容简要描述
1．实验目标：
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。
2．实验要求：
银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
用银行家算法实现资源分配。
设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统，例如，{A,B,C}的资源数量分别为10，5，7。
进程可动态地申请资源和释放资源，系统按进程的申请动态地分配资源，要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列；
显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。
二、报告主要内容
1．设计思路
A、设计进程对各在资源最大申请表示及初值确定。
B、设定系统提供资源初始状态。
C、设定每次某个进程对各类资源的申请表示。
D、编制程序，依据银行家算法，决定其申请是否得到满足。
2．主要数据结构
假设有M个进程N类资源，则有如下数据结构：
MAX[M*N] M个进程对N类资源的最大需求量
AVAILABLE[N] 系统可用资源数
ALLOCATION[M*N] M个进程已经得到N类资源的资源量
NEED[M*N] M个进程还需要N类资源的资源量
3.主要代码
三、实验心得(实验中遇到的问题及解决过程、实验中产生的错误及原因分析、实验的体会及收获、对做好今后实验提出建设性建议等。
)。
实验报告_银行家算法
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年五、附录（示例代码省略）以上是本次实验的实验报告，通过实验我们深入了解了银行家算法，了解了它在操作系统中的应用和重要性。
实验3 银行家算法
实验三银行家算法一、实验目的模拟银行家算法，用银行家算法实现资源分配二、实验内容写程序用银行家算法判断系统能否将资源分配给它；（2）若进程P2提出请求Request(0，1，0)，用银行家算法程序验证系统能否将资源分配给它。
#include<stdio.h>#include<string.h>#define RESOURCE 3#define PRO 5class Process{public :int max[RESOURCE];int allocation[RESOURCE];int need[RESOURCE];int request[RESOURCE];//对资源第一次分配void Inital(int index,int allo,int n){allocation[index] = allo;need[index] = n;}//某个进程需要资源void Request(int index,int req){request[index] = req;}};//检测安全性bool Safe(int work[],Process pro[]){bool finish[PRO];for(int i=0;i<PRO;i++){finish[i] =false;}int j=0; //用来表示资源下标int k=0;int index[PRO];for(i=0;i<PRO-1;i++){for(int m=0;m<PRO;m++){if(work[j] >= pro[m].need[j] && work[j+1] >= pro[m].need[j+1]&& work[j+2] >= pro[m].need[j+2] && finish[m] == false){finish[m] = true;index[k++] = m;for(int j=0;j<RESOURCE;j++){work[j] = work[j] + pro[m].allocation[j];}}}for(i=0;i<PRO;i++){if(finish[i] ==false){printf("该申请资源数量不合法，不存在安全序列~\n");return false;}}printf("该进程申请的资源数量合法，其安全序列为：\n{");for(i=0;i<PRO;i++){{printf(" p%d;",index[i]);}}printf("}\n");return true;}//用来比较所申请的资源是否满足要求bool Compare(int index,int avaliable[],Process pro[]){for(int i=0;i<RESOURCE;i++){if(pro[index].need[i] < pro[index].request[i] || avaliable[i] < pro[index].request[i])return false;}return true;}//void Require(int index, bool check,int avaliable[], Process pro[]){if(check == false){printf("第一次分配资源造成死锁，不合理。
银行家算法实验报告-计算机操作系统教程(第三版)
计算机操作系统教程（第三版）银行家算法实验报告一、实验目的银行家算法是避免死锁的一种重要方法。
通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法二、实验要求根据银行家算法的基本思想，编写和调试一个实现动态资源分配的模拟程序，并能够有效地防止和避免死锁的发生。
（1）设计思想说明设计银行家算法是为了避免死锁三、实验方法内容1.算法设计思路银行家算法又称“资源分配拒绝”法，其基本思想是，系统中的所有进程放入进程集合，在安全状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。
这时系统将该进程从进程集合中将其清除。
此时系统中的资源就更多了。
反复执行上面的步骤，最后检查进程的集合为空时就表明本次申请可行，系统处于安全状态，可以实施本次分配，否则，只要进程集合非空，系统便处于不安全状态，本次不能分配给他。
请进程等待2.算法流程图3.算法中用到的数据结构数据结构的说明1.可利用资源向量AVAILABLE。
这是一个含有M个元素的数组，其中的每一个元素代表一类可利用的资源数目，其3初始值是系统中所配置的该类全部可哦那个资源的数目，其数值随该类资源的分配和回收而动态的改变。
2.最大需求矩阵MAX。
这是一个M*N的矩阵，它定义了系统中N个进程中的每一个进程对M类资源的最大需求。
3.分配矩阵ALLOCATION。
这也是一个M*N的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。
4.需求矩阵NEED。
这也是一个M*N的矩阵，用以表示每一个进程尚需的各类资源数。
5.NEED[R,W]=MAX[R,W]-ALLOCATION[R,W]4.主要的常量变量#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20 int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void changdata(int k);//进程请求资源数据改变int chksec(int s); //系统安全性的检测5.主要模块void inputdata()void showdata()void changdata(int k)void restoredata(int k) int chksec(int s)int chkmax(int s)四、实验代码#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.结果分析银行家算法就是当接收到一个系统资源的分配后找到一个安全序列，使得进程间不会发生死锁，若发生死锁则让进程等待。
操作系统实验银行家算法
实验三银行家算法一、实验内容简要描述1．实验目标：加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。
2．实验要求：银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
用银行家算法实现资源分配。
设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统，例如，{A,B,C}的资源数量分别为10，5，7。
进程可动态地申请资源和释放资源，系统按进程的申请动态地分配资源，要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。
二、报告主要内容1．设计思路A、设计进程对各在资源最大申请表示及初值确定。
B、设定系统提供资源初始状态。
C、设定每次某个进程对各类资源的申请表示。
D、编制程序，依据银行家算法，决定其申请是否得到满足。
2．主要数据结构假设有M个进程N类资源，则有如下数据结构：MAX[M*N] M个进程对N类资源的最大需求量AVAILABLE[N] 系统可用资源数ALLOCATION[M*N] M个进程已经得到N类资源的资源量NEED[M*N] M个进程还需要N类资源的资源量银行家算法：设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。
(2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。
(3)系统试探分配资源，修改相关数据：AVAILABLE=AVAILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
湖南文理学院实验报告
课程名称实验三实验名称银行家算法成绩
学生姓名刘照专业班级网工15102 学号201517030216
同组者姓名实验日期2017-05-05
一、实验目的
死锁会引起计算机工作僵死，因此操作系统中必须防止。
本实验的目的在于使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。
二、实验要求
设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；
三、数据结构
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。
Allocation i表示进程i的分配向量，有矩阵Allocation的第i行构成。
4．需求矩阵Need，这是一个n×m的矩阵，用以表示每个进程还需要的各类资源的数目。
如果Need（i，j）=k，表示进程i还需要Rj类资源k个，才能完成其任务。
Need i表示进程i的需求向量，由矩阵Need的第i行构成。
上述三个矩阵间存在关系：Need（i，j）=Max（i，j）-Allocation（i，j）；
四、银行家算法
Request i是进程Pi 的请求向量。
Request i（j）=k表示进程Pi请求分配Rj类资源k个。
当Pi发出资源请求后，系统按下述步骤进行检查：
1．如果Request i≤Need，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。
2．如果Request i≤Available，则转向步骤3；否则，表示系统中尚无足够的资源满足Pi的申请，Pi必须等待。
3．系统试探性地把资源分配给进程Pi，并修改下面数据结构中的数值：Available = Available - Request i
Allocation i= Allocation i+ Request i
Need i= Need i - Request i
4．系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
如果安全才正式将资源分配给进程Pi，
次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
五、安全性算法
1．设置两个向量。
Work：它表示系统可提供给进程继续运行的各类资源数目，它包含m个元素，开始执行安全性算法时，Work = Available。
Finish：它表示系统是否有足够的资源分配给进程，使之运行完成，开始Finish （I）=false；当有足够资源分配给进程Pi时，令Finish（i）=true；2．从进程集合中找到一个能满足下述条件的进程。
Finish（i）= = false；
Need i≤work；
如找到则执行步骤3；否则，执行步骤4；
3．当进程Pi获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行
Work = work + Allocation i
Finish（i）=true；转向步骤2；
4．若所有进程的Finish（i）都为true，则表示系统处于安全状态；否则，系统处于不安全状态。
七．银行家算法程序代码
int check() //安全性检查
{
int WORK[R],FINISH[W];
int i,j,l=0;
for(j=0;j<N;j++) WORK[j]=A V AILABLE[j];
for(i=0;i<M;i++) FINISH[i]=FALSE;
for(i=0;i<M;i++)
{
if(FINISH[i]==TRUE) continue;
else
{
for(j=0;j<N;j++)
{
if( NEED[i][j]>WORK[j] ) break;
}
if(j==N)
{
FINISH[i]=TRUE;
for(int k=0;k<N;k++)
WORK[k]=WORK[k]+ALLOCATION[i][k];
P[l++]=i;
i=-1;
}
else continue;
}
if( l==M )
{
cout<<endl;
cout<<" 经安全性检查，系统安全，本次分配成功。
"<<endl;
cout<<endl;
cout<<"安全序列是："<<endl;
for(i=0;i<l;i++)
{
cout<<P[i];
if(i!=l-1)cout<<"-->";
}
cout<<endl;
return 0;
}
}
cout<<endl;
cout<<" 系统不安全本次资源申请不成功"<<endl;
cout<<endl;
return 1;
}
八．实验结果分析
1.根据下面给出的系统中资源分配情况，以及各个进程的资源申请情况，通过银行家算法来判断各进程的资源请求能否满足（要求记录程序的运行过程）。
已分配的资源最大需求量
A B C A B C
P0 0 1 0 7 5 3
P1 2 0 0 3 2 2
P2 3 0 2 9 0 2
P3 2 1 1 2 2 2
P4 0 0 2 4 3 3
剩余资源A B C
3 3 2
P1 申请（1，0，2）能否分配？为什么？
答：可以分配，因为存在安全序列1—>3—>0—>2—>4。
只要系统按此进程序列分配资源，就能使每个进程都顺利完成。
结果如下:
P4 申请（3，3，0）能否分配？为什么？
答：不能，因为找不到一个安全序列可使所有进程都安全完成。
结果如下：
P0 申请（0，2，0）能否分配？为什么？
答：不能，因为找不到一个安全序列可使所有进程都安全完成。
2．结合代码分析check（）函数的执行流程，并画出对应的程序流程图。
check（）函数程序流程图
5．安全检查函数首先用系统可提供给进程继续运行的各类资源数目（Work），它包含m个元素，开始执行安全性算法时，Work = Available(可利用资源向量)。
Finish（I）=false；当有足够资源分配给进程Pi时，令Finish（i）=true；从进程集合中找到一个能满足下述条件的进程（用if语句判断）。
Finish（i）= = false；Need i ≤work；成立则执行当进程Pi获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行Work = work + Allocation i Finish（i）=true；并继续回到上一步if判断那；如果if判断不成立则执行判断所有进程的Finish（i）都是否为true是则系统处于
安全状态；否则，系统处于不安全状态。