川师实验三死锁的避免

合集下载

操作系统实验报告-死锁的避免

操作系统实验报告-死锁的避免操作系统实验（二）死锁的避免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("安全性检查失败。

3实验三银行家算法避免进程死锁

实验三预防进程死锁的银行家算法一：需求分析程序设计的任务和目的：设计程序模拟预防进程死锁的银行家算法的工作过程。

假设系统中有n个进程P1, … ,Pn，有m类可分配的资源R1, … ,Rm，在T0时刻，进程Pi分配到的j 类资源为Allocationij个，它还需要j类资源Need ij个，系统目前剩余j类资源Workj个，现采用银行家算法进行进程资源分配预防死锁的发生。

通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。

(1)输入的形式和输入值的范围；为免去测试时候需要逐步输入数据的麻烦，输入时采用输入文件流方式将数据放在.txt文件中，第一行为进程个数和资源个数，二者之间用空格隔开。

第二行为进程已分配的各资源个数（之间用空格隔开），第三行为进程仍需要的进程个数（之间用空格隔开），第四行为各个资源的可用数。

运行程序后按照提示输入请求资源的进程号和请求的各资源数。

(2)输出的形式；先输出初始状态下的安全序列，后用户输入申请的进程号和资源数后判断，若为安全状态则输出安全序列，若不安全，则输出不安全。

(3)程序所能达到的功能；可以判断给出的数据是否为安全状态，若安全则输出安全序列，不安全则提示信息。

申请资源后可先判断资源是否合理，若合理则预分配，然后判断是否安全，若安全则输出安全序列，不安全则恢复各数据并提示信息。

(4)测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。

详见运行结果截图。

二：概要设计主程序模块void main()调用银行家算法bool bank()和安全比较算法boolcompare();以及打印输出函数bool bank()；银行家算法bool bank()调用输出函数bool bank(int* availabled,int n,int m)主要思路：先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。

实验三死锁的检测与避免

实验三死锁的检测与避免1．实验目的通过本实验，使学生进一步了解死锁、系统安全与不安全和资源动态分配的概念，学会编程实现银行家算法检验系统状态是否安全的方法，从而为将来在实际系统中使用该方法打下基础。

2．实验内容1.输入并显示资源类型数，进程数，每类资源的个体数；2.输入每个进程对每类资源的最大需求量，已分量，算出其剩余需求量。

算出系统每类资源的当前剩余量；显示输入和计算出的数据；3.按银行家算法检测系统当前是否处于安全状态，若是，往下；若否，转1，重新设置数据；4.给出某个进程的资源分配请求，按死锁避免方法检测可否将资源分配给它？若可，输出一个进程安全序列、资源分配成功的说明和新的系统资源分配状态表；若否，输出“资源分配失败”和失败的原因：①，申请量大于系统的当前剩余量，②，申请量大于自己的剩余需求量，③，若分配系统将处于不安全状态。

4．实验方法和步骤（含设计）初始化算法流程图：银行家算法流程图：安全性算法流程图：源代码：#include<iostream>using namespace std;#define MAXPROCESS 50 //最大进程数#define MAXRESOURCE 100 //最大资源数int AVAILABLE[MAXRESOURCE]; //可用资源数组int MAX[MAXPROCESS][MAXRESOURCE]; //最大需求矩阵int ALLOCATION[MAXPROCESS][MAXRESOURCE]; //分配矩阵int NEED[MAXPROCESS][MAXRESOURCE]; //需求矩阵intREQUEST[MAXPROCESS][MAXRESOURCE]; //进程需要资源数bool FINISH[MAXPROCESS]; //系统是否有足够的资源分配int p[MAXPROCESS]; //记录序列int m,n; //m个进程,n个资源void Init();bool Safe();void Bank();int main(){ Init();//初始化函数Safe();//安全性检测函数Bank();//银行家算法 }void Init(){ int i,j;cout<<"请输入进程的数目:";cin>>m;cout<<"请输入资源的种类:";cin>>n;cout<<"请输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>MAX[i][j];cout<<"请输入每个进程已分配的各资源数,也按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++){ for(j=0;j<n;j++){ cin>>ALLOCATION[i][j];NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];if(NEED[i][j]<0){cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl;j--; continue; } } }cout<<"请输入各个资源现有的数目:"<<endl;for(i=0;i<n;i++){ cin>>AVAILABLE[i];}}void Bank(){ int i,cusneed;char again;while(1){cout<<"请输入要申请资源的进程号(注:第1个进程号为0,依次类推)"<<endl; cin>>cusneed;cout<<"请输入进程所请求的各资源的数量"<<endl;for(i=0;i<n;i++){ cin>>REQUEST[cusneed][i];}for(i=0;i<n;i++){ if(REQUEST[cusneed][i]>NEED[cusneed][i]){ cout<<"您输入的请求数超过进程的需求量!请重新输入!"<<endl;continue;}if(REQUEST[cusneed][i]>AVAILABLE[i]){ cout<<"您输入的请求数超过系统有的资源数!请重新输入!"<<endl;continue;}}for(i=0;i<n;i++){ AVAILABLE[i]-=REQUEST[cusneed][i];ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];NEED[cusneed][i]-=REQUEST[cusneed][i]; }if(Safe()){ cout<<"同意分配请求!"<<endl;}else{ cout<<"您的请求被拒绝!"<<endl;for(i=0;i<n;i++){ AVAILABLE[i]+=REQUEST[cusneed][i];ALLOCATION[cusneed][i]-=REQUEST[cusneed][i];NEED[cusneed][i]+=REQUEST[cusneed][i];} }for(i=0;i<m;i++){ FINISH[i]=false;}cout<<"您还想再次请求分配吗?是请按y/Y,否请按其它键"<<endl;cin>>again;if(again=='y'||again=='Y'){ continue;} break; }}bool Safe(){ int i,j,k,l=0;int Work[MAXRESOURCE]; /*工作数组*/for(i=0;i<n;i++) Work[i]=AVAILABLE[i];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(k=0;k<n;k++){ Work[k]+=ALLOCATION[i][k];} p[l++]=i; i=-1;}else{ continue; } }if(l==m){ cout<<"系统是安全的"<<endl;cout<<"安全序列:"<<endl;for(i=0;i<l;i++){ cout<<p[i];if(i!=l-1){ cout<<"-->"; } }cout<<""<<endl;return true;} }cout<<"系统是不安全的"<<endl;return false; }数据结构设计：1.可利用资源向量矩阵AVAILABLE。

实验三死锁的避免--银行家算法

实验三死锁的避免――银行家算法一、实验目的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；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。

2．如果Request ≤Available，则转向步骤3；否则，表示系统中尚无足够的资源满足进程i 的申请，进程i必须等待。

3．系统试探性地把资源分配给进程i，并修改下面数据结构中的数值：Available = Available - RequestAllocation[i]= Allocation[i]+ RequestNeed[i]= Need[i]- Request4．系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

操作系统实验3_死锁

实验三死锁一、实验内容模拟实现资源分配。

二、实验目的多个进程动态地共享系统的资源可能会产生死锁现象。

死锁的产生，必须同时满足四个条件，第一个是互斥条件，即一个资源每次只能由一个进程占用；第二个为等待条件，即一个进程请求资源不能满足时，它必须等待，但它仍继续保持已得到的所有其它资源；第三个是非出让条件，任何一个进程不能抢占另一个进程已经获得且未释放的资源；第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一个进程所持有的资源。

防止死锁的机构只须确保上述四个条件之一不出现，则系统就不会发生死锁。

在实验中假定系统中任一资源在每一时刻只能则由一个进程使用，任何进程不能抢占它进程正在使用的资源，当进程得不到资源时必须等待。

因此只要资源分配策略能保证进程不出现循环等待，则系统就不会发生死锁。

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

三、实验题目本实验中共有两个实验题。

第一题：用银行家算法实现资源分配。

要求：(1) 设计一个3个并发进程共享10个同类资源的系统，进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源。

(2) 设计用银行家算法和随机分配算法，实现资源分配的两个资源分配程序，应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况。

(3) 确定一组各进程依次申请资源数的序列，在相同的情况下分别运行上述两种资源分配程序，观察运行结果。

[提示]：(1) 银行家算法，顾名思义是来源于银行的借贷业务，一定数量的本金要应付多个客户的借贷周转，为了防止银行因资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。

在操作系统中研究资源分配策略时也有类似的问题，系统中有限的资源要供多个进程使用，必须保证得到资源的进程能在有限的时间内归还资源，以供它进程使用资源。

如果资源分配不得当就会发生进程循环等待资源，各进程都无法继续执行下去的死锁现象。

操作系统实验三报告-预防进程死锁的银行家算法

操作系统实验报告实验三预防进程死锁的银行家算法学号：班级：姓名：【实验目的】通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。

【实验内容】问题描述：设计程序模拟预防进程死锁的银行家算法的工作过程。

假设有系统中有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)上机时独立编程、调试程序；3)根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图）。

死锁避免实验报告

“死锁避免”实验报告实验思路：先定义进程控制块的数据结构pcb，确定进程并发数目SIZE，在初始化进程时，保证各进程最大资源申请量不大于系统的资源总量，如果大于，则重新输入。

初始化完成之后，选择相应的死锁避免的算法，或随机分配算法，或银行家算法。

随机分配方法：运用取余的方法，轮询各个进程，选择处于就绪状态的进程之一，然后输入该进程的当前资源申请量apply，判断该申请量是否大于系统当前资源剩余量，若大于，将就绪进程状态设置为阻塞态，然后查找就绪队列中是否还有就绪进程，若有，则选择一个就绪进程，继续执行，若没有就绪进程，则表示发生死锁。

若不大于，则给满足该进程的申请量，并将其自愿申请量的变量设为0。

接着再进行判断该进程是否得到全部所需资源，若没有，则选择就绪队列中一个就绪进程，若全部得到，归还该进程所占有的全部资源给系统，并将该进程设置为完成态。

此时，再进行检查有无等待态的进程，若没有，则选择就绪队列中一个就绪进程，若有，则顺序检查等待进程，判断系统现有资源能满足某一等待进程，若能，则将该等待进程状态设置为就绪态，若没有，查找就绪队列中是否还有就绪进程，若有，则选择一个就绪进程，继续执行，若没有就绪进程，则表示发生死锁。

银行家算法：运用取余的方法，轮询各个进程，选择处于就绪状态的进程之一，然后输入该进程的当前资源申请量apply，判断该申请量是否大于系统当前资源剩余量，若大于，将就绪进程状态设置为阻塞态，然后查找就绪队列中是否还有就绪进程，若有，则选择一个就绪进程，继续执行，若没有就绪进程，则表示发生死锁。

若不大于，则假定满足该进程的申请量，并将其资源申请量的变量设为0，表示系统资源的变量减少相应的该进程的资源申请量，然后系统资源暂时用一个变量current保存起来。

将分配后系统剩余的资源数量与各进程的剩余需求量比较寻找一个系统能满足其需求的进程，每找一次，都要计数，用num变量，若找到，在标记数组a[SIZE]中进行相应标记，同时没找到一个都要进行一次对标记数组的循环测试，若测试到所有项都进行了标记，则退出循环，说明此次分配是安全的，若找不到，测试num的值，（对于确定数目的并发进程，其最大分配安全的循环次数<=SIZE!）。

操作系统实验3死锁

实验报告班级：系统本111 学号：2011415108姓名：张国锋日期：2013.5.23⒈实验题目死锁避免实验。

2．实验要求编写一段程序模拟银行家算法3. 实验目的多个进程动态地共享系统的资源时可能会产生死锁现象。

银行家算法是通过对资源的分配进行动态地检查来达到避免死锁的目的。

本实验通过模拟银行家算法的应用，使读者了解银行家算法的执行过程。

从而进一步理解死锁产生的条件和避免死锁问题产生的方法。

⒋实验原理分析⑴死锁的产生必须同时满足4个条件：●互斥条件，即一个资源每次只能由一个进程占用。

●请求与保持条件，即一进程请求资源不能满足时，它必须等待，同时它仍保持已得到的所有其它资源。

●不可剥夺条件，任何一个进程不能抢占另一个进程已经获得且未释放的资源。

●环路等待条件，系统进入死锁的状态时，进程和资源之间形成一个封闭的环路。

⑵银行家算法是一种具有代表性的避免死锁的算法。

银行家算法为资源分配定义了两种状态，安全状态和不安全状态。

●安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。

处于安全状态的系统一定没有死锁发生。

●不安全状态：当系统中不存在一个安全序列时系统处于不安全状态。

不安全状态下一定导致死锁发生。

5.实验代码清单#include<iostream.h>#include<string.h>#include<stdio.h>#define False 0#define True 1int 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;//作业的最大数为100int N=100;//资源的最大数为100void 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<<"*****************资源管理系统的设计与实现*****************"<<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;}6.实现①运行程序后，输入课本中银行家算法之例，数据如下表进程Max Allocation NeedA B C A B C A B C1 7 5 3 0 1 0 7 4 32 3 2 2 2 0 0 1 2 23 9 0 2 3 0 2 6 0 0图1 输入各类资源的数量和Max ②输入Allocation图2 输入Allocation③输入完毕后，回车选显示资源菜单如图3所示图3 显示各种资源④在选择用银行家加算法判定系统是否安全，运行后如图4所示图4 用银行家算法判定安全序列。

死锁的检测和预防

实验三：死锁的检测和预防一、实验目的1、进一步了解进程的并发执行。

2、加强对进程死锁的理解3、是用银行家算法完成死锁检测二、实验内容给出进程需求矩阵、资源向量以及一个进程的申请序列。

使用进程启动拒绝和资源分配拒绝（银行家算法）模拟该进程组的执行情况。

要求：初始状态没有进程启动计算每次进程申请是否分配？如：计算出预分配后的状态情况（安全状态、不安全状态），如果是安全状态，输出安全序列。

每次进程申请被允许后，输出资源分配矩阵A和可用资源向量V。

每次申请情况应可单步查看，如：输入一个空格，继续下个申请三、实验环境VC++四、实验原理及实验思路1、安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。

安全状态一定是没有死锁发生。

2、不安全状态:不存在一个安全序列。

不安全状态一定导致死锁。

安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。

3、银行家算法：把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。

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

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

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

4、银行家算法的思路：1.进程一开始向系统提出最大需求量.2.进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.3.若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待.5、银行家算法的数据结构：1.系统剩余资源量A[n],其中A[n]表示第I类资源剩余量.2.各进程最大需求量,B[m][n],其中B[j][i]表示进程j对i类资源最大需求.3.已分配资源量C[m][n],其中C[j][i]表示系统j程已得到的第i资源的数量.4.剩余需求量.D[m][n],其中D[j][i]对第i资源尚需的数目.五、流程图银行家算法：安全检测：六、源代码#include "string.h"#include <stdio.h>#include <stdlib.h>#define M 5#define N 3#define FALSE 0#define TRUE 1/*M个进程对N类资源最大资源需求量*/int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*系统可用资源数*/int AVAILABLE[N]={10,5,7};/*M个进程对N类资源最大资源需求量*/int ALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};/*M个进程还需要N类资源的资源量*/int NEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*M个进程还需要N类资源的资源量*/int Request[N]={0,0,0};void main(){int i=0,j=0;char flag='Y';char finishFlag='Y';void showdata();void changdata(int);void rstordata(int);int chkerr(int);showdata();while(finishFlag=='Y'||finishFlag=='y') //可以分配资源{i=-1;while(i<0||i>=M) //判断申请的资源号是否有效{printf("请输入需申请资源的进程号（从0到%d，否则重输入!）:",M-1);scanf("%d",&i);if(i<0||i>=M)printf("输入的进程号不存在，重新输入!\n");}printf("请输入进程%d申请的资源数\n",i);for (j=0;j<N;j++){printf("资源%d:",j);scanf("%d",&Request[j]);if(Request[j]>NEED[i][j]) //进程申请资源数大于进程还需要的资源{printf("进程%d申请的资源数大于进程%d还需要%d类资源的资源量!申请不合理，出错!请重新选择!\n",i,i,j);flag='N';break;}else{if(Request[j]>AVAILABLE[j]) //进程申请资源数大于系统可用该类资源量{printf("进程%d申请的资源数大于系统可用%d类资源的资源量!申请不合理，出错!请重新选择!\n",i,j);flag='N';break;}}}if(flag=='Y'||flag=='y'){int result;changdata(i);result=chkerr(i);if(result==1){rstordata(i);showdata();}elseshowdata();}//else//showdata();printf("\n");printf("是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ");getchar();scanf("%c",&finishFlag);}}void showdata() //显示各类资源的分配情况{int i,j;printf("系统可用的资源数为:\n");printf(" ");for (j=0;j<N;j++){printf(" 资源%d:%d ",j,AVAILABLE[j]);}printf("\n");printf("各进程还需要的资源量:\n");for (i=0;i<M;i++){printf(" 进程%d ",i);for (j=0;j<N;j++){printf("资源%d:%d ",j,NEED[i][j]);}printf("\n");}printf("各进程已经得到的资源量: \n");for (i=0;i<M;i++){printf(" 进程%d ",i);for (j=0;j<N;j++)printf("资源%d:%d ",j,ALLOCATION[i][j]);printf("\n");}}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 rstordata(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 chkerr(int s) //检查是否能够分配该资源{int WORK,FINISH[M],temp[M];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;while(i<M){if (FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;temp[k]=i;k++;i=0;}else{i++;}}for(i=0;i<M;i++)if(FINISH[i]==FALSE){printf("\n系统不安全!!! 本次资源申请不成功!!!\n\n");return 1;}}printf("\n经安全性检查，系统安全，本次分配成功。

预防死锁和存储器管理实验报告

班级：学号：姓名：1、死锁避免算法的模拟实现一、实验目的通过本次实验,让同学们进一步了解死锁.对死锁有了认识以后，然后对系统安全和资源动态分配有了全新的的概念.学会编程实现银行家算法检验系统状态是否安全的方法.以便将来在实际中使用该方法打下基础。

二、实验环境Windows XP或者windows7环境下的VC++环境之下三、实验任务设系统中资源类集合为{A，B，C}，资源类A中含有十个资源实例，资源类B中含有五个资源实例，资源类C中含有七个资源实例，又设系统中进程集合为{p0,p1,……，p4}。

在t0时刻系统状态如下：Maximum Allocation Need AvailableA B C A B C A B C AB CP0 7 5 3 0 1 0 7 4 3 3 3 2P1 3 2 2 2 0 0 1 2 2P2 9 0 2 3 0 2 6 0 0P3 2 2 2 2 1 1 0 1 1P4 4 3 3 0 0 2 4 3 11)判断此时系统是否处于安全状态；2)模拟某进程发出一个资源申请，作出决策，是否给该进程分配资源（如不造成死锁则分配，否则拒绝分配）。

3)修改程序，从数据文件中读取上述信息，并且可以适应具有不同资源类个数的系统，即不用修改程序就可处理含不同资源类个数系统。

1.提示1）．安全状态介绍：说系统处于安全状态，如果系统中的所有进程能够按照某一种次序依次地进行完。

可形式化定义为：说系统处于安全状态，如果存在一个有系统中所有进程构成的安全进程序列<P1,P2,P3,……Pn>,一个进程序列是安全的，如果对于每一个进程Pi(1<=i<=n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj(j<i)当前占有资源量之和。

2）．可采用避免死锁的银行家算法，为简化问题，现对该算法的思想及用到的数据结构描述如下：当一个新进程进入，它必须申明其资源需求最大量，即每个资源类各需多少资源实例。

死锁避免

(3) 系统试探着把资源分配给进程 i，并修改下面数据系统试探着把资源分配给进程P 结构中的数值：结构中的数值： Available［j］∶=Available［j］-Requesti［j］; ［］［］］ Allocation［ i,j］ ∶ =Allocation［ i,j］ +Requesti ［ j］ ; ［］［］］ Need［i,j］∶=Need［i,j］-Requesti［j］; ［］［］］ (4) 系统执行安全性算法，检查此次资源分配后，系统系统执行安全性算法，检查此次资源分配后，是否处于安全状态。若安全，才正式将资源分配给进程P 是否处于安全状态。若安全，才正式将资源分配给进程 i，以完成本次分配；否则，将本次的试探分配作废，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程等待。来的资源分配状态，让进程Pi等待。
3) 由安全状态向不安全状态的转换
如果不按照安全序分配资源，如果不按照安全序分配资源，则系统可能会由安全状态进入不安全状态。例如，时刻以后，又请求1台磁态进入不安全状态。例如，在T0时刻以后，P3又请求台磁带机，若此时系统把剩余3台中的台分配给P 台中的1台分配给带机，若此时系统把剩余台中的台分配给 3，则系统便进入不安全状态。因为，此时也无法再找到一个安全序列，进入不安全状态。因为，此时也无法再找到一个安全序列，例如，把其余的2台分配给台分配给P 这样，例如，把其余的台分配给 2，这样，在P2完成后只能释放台的要求，出4台，既不能满足 1尚需台的要求，也不能满足 3尚需台既不能满足P 尚需5台的要求也不能满足P 尚需6 台的要求，致使它们都无法推进到完成，台的要求，致使它们都无法推进到完成，彼此都在等待对方释放资源，即陷入僵局，结果导致死锁。方释放资源，即陷入僵局，结果导致死锁。

《死锁避免》实验报告

一、实验目的本次实验旨在通过模拟操作系统的资源分配和请求过程，深入理解死锁的概念、产生死锁的必要条件以及如何通过银行家算法来避免死锁的发生。

通过实验，学生能够掌握以下知识点：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. 分析实验结果，验证银行家算法是否能够避免死锁的发生。

第十讲死锁的避免

Finish[i]=false;Need[i][j]<=Work[j]的进程，
找到则执行步骤（3）；否则执行步骤（4）。
（3）当进程Pi获得资源后可顺利执行直至完成，并释放
分配给它的资源，Work[j]=Work[i]+Allocation[i][j];
当前j类资源的可用数等于剩余资源数加上进程 i 先前
这是—个n×m的矩阵，它定义了系统中n个进程
中每个进程对m类资源的最大需求。 Max[ i ][ j ]＝k，表示进程 i 需要 j 类资源的最大数目为k。
3．分配矩阵Allocation n×m的矩阵，它定义了系统中每一类资源当前已分配给各进程的资源数。 Allocation [i][j] ＝k，表示进程 i 当前已分得 j 类资源的数量为k。
3）系统试探把所需资源分配给进程Pi，并修改相应数据
结构中的数值；接着执行安全性算法，检查此次资源
分配后系统是否安全。
若安全，正式将资源分配给进程Pi以完成本次分配，
否则，本次分配作废，恢复原来资源分配状态，让进程Pi等待。
C、安全性算法系统通过执行安全性算法检测当前系统状态是否安全，
（1）设臵两个向量
3.6.2 死锁的避免一、系统安全状态 1、在避免死锁的方法中，允许进程动态地申请资源但系统在进行资源分配之前，应先计算此次资源分配的安全性。若此次分配不会导致系统进入不安全状态，则将资源分配给进程；否则，令进程等待。
2、安全状态定义是指系统能按某种顺序，如 <P1，P2，…，Pn> 来为每个进程分配资源，直至满足每个进程对资源的最大需求每个进程都可顺序完成。则称<P1，P2，…，Pn> 序列为安全序列。

死锁的避免=实验要求

死锁的避免（选做）一、实验内容模拟进程的资源分配算法，了解死锁的产生和避免的办法二、实验目的为了了解系统的资源分配情况，假定系统的任何一种资源在任一时刻只能被一个进程使用。

任何进程已经占用的资源只能由进程自己释放，而不能由其他进程抢占。

当进程申请的资源不能满足时，必须等待。

因此，只要资源分配算法能保证进程的资源请求，且不出现循环等待，则系统不会出现死锁。

要求编写系统进行资源调度的程序。

一个是随机动态地进行资源分配的模拟程序，即只要系统当前剩余资源满足进程的当前请求，就立即将资源分配给进程，以观察死锁的产生情况；一个是采用银行家的算法，有效地避免死锁产生。

三、实验题目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. 不可抢占条件：已分配的资源不能被强制性地剥夺。

4. 循环等待条件：存在一个进程资源的循环链，每个进程都在等待下一个进程的资源。

二、死锁的检测方法为了及时发现死锁，操作系统通常会采用以下两种死锁检测的方法之一：1. 资源分配图法：将资源和进程之间的关系表示为一个资源分配图，通过遍历图来检测是否存在环路。

如果存在环路，则表示系统发生了死锁。

2. 银行家算法：银行家算法是一种预防死锁的算法，通过判断系统资源的分配情况和进程的最大资源需求，来判断是否会发生死锁。

如果不会发生死锁，那么允许进程请求资源；否则，拒绝进程的资源请求。

三、死锁的避免方法为了避免死锁的发生，操作系统可以采取以下几种策略：1. 资源预分配：在进程执行前，通过分析进程对资源的需求，提前进行资源的合理分配。

这种方法需要事先获得进程的资源请求序列，并且不会导致资源浪费。

2. 有序资源请求：要求进程只能按照某种预定义的顺序请求资源，避免进程之间形成循环等待的条件。

3. 资源剥夺和回收：当某个进程等待时间过长或者已经执行完毕时，操作系统可以剥夺该进程的资源，并分配给其他进程。

这种方法可以打破循环等待条件。

4. 资源合并和分割：当某个进程请求多个资源时，操作系统可以尝试将多个资源合并为一个，并且保证合并后还可以满足其他进程的需要。

这样就可以避免死锁的产生。

在实际操作系统中，通常会结合多种方法来进行死锁的检测和避免。

死锁避免实验报告

沈阳工程学院学生实验报告（课程名称：操作系统）一、实验题目死锁避免实验。

二、实验要求编写一段程序模拟银行家算法。

三、实验目的多个进程动态地共享系统的资源时可能会产生死锁现象。

银行家算法是通过对资源的分配进行动态地检查来达到避免死锁的目的。

本实验通过模拟银行家算法的应用，使读者了解银行家算法的执行过程。

从而进一步理解死锁产生的条件和避免死锁问题产生的方法。

四、实验原理分析⑴死锁的产生必须同时满足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<<"申请的资源大于可利用的资源。

川师实验三 死锁的避免

操作系统实验报告-死锁的避免

3实验三银行家算法避免进程死锁

实验三 死锁的检测与避免

实验三 死锁的避免--银行家算法

操作系统实验3_死锁

操作系统实验三报告-预防进程死锁的银行家算法

死锁避免实验报告

操作系统实验3死锁

死锁的检测和预防

预防死锁和存储器管理实验报告

死锁避免

《死锁避免》实验报告

第十讲 死锁的避免

死锁的避免=实验要求

操作系统的死锁检测与避免

死锁避免实验报告

川师实验三死锁的避免

实验三死锁的检测与避免

实验三死锁的避免--银行家算法

第十讲死锁的避免