实验四 死锁避免的算法
操作系统实验报告-死锁的避免
操作系统实验报告-死锁的避免操作系统实验（二）死锁的避免1.实验内容使用C++实现模拟随机算法和银行家算法2.实验目的（1）了解死锁的产生原因（随机算法）（2）理解死锁的解决办法（银行家算法）3.实验题目使用随机算法和银行家算法设计程序4.程序流程图主要过程流程图银行家算法流程图安全性算法流程图5.程序代码和运行结果#include <stdio.h>#include<stdlib.h> typedef struct{int A;int B;int C;}RES;#define false 0#define true 1//系统中所有进程数量#define PNUMBER 3//最大需求矩阵RES Max[PNUMBER];//已分配资源数矩阵RES Allocation[PNUMBER];//需求矩阵RES Need[PNUMBER];//可用资源向量RES Available={0,0,0};//安全序列int safe[PNUMBER];void setConfig(){int i=0,j=0;printf("================开始手动配置资源==================\n");//可分配资源printf("输入可分配资源\n");scanf("%d%d%d",&Available.A,&Available.B,&Available.C);//最大需求矩阵MAXprintf("输入最大需求矩阵%dx%d\n",PNUMBER,PNUMBER );for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);}//已分配矩阵Allocprintf("输入已分配矩阵%dx%d\n",PNUMBER,PNUMBER);for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);}//需求矩阵printf("输入需求矩阵%dx%d\n",PNUMBER,PNUMBER);for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);}printf("================结束配置资源==================\n");}void loadConfig(){FILE *fp1;if ((fp1=fopen("config.txt","r"))==NULL){printf("没有发现配置文件,请手动输入\n");setConfig();}else{int i=0;printf("发现配置文件,开始导入..\n");//可分配资源fscanf(fp1,"%d%d%d",&Available.A,&Available.B,&Available.C);//最大需求矩阵MAXfor (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);}//已分配矩阵Allocfor (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);}//需求矩阵for (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);}}}//试探分配void ProbeAlloc(int process,RES *res){Available.A -= res->A;Available.B -= res->B;Available.C -= res->C;Allocation[process].A += res->A;Allocation[process].B += res->B;Allocation[process].C += res->C;Need[process].A -= res->A;Need[process].B -= res->B;Need[process].C -= res->C;}//若试探分配后进入不安全状态，将分配回滚void RollBack(int process,RES *res){Available.A += res->A;Available.B += res->B;Available.C += res->C;Allocation[process].A -= res->A;Allocation[process].B -= res->B;Allocation[process].C -= res->C;Need[process].A += res->A;Need[process].B += res->B;Need[process].C += res->C;}//安全性检查bool SafeCheck(){RES Work;Work.A = Available.A;Work.B = Available.B;Work.C = Available.C;bool Finish[PNUMBER] = {false,false,false};int i;int j = 0;for (i = 0; i < PNUMBER; i++){//是否已检查过if(Finish[i] == false){//是否有足够的资源分配给该进程if(Need[i].A <= Work.A && Need[i].B <= Work.B && Need[i].C <= Work.C){//有则使其执行完成，并将已分配给该进程的资源全部回收Work.A += Allocation[i].A;Work.B += Allocation[i].B;Work.C += Allocation[i].C;Finish[i] = true;safe[j++] = i;i = -1; //重新进行遍历}}}//如果所有进程的Finish向量都为true则处于安全状态，否则为不安全状态for (i = 0; i < PNUMBER; i++){if (Finish[i] == false){return false;}}return true;}//资源分配请求bool request(int process,RES *res){//request向量需小于Need矩阵中对应的向量if(res->A <= Need[process].A && res->B <= Need[process].B && res->C <=Need[process].C){//request向量需小于Available向量if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C){//试探分配ProbeAlloc(process,res);//如果安全检查成立，则请求成功，否则将分配回滚并返回失败if(SafeCheck()){return true;}else{printf("安全性检查失败。
操作系统实验报告 预防进程死锁的银行家算法
操作系统实验预防进程死锁的银行家算法一、需求分析：1、实验目的：通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
2、问题描述：设计程序模拟预防进程死锁的银行家算法的工作过程。
假设系统中有n个进程P1, … ,P n，有m类可分配的资源R1, … ,R m，在T0时刻，进程P i分配到的j类资源为Allocation ij个，它还需要j类资源Need ij个，系统目前剩余j类资源Work j个，现采用银行家算法进行进程资源分配预防死锁的发生。
3、程序要求：1）判断当前状态是否安全，如果安全给出安全序列；如果不安全给出理由。
2）对于下一个时刻T1，某个进程P k会提出请求Request(R1, … ,R m)，判断分配给P k进程请求的资源之后系统是否安全。
3）输入：进程个数n，资源种类m，T0时刻各个进程的资源分配情况（可以运行输入，也可以在程序中设置）；4）输出：如果安全，输出安全的进程序列，不安全则提示信息。
二、概要设计：1、进程调度的实现过程2、程序中的变量及数据结构struct ResItem{string Name;int Number;}; //资源项typedef vector<ResItem> Resource;struct Progress{string Name;Resource Max; //最大需求Resource Allocation; //分配Resource Need; //需求}; //进程vector <Progress> Progresses; //所有进程vector <ResItem> Available; //可利用资源向量vector <Progress> SafeOrder; //安全序列3、主要函数//初始化数据void InitData(int &n);//判断rs1是否小于等于rs2，是返回true，否则返回falseinline bool LessThan(Resource rs1,Resource rs2);//安全性算法bool SafeAlg();//银行家算法bool BankerAlg(Resource request,Progress &pro);4、主函数int main(){int n;InitData(n);cout<<"\n\n=============================================\n ";if(SafeAlg()){cout<<"由安全性检查可知：可以找到一个安全序列为：{";for(int i = 0 ; i < SafeOrder.size(); i++)cout<<SafeOrder[i].Name<<",";cout<<"}。
实验报告(死锁的避免)
三、程序设计和说明
1.算法描述
2.算法实现
四、实课程实验报告
实验名称：死锁的避免
姓名：
学号：
专业：
五邑大学计算机学院
一、实验目的
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
二、实验内容
编写一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法有效地避免死锁的发生。实验要求设计一个有三类资源A、B、C的系统，它们的资源总量分别为10、5、7，资源由五个进程p0、p1、p2、p3、p4共享。假设当前的资源分配状态为：
避免死锁银行家算法的模拟实现
避免死锁银行家算法的模拟实现实验题目：机时：4实验一避免死锁银行家算法的模拟实现目的与任务银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
内容和要求在了解和掌握银行家算法的基础上，能熟练的处理课本例题中所给状态的安全性问题，能编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。
具体程序的功能要求：1.设定进程对各类资源最大申请表示及初值确定。
2.设定系统提供资源初始状况(已分配资源、可用资源)。
3.设定每次某个进程对各类资源的申请表示。
4.编制程序，依据银行家算法，决定其申请是否得到满足。
设计内容(原理图以及相关说明、调试过程、结果设requesti为进程p[i]的请求向量，如果requesti[j]=K，表示进程p[i]需要K 个Rj资源。
当系统发出请求后，系统按下述步骤开始检查：(1)、如果requesti[j]=need[i][j],转向步骤2；否则报告出错，申请的资源已经大于它需要的最大值。
(2)、如果requesti[j]=available[j],转向步骤3；否则报告出错，尚无足够的资源。
(3)、系统试探着把资源分配给p[i]，并修改下列数据结构中的值：available[j]=available[j]-request[j]allocation[i][j]=allocation[i][j]+request[j]need[i][j]=need[i] [j]-request[j](4)、系统进行安全性算法，检查此次分配后，系统是否还处于安全状态，若安全，把资源分配给进程p[i]；否则，恢复原来的资源分配状态，让进程p[i]等待。
安全性算法1.为实现银行家算法，系统中需要设置若干数据结构，用来表示系统中各进程的资源分配及需求情况。
假定系统中有m个进程，n类资源进程数和资源数由程序中直接定义，#define m5//总进程数#define n4//总资源数对于不同规模的进程和资源数，在程序中直接修改m和n值即可。
死锁避免实验报告
“死锁避免”实验报告实验思路：先定义进程控制块的数据结构pcb，确定进程并发数目SIZE，在初始化进程时，保证各进程最大资源申请量不大于系统的资源总量，如果大于，则重新输入。
初始化完成之后，选择相应的死锁避免的算法，或随机分配算法，或银行家算法。
随机分配方法：运用取余的方法，轮询各个进程，选择处于就绪状态的进程之一，然后输入该进程的当前资源申请量apply，判断该申请量是否大于系统当前资源剩余量，若大于，将就绪进程状态设置为阻塞态，然后查找就绪队列中是否还有就绪进程，若有，则选择一个就绪进程，继续执行，若没有就绪进程，则表示发生死锁。
若不大于，则给满足该进程的申请量，并将其自愿申请量的变量设为0。
接着再进行判断该进程是否得到全部所需资源，若没有，则选择就绪队列中一个就绪进程，若全部得到，归还该进程所占有的全部资源给系统，并将该进程设置为完成态。
此时，再进行检查有无等待态的进程，若没有，则选择就绪队列中一个就绪进程，若有，则顺序检查等待进程，判断系统现有资源能满足某一等待进程，若能，则将该等待进程状态设置为就绪态，若没有，查找就绪队列中是否还有就绪进程，若有，则选择一个就绪进程，继续执行，若没有就绪进程，则表示发生死锁。
银行家算法：运用取余的方法，轮询各个进程，选择处于就绪状态的进程之一，然后输入该进程的当前资源申请量apply，判断该申请量是否大于系统当前资源剩余量，若大于，将就绪进程状态设置为阻塞态，然后查找就绪队列中是否还有就绪进程，若有，则选择一个就绪进程，继续执行，若没有就绪进程，则表示发生死锁。
若不大于，则假定满足该进程的申请量，并将其资源申请量的变量设为0，表示系统资源的变量减少相应的该进程的资源申请量，然后系统资源暂时用一个变量current保存起来。
将分配后系统剩余的资源数量与各进程的剩余需求量比较寻找一个系统能满足其需求的进程，每找一次，都要计数，用num变量，若找到，在标记数组a[SIZE]中进行相应标记，同时没找到一个都要进行一次对标记数组的循环测试，若测试到所有项都进行了标记，则退出循环，说明此次分配是安全的，若找不到，测试num的值，（对于确定数目的并发进程，其最大分配安全的循环次数<=SIZE!）。
实验四死锁
实验四 死锁一. 死锁的避免（一）实验目的当系统的总资源数m 小于或等于所有进程对资源的最大需求n S n i i −∑=1时，就可能产生死锁。
死锁会引起计算机系统的瘫痪。
银行家算法是在实现资源分配时避免死锁的一个著名算法，该算法是在能确保系统处于安全状态时才把资源分配给申请者。
通过本实验使学生能进一步理解死锁的概念，并能选择一个算法来避免死锁。
（二）实验题目系统中有m 个同类资源被n 个进程共享，每个进程对资源的最大需求数分别为S 1, S 2,…,S n ，且Max(S i )<=m, (i=1,2,…n)。
进程可以动态地申请资源和释放资源。
编写一个程序，实现银行家算法，当系统将资源分配给某一进程而不会死锁时，就分配之。
否则，推迟分配，并显示适当的信息。
（三）数据结构和操作说明参照教材上有关银行家算法的资源分配表，设计适当的数据结构。
进程要分配的资源数可由随机数决定或命令行输入，但要注意数据的有效范围。
（四）实验报告要求画出实现银行家算法的程序框图，说明数据结构。
在每当进程要分配资源时以及释放资源后，打印输出资源分配或释放后的分配情况表，如可能产生死锁，显示适当信息；如不会产生死锁，更新系统的资源分配状态表。
二． 死锁的检测（一）实验目的采用银行家算法来预防死锁是可靠的，但也是非常保守的，因为它限制了进程对资源的存取，从而降低了进程的并发运行程度。
死锁检测并不限制进程对资源的申请，只要有，就分配，但这也可能造成死锁。
但由于死锁并不是经常发生的，故大大提高了系统运行的效率。
通过本实验，可使学生进一步加深理解和掌握死锁的检测算法。
（二）实验题目分别使用检测“进程—资源循环等待链”的方法和Coffman 的算法来检测进程的死锁状态。
对于相同的进程资源分配、占用次序，比较两个算法的结果。
（三）数据结构Coffman 的死锁检测算法的数据结构参考书本4.7节图4-13的资源占用矩阵、进程等待资源矩阵Q 、资源总数向量和可用资源向量W 。
什么是死锁？如何避免死锁的算法
什么是死锁？如何避免死锁的算法所谓死锁：是指两个或两个以上的进程在执⾏过程中，因争夺资源⽽造成的⼀种互相等待的现象，若⽆外⼒作⽤，它们都将⽆法推进下去。
此时称系统处于死锁状态或系统产⽣了死锁，这些永远在互相等待的进程称为死锁进程。
由于资源占⽤是互斥的，当某个进程提出申请资源后，使得有关进程在⽆外⼒协助下，永远分配不到必需的资源⽽⽆法继续运⾏，这就产⽣了⼀种特殊现象死锁。
虽然进程在运⾏过程中，可能发⽣死锁，但死锁的发⽣也必须具备⼀定的条件，死锁的发⽣必须具备以下四个必要条件。
1）互斥条件：指进程对所分配到的资源进⾏排它性使⽤，即在⼀段时间内某资源只由⼀个进程占⽤。
如果此时还有其它进程请求资源，则请求者只能等待，直⾄占有资源的进程⽤毕释放。
2）请求和保持条件：指进程已经保持⾄少⼀个资源，但⼜提出了新的资源请求，⽽该资源已被其它进程占有，此时请求进程阻塞，但⼜对⾃⼰已获得的其它资源保持不放。
3）不剥夺条件：指进程已获得的资源，在未使⽤完之前，不能被剥夺，只能在使⽤完时由⾃⼰释放。
4）环路等待条件：指在发⽣死锁时，必然存在⼀个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待⼀个P1占⽤的资源；P1正在等待P2占⽤的资源，……，Pn正在等待已被P0占⽤的资源。
1) 预防死锁。
这是⼀种较简单和直观的事先预防的⽅法。
⽅法是通过设置某些限制条件，去破坏产⽣死锁的四个必要条件中的⼀个或者⼏个，来预防发⽣死锁。
预防死锁是⼀种较易实现的⽅法，已被⼴泛使⽤。
但是由于所施加的限制条件往往太严格，可能会导致系统资源利⽤率和系统吞吐量降低。
a 破坏互斥条件 如果允许系统资源都能共享使⽤，则系统不会进⼊死锁状态。
但有些资源根本不能同时访问，如打印机等临界资源只能互斥使⽤。
所以，破坏互斥条件⽽预防死锁的⽅法不太可⾏，⽽且在有的场合应该保护这种互斥性。
b 破坏不剥夺条件 当⼀个已保持了某些不可剥夺资源的进程，请求新的资源⽽得不到满⾜时，它必须释放已经保持的所有资源，待以后需要时再重新申请。
银行家算法
实验四银行家算法一、实验学时2 学时二、实验目的与要求（1）了解多道程序系统中，多个进程并发执行的资源分配。
（2）掌握死锁产生的原因、产生死锁的必要条件和处理死锁的基本方法。
（3）掌握预防死锁的方法，系统安全状态的基本概念。
（4）掌握银行家算法，了解资源在进程并发执行中的资源分配策略。
（5）理解避免死锁在当前计算机系统中不常使用的原因。
三、实验内容在多道程序系统中，虽可借助于多个进程的并发执行来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险——死锁。
死锁是指多个进程在运行中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，他们都将无法再向前推进。
银行家算法是最具代表性的避免死锁的算法，它的基本思想是分配资源之前，判断系统是否是安全的，若是才分配资源。
设计一个n个并发进程共享m个系统资源的程序实现银行家算法。
要求包含：1、一个简单的界面。
2、显示或修改当前系统资源情况。
3、添加进程对资源的需求。
4、判断是否存在死锁，若无死锁则显示其安全序列。
5、若产生死锁，制定策略，以最小的代价解决死锁问题。
四、实验重点、难点银行家算法的实现、解除死锁的策略。
五、实验教学方法集中讲授，讨论需求，由学生独立完成六、运行结果分析1、给出一组初始数据。
2、根据给出的数据得出运行结果。
3、分析结果是否符合原理。
4、产生死锁时你采用的策略是什么？为什么？5、分析所写程序还有什么可以改进的地方。
七、关键数据结构及源代码1、带注释的源代码。
实验四 银行家算法模拟
实验四银行家算法模拟【实验目的】（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: 它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish ［i］∶=false; 当有足够资源分配给进程时，再令Finish［i］∶=true。
死锁产生条件以及预防和处理算法
死锁产⽣条件以及预防和处理算法 ⼀、死锁的概念 在多道程序系统中，虽可借助于多个进程的并发执⾏，来改善系统的资源利⽤率，提⾼系统的吞吐量，但可能发⽣⼀种危险━━死锁。
所谓死锁(Deadlock),是指多个进程在运⾏中因争夺资源⽽造成的⼀种僵局(Deadly_Embrace),当进程处于这种僵持状态时，若⽆外⼒作⽤，它们都将⽆法再向前推进。
⼀组进程中，每个进程都⽆限等待被该组进程中另⼀进程所占有的资源，因⽽永远⽆法得到的资源，这种现象称为进程死锁，这⼀组进程就称为死锁进程。
⼆、死锁产⽣的原因 产⽣死锁的原因主要是： （1）因为系统资源不⾜。
（2）进程运⾏推进的顺序不合适。
（3）资源分配不当等。
如果系统资源充⾜，进程的资源请求都能够得到满⾜，死锁出现的可能性就很低，否则就会因争夺有限的资源⽽陷⼊死锁。
其次，进程运⾏推进顺序与速度不同，也可能产⽣死锁。
产⽣死锁的四个必要条件： （1）互斥条件：⼀个资源每次只能被⼀个进程使⽤。
（2）请求与保持条件：⼀个进程因请求资源⽽阻塞时，对已获得的资源保持不放。
（3）⾮抢占:进程已获得的资源，在末使⽤完之前，不能强⾏抢占。
（4）循环等待条件:若⼲进程之间形成⼀种头尾相接的循环等待资源关系。
三、死锁处理⽅法： （1）可使⽤协议以预防或者避免死锁，确保系统不会进⼊死锁状态； （2）可允许系统进⼊死锁状态，然后检测他，并加以恢复； （3）可忽视这个问题，认为死锁不可能发⽣在系统内部。
四、死锁预防 1、互斥：对于⾮共享资源，必须要有互斥条件； 2、占有并等待： 为了确保占有并等待条件不会出现在系统中，必须保证：当⼀个进程申请⼀个资源时，它不能占有其他资源。
⼀种可以使⽤的协议是每个进程在执⾏前申请并获得所有资源，可以实现通过要求申请资源的系统调⽤在所有的其他系统调⽤之前执⾏。
3、⾮抢占： 为了确保第三个条件不成⽴，可以使⽤如下协议：如果⼀个进程占有资源并申请另⼀个不能⽴即分配的资源，那么其现已分配资源都可被抢占； 4、循环等待： 为了确保循环等待条件不成⽴，⼀种可⾏的算法是：对所有资源进程排序，且要求每个进程按照递增顺序来申请进程。
死锁避免算法设计报告
漳州师范学院操作系统课程设计死锁避免算法设计姓名：学号：系别：专业：年级：指导教师：一、课程设计题目介绍（含设计目的）死锁避免算法设计是通过模拟实现银行家算法实现死锁避免目的：1、了解进程产生死锁的原因，了解为什么要进行死锁的避免。
2、掌握银行家算法的数据结构，了解算法的执行过程，加深对银行家算法的理解。
3、通过运用Dijkstra的银行家算法来避免多个进程运行中因争夺资源而造成僵局，即死锁要求：本课程设计可以实现教材3.6.3节中所描述的银行家避免死锁算法。
可自定义进程数目、资源类型和每种类型资源的数目；可输入每个进程对每种资源的最大需求、已经获得的数量；当某进程发起某种资源请求时，计算系统状态是否安全。
思想：操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配，从而达到死锁的避免。
二、总体设计（含系统的结构、原理框图或模块介绍等）1.系统的结构2.原理框图从主函数开始进入银行家算法系统，先调用初始化函数chushihua()分别输入Allocation[i][j]，Max[i][j]，All[y]并判断是否符合条件，在调用函数show(),输出当前状态Available，Max[i][j]，Allocation[i][j]，Need[i][j]。
然后调用安全性算法函数safe()判断在该时刻是否处于安全状态，并输出安全序列。
然后调用银行家算法函数bank()进行试分配后再调用安全性算法函数判断在该时刻是否处于安全状态，若不安全，则恢复试分配时改变的值。
《死锁避免》实验报告
一、实验目的本次实验旨在通过模拟操作系统的资源分配和请求过程，深入理解死锁的概念、产生死锁的必要条件以及如何通过银行家算法来避免死锁的发生。
通过实验，学生能够掌握以下知识点：1. 死锁的概念及产生条件；2. 银行家算法的基本原理和实现方法；3. 资源分配和请求过程中的安全性检查；4. 通过银行家算法避免死锁的发生。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 20194. 实验环境：一台配置较高的计算机三、实验原理1. 死锁的概念死锁是指多个进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，这些进程都将无法继续执行。
2. 产生死锁的必要条件产生死锁的必要条件有四个，分别为：（1）互斥条件：资源不能被多个进程同时使用；（2）持有和等待条件：进程已获得至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时该进程会等待；（3）非抢占条件：已分配给进程的资源，在进程完成之前，不能被抢占；（4）循环等待条件：存在一种进程资源的循环等待链，即进程P1等待P2占有的资源，P2等待P3占有的资源，以此类推，最后Pn等待P1占有的资源。
3. 银行家算法银行家算法是一种避免死锁的算法，通过以下步骤实现：（1）初始化系统资源、进程最大需求、已分配资源等数据结构；（2）当进程请求资源时，判断是否满足以下条件：a. 当前可用资源数量大于等于进程请求的资源数量；b. 根据当前资源分配情况，系统处于安全状态；若满足以上条件，则分配资源；否则，进程等待。
（3）当进程释放资源时，更新可用资源数量和分配资源情况。
四、实验内容1. 设计系统资源、进程最大需求、已分配资源等数据结构；2. 实现银行家算法，包括资源分配、安全性检查等功能；3. 模拟进程请求资源和释放资源的过程，观察系统状态变化；4. 分析实验结果，验证银行家算法是否能够避免死锁的发生。
实验4--利用银行家算法避免死锁
实验10 利用银行家算法避免死锁一．实验目的1．加深对死锁概念的理解。
2．能够利用银行家算法，有效避免死锁的发生，或检测死锁的存在。
二．实验内容利用银行家算法写一个程序，判定系统的安全性。
已知某系统有5个进程P0、P1、P2、P3、P4，三类资源A，B，C。
死锁检测程序工作时各进程对资源的需求和占用情况如表10-1所示，当前可用资源向量available=(0,0,0)。
表10-1 进程需求资源情况三．实验程序及分析# define m 3# define n 5main(){int test(int av[],int ned[],int all[]);int available[m]={0,0,0}, need[n][m];int allocation[n][m]={{0,1,0},{2,0,0},{3,0,3},{2,1,1},{0,0,2}};int i,j,g=1;int finish[n]={0,0,0,0,0};clrscr();printf("please input the need resource data\n");for(i=0;i<n;i++)for(j=0;j<m;j++)scanf("%d",&need[i][j]); /*输入need*/j=0; /*以下循环用来寻找能够运行完成的进程Pi*/do{for(i=0;i<n;i++)if (finish[i]==0 && test(need[i],available,allocation[i]))finish[i]=1;j++;}while(j<n);for(i=0;i<n;i++) /*g表示系统是否处于安全状态*/ g=g&&finish[i];if (g) printf("safe state");else printf("not safe state");}int test(int nd[],int av[],int all[]){int z=0;int i;for(i=0;i<m;i++)if (nd[i]>av[i]) break;if (i==m) z=1;if (z==1)for(i=0;i<m;i++)av[i]=av[i]+all[i];return(z);}运行输入：0 0 22 2 20 0 01 0 00 0 2输出结果：safe state10for(int i=0;i<n;i++){cout<<"名称:";cin>>name[flag];cout<<"数量:";cin>>Avaliable[flag++];}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 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();11safe();}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<<"*****************资源管理系统的设计与实现*****************"<<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<<"**************银行家算法演示***************"<<endl;cout<<" 1:增加资源"<<endl;cout<<" 2:删除资源"<<endl;cout<<" 3:修改资源"<<endl;cout<<" 4:分配资源"<<endl;cout<<" 5:增加作业"<<endl;cout<<" 0:离开"<<endl;cout<<"*******************************************"<<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;}。
操作系统第七章实验——死锁的避免
第七章 死锁的避免软件121 1102052019 金凯1.实验题目：用银行家算法实现资源的分配银行家算法：Dijkstra (1965)提出了一种能够避免死锁的调度算法，称为银行家算法。
其基本思想是：系统中的所有进程放入一个进程集合，先把资源试探性地分配给它。
然后找出剩余资源能满足最大需求量的进程，进行分配。
（来源于教材202页）2.程序中所使用的数据结构及主要符号说明考虑到一个系统有n 个进程和m 种不同类型的资源，定义以下向量和矩阵数据结构。
1.系统中每类资源总数向量 Resource=（R 1，R 2，…，R m ）2.系统中当前每类资源可用数向量 Available=（V 1，V 2，…,V m ）3.进程对各类资源的最大需求矩阵（C ij 表示进程P i 需要R j 类资源的最大数目）C 11 C 12 … C 1mC 21 C 22 … C 2m Claim= ………C n1 C n2 … C nm4.系统中当前资源的已分配情况矩阵（Aij 表示进程P i 已分配到R j 类资源的数目）A11 A 12 … A 1m A 21 A 22 … A 2mAllocation= ……… A n1 A n2 … A nm系统安全性定义：在时刻T 0系统是安全的，仅当存在一个进程序列P 1，P 2，… ，P n ，对进程P k （k=1,2，… n ）满足公式：{C ki -A ki <=V i +∑A ji (j=1...<k-1>)，k=1,2，… ,n;i=1,2, … ,m}此公式为安全序列（参考教材201页）3.程序流程图1、系统主要过程流程图2、银行家算法流程图3、安全性算法流程图4.源程序本程序在c++编译器cfree上通过测试，vc6.0没有经过测试。
说明：这里建立了如教材204-206页上面的一个例子，模拟了5个进程请求资源的情况。
具体可以对照教材说明进行查阅。
死锁实验报告
操作系统实验报告银行家算法避免死锁时间：2014-04-17计122吴泽元1213023057计122 刘奔1213023062一、实验内容(1)死锁的避免编写一个程序，实现银行家算法，当系统将资源分配给某一进程而不会死锁时，就分配之。
否则，推迟分配，并显示适当的信息。
(2)死锁的检测分别使用检测“进程—资源循环等待链”的方法和Coffman 的算法来检测进程的死锁状态。
对于相同的进程资源分配、占用次序，比较两个算法的结果。
二、实验目的通过本实验使学生进一步理解死锁的概念，并能选择一个算法来避免死锁，让学生进一步加深理解和掌握死锁的检测算法三、实验题目题目：死锁的避免和死锁的检测。
①数据结构struct Bank{int Available[m];//可利用资源向量int Max[m][n];//最大需求矩阵int Allocation[m][n];//分配矩阵int Need[m][n]; //需求矩阵};②程序总体框图四、源程序#include<iostream>using namespace std;#define m 5 //进程数#define n 3 //资源种类数struct Bank{int Available[m]; //可利用资源向量int Max[m][n]; //最大需求矩阵int Allocation[m][n]; //分配矩阵int Need[m][n]; //需求矩阵}void Initilize(Bank &); //初始化int SafeTest(Bank); //检查安全性void ResoureAllocate(Bank &); //系统对进程资源申请的处理void main(){cout<<"当前系统中存在"<<m<<"个进程"<<n<<"种资源"<<endl;Bank current; //定义变量int flag=1,temp;Initilize(current); //初始化SafeTest(current); //检查安全性while(flag) //循环执行进程申请资源和系统对申请的处理{cout<<"要退出吗？（0=退出，1=继续）"<<endl;cin>>temp;flag=temp;if(flag==1){ResoureAllocate(current);}}}void Initilize(Bank &bank){int i,j;cout<<"输入各进程的相关信息\n";cout<<"请输入进程的最大需求矩阵Max："<<'\n';for(i=0;i<m;i++) //设置最大需求矩阵for(j=0;j<n;j++){ cin>>bank.Max[i][j];}cout<<"请输入分配矩阵Allocation："<<endl;for(i=0;i<m;i++) //设置分配矩阵for(j=0;j<n;j++){ cin>>bank.Allocation[i][j];}for(i=0;i<m;i++) //设置需求矩阵for(j=0;j<n;j++){ bank.Need[i][j]=bank.Max[i][j]-bank.Allocation[i][j];} cout<<"请输入系统当前可利用资源向量："<<'\n';for(i=0;i<n;i++) //设置可利用资源向量cin>>bank.Allocation[i];}int SafeTest(Bank bank){int i,j;int safePCB[m]; //安全序列向量int work[n]; //空闲资源矩阵int Finish[m]; //进程完成标志矩阵for(i=0;i<m;i++)work[i]=bank.Allocation[i];for(i=0;i<m;i++)Finish[i]=false;int k=0;for(i=0;i<m;i++){if(Finish[i]==false){for(j=0;j<n;j++){if(bank.Need[i][j]>work[j])break;}if(j==n){safePCB[k++]=i;for(int q=0;q<n;q++)work[q]+=bank.Allocation[i][q];Finish[i]=ture;i=-1;}}}for(i=0;i<m;i++)if(!Finish[i]){ cout<<"找不到安全序列，系统处于不安全状态！\n";return 0;}cout<<"存在安全序列：";for(i=0;i<m;i++)cout<<"P"<<safePCB[i]+1<<"";cout<<"\n系统处于安全状态";return 1;void ResoureAllocate(Bank &bank){Bank temp=bank;int Request[n];int PCBNum;int i;cout<<"请输入要申请资源的进程序号（1~5）：\n";cin>>PCBNum;cout<<"请输入请求向量：\n";for(i=0;i<n;i++)cin>>Request[i];for(i=0;i<n;i++){if(Request[i]>bank.Need[PCBNum-1][i]){cout<<"进程所需要的资源数已超过它所宣布的最大值，系统不予分派资源！\n";return ;}if(Request[i]>bank.Available[i]){cout<<"系统中无足够的资源满足进程的申请，系统不予分配资源！\n";return ;}}for(i=0;i<n;i++){bank.Available[i]-=Request[i];bank.Need[PCBNum-1][i]-=Request[i];bank.Allocation[PCBNum-1][i]+=Request[i];}if(SafeTest(bank)){cout<<"系统可以为该进程分配资源\n";return ;}else{cout<<"系统不为该进程分配资源\n";bank=temp;return ;}六、实验总结银行家算法是一个经典的避免死锁的算法，它可以有效的避免资源分配时产生死锁。
死锁避免算法模拟实验——银行家算法
操作系统实验报告死锁避免算法的模拟实验——银行家算法班级：2013级软件工程1班学号：X X X姓名：萧氏一郎数据结构说明：①可利用资源向量available, n个元素的数组,每个元素代表一类可用资源的数目, available [ i ] = k，表示系统中有Rj 类资源k 个。
②最大需求矩阵MAX, n3 m矩阵定义n 个进程时,m 类资源的最大需求max ( i, j) = k 表示进程需要Rj类资源最大数目为k 。
③分配矩阵allocation, n3 m矩阵,表示n个进程的每个进程已分配资源情况, alloction ( i, j) = k表示进程i已分配Rj类资源k 个。
④需求矩阵need, n3 m矩阵,表示各进程仍需要各类资源, need ( i, j) = k表示进程i仍需要资源Rj的数目为k.由上述分析可知need i =max i - allocation i。
流程图：源代码：#include<stdio.h>int Isprocessallover(); //判断系统中的进程是否全部运行完毕void Systemstatus(); //显示当前系统中的资源及进程情况void Allow(int ,int *); //若进程申请不导致死锁，用此函数分配资源void Forbidenseason(int ); //若发生死锁，则显示原因int Banker(int ,int *); //银行家算法int Availiable[5] = { 5,6, 6,5,4}; //初始状态，系统可用资源量int Max[5][5] = {{1,2,3,2,3},{3,2,2,3,3},{7,0,2,3,3},{2,2,2,2,3},{4,3,3,1,3 }}; //各进程对各资源的最大需求量intAllocation[5][5]={{0,1,0,0,1},{2,0,0,1,1},{3,0,2,0,1},{2,1, 1,0,1},{0,0,2,0,1},}; //初始状态，各进程占有资源量intNeed[5][5]={{1,1,3,2,2},{1,2,2,2,2},{4,0,0,3,2},{0,1,1,2,2} ,{4,3,1,1,2},}; //初始状态时，各进程运行完毕，还需要的资源量int over[5]={0,0,0,0,0}; //标记对应进程是否得到所有资源并运行完毕int main(){int i,j,k;int process=0; //发出请求的进程int decide=0; //银行家算法的返回值int Request[5]={0,0,0,0,0}; //申请的资源量数组int sourcenum=0; //申请的各资源量/*判断系统中进程是否全部运行完毕*/step1: if(Isprocessallover()==1){puts("系统中全部进程运行完毕！");return 0;}/*显示系统当前状态*/Systemstatus();/*人机交互界面*/step2: printf("输入发出请求的进程（输入“0”退出系统）:"); scanf("%d",&process);if(process == 0){printf("放弃申请，退出系统！");return 0;}if(process<1 || process>5 ||over[process-1]==1){puts("系统无此进程!");goto step2;}puts("此进程申请各资源（A,B,C,D,E）数目： ");for(i=0;i<5;i++){printf("%c资源:",65+i);scanf("%d",&sourcenum);Request[i] = sourcenum;}/*用银行家算法判断是否能够进行分配*/decide=Banker(process,Request);if (decide==0){/*将此进程申请资源分配给它*/Allow(process,Request);goto step1;}else{/*不能分配，显示原因*/Forbidenseason(decide);goto step2;}return 0;}int Isprocessallover(){int i,j;int processnum=0;for(i=0;i<6;i++){//判断每个进程是否运行完毕if(over[i]==1) processnum++;}if(processnum == 5) return 1; //系统中全部进程运行完毕return 0;}void Systemstatus(){int i,j;puts("此刻系统中存在的进程:");for(i=0;i<5;i++)if(over[i]!=1) printf("P%d ",i+1);puts("");puts("此刻系统可利用资源（单位：个）:");puts("A B C D E");for(i=0;i<5;i++) printf("%d ",Availiable[i]);puts("");puts("此刻各进程已占有资源如下（单位：个）:");puts(" A B C D E");for(i=0;i<5;i++){if(over[i]==1) continue;printf("P%d ",i+1);for(j=0;j<5;j++) printf("%d ",Allocation[i][j]);puts("");}puts("各进程运行完毕还需各资源如下（单位：个）:"); puts(" A B C D E");for(i=0;i<6;i++)if(over[i]==1) continue;printf("P%d ",i+1);for(j=0;j<5;j++) printf("%d ",Need[i][j]); puts("");}}int Banker(int p,int *R){int i,j,m,n;int num=0;int Finish[5]={0,0,0,0,0};int work[5]={0,0,0,0,0};int AvailiableTest[5];int AllocationTest[5][5];int NeedTest[5][5];/*判断申请的资源是否大于系统可提供的资源总量*/for(i=0;i<5;i++){if(*(R+i)>Availiable[i]) return 1;}/*判断该进程申请资源量是否大于初始时其申明的需求量*/for(i=0;i<5;i++){if(*(R+i)>Need[p-1][i]) return 2;}/*为检查分配的各数据结构赋初值*/for(i=0;i<5;i++)AvailiableTest[i]=Availiable[i];for(i=0;i<6;i++)for(j=0;j<5;j++)AllocationTest[i][j] = Allocation[j][i];for(i=0;i<6;i++)for(j=0;j<5;j++)NeedTest[i][j]=Need[j][i];/*进行试分配*/for(i=0;i<5;i++)AvailiableTest[i]-=*(R+i);AllocationTest[p-1][i]+=*(R+i);NeedTest[p-1][i]-=*(R+i);}/*检测进程申请得到满足后，系统是否处于安全状态*/for(i=0;i<5;i++)work[i]=AvailiableTest[i];for(m=1;m<=6;m++){for(n=0;n<6;n++){num = 0;/*寻找用此刻系统中没有运行完的进程*/if(Finish[n]==0&&over[n]!=1){for(i=0;i<4;i++)if(NeedTest[n][i]<=work[i])num++;if(num==4){for(i=0;i<4;i++)work[i]=work[i]+AllocationTest[n][i];Finish[n]=1;}}}}for(i=0;i<6;i++)if(Finish[i]==0 && over[i]!=1)return 3;return 0;}void Allow(int p,int *R){int i,j;puts("可以满足申请！") ;//可以满足申请！static int overnum;/*对进程所需的资源进行分配*/for(i=0;i<5;i++){Availiable[i]=Availiable[i]-*(R+i);Allocation[p-1][i]=Allocation[p-1][i]+*(R+i);Need[p-1][i]=Need[p-1][i]-*(R+i);}/*分配后判断其是否运行完毕*/overnum = 0;for(i=0;i<5;i++)if(Need[p-1][i] == 0) overnum++;if(overnum==5){/*此进程运行完毕，释放其占有的全部资源*/for(i=0;i<5;i++)Availiable[i]=Availiable[i]+Allocation[p-1][i];/*标记该进程运行完毕*/over[p-1]=1;printf("进程 P%d 所需资源全部满足，此进程运行完毕！\n");}}void Forbidenseason(int d){puts("不能满足申请，此进程挂起，原因为:");switch(d){case 1: puts("申请的资源量大于系统可提供的资源量!"); break;case 2: puts("申请的资源中有某种资源大于其声明的需求量!"); break;case 3: puts("若满足申请，系统将进入不安全状态，可能导致死锁!");}}。
死锁避免实验报告
沈阳工程学院学生实验报告（课程名称：操作系统）一、实验题目死锁避免实验。
二、实验要求编写一段程序模拟银行家算法。
三、实验目的多个进程动态地共享系统的资源时可能会产生死锁现象。
银行家算法是通过对资源的分配进行动态地检查来达到避免死锁的目的。
本实验通过模拟银行家算法的应用，使读者了解银行家算法的执行过程。
从而进一步理解死锁产生的条件和避免死锁问题产生的方法。
四、实验原理分析⑴死锁的产生必须同时满足4个条件：●互斥条件，即一个资源每次只能由一个进程占用。
●请求与保持条件，即一进程请求资源不能满足时，它必须等待，同时它仍保持已得到的所有其它资源。
●不可剥夺条件，任何一个进程不能抢占另一个进程已经获得且未释放的资源。
●环路等待条件，系统进入死锁的状态时，进程和资源之间形成一个封闭的环路。
⑵银行家算法是一种具有代表性的避免死锁的算法。
银行家算法为资源分配定义了两种状态，安全状态和不安全状态。
●安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。
处于安全状态的系统一定没有死锁发生。
●不安全状态：当系统中不存在一个安全序列时系统处于不安全状态。
不安全状态下一定导致死锁发生。
五、实验过程记录1.流程图安全算法流程图银行家算法2.实验结果图1图2图3图43.结果分析1.对于图1来说因为P0 申请的资源大于他所需求的，所以认为此次分配出错2.对于图2来说因为P0申请的资源大于剩余的资源，所以此次分配出错3对于图3来说对于系统安全且能分配序列的t0安全时刻表资源情况进程max Need allocation Work+allocationfinishQ W QWQ W Q WP0 4 5 1 2 3 3 4 11 true P1 3 6 1 2 2 4 6 15 true P2 5 7 1 2 4 5 10 20 trueP0申请资源是的安全性检查资源情况进程work need allocation Work+allocation finish Q W Q W Q W Q WP0 0 7 0 1 4 4 4 11 truep1 4 11 1 2 2 4 6 15 True P2 6 15 1 2 4 5 10 20 TRUE4.对于图4来说因为最大需求大于可利用资源所以系统不安全五、成绩评定优良中及格不及格出勤内容格式分析总评指导教师：年月日源代码#include <iostream>using namespace std;#define False 0#define True 1int Max[100][100]={0};int Allocation[100][100]={0};int Need[100][100]={0};int Available[100]={0};int Work[100]={0};char name[100]={0};int temp[100]={0};int S=100,P=100;int safequeue[100]={0};int Request[100]={0};//void Showdata(){int i,j,k,l;cout<<"\t资源分配情况\n"<<endl;cout<<"\tMax"<<"\t已分配"<<"\tNeed"<<endl;cout<<"\t";for(j=0;j<3;j++){for (i=0;i<S;i++){cout<<name[i]<<" ";}cout<<"\t";}cout<<endl;for(i=0;i<P;i++){cout<<i<<"\t";for (j=0;j<S;j++){cout<<Max[i][j]<<" ";}cout<<"\t";for (k=0;k<S;k++){cout<<Allocation[i][k]<<" ";}cout<<"\t";for (l=0;l<S;l++){cout<<Need[i][l]<<" ";}cout<<endl;}cout<<"\nAvailable"<<endl;for (i=0;i<S;i++){cout<<name[i]<<" ";}cout<<endl;for (i=0;i<S;i++){cout<<Available[i]<<" ";}cout<<endl;}int Judgesafe(){int tempwork[100][100]={0};int i,x,k=0,m,apply,Finish[100]={0};int j;int flag=0;for (i=0;i<S;i++){Work[i]=Available[i];}for(i=0;i<P;i++){apply=0;for(j=0;j<S;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==S){for(m=0;m<S;m++){tempwork[i][m]=Work[m];Work[m]=Work[m]+Allocation[i][m];}Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<P;i++)if(Finish[i]==False){cout<<"系统不安全"<<endl;return -1;}}cout<<"系统是安全的"<<endl;cout<<"分配的序列:";for(i=0;i<P;i++){cout<<temp[i];if(i<P-1) cout<<"->";}cout<<endl;return 0;}void Changedata(int flag){for (int i=0;i<S;i++){Available[i]=Available[i]-Request[i];Allocation[flag][i]=Allocation[flag][i]+Request[i];Need[flag][i]=Need[flag][i]-Request[i];}//void Share(){int i,flag;char ch='Y';cout<<"输入请求资源的进程："<<endl;cin>>flag;if (flag>=P){cout<<"此进程不存在!"<<endl;}else{cout<<"输入此进程对各个资源的请求数量："<<endl;for (i=0;i<S;i++){cin>>Request[i];}for (i=0;i<S;i++){if (Request[i]>Need[flag][i]){cout<<"进程"<<flag<<"申请的资源大于它所需要的资源!"<<endl;cout<<"分配不合理不予分配!"<<endl;ch='N';break;}else if (Request[i]>Available[i]){cout<<"进程"<<flag<<"申请的资源大于可利用的资源。
死锁的避免=实验要求
死锁的避免（选做）一、实验内容模拟进程的资源分配算法，了解死锁的产生和避免的办法二、实验目的为了了解系统的资源分配情况，假定系统的任何一种资源在任一时刻只能被一个进程使用。
任何进程已经占用的资源只能由进程自己释放，而不能由其他进程抢占。
当进程申请的资源不能满足时，必须等待。
因此，只要资源分配算法能保证进程的资源请求，且不出现循环等待，则系统不会出现死锁。
要求编写系统进行资源调度的程序。
一个是随机动态地进行资源分配的模拟程序，即只要系统当前剩余资源满足进程的当前请求，就立即将资源分配给进程，以观察死锁的产生情况；一个是采用银行家的算法，有效地避免死锁产生。
三、实验题目1、设计3～4个并发进程，共享系统的10个同类不可抢占的资源。
各进程动态进行资源的申请和释放。
（代码参考四，需调试并加注释）2、用银行家算法设计一个资源分配程序，运行这个程序，观察系统运行情况，并对系统运行的每一步情况进行显示。
四、实验程序//资源分配算法#include <iostream>#include <vector>#include <fstream>using namespace std;const int TASK_RUNNING=0;const int TASK_SUCCEED=1;const int TASK_WAITTING=2;const int RLength=10;int Rcs_left =RLength;ofstream ff("result.txt");class pcb{public:int p_pid;int p_stat;int p_apply;int p_occupy;bool p_issuc;int p_require;pcb(int id,int require){p_pid=id;p_require=require;p_stat=TASK_RUNNING;p_occupy=0;p_issuc=false;p_apply=0;}friend ostream&operator<<(ostream&cout,const pcb&p){cout<<p.p_pid<<'\t'<<p.p_stat<<'\t'<<p.p_require<<'\t'<<p.p_occupy<<endl; return cout;}};void rand (vector<int>&resource,vector<pcb>&pgrp);void banker(vector<int>&resource,vector<pcb>&pgrp);int main(){vector<int>resource;vector<pcb> pgrp;vector<int>::iterator r;vector<pcb>::iterator p;cout<<"ENTER THE MAX NUMBER FOR THE REQUESTED RESOURCE:"<<endl;cout <<"ID\tREQUESTED"<<endl;ff<<"ENTER THE MAX NUMBER FOR THE REQUESTED RESOURCE:"<<endl;ff<<"ID\tREQUESTED"<<endl;int id,qty;for (int i(1);i<=4;i++){do{cout<< i<<'\t';ff<<i<<'\t';cin>>qty;ff<<qty<<endl;}while(qty>Rcs_left||qty< 1);pgrp.insert(pgrp.begin(),pcb(i,qty));}//输入各进程申请的资源总量，以及初始化各进程cout <<"ALOGRITHM"<<endl<<"Random(R)"<<'\t'<<"Banker(B)"<<endl<<"ANY OTHER KEY TO QUIT"<<endl;ff<<"ALOGRITHM"<<endl<<"Random(R)"<<'\t'<<"Banker(B)"<<endl<<"ANYOTHER KEY TO QUIT"<<endl;char choice;cin>>choice;ff<<choice<<endl;if (choice=='R'||choice=='r')rand(resource,pgrp);else if (choice=='B'||choice=='b')banker(resource,pgrp);elsereturn (0);return(1);}void rand (vector<int>&resource,vector<pcb>&pgrp){vector<pcb>::iterator p,q;vector<pcb>::iterator current;vector<int>::iterator r;int temp;cout<<"NOW---------BANKER ALOGRITHM"<<endl;ff<<"NOW---------BANKER ALOGRITHM"<<endl;for(; ;){//select a TASK_RUNNING process,maybe different form the former one;for(p=pgrp.begin();p!=pgrp.end();p++){if(p->p_stat==TASK_RUNNING){current=p;break;}}if (current->p_apply==0){cout<<"ENTER THE APPLY FOR THE PROCESS\n"<<current->p_pid<<'\t';ff<<"ENTER THE APPLY FOR THE PROCESS\n"<<current->p_pid<<'\t';cin>>temp;ff<<temp<<endl;while (temp>p->p_require-p->p_occupy){cout<<"beyond the real need!"<<endl;cout<<"ENTER THE APPLY FOR THE PROCESS\n"<<current->p_pid<<'\t';ff<<"beyond the real need!"<<endl;ff<<"ENTER THE APPLY FOR THE PROCESS\n"<<current->p_pid<<'\t';cin>>temp;ff<<temp<<endl;}p->p_apply=temp;}//input the apply for the current process;if (current->p_apply>Rcs_left){//has problem//apply too much,please wait...current->p_stat=TASK_WAITTING;cout<<endl<<current->p_pid<<"is waitting\n";ff<<endl<<current->p_pid<<"is waitting\n";for(p=pgrp.begin();p!=pgrp.end();p++){if (p->p_stat==TASK_RUNNING) break;}if (p==pgrp.end()){ cout<<"LOCKED!!!"<<endl;ff<<"LOCKED!!!"<<endl;exit(1);}continue;}//满足该进程当前的申请resource.insert(resource.begin(),current->p_apply,current->p_pid); cout<<temp<<"\tresources are accepted for"<<p->p_pid<<endl;cout<<endl;ff<<temp<<"\tresources are accepted for"<<p->p_pid<<endl;ff<<endl;Rcs_left-=current->p_apply;current->p_occupy+=current-> p_apply;current->p_apply=0;//看该进程是否已满足if (current->p_occupy<current->p_require){pcb proc(*current);pgrp.erase(current);pgrp.insert(pgrp.end(),proc);//current->p_apply=0;//delete current and insert into the endcontinue;}//succedcout<<endl<<"process\t"<<p->p_pid<<"\thas succeed!!"<<endl; ff<<endl<<"process\t"<<p->p_pid<<"\thas succeed!!"<<endl; Rcs_left+=current->p_occupy;resource.clear();current->p_stat=TASK_SUCCEED;//current->p_apply=0;for (p=pgrp.begin();p!=pgrp.end();p++){if (p->p_stat==TASK_WAITTING)break;}if (p==pgrp.end()){for (q=pgrp.begin();q!=pgrp.end();q++){if (q->p_stat==TASK_RUNNING)break;}if (q==pgrp.end()){cout<<"SUCCEED!!!"<<endl;ff<<"SUCCEED!!!"<<endl;exit(0);}else continue;//there is a process in the queue}for (p=pgrp.begin();p!=pgrp.end();p++){if (p->p_stat==TASK_WAITTING&&Rcs_left>=p->p_apply)break;}if (p!=pgrp.end()){p->p_stat=TASK_RUNNING;pcb proc(*p);pgrp.erase(p);pgrp.insert(pgrp.end(),proc);continue;}else{cout<<"LOCKED!!!"<<endl;ff<<"LOCKED!!!"<<endl;exit(1);}}}void banker(vector<int>&resource,vector<pcb>&pgrp){vector<pcb>::iterator p;vector<int>::iterator r;vector<pcb>::iterator current,q;pcb proc(0,0);int length;cout<<"NOW-------BANKER ALOGRITHM"<<endl;ff<<"NOW-------BANKER ALOGRITHM"<<endl;for (; ;){for(p=pgrp.begin();p!=pgrp.end();p++){if (p->p_stat==TASK_RUNNING){current=p;break;}}if (current->p_apply==0){cout<<"ENTER THE APPLY FOR THE PROCESS\n"<<current->p_pid<<'\t';ff<<"ENTER THE APPLY FOR THE PROCESS\n"<<current->p_pid<<'\t';cin>>current->p_apply;ff<<current->p_apply<<endl;while (current->p_apply>current->p_require-current->p_occupy){cout<<cout<<"ENTER THE APPLY FOR THE PROCESS\n"<<current->p_pid<<'\t'; ff<<cout<<"ENTER THE APPLY FOR THE PROCESS\n"<<current->p_pid<<'\t'; cin>>current->p_apply;ff<<current->p_apply<<endl;}}if (current->p_apply>Rcs_left){current->p_stat=TASK_WAITTING;proc=*current;pgrp.erase(current);pgrp.insert(pgrp.end(),proc);cout<<endl<<p->p_pid<<"is waitting!"<<endl;ff<<endl<<p->p_pid<<"is waitting!"<<endl;continue;}//假定对申请资源的进程分配资源pcb backup(*current);//backuplength=Rcs_left;current->p_occupy+=current->p_apply;length-=current->p_apply;if (current->p_occupy==current->p_require)length+=current->p_require;current->p_issuc=true;for (p=pgrp.begin();p!=pgrp.end();p++){if (p->p_stat==TASK_SUCCEED) continue;if (p==current&&p->p_issuc==true)continue;if ((p->p_require-p->p_occupy)>length) continue;else{p->p_issuc=true;length+=p->p_occupy;continue;}}//检查是否还有标志位未设置的进程for (p=pgrp.begin();p!=pgrp.end();p++){if (p->p_issuc==false&&p->p_stat!=TASK_SUCCEED)break; }if (p!=pgrp.end()){current->p_occupy=backup.p_occupy;current->p_stat=TASK_WAITTING;cout<<endl<<current->p_pid<<"is waitting."<<endl;ff<<endl<<current->p_pid<<"is waitting."<<endl;proc=*current;pgrp.erase(current);pgrp.insert(pgrp.end(),proc);for (p=pgrp.begin();p!=pgrp.end();p++)p->p_issuc=false;continue;}//分配安全，可对进程进行实际的分配resource.insert(resource.end(),current->p_apply,current->p_pid);Rcs_left-=current->p_apply;cout<<endl<<current->p_pid<<"get"<<current->p_apply<<"resource(s)"<<endl; ff<<endl<<current->p_pid<<"get"<<current->p_apply<<"resource(s)"<<endl; current->p_apply=0;if (current->p_occupy<current->p_require){proc=*current;pgrp.erase(current);pgrp.insert(pgrp.end(),proc);for(p=pgrp.begin();p!=pgrp.end();p++)p->p_issuc=false;continue;}current->p_stat=TASK_SUCCEED;current->p_occupy=0;cout<<endl<<current->p_pid<<"has finished!!!"<<endl;ff<<endl<<current->p_pid<<"has finished!!!"<<endl;//归还全部系统资源resource.clear();Rcs_left+=current->p_require;for(p=pgrp.begin();p!=pgrp.end();p++){if (p->p_stat==TASK_WAITTING)break;}if (p==pgrp.end()){for(q=pgrp.begin();q!=pgrp.end();q++){if (q->p_stat==TASK_RUNNING)break;}if (q==pgrp.end()){cout<<endl<<"SUCCEED!!"<<endl;ff<<endl<<"SUCCEED!!"<<endl;exit(0);}elsecontinue;}proc=*p;pgrp.erase(p);pgrp.insert(pgrp.end(),proc); p->p_stat=TASK_RUNNING;continue;}}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验六死锁避免的算法
【实验目的】
1、了解死锁避免的原理。
2、研究银行家算法的实现方法。
【实验内容】
编程实现银行家算法。
通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁地发生。
要求如下：
（1）模拟一个银行家算法；
（2）初始化时让系统拥有一定的资源；
（3）用键盘输入的方式申请资源；
（4）如果预分配后，系统处于安全状态，则修改系统的资源分配情况；
（5）如果预分配后，系统处于不安全状态，则提示不能满足请求，
【实验报告】
1、列出调试通过程序的清单，并附上文档说明。
2、总结上机调试过程中所遇到的问题和解决方法及感想。
【实验相关资料】
一、死锁概念
多个并发进程,每个进程占有部分资源,又都等待其它进程释放所占资源,造成均不能向前推进的现象。
二、死锁的避免
死锁避免原理就是使系统始终处于安全状态。
安全状态：所谓安全状态是指能够找到一个安全序列，系统能够按照这个安全序列依次为进程分配资源，使所有进程都能执行完毕，如果找不到这样的安全序列，系统就处于不安全状态。
三、银行家算法
银行家算法要求每个进程的最大资源需求，其基本思想是：始终保持系统处于安全状态，当进程提出资源请求时，系统先进行预分配，再判断系统分配后是否仍然处于安全状态。
如果仍然处于安全状态，就进行实际分配；如果处于不安全状态，则拒绝该进程的资源请求。
四、银行家算法相关数据结构
1． 最大需求矩阵：
d (t)=⎪⎪⎪⎪⎪⎭
⎫ ⎝⎛⋅
⋅⋅⋅nm n n m m d d d d d d d d d .........212222111211 其中，行表示进程，列表示资源，如：d ij =5表示第 i 个进程最多需要j 类资源5个。
2． 资源分配矩阵：
a(t)=⎪⎪⎪⎪⎪⎭
⎫ ⎝⎛⋅
⋅⋅⋅nm n n m m a a a a a a a a a .........212222111211 元素a ij =8表示分配给第 i 进程8个j 类资源。
3． 需求矩阵：
b(t)=⎪⎪⎪⎪⎪⎭
⎫ ⎝⎛⋅
⋅⋅⋅nm n n m m b b b b b b b b b .........212222111211 元素b ij =3表示第i 类进程还需要3个j 类资源。
最大需求矩阵=分配矩阵+需求矩阵，即d(t)=a(t)+b(t)。