安徽大学操作系统实验银行家算法

操作系统实验报告----银行家算法班级：______计算机03(7)班______________ 姓名：_________李君益__________________ 学号：______________(61号)___提交日期：____06.7.11___________________ 指导老师: ______林穗____________________一、设计题目加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。

二、设计要求内容：编制银行家算法通用程序，并检测思考题中所给状态的安全性。

要求：(1)下列状态是否安全？(三个进程共享12个同类资源)进程已分配资源数最大需求数1 1 4 (状态a)2 4 43 5 81 1 42 4 6 (状态b)3 6 8(2)考虑下列系统状态分配矩阵最大需求矩阵可用资源矩阵0 0 1 2 0 0 1 2 1 5 2 01 0 0 0 1 7 5 01 3 5 423 5 60 6 3 2 0 6 5 20 0 1 4 0 6 5 6问系统是否安全？若安全就给出所有的安全序列。

若进程2请求(0420)，可否立即分配？三、设计分析一．关于操作系统的死锁1．死锁的产生计算机系统中有许多独占资源，他们在任一时刻只能被一个进程使用，如磁带机，绘图仪等独占型外围设备，或进程表，临界区等软件资源。

两个进程同时向一台打印机输出将导致一片混乱，两个进程同时进入临界区将导致数据库错误乃至程序崩溃。

正因为这些原因，所有操作系统都具有授权一个进程独立访问某一辞源的能力。

一个进程需要使用独占型资源必须通过以下的次序：●申请资源●使用资源●归还资源若申请施资源不可用，则申请进程进入等待状态。

对于不同的独占资源，进程等待的方式是有差别的，如申请打印机资源、临界区资源时，申请失败将一位这阻塞申请进程；而申请打开文件文件资源时，申请失败将返回一个错误码，由申请进程等待一段时间之后重试。

《操作系统》实验报告题目：银行家算法班级：网络工程姓名：朱锦涛学号：E31314037一、实验目的用代码实现银行家算法，了解通过银行家算法避免死锁的思想。

通过代码的具体实现，加深对算法的核心的理解。

二、实验原理我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。

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

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

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

三、实验内容源程序：#include<stdio.h>#include<time.h>#include<stdlib.h>typedef struct Procedure{i nt Max[3]; //满足此进程需要三类资源的数量i nt Allocation[3]; //系统已经为该进程分配的资源情况i nt Need[3]; //该进程还需要资源数量i nt flag; //标志位，执行完之前为0，执行完之后为1 c har p; //在执行完之后，给出相应的编号，如P1，P2 s truct Procedure * pNext;}Pro,*PNODE; //如果系统资源足够多的话，那么所有的安全序列的数量就会是5*4*3*2*1=120个PNODE create_list(int &len);void traverse_list(PNODE pHead);int cnt_exe(PNODE pHead,int *system,int i); //计算目前系统能够执行的进程数int work(PNODE pHead,int *system);int main(){i nt ok;i nt len;s rand(time(0));i nt system[3] = {rand()%5+10,rand()%5+2,rand()%5+5}; p rintf("系统中可用的各类资源数分别为:%d %d %d\n",system[0],system[1],system[2]);P ro *pHead = create_list(len);t raverse_list(pHead);i nt cnt = cnt_exe(pHead,system,3);i f(cnt == 0){printf("对不起，不存在安全序列\n");return 0;}e lse{int ok = work(pHead,system);if(ok == len)printf("恭喜！存在安全序列！\n");elseprintf("很抱歉！不存在安全序列！\n"); }r eturn 0;}PNODE create_list(int &len){i nt i,j;c har c = 'A'; //用来临时存放用户输入的结点的值//分配了一个不存放有效数据的头结点P NODE pHead = (PNODE)malloc(sizeof(Pro));i f (NULL == pHead){printf("分配失败, 程序终止!\n");exit(-1);}P NODE pTail = pHead;p Tail->pNext = NULL;p rintf("请输入您需要生成的链表节点的个数:"); s canf("%d", &len);f or (i=0; i<len; ++i){PNODE pNew = (PNODE)malloc(sizeof(Pro));if (NULL == pNew){printf("分配失败, 程序终止!\n");exit(-1);}for(j=0;j<3;j++){pNew->Max[j] = rand()%5+4;pNew->Allocation[j] = rand()%5;pNew->Need[j] = pNew->Max[j] -pNew->Allocation[j];}pNew->flag = 0;pNew->p = c;pTail->pNext = pNew;pNew->pNext = NULL;pTail = pNew;c++;}r eturn pHead;}void traverse_list(PNODE pHead) {P NODE p = pHead->pNext;i nt i = 1;w hile (NULL != p){printf("第%d个资源的需要资源总数各为:%d %d %d",i, p->Max[0],p->Max[1],p->Max[2]);printf("\n");printf("第%d个资源已分配资源总数各为:%d %d %d",i, p->Allocation[0],p->Allocation[1],p->Allocation[2]);printf("\n");printf("第%d个资源还需要资源总数各为:%d %d %d",i, p->Need[0],p->Need[1],p->Need[2]);printf("\n");printf("\n");p = p->pNext;i++;}p rintf("\n");r eturn;}^` int cnt_exe(PNODE pHead,int *system,int i){P NODE p;p = pHead->pNext; //p指向第一个节点i nt count = 0;w hile(p != NULL){if(system[0] >= p->Need[0] && system[1] >=p->Need[1] && system[2] >= p->Need[2])count++;p = p->pNext;}r eturn count;}int work(PNODE pHead,int *system){P NODE p;p = pHead->pNext; //p指向第一个节点int ok = 0;w hile(p != NULL){if(system[0] >= p->Need[0] && system[1] >=p->Need[1] && system[2] >= p->Need[2]){system[0] += p->Allocation[0];system[1] += p->Allocation[1];system[2] += p->Allocation[2];p->flag = 1;ok++;printf("系统已经为您执行了进程：%c\n",p->p);PNODE q;q = pHead; //寻找q的前一个节点，方便删掉q 节点while( q->pNext != p ){q = q->pNext;}q->pNext = p->pNext;free(p);p = NULL;p = pHead->pNext;//p又重新指向第一个节点}elsep = p->pNext;}r eturn ok;}存在安全序列的情况：不存在安全序列的情况：四、实验小结用随机数为系统分配三类资源的个数，随后系统为每个作业分配每个资源需要的个数和已经分配的资源数量，那么还需要资源的数量则有最大分配量减去已经分配的数量。

海南大学三亚学院《计算机操作系统》课程设计死锁的避免——银行家算法专业班级：成员：提交时间：一、问题描述（标题：宋体四号）内容：1、解释什么是银行家算法（宋体，小四，行间距1.5倍）银行家算法又称“资源分配拒绝”法，其基本思想是，系统中的所有进程放入进程集合，在安全状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。

这时系统将该进程从进程集合中将其清除。

此时系统中的资源就更多了。

反复执行上面的步骤，最后检查进程的集合为空时就表明本次申请可行，系统处于安全状态，可以实施本次分配，否则，只要进程集合非空，系统便处于不安全状态，本次不能分配给他。

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

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

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

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

2、银行家算法提出的原因在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险━━死锁。

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

一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源，这种现象称为进程死锁，这一组进程就称为死锁进程。

广东海洋大学学生实验报告书（学生用表）实验名称实验三死锁的避免(银行家算法) 课程名称计算机操作系统课程号学院(系) 专业班级学生姓名学号实验地点实验日期实验三死锁的避免――银行家算法一、实验目的1．掌握死锁产生的原因。

2．掌握银行家算法。

3．能使用高级语言模拟实现银行家算法。

二、相关知识介绍参与死锁的进程最少是两个。

参与死锁的进程至少有两个已经占有资源。

参与死锁的所有进程都在等待资源。

参与死锁的进程是当前系统中所有进程的子集。

三、相关数据结构1．可利用资源向量Available ，它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。

其数值随该类资源的分配和回收而动态地改变。

如果Available[j]=k，标是系统中现有j类资源k个。

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

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

3．分配矩阵Allocation，这是一个n×m的矩阵，它定义了系统中的每类资源当前分配到每一个进程的资源数。

如果Allocation[i][j]=k，表示进程i当前已经分到j类资源的数目为k个。

Allocation[i]表示进程i的分配向量。

4．需求矩阵Need，这是一个n×m的矩阵，用以表示每个进程还需要的各类资源的数目。

如果Need[i][j]=k，表示进程i还需要j类资源k个，才能完成其任务。

Need[i]表示进程i的需求向量。

上述三个矩阵间存在关系：Need[i][j]=Max[i][j]-Allocation[i][j]；四、银行家算法Request是进程i的请求向量。

Request[j]=k表示进程i请求分配j类资源k个。

当进程i发出资源请求后，系统按下述步骤进行检查：1．如果Request ≤Need[i]，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。

操作系统实验银行家算法模拟实现（强烈推荐）银行家算法模拟实现一．实验目的1) 理解死锁避免相关内容；2) 掌握银行家算法主要流程；3) 掌握安全性检查流程。

二．实验描述本实验主要对操作系统中的死锁预防部分的理论进行实验。

要求实验者设计一个程序，该程序可对每一次资源申请采用银行家算法进行分配。

三．实验内容1) 设计多个资源（≥3）；2) 设计多个进程（≥3）；3) 设计银行家算法相关的数据结构；4) 动态进行资源申请、分配、安全性检测并给出分配结果。

四．实验要求1) 编写程序完成实验内容；2) 画出安全性检测函数流程图；3) 小组派1人上台用PPT演讲实现过程；4) 撰写实验报告。

测试要求1) 进行Request请求，输入参数为进程号、资源号和资源数；2) 进行3次以上的Request请求；3) 至少进行1次资源数目少于可用资源数，但不安全的请求。

五．实验设备PC机1台，要求安装DOS7.1、Turbo C3.0、Windows2000。

六．实验结果七.实验思考1）针对死锁有哪些可行方案？2）死锁解除的难点是什么？八.银行家算法介绍8.1银行家算法的数据结构1) 可利用资源向量Available。

其中每个元素代表每类资源的数目。

2) 最大需求矩阵Max。

其中每个元素代表每个进程对于每类资源的最大需求量。

Max[i，j]=K表示i进程对于j类资源的最大需求量为K。

3) 分配矩阵Allocation。

其中每个元素代表每个进程已得到的每类资源的数目。

4) 需求矩阵Need。

其中每个元素代表每个进程还需要的每类资源的数目。

8.2银行家算法Request i [j]=K表示进程Pi需要K个j类资源。

1）如果Request i [j]≤Need[i , j]，便转向步骤2，否则认为出错。

2）如果Request i [j]≤Available[j]，便转向步骤3，否则表示无足够资源，Pi需等待；3）系统尝试分配资源给Pi；4）系统进行安全性检查，检查此次资源分配后，系统是否安全。

计算机科学与技术系实验报告课程名称：操作系统原理与linux实验名称：银行家算法2011年04 月6日实验三银行家算法一、实验目的：（1）进一步理解利用银行家算法避免死锁的问题；（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。

（3）理解和掌握安全序列、安全性算法二、实验内容：（1）了解和理解死锁；（2）理解利用银行家算法避免死锁的原理；（3）会使用某种编程语言。

三、实验作业：一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列)，为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。

二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后，表示为Requesti[j]=k。

系统按下述步骤进行安全检查：（1）如果Requesti≤Needi则继续以下检查，否则显示需求申请超出最大需求值的错误。

（2）如果Requesti≤Available则继续以下检查，否则显示系统无足够资源，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）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

三、安全性算法（1）设置两个向量：①工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。

《运算机操作系统》课程设计题目银行家算法分析学院运算机与软件学院专业运算机科学与技术班级学号姓名指导教师起止时刻一、算法综述银行家算法：在进程向系统提出资源分派请求时，算法会先对进程提出的请求进行合法性检查，即检查请求的是不大于需要的，是不是不大于可利用的。

假设请求合法，那么进行试分派。

最后对试分派后的状态挪用平安性检查算法进行平安性检查。

假设平安，那么分派，不然，不分派，恢恢复先状态，拒绝申请。

二．算法分析银行家算法中的数据结构为资源的种类i进程的数量j可利用资源向量int Available[j]最大需求矩阵int Max[i][j]分派矩阵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]银行家算法设Request i是进程P i的请求向量，若是Request i[j]=K，表示进程P i需要k个Rj类型的资源，当P i发出资源请求后，系统依照下述步骤进行检查：(1)若是Request i[j]≤Need[j],便转向步骤（2）；不然以为犯错，因为它所需要的资源数已经超过它所宣布的最大值。

(2)若是Request i[j]≤Available[j]，便转向步骤（3）；不然，表示尚无足够资源，P i须等待。

(3)系统试探着将资源分派给进程P i，并修改下面数据结构中的数值：Available[j]:=Available[j]-Request i[j];Allocation[i,j]:=Allocation[i,j]+Request i[j];Need[i,j]:=Need[i,j]-Request i[j];(4)系统执行平安性算法，检查这次资源分派后系统是不是处于平安状态。

假设平安，才正式将资源分派给进程P i，以完本钱次分派；不然本次的试探分派作废，恢恢复先的资源分派状态，让进程P i等待。

操作系统实验三：银行家算法时间：2013-12-13地点：计算机实验机房2实验人：朱蓉蓉学号：E01114336本次实验主要针对银行家算法的实现和安全序列的检测。

银行家算法实验代码：#include<iostream>#include<string.h>#include<stdio.h>#define False 0#define True 1using namespace std;int Max[100][100]={0};//各进程所需各类资源的最大需求int Avaliable[100]={0};//系统可用资源char name[100]={0};//资源的名称int Allocation[100][100]={0};//系统已分配资源int Need[100][100]={0};//还需要资源int Request[100]={0};//请求资源向量int temp[100]={0};//存放安全序列int Work[100]={0};//存放系统可提供资源int M=100;//进程的最大数为int N=100;//资源的最大数为void showdata()//显示资源矩阵{int i,j;cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<endl;for (j=0;j<N;j++)cout<<Avaliable[j]<<" ";//输出分配资源cout<<endl;cout<<" Max Allocation Need"<<endl;cout<<"进程名 ";for(j=0;j<3;j++){for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<" ";}cout<<endl;for(i=0;i<M;i++){cout<<" "<<i<<" ";for(j=0;j<N;j++)cout<<Max[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Allocation[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Need[i][j]<<" ";cout<<endl;}}int changdata(int i)//进行资源分配{int j;for (j=0;j<M;j++) {Avaliable[j]=Avaliable[j]-Request[j];Allocation[i][j]=Allocation[i][j]+Request[j];Need[i][j]=Need[i][j]-Request[j];}return 1;}int safe()//安全性算法{int i,k=0,m,apply,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){apply=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==N){for(m=0;m<N;m++)Work[m]=Work[m]+Allocation[i][m];//变分配数Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){cout<<"系统不安全"<<endl;//不成功系统不安全return -1;}}cout<<"系统是安全的!"<<endl;//如果安全，输出成功cout<<"分配的序列:";for(i=0;i<M;i++){//输出运行进程数组cout<<temp[i];if(i<M-1) cout<<"->";}cout<<endl;return 0;}void share()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch='y';cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";cin>>i;//输入须申请的资源号cout<<"请输入进程"<<i<<" 申请的资源:"<<endl;for(j=0;j<N;j++){cout<<name[j]<<":";cin>>Request[j];//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错{cout<<"进程"<<i<<"申请的资源大于它需要的资源";cout<<" 分配不合理，不予分配！"<<endl;ch='n';break;}else {if(Request[j]>Avaliable[j])//判断申请是否大于当前资源，若大于则{ //出错cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";cout<<" 分配出错，不予分配!"<<endl;ch='n';break;}}}if(ch=='y') {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}void addresources(){//添加资源int n,flag;cout<<"请输入需要添加资源种类的数量:";cin>>n;flag=N;N=N+n;for(int i=0;i<n;i++){cout<<"名称:";cin>>name[flag];cout<<"数量:";cin>>Avaliable[flag++];}showdata();safe();}void delresources(){//删除资源char ming;int i,flag=1;cout<<"请输入需要删除的资源名称：";do{cin>>ming;for(i=0;i<N;i++)if(ming==name[i]){flag=0;break;}if(i==N)cout<<"该资源名称不存在，请重新输入：";}while(flag);for(int j=i;j<N-1;j++){name[j]=name[j+1];Avaliable[j]=Avaliable[j+1];}N=N-1;showdata();safe();}void changeresources(){//修改资源函数cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(int i=0;i<N;i++)cout<<name[i]<<":"<<Avaliable[i]<<endl;cout<<"输入系统可用资源[Avaliable]:"<<endl;cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];cout<<"经修改后的系统可用资源为"<<endl;for (int k=0;k<N;k++)cout<<name[k]<<":"<<Avaliable[k]<<endl;showdata();safe();}void addprocess(){//添加作业int flag=M;M=M+1;cout<<"请输入该作业的最大需求量[Max]"<<endl;for(int i=0;i<N;i++){cout<<name[i]<<":";cin>>Max[flag][i];Need[flag][i]=Max[flag][i]-Allocation[flag][i];}showdata();safe();}int main()//主函数{int i,j,number,choice,m,n,flag;char ming;cout<<"\t---------------------------------------------------"<<endl;cout<<"\t|| ||"<<endl;cout<<"\t|| 银行家算法的实现 ||"<<endl;cout<<"\t|| E01114336 ||"<<endl;cout<<"\t|| 朱蓉蓉 ||"<<endl;cout<<"\t|| ||"<<endl;cout<<"\t|| ||"<<endl;cout<<"\t---------------------------------------------------"<<endl;cout<<"请首先输入系统可供资源种类的数量:";cin>>n;N=n;for(i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>ming;name[i]=ming;cout<<"资源的数量:";cin>>number;Avaliable[i]=number;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m;cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>Max[i][j];do{flag=0;cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j]) flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)cout<<"申请的资源大于最大需求量，请重新输入!\n";}while(flag);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){cout<<"\t-------------------银行家算法演示------------------"<<endl;cout<<" 1:增加资源 "<<endl;cout<<" 2:删除资源 "<<endl;cout<<" 3:修改资源 "<<endl;cout<<" 4:分配资源 "<<endl;cout<<" 5:增加作业 "<<endl;cout<<" 0:离开 "<<endl;cout<<"\t---------------------------------------------------"<<endl;cout<<"请选择功能号：";cin>>choice;switch(choice){case 1: addresources();break;case 2: delresources();break;case 3: changeresources();break;case 4: share();break;case 5: addprocess();break;case 0: choice=0;break;default: cout<<"请正确选择功能号(0-5)!"<<endl;break;}}return 1;}实验程序截图：随机算法实现：#include <iostream>#include <time.h>#include <vector>#include <windows.h>using namespace std;int r[3]={3,3,2};//系统拥有的资源int r0=0,r1=0,r2=0;//记录申请资源class pcb{public:int id;bool state;int max[3];int alc[3];int need[3];pcb(){}void init(){state=false;cout<<"请输入进程的id，各个资源总需求量和已占用资源"<<endl;cin>>id;cout<<"a,b,c三种资源的最大使用量"<<endl;cin>>max[0]>>max[1]>>max[2];cout<<"a,b,c三种资源的已占有量"<<endl;cin>>alc[0]>>alc[1]>>alc[2];}int rd(int n){return rand()%(n+1);}int request(){// Sleep(1000);r0=rd(max[0]-alc[0]);r1=rd(max[1]-alc[1]);r2=rd(max[2]-alc[2]);cout<<"进程"<<id<<"申请资源a"<<" "<<r0<<" 申请资源b"<<" "<<r1<<"申请资源c"<<" "<<r2<<endl;if(r0>r[0]||r1>r[1]||r2>r[2]){cout<<"没有那么多资源!!!"<<endl;return 0;}if((r0==(max[0]-alc[0]))&&r1==(max[1]-alc[1])&&r2==(max[2]-alc[2])) {r[0]=r[0]+alc[0];r[1]=r[1]+alc[1];r[2]=r[2]+alc[2];return 1;}return 2;}};bool safe(vector <pcb> temp,int i){int u=r[0]-r0,k=r[1]-r1,l=r[2]-r2;for(int j=i;j<temp.size()-1;j++)temp[j]=temp[j+1];temp.pop_back();int size=temp.size();//记录下容器内还有多少个进程// int range[size];//记录下队列int x=0;//计数器while(!temp.empty()){static int j=0;if((temp[j].max[0]-temp[j].alc[0])<=u&&(temp[j].max[1]-temp[j].alc[1 ])<=k&&(temp[j].max[2]-temp[j].alc[2])<=l)//判断是否能运行完{cout<<"运行"<<temp[j].id<<endl;u=u+temp[j].alc[0];k=k+temp[j].alc[1];l=l+temp[j].alc[2];for(int e=j;e<temp.size()-1;e++)temp[e]=temp[e+1];temp.pop_back();if(j>=temp.size())j=0;}else{j++;if(j>=temp.size())j=0;}x++;if(x==(size*size)){cout<<"没有安全队列,以上情况不成立"<<endl;cout<<endl;return false;}}return true;}int main(){srand(time(0));pcb p[5];vector <pcb> vp;for(int i=0;i<5;i++){p[i].init();vp.push_back(p[i]);}int x=0;//计算器int c;cout<<"请选择分配资源方法:1.银行家算法 2.随机算法"<<endl;cin>>c;switch(c){case 1:while(!vp.empty()){int a;static int i=0;if((a=vp[i].request())!=0){if(a==1){cout<<"进程"<<vp[i].id<<"已经结束"<<endl;for(int j=i;j<vp.size()-1;j++){vp[j]=vp[j+1];}vp.pop_back();if(i>=vp.size())i=0;cout<<"a资源还剩"<<r[0]<<" b资源还剩"<<r[1]<<" c资源还剩"<<r[2]<<endl;cout<<endl;}else{if(safe(vp,i)){cout<<"存在安全队列"<<endl;cout<<endl;vp[i].alc[0]=vp[i].alc[0]+r0;vp[i].alc[1]=vp[i].alc[1]+r1;vp[i].alc[2]=vp[i].alc[2]+r2;r[0]=r[0]-r0;r[1]=r[1]-r1;r[2]=r[2]-r2;cout<<"a资源还剩"<<r[0]<<" b资源还剩"<<r[1]<<" c 资源还剩"<<r[2]<<endl;cout<<endl;}i++;if(i>=vp.size())i=0;}}elsei++;if(i>=vp.size())i=0;x++;if(x>=200){cout<<"初始化的表不安全"<<endl;return 0;}}cout<<"进程已经全部结束"<<endl;break;case 2:while(!vp.empty()){int a2;static int i2=0;if((a2=vp[i2].request())!=0){if(a2==1){cout<<"进程"<<vp[i2].id<<"已经结束"<<endl;for(int j=i2;j<vp.size()-1;j++){vp[j]=vp[j+1];}vp.pop_back();if(i2>=vp.size())i2=0;cout<<"a资源还剩"<<r[0]<<" b资源还剩"<<r[1]<<" c资源还剩"<<r[2]<<endl;cout<<endl;}else{vp[i2].alc[0]=vp[i2].alc[0]+r0;vp[i2].alc[1]=vp[i2].alc[1]+r1;vp[i2].alc[2]=vp[i2].alc[2]+r2;r[0]=r[0]-r0;r[1]=r[1]-r1;r[2]=r[2]-r2;cout<<"a资源还剩"<<r[0]<<" b资源还剩"<<r[1]<<" c资源还剩"<<r[2]<<endl;cout<<endl;i2++;if(i2>=vp.size())i2=0;}}elsei2++;if(i2>=vp.size())i2=0;x++;if(x>=200){cout<<"产生死锁"<<endl;return 0;}}cout<<"进程已经全部结束"<<endl;break;default:cout<<"选择错误"<<endl;break;}return 1;}。

海南大学三亚学院《计算机操作系统》课程设计死锁的避免——银行家算法专业班级：成员：提交时间：一、问题描述（标题：宋体四号）内容：1、解释什么是银行家算法（宋体，小四，行间距1.5倍）银行家算法又称“资源分配拒绝”法，其基本思想是，系统中的所有进程放入进程集合，在安全状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。

这时系统将该进程从进程集合中将其清除。

此时系统中的资源就更多了。

反复执行上面的步骤，最后检查进程的集合为空时就表明本次申请可行，系统处于安全状态，可以实施本次分配，否则，只要进程集合非空，系统便处于不安全状态，本次不能分配给他。

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

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

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

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

2、银行家算法提出的原因在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险━━死锁。

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

一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源，这种现象称为进程死锁，这一组进程就称为死锁进程。