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

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

第6章 进程间的制约关系181图6-17 用顺序编号破坏“循环等待条件”6.3.3 死锁的避免死锁的避免是指虽然系统中存在产生死锁的条件，但小心对待进程提出的每一个资源请求。

在接到一个资源请求时，不是立即进行分配，而是根据当时资源的使用情况，按照一定的算法去模拟分配，探测出模拟分配的结果。

只有在探测结果表明绝对不会出现死锁时，才真正接受这次资源请求。

通常，进行模拟分配的探测算法称为“银行家算法”。

在这个算法中，要用到“安全状态”和“不安全状态”两个概念。

如果能在有限的时间内，能保证所有进程得到自己需要的全部资源，那么称系统处于“安全状态”；否则称系统处于“不安全状态”。

很明显，在系统处于安全状态时，绝对不会发生死锁；在系统处于不安全状态时，系统有可能发生死锁。

为了实行银行家算法，对系统中的每个进程提出如下要求。

（1）必须预先说明自己对资源的最大需求量。

（2）只能一次一个地申请所需要的资源。

（3）如果已经获得了资源的最大需求量，那么应该在有限的时间内使用完毕，并归还给系统。

为了实行银行家算法，系统的承诺如下。

（1）如果一个进程对资源的最大需求量没有超过该资源的总量，则必须接纳这个进程，不得拒绝它。

（2）在接到一个进程对资源的请求时，有权根据当前资源的使用情况暂时加以拒绝（即阻塞该进程），但保证在有限的时间内让它得到所需要的资源。

银行家算法有单种资源和多种资源之分。

“单种资源”的银行家算法，只针对一种资源的情况；“多种资源”的银行家算法，针对多种资源的情况。

下面分别进行介绍。

单种资源银行家算法的基本思想如图6-18所示。

单种资源银行家算法的执行步骤如下所述。

（1）在安全状态下，系统接到一个进程的资源请求后，先假定接受这一请求，把需要的资源分配给这个进程。

（2）在这一假设下，检查每一个进程对资源的还需要数，看能否找到一个进程，其还需数量小于系统剩余资源数。

如果找不到，系统就有可能死锁，因为任何进程都无法运行结束。

操作系统的死锁避免操作系统是计算机系统中负责管理和控制各种软硬件资源的核心组件。

在多任务环境下，操作系统需要合理地分配和管理资源，以确保系统的高效运行。

然而，由于资源的有限性和多任务并发执行的特点，死锁问题成为操作系统设计中需要解决的重要挑战之一。

一、死锁的定义和原因探究1. 死锁概述死锁是指多个进程在争夺系统资源时，由于彼此之间的资源相互独占和相互等待，导致程序无法继续执行的状态。

在死锁状态下，无论如何分配资源，都无法满足所有进程的资源需求。

因此，死锁会导致系统的停滞和资源的浪费。

2. 死锁的原因死锁产生的根本原因是进程的资源争夺和资源等待。

在多任务环境中，进程可能会同时请求多个资源，并且在等待某个资源满足条件时可能会主动释放已获取的资源。

然而，如果不加限制和控制，进程可能会陷入相互等待的死循环，导致死锁的发生。

二、死锁避免的方法和策略为了解决死锁问题，操作系统设计中采用了多种避免死锁的方法和策略。

下面介绍几种常见的死锁避免方法：1. 资源分配策略操作系统可以通过限制资源的分配数量、调整调度策略以及实施优先级控制等方式，来避免死锁的发生。

例如，可以采用银行家算法来预测进程的资源需求，只有在分配资源后仍然能够满足所有进程的需求时才进行分配。

2. 进程资源申请策略操作系统可以要求进程一次性申请所有资源，充分利用资源的可重用性，并在资源不足时进行等待，以避免死锁。

这种策略可以有效减少进程的等待时间，提高系统的吞吐量。

3. 死锁检测与恢复策略操作系统设计中的死锁检测和恢复策略可以帮助系统及时发现死锁的存在，并采取相应措施进行恢复。

一种常见的策略是使用资源分配图来进行死锁检测，如果存在环路则表示死锁的发生，操作系统可以通过抢占资源或终止进程等方式解除死锁。

4. 死锁预防策略操作系统可以通过改变资源分配的策略和限制条件，从根本上预防死锁的发生。

例如，可以引入资源剥夺策略，即在进程使用资源时，如果该资源被其他进程请求，则操作系统可以强制剥夺该资源并分配给其他请求进程。

实验五 死锁避免的算法【实验目的】1、 了解死锁避免的原理。

2、 研究银行家算法的实现方法。

【实验内容】编程实现银行家算法。

【实验报告】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)。

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

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

假设有系统中有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!）。

操作系统与死锁避免操作系统是现代计算机系统中至关重要的组成部分，它负责管理和协调计算机硬件和软件资源，保障计算机系统正常运行。

在操作系统的设计与实现中，解决死锁问题是一个非常重要的议题。

一、什么是死锁？死锁是指在多个进程或线程竞争有限的资源时出现的一种阻塞状态，每个进程都在等待其他进程释放所需的资源，从而陷入无法继续执行的僵局。

二、死锁产生的原因1. 资源竞争：当多个进程同时请求相同的资源时，若这些资源只能被一个进程占用，则有可能发生死锁。

2. 进程推进顺序不当：若进程在申请资源时不按照预定的顺序申请，也可能导致死锁的发生。

3. 资源分配不足：系统的资源总量不能满足所有进程的需求，没有足够的资源分配给每个进程，也是死锁发生的原因之一。

三、死锁避免的方法1. 银行家算法：银行家算法是一种经典的死锁避免方法，它通过对资源分配进行安全性检查，确保分配资源后不会导致死锁的发生。

当进程请求资源时，系统根据银行家算法判断资源分配是否安全，如果安全就分配资源，否则让进程等待。

2. 预防死锁：在系统设计阶段采取一些策略来预防死锁的发生，如避免使用不可抢占的资源、避免使用资源循环等待、合理规划资源的分配等。

3. 检测与解除死锁：通过死锁检测算法，周期性地检测系统是否处于死锁状态。

一旦检测到死锁的存在，可以采取解除死锁的策略，如剥夺某些进程已占用的资源、进行进程终止等。

四、操作系统中的死锁避免实例以银行家算法为例，假设有三个进程（P1、P2、P3）和三个资源（R1、R2、R3），进程对资源的最大需求如下：```进程最大需求P1 (3, 2, 1)P2 (2, 4, 3)P3 (1, 1, 2)```系统中当前资源的分配情况如下：```资源可用量R1 2R2 2R3 2```根据银行家算法，先进行安全性检查，判断当前资源分配是否安全。

假设按照以下顺序分配资源：P1→P3→P2。

分配过程如下：1. 进程P1申请资源，需求为(3, 2, 1)。

操作系统中的死锁避免策略在操作系统中，死锁是指由于资源竞争而导致进程无法继续执行的现象。

为了解决这个问题，操作系统采用了多种死锁避免策略。

本文将介绍其中的几种常见策略，并分析其优缺点。

1. 死锁预防死锁预防是一种常见的死锁避免策略，它通过限制进程对资源的申请，防止死锁的发生。

其核心思想是破坏死锁的四个必要条件：互斥、占有并等待、不可抢占和循环等待。

具体措施包括：- 互斥条件：对于某些资源，可以将其设置为非互斥的，允许多个进程同时访问。

- 占有并等待条件：要求进程在开始执行之前一次性申请所需的所有资源，避免占有部分资源后再申请其他资源。

- 不可抢占条件：当进程获取到某些资源后，不允许被其他进程抢占。

- 循环等待条件：对系统中所有资源进行全局排序，进程按照顺序申请资源，避免形成循环等待。

2. 资源剥夺资源剥夺是另一种常见的死锁避免策略，它通过剥夺进程当前占有的资源来避免死锁的发生。

当系统检测到死锁的可能时，可以选择抢占进程的资源，分配给其他需要的进程。

资源的选择原则可以采用优先级、等待时间等因素来确定。

3. 死锁检测与恢复死锁检测与恢复是一种被广泛使用的死锁避免策略。

系统周期性地检测死锁的发生，并在检测到死锁时采取相应的恢复措施。

具体流程包括：- 构建资源分配图：将进程和资源之间的关系表示为一个图，根据该图判断是否存在环路。

- 检测死锁：通过遍历资源分配图查找环路，如果存在环路则判断为死锁。

- 恢复操作：一旦检测到死锁，系统可以采取多种策略进行恢复，如终止部分或全部进程、剥夺资源等。

以上是操作系统中常见的死锁避免策略。

每种策略都有其优缺点，具体选择应根据系统需求和性能要求而定。

在实际应用中，多数操作系统会综合运用以上策略以提高死锁避免能力。

总结：操作系统中的死锁是一种由于资源竞争导致的进程无法继续执行的现象。

为了解决死锁问题，操作系统采用了多种死锁避免策略，如死锁预防、资源剥夺和死锁检测与恢复。

每种策略都有其优缺点，必须根据具体情况选择适合的策略。