当前位置：文档之家 › 死锁避免实验

死锁避免实验

  • 格式：doc
  • 大小：8.04 MB
  • 文档页数：17

沈 阳 工 程 学 院 学 生 实 验 报 告

（课程名称：计算机操作系统 ）

实验题目：死锁避免实验

班 级 计算机 学 号 19 姓 名 地 点 指导教师 实 验 日 期 : 2014 年 月 日 1

一、实验目的 多个进程动态地共享系统的资源时可能会产生死锁现象。银行家算法是通过对资源的分配进行动态地检查来达到避免死锁的目的。本实验通过模拟银行家算法的应用，使读者了解银行家算法的执行过程。从而进一步理解死锁产生的条件和避免死锁问题产生的方法。 二、实验环境

VC++ 三、实验内容与要求 编写一段程序模拟银行家算法 ⑴死锁的产生必须同时满足4个条件： ● 互斥条件，即一个资源每次只能由一个进程占用。 ● 请求与保持条件，即一进程请求资源不能满足时，它必须等待，同时它仍保持已得到的所有其它资源。 ● 不可剥夺条件，任何一个进程不能抢占另一个进程已经获得且未释放的资源。 ● 环路等待条件，系统进入死锁的状态时，进程和资源之间形成一个封闭的环路。 ⑵银行家算法是一种具有代表性的避免死锁的算法。银行家算法为资源分配定义了两种状态，安全状态和不安全状态。 ● 安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统

处于安全状态。处于安全状态的系统一定没有死锁发生。 ● 不安全状态：当系统中不存在一个安全序列时系统处于不安全状态。不安全状态下一定导致死锁发生。

四、实验过程及结果分析 实验代码如下： // BB.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include #include #include #define False 0 2

#define True 1 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;//作业的最大数为100 int N=100;//资源的最大数为100 void showdata()//显示资源矩阵 { int i,j; cout<<"系统目前可用的资源[Avaliable]:"

cout

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;iapply=0; for(j=0;jif (Finish[i]==False&&Need[i][j]<=Work[j]){ apply++; if(apply==N){ for(m=0;mWork[m]=Work[m]+Allocation[i][m];//变分配数 Finish[i]=True; temp[k]=i; i=-1; k++; flag++; } 5

} } } for(i=0;iif(Finish[i]==False){ cout<<"系统不安全"

{ char ch; int i=0,j=0; ch='y'; cout<<"请输入要求分配的资源进程号(0-"<6

cin>>i;//输入须申请的资源号 cout<<"请输入进程">Request[j];//输入需要申请的资源 }

for (j=0;jif(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错 { cout<<"进程"Avaliable[j])//判断申请是否大于当前资源，若大于则 { //出错 cout<<"进程"

} } if(ch=='y') { changdata(i);//根据进程需求量变换资源 showdata();//根据进程需求量显示变换后的资源 safe();//根据进程需求量进行银行家算法判断 } } void addresources(){//添加资源 int n,flag; cout<<"请输入需要添加资源种类的数量:"; cin>>n; flag=N; N=N+n; for(int i=0;icout<<"名称:"; cin>>name[flag]; cout<<"数量:"; cin>>Avaliable[flag++]; } showdata(); safe(); } void delresources(){//删除资源 char ming; 8

int i,flag=1; cout<<"请输入需要删除的资源名称："; do{ cin>>ming; for(i=0;iif(ming==name[i]){ flag=0; break; } if(i==N) cout<<"该资源名称不存在，请重新输入："; } while(flag); for(int j=i;j{ name[j]=name[j+1]; Avaliable[j]=Avaliable[j+1]; } N=N-1; showdata(); safe(); } void changeresources(){//修改资源函数 cout<<"系统目前可用的资源[Avaliable]:"

合集下载

银行家算法c语言流程图代码全

银行家算法c语言流程图代码全

操作系统教程
——银行家算法
院系 班级 学号 姓名
计算机与软件学院 08 软件工程 2 班
20081344066 何丽茗
一、实验目的
银行家算法是避免死锁的一种重要方法。通过编写一个模拟动态资源分配的银行家算法 程序�进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念�并掌握避免死锁 的具体实施方法。
四、实验代码以及运行示例
1. 源代码�
#include<iostream>
#include<string.h>
#include<stdio.h>
#define False 0
#define True 1
using namespace std;
intMax[100][100]={0};//各进程所需各类资源的最大需求
for(j=0;j<N;j++)
cout<<Allocation[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Need[i][j]<<" ";
cout<<endl;
}
}
intchangdata(inti)//进行资源分配 {
int j; for (j=0;j<M;j++) {
Y
i加1
提示 错误 重新 输入
所有进程运行 都结束
结束
初始化 need 矩阵 Y Need 矩阵为 0
N
任选一个进程作为当前进程
Need 向量为 0 N
什么是死锁以及避免死锁

什么是死锁以及避免死锁

什么是死锁以及避免死锁⼀、定义 线程死锁是指由于两个或者多个线程互相持有对⽅所需要的资源，导致这些线程处于等待状态，⽆法前往执⾏。

当线程进⼊对象的synchronized代码块时，便占有了资源，直到它退出该代码块或者调⽤wait⽅法，才释放资源，在此期间，其他线程将不能进⼊该代码块。

当线程互相持有对⽅所需要的资源时，会互相等待对⽅释放资源，如果线程都不主动释放所占有的资源，将产⽣死锁。

当然死锁的产⽣是必须要满⾜⼀些特定条件的：1.互斥条件：进程对于所分配到的资源具有排它性，即⼀个资源只能被⼀个进程占⽤，直到被该进程释放2.请求和保持条件：⼀个进程因请求被占⽤资源⽽发⽣阻塞时，对已获得的资源保持不放。

3.不剥夺条件：任何⼀个资源在没被该进程释放之前，任何其他进程都⽆法对他剥夺占⽤4.循环等待条件：当发⽣死锁时，所等待的进程必定会形成⼀个环路（类似于死循环），造成永久阻塞。

package com.sxy.thread;/*** 线程Thread1率先占有了resource1, 继续运⾏时需要resource2, 但此时resource2却被线程Thread2占有了，* 因此只能等待Thread2释放resource2才能够继续运⾏；同时，Thread2也需要resource1,* 它只能等待Thread1释放resource1才能够继续运⾏，因此，Thread1和Thread2都处于等待状态，* 谁也⽆法继续运⾏，即产⽣了死锁。

** @author sunxy*/public class DeadLock {public static void main(String[] args) {dead_lock();}private static void dead_lock() {// 两个资源final Object resource1 = "resource1";final Object resource2 = "resource2";// 第⼀个线程，想先占有resource1,再尝试着占有resource2Thread t1 = new Thread() {public void run() {// 尝试占有resource1synchronized (resource1) {// 成功占有resource1System.out.println("Thread1 1:locked resource1");// 休眠⼀段时间try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}// 尝试占有resource2，如果不能占有，该线程会⼀直等到synchronized (resource2) {System.out.println("Thread1 1:locked resource2");}}}};// 第⼆个线程，想先占有resource2，再占有resource1Thread t2 = new Thread() {public void run() {// 尝试占有resource2synchronized (resource2) {// 成功占有resource2System.out.println("Thread 2 :locked resource2");// 休眠⼀段时间try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}// 尝试占有resource1，如果不能占有，该线程会⼀直等到synchronized (resource1) {System.out.println("Thread1 2:locked resource1");}}}};// 启动线程t1.start();t2.start();}}死锁的另⼀种：递归死锁，举例：所谓递归函数就是⾃调⽤函数，在函数体内直接或间接的调⽤⾃⼰，即函数的嵌套是函数本⾝。

银行家算法

银行家算法

操作系统银行家算法课后作业一、实验目的加深对多实例资源分配系统中死锁避免方法——银行家算法的理解，掌握Windows 环境下银行家算法的实现方法。

强调对于资源的管理、申请、比较来避免出现死锁的情况，保证系统的正常运行。

二、实验内容1.在Windows 操作系统上，利用DEVC++编写应用程序实现银行家算法。

2.创建n 个线程来申请或释放资源，只有保证系统安全，才会批准资源申请。

三、实验步骤（一）设计思路：银行家算法可分为个主要的功能模块，其描述如下：1.初始化由用户输入数据，分别对运行的进程数、总的资源种类数、总资源数、各进程所需要的最大资源数量（Max），已分配的资源数量赋值。

2.安全性检查算法(1)设置两个工作向量Work=AVAILABLE;FINISH=false;(2)从进程集合中找到一个满足下述条件的进程，FINISH==false;NEED<=Work;如找到，执行(3)；否则，执行(4)(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。

Work+=ALLOCATION;Finish=true;(4).如所有的进程Finish= true，则表示安全；否则系统不安全。

3. 银行家算法在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。

在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。

银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。

它是最具有代表性的避免死锁的算法。

设进程j提出请求REQUEST [i]，则银行家算法按如下规则进行判断。

(1).如果REQUEST [j] [i]<= NEED[j][i]，则转(2)；否则，出错。

(2).如果REQUEST [j] [i]<= AVAILABLE[j][i]，则转(3)；否则，出错。

(3).系统试探分配资源，修改相关数据：AVAILABLE[i]-=REQUEST[j][i];ALLOCATION[j][i]+=REQUEST[j][i];NEED[j][i]-=REQUEST[j][i];用到的数据结构：实现银行家算法要有若干数据结构，它们用来表示资源分配系统的状态。

死锁的排查方法

死锁的排查方法

死锁的排查方法
死锁的排查主要有以下几种方法：
1. 资源分级：对系统中的各种资源（如CPU、内存、磁盘等）进行分级，
优先分配高级别的资源给进程。

2. 请求和保持：当一个进程在等待一个资源时，如果该资源被其他进程占用，则该进程请求其他空闲资源，并保持对已分配资源的占有，防止释放可能引起死锁的资源。

3. 饥饿策略：当一个进程等待时间过长而无法获得需要的资源时，由系统自动收回其已占有的资源，并在一段时间内不再分配给该进程。

4. 死锁检测与恢复：定期检测系统中是否存在死锁，如果存在则采取相应措施（如回滚、重试等）来解除死锁。

5. 避免死锁：通过一些算法（如银行家算法、避免循环等待等）来避免死锁的发生。

以上方法各有优缺点，实际应用中需要综合考虑各种因素选择适合的方法。