【OS学习笔记】死锁总结（含银行家算法的实现Java版）

最新推荐文章于 2022-05-27 00:10:37 发布
最新推荐文章于 2022-05-27 00:10:37 发布
阅读量362 收藏 3
点赞数 7
分类专栏： 操作系统&深入Linux 文章标签： java 操作系统 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44654974/article/details/117135178
版权

一、背景

作为一个合格的程序员，必然会涉及到进行代码的规范以及对性能的调优，而调优主要是除了负载均衡、缓存优化、数据库优化（例如建立索引）非代码层面外，还要代码层面的调用，那必须做到对OS比较熟悉，尽量少写烂代码，合理调用OS提供的库函数以及计算机所提供的CPU、内存等重要资源。

二、死锁的基本概念

1.概念：多个并发进程因争夺系统资源而产生相互等待的现象。

2.原理： 当一组进程中的每个进程都在等待某个事件发生，而只有这组进程中的其他进程才能触发该事件，这就称这组进程发生了死锁。
本质原因：
1）、系统资源有限。
2）、进程推进顺序不合理。

3.死锁产生的4个必要条件
1、互斥： 某种资源一次只允许一个进程访问，即该资源一旦分配给某个进程，其他进程就不能再访问，直到该进程访问结束。
2、占有且等待： 一个进程本身占有资源（一种或多种），同时还有资源未得到满足，正在等待其他进程释放该资源。
3、不可抢占： 别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过来。
4、循环等待： 存在一个进程链，使得每个进程都占有下一个进程所需的至少一种资源。

4.破坏死锁的方法
原理：破坏以上四个条件之一，即可。

`分配策略可能存在的模式优点缺点代表策略
死锁预防保守，宁可资源闲置一次性请求所有资源，按序分配使用于突发处理，不必进行掠夺效率低，剥夺次数过多资源有序分配法
死锁避免折中，在运行时判断是否死锁寻找可能的安全允许顺序不必进行掠夺必须知道将来的资源银行家算法（破坏循环等待条件）
死锁检测宽松，允许则分配定期检测死锁是否已经发生允许对死锁进行现场处理通过剥夺解除死锁，造成损失死锁检测算法、资源分配图化简法、资源剥夺法（解除法，破坏请求保持条件）、死锁定理

三、银行家算法实现

银行家算法中的数据结构
为了实现银行家算法，必须设置以下四个数据结构:
（1）可利用资源向量Available:其初始值是系统中所配置的该类全部可用资源的数目。
（2）最大需求矩阵Max:它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
（3）分配矩阵Allocation:它定义了系统中每一类资源当前已分配给每一个进程的资源数。
（4）需求矩阵Need：用一表示每一个进程尚需的各类资源数。

private final int maxPNum = 100;//最大进程数量
    private final int maxRNum = 100;//最大资源数量
    private int curPNum=0;
    private int curRNUm=0;
    //最大需求矩阵,0位需要空出来
    private int[][] maxMatrix={
            {0,7,5,3},
            {0,3,2,2},
            {0,9,0,2},
            {0,2,2,2},
            {0,4,3,3}
    };
            //new int[maxPNum][maxRNum];
    // 分配矩阵,第一位空出来判断该进程是否已经分配成功无需再进行分配
    private int[][] allocateMatrix = {
            {0,0,1,0},
            {0,2,0,0},
            {0,3,0,2},
            {0,2,1,1},
            {0,0,0,2}
    };// 若第一位等于0则未成功完成该进程分配，若为1则表示该进程已经成功分配）申请

    private int[] allResources = {10,5,7};
                    //new int[maxPNum][maxRNum];
    private int[] availableVector;

  1. 安全性算法
    （1）初始化安全序列为空
    （2）从Need中寻找符合要求的进程请求，并将其加入安全序列
    （3）在步骤（2）如出现无法寻找，并且安全序列并未满，则不安全，反之安全。若步骤（2）能够能够找到一个安全的进程请求，则加入安全序列，继续扫描，并设立一个flag标志表示还可以进行下一波扫描

  2. 银行家算法
    Request(i)是进程P(i)的请求向量。如果Requst(i)[j] = K,表示进程P(i)需要K个R(j)类型的资源。
    （1）如果Request(i)[j] <= Need[i,j],便转向步骤2,否则出错；
    （2）如果Request(i)[j] <= Available[j],便转向步骤3，否则出错；
    （3）系统试探着把资源分配给进程P,并修改下面数据结构中的数值:
    Available[j] = Avaliable[j] - Request(i)[j];
    Allocation[i,j] = Allocation[i,j] + Request(i)[j];
    Need[i,j] = Need[i,j] - Request(i)[j];
    （4）执行**安全性算法*,检查此次资源分配后系统是否处于安全状态*。安全则分配，否则分配作废

  3. 代码实现

package practice.os.practice.threadmodule.deadlock;

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Random;

/**
 * @AUTHOR LYF
 * @DATE 2021/5/19
 * @VERSION 1.0
 * @DESC
 *
 */

public class BankerDemo {
    private final int maxPNum = 100;//最大进程数量
    private final int maxRNum = 100;//最大资源数量
    private int curPNum=0;
    private int curRNUm=0;
    //最大需求矩阵,0位需要空出来
    private int[][] maxMatrix={
            {0,7,5,3},
            {0,3,2,2},
            {0,9,0,2},
            {0,2,2,2},
            {0,4,3,3}
    };
            //new int[maxPNum][maxRNum];
    // 分配矩阵,第一位空出来判断该进程是否已经分配成功无需再进行分配
    private int[][] allocateMatrix = {
            {0,0,1,0},
            {0,2,0,0},
            {0,3,0,2},
            {0,2,1,1},
            {0,0,0,2}
    };// 若第一位等于0则未成功完成该进程分配，若为1则表示该进程已经成功分配）申请

    private int[] allResources = {10,5,7};
                    //new int[maxPNum][maxRNum];
    private int[] availableVector;


    //断点
    // 最大需求矩阵不会变，无需保存
//    private int[][] breakPointMaxMatrix={
//            {0,7,5,3},
//            {0,3,2,2},
//            {0,9,0,2},
//            {0,2,2,2},
//            {0,4,3,3}
//    };
    private int[][] breakPointAllocateMatrix;// 若第一位等于0则未成功完成该进程分配，若为1则表示该进程已经成功分配）申请
    private int[] breakPointAllResources;
    private int[] breakPointAvailableVector;

    void init(){
           curPNum = 5;//5个进程
           curRNUm = 3;//三个资源
           //allResources = new int[curRNUm];
           breakPointAllResources = new int[curRNUm];
           breakPointAvailableVector=new int[curRNUm];
           breakPointAllocateMatrix = new int[curPNum][curRNUm+1];
           availableVector=new int[curRNUm];
           System.out.println("init successfully...");       //...已初始化
    }
    // need矩阵无必要再设立？
    int[][] getNeedMatrix(){
        int [][]needMatrix = new int[maxPNum][maxRNum];
        for(int i = 0;i < curPNum;i++){
            for(int j = 0;j < curRNUm+1;j++){//空了一位，因此需要加1
                if(j==0){
                    if(allocateMatrix[i][j]==1){ //表示已经成功分配，无需再分配
                        needMatrix[i][j]=0;//表示该进程等待分配,若为1则说明已经成功分配，无需考虑再进行分配资源
                    }else{
                        // 表示该进程还未成功分配，还需要资源
                        needMatrix[i][j]=1;//表示该进程等待分配,若为1则说明已经成功分配，无需考虑再进行分配资源
                    }
                }
                else {
                    needMatrix[i][j]=maxMatrix[i][j]-allocateMatrix[i][j];
                }
            }
        }
        return needMatrix;
    }

    int[] getAvailableVector(){
        if(availableVector==null){
           System.err.println("System has‘nt allocated the resources,which is available.Please check " +
                   "the operator of init...");
        }
        int []availableV = new int[curRNUm];
        for(int j=1;j<curRNUm+1;j++){
            int sum=0;
            for(int i =0;i<curPNum;i++){
               if(allocateMatrix[i][j]==1){
                   sum+=0;//已成功分配，（该进程无需资源）
               }else{
                   sum+=allocateMatrix[i][j];
               }
            }

            availableV[j-1]=allResources[j-1]-sum;//
            System.out.println("has allocated resource"+(j-1)+":"+sum+";available :"+availableV[j-1]);
        }
        return availableV;
    }

    void workCheck(){
         int[][] tempNeed = getNeedMatrix();
         int[] tempAvailable=getAvailableVector();
         System.out.println("check variable...");
         System.out.println("maxNeed is...");
         for(int[] i:maxMatrix){
             for(int j:i){
                 System.out.print(j+"->");
             }
             System.out.println();
         }
         System.out.println("allocateMatrix is...");
         for(int[] i:allocateMatrix){
            for(int j:i){
                System.out.print(j+"->");
            }
            System.out.println();
         }
         System.out.println("allResources is...");
         for(Integer i:allResources){
             System.out.print(i+"->");
         }
         System.out.println();
         System.out.println("available is...");
         for(Integer i:tempAvailable){
             System.out.print(i+"->");
         }
         System.out.println();
         System.out.println("need is ...");
         for(int i=0;i<curPNum;i++){
             for(int j=0;j<curRNUm+1;j++){
                 System.out.print(tempNeed[i][j]+" ");
             }
             System.out.println();
         }
    }

    int counter =1;
    boolean isSafe(){
        Queue<String> queue = new ArrayDeque();//序列, 直接P+no即可，无需map映射

        //检查序列
        while (queue.size()!=curPNum){//当序列未满时则一直检查 &&isContinueAllocate
            boolean isContinueAllocate=false; //无需设置标志位，直接找出口即可？,每次扫描前都置为false，判断该次扫描有无获取可成功分配的
            System.out.println("第"+counter+"次扫描");
            System.out.println();

            // 检查need矩阵与可获取资源对比
            for(int i=0;i<curPNum;i++)
            {
                int[] tempAvailable = getAvailableVector();
                int[][] tempNeed = getNeedMatrix();//每进行进程分配之前都需要更新一下
                if(tempNeed[i][0]==0){//表示已经成功分配该进程，无再需资源
                    ///queue.add("P"+i); ,已添加过无需重复添加
                    if(!queue.contains("P"+i))
                        queue.add("P"+i);
                    if(queue.size()==curPNum){
                        while(!queue.isEmpty()){
                            System.out.print(queue.poll());
                        }
                        System.out.println();
                        return true;
                    }
                    continue;
                }


                boolean curFlag = true;// 判断当前进程是否可以成功分配
                for(int j=0;j<curRNUm;j++)
                {
                     if(tempNeed[i][j+1]>tempAvailable[j]){
                         curFlag=false;
                     }
                    //if(tempNeed[i][j+1])
                }

                if(curFlag){//可成功分配,进行序列添加,allocate调整 (有点贪心》)

                    // update allocateTable 和 available
                    allocateMatrix[i][0]=1;
                    for(int j=0;j<curRNUm;j++)
                    {
                        availableVector[j]= allocateMatrix[i][j+1]+availableVector[j];
                        allocateMatrix[i][j+1]=0;//置零
                    }
                     queue.add("P"+i);
                     if (i==curPNum-1&&queue.size()==curPNum){
                         System.out.println("safe...");
                         System.out.println("safe sequence is ...");
                         while(!queue.isEmpty()){
                             System.out.print(queue.poll());
                         }
                         System.out.println();
                         return true;
                     }

                     isContinueAllocate =true;//一旦出现成功分配的，则可以再进行一波扫描
                }else{// 不可成功分配，检查是否为最后一个且序列未满，若是则不安全，若不是则继续
                      // 不可分配，size必然不满
                     if(i==curRNUm-1&&queue.size()!=curRNUm)
                     {
                         counter++;
                         if(isContinueAllocate)
                             continue;
                         System.err.println("unsafe...");
                         return false;
                     }
                }
            }
        }
        return false;
    }

    boolean saveBreakPoint(){
        for(int i =0;i<curPNum;i++){
            for(int j =0;j<curRNUm+1;j++){
                breakPointAllocateMatrix[i][j]=allocateMatrix[i][j];
            }
        }

        for (int i =0;i<curRNUm;i++){
            breakPointAllResources[i]=allResources[i];
            breakPointAvailableVector[i]=availableVector[i];
        }

        return true;
    }

    boolean recoveryBreakPoint(){

        for(int i = 0;i < curPNum;i++){
            for(int j =0;j<curRNUm+1;j++){
                allocateMatrix[i][j]=breakPointAllocateMatrix[i][j];
            }
        }

        for (int i =0;i<curRNUm;i++){
            allResources[i] =  breakPointAllResources[i];
            availableVector[i]=breakPointAvailableVector[i];
        }

        return true;
    }

    // 判断是否能够安全分配
    boolean bankerHandle(int[] req,int pId){
          // 判断need
          //boolean flag = true;
          int[][] tempNeed = getNeedMatrix();
          int[] tempAvailable=getAvailableVector();

          for(int i=0;i<req.length;i++){
              if(req[i]>tempNeed[pId][i+1]){
                  System.err.println("request is unreasonable!!!");
                  return false;
              }
          }

          //保存当前状态
          saveBreakPoint();
          if(isSafe()){
              recoveryBreakPoint();
              return true;
          }else {
              recoveryBreakPoint();
              return false;
          }
    }


    void mockReq(){
          final int reqNum = 10;
          int[][] reqs= new int[reqNum][curRNUm];// 若无需该资源则为0

          for(int i =0;i<reqNum;i++){
            int pId = new Random().nextInt(5);

            System.out.println("Attention! process"+pId+" will request resource");
            for(int j = 0;j<curRNUm;j++){
                reqs[i][j]=new Random().nextInt(5);
                System.out.print(reqs[i][j]+">>");
            }
            bankerHandle(reqs[i],pId);


            try {
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[]args){
         BankerDemo bankerDemo = new BankerDemo();
         bankerDemo.init();
         bankerDemo.workCheck();
         //bankerDemo.isSafe();
         bankerDemo.mockReq();
    }

}
adventure.Li
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
Android多进程加载资源失败问题分析:android.content.res.Resources$NotFoundException: Resource ID #0x7f08XXXX
zhanghao_Hulk的专栏
09-08 1923
在Android开发中如果存在多进程共享资源用法时, 会出现资源到不到问题. 真实碰到的问题, 记录下来提供同学们参考 一, 崩溃信息 崩溃日志如下 --------- beginning of crash 08-17 18:54:00.622 17167 17167 E AndroidRuntime: FATAL EXCEPTION: main 08-17 18:54:00.622 17167 17167 E AndroidRuntime: Process: com.mobile.emm.trus
死锁避免——银行家算法的模拟实现 java源代码
03-07
死锁避免——银行家算法的模拟实现 java源代码 java源代码 java源代码 java源代码 java源代码
OS-银行家算法简单实现
qq_40604099的博客
11-10 202
首先，基本数据我们需要一个存储，这里选择使用数组存储 //5进程3资源，如果n进程m资源数组实例化放到main里即可 Max[][]=new int[5][3],//最大资源数 Allocation[][]=new int[5][3],//当前占用资源数 Need[][]=new int[5][3],//仍需要资源数 Availables[]=new int[3],//系统可提供资...
预防和避免死锁的方法及银行家算法的java简单实现
weixin_37711738的博客
04-25 1462
预防死锁 (1) 摒弃“请求和保持”条件 基本思想：规定所有进程在开始运行之前，要么获得所需的所有资源，要么一个都不分配给它，直到所需资源全部满足才一次性分配给它。 优点：简单、易于实现且很安全 缺点：资源被严重浪费，进程延迟运行 (2) 摒弃“不剥夺”条件 基本思想：当一个已经保持了某些资源的进程，再提出新的资源请求而不能立即得到满足时，必须释放它已经保持了的所有资源，待以后需要时再重新申请。...
模拟死锁检测算法[死锁检测算法实现]
09-06
死锁检测算法：当任一进程Pj申请一个已被其他进程占用的资源ri时，进行死锁检测。检测算法通过反复查找进程等待表和资源分配表， 来确定进程Pj对资源ri的请求是否导致形成环路，若是，便确定出现死锁。
java版本银行家算法
我不起名字
05-19 663
import java.util.Scanner; public class yinhangjia { int available[] = new int[]{3,3,2}; int max[][] = new int[][]{{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; int allocation[][] = new int[][]{{0,1,0},{2,
使用C语言编写一个程序，实现死锁检测算法。
quiet2333的博客
04-21 1260
#include <stdio.h> #include <stdlib.h> int main(){ int init = 0; int count = 1; int L[5] = {0,0,0,0,0}; int Allocation[5][3] = {2,1,2,4,0,2,4,0,5,2,0,4,3,1,4}; int Need[5][3] = {3,4,7,1,3,4,0,0,6,2,2,1,1,1,0}; int Available[3] = {2,0,
死锁的实现
qq_40207976的博客
10-18 565
死锁：就是当程序拿着锁A的时候再想拿锁B去做一些事情，在没拿到锁B之前这个锁B被另外一个线程拿去了，另外一个线程拿到B再想拿锁A去做事情。但是线程1没有释放锁A，所以线程2一直不能继续做事情，就释放不了锁B导致线程1也无法继续进行下面的事情。所以形成了死锁。 死锁必须是多线程的。 public class DealLockDemo implements Runnable{     privat...
os-银行家算法
power_to_go
05-13 626
银行家算法是什么 银行家主要就是通过放贷来赚钱的。那最重要的问题是啥？当然是把钱借给还得起的人咯。试想，银行把钱都借给了还不起的人，那银行就完蛋了。假设有一批人（多个进程）来借钱（将要申请资源），但是银行剩下的钱满足不了任何人，那就直接拒绝借贷。当然了，有一部分已经借出的钱回收之后（回收已经分配的资源），又可以满足一批人中某些人的借贷需求。依次类推，可以银行判定能不能按照某个顺序来给这批人放贷。类似的思路延伸到计算机世界，同理。操作系统给多个进程分配资源，能不能找到一个顺序给这些进程分配资源，并逐渐回收资源
死锁/死锁的实现
weixin_45358354的博客
05-27 399
首先明白死锁产生的原因： 死锁指两个或两个以上线程执行过程中，因争夺资源而造成的互相等待现象。 四个必要条件： 1. 互斥性：线程对资源的占有是排他性的，一个资源只能被一个线程占有，直到释放。 2. 请求和保持条件：一个线程对请求被占有资源发生阻塞时，对已经获得的资源不释放。 3. 不剥夺：一个线程在释放资源之前，其他的线程无法剥夺占用。 4. 循环等待：发生死锁时，线程进入死循环，永久阻塞 C++编写锁的代码 第一种是单线程对一个资源重复申请上锁； #include <iostream> #i
模拟实现银行家算法实现死锁避免
01-12
银行家算法是避免死锁的一种重要方法，本实验要求用级语言编写和调试一个简单的银行家算法程序。
操作系统——死锁算法c++实现
yuntai123的博客
05-30 298
具体如下，有问题请联系，一起交流吧 #include<stdio.h> #include<algorithm> #include<cstring> #include<iostream> using namespace std; typedef struct data{ char name;//进程名称 int at;//arrivetime到达时间 int st;//starttime开始时间 int pri;//优先权 double
【项目展示】C语言实现死锁检测算法
qq_45822589的博客
03-18 2601
C语言实现死锁检测和解决，使用DFS判断环路
操作系统——死锁（银行家算法java实现）
LengDanRan
05-15 366
#操作系统——死锁（银行家算法Java实现） package com.layui.book.IDL; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Scanner; /** * @Classname DeadLock * @Description TODO * @Date 2021/5/13 15:17 * @Created by ASUS */ p
死锁的检测与实现
Birate的博客
04-10 1654
死锁的发生是由于线程间资源争夺引起的，这里不对线程的死锁的概念和原理解释。主要介绍死锁的检测和具体实现，检测我们可以使用一个有向图来表示， 线程 A 获取线程 B 已占用的锁，则为线程 A 指向线程 B。 如何为线程 B 已占用的锁？运行过程线程 B 获取成功的锁。检测的原理采用另一个线程定时对图进程检测是否有环的存在。 数据结构定义: typedef enum { PROCESS, RESOURCE} Type; // 定义资源的类型 typedef struct source_type_t { /
Java多线程——死锁概述、银行家算法
Jewel’s blog
05-09 580
一、死锁的一些常识 概念 死锁是指两个或两个以上的线程在执行过程中，由于竞争资源而造成的阻塞问题，若无外力作用下，他们将无法推进下去，此时系统处于死锁状态 产生的原因 竞争资源产生死锁 进程顺序推进不当 出现死锁的必要条件 互斥条件： 资源每次只能是一个线程使用 请求与保持条件 ：一个线程因请求资源而阻塞时，对已经获取的资源保持不放 不可剥夺条件 ： 线程已获取的资源，在未使用之...
死锁、银行家算法
qq_36610334的博客
08-31 164
文中图片来自：https://www.bilibili.com/video/BV1YE411D7nH?p=29 目录 1. 死锁的概念 1.1 产生死锁的必要条件 1.2 什么时候会发生死锁 2. 预防死锁 2.1 破坏互斥条件 2.2 破坏不剥夺条件 2.3 破坏请求和保持条件 2.4 破坏循环等待条件 3. 避免死锁 3.1 安全序列 3.2 银行家思想 4. 死锁的检测和解除 4.1 死锁的检测 4.2 死锁的解除 1. 死锁的概念 产生死锁的例子见，ht...
操作系统之银行家算法的学习Java系列
苏熊猫
11-21 1143
在网上看到很多关于银行家算法的文章，感觉和真正的算法有点出入，安全检查是银行家算法中的一个环节，但是很多网上的代码只有检查代码，没有银行家算法的代码，一下贴出本人对银行家算法的理解，这段代码借鉴与网上，应该很多人都见过，但是我对其有所改正，如果有人为源代码正确的请和我讨论。 package first; import java.util.Scanner; public class E
基于JAVA的银行家算法实现实验报告
u011361470的博客
04-03 4368
一、实验概述 1. 实验名称 基于JAVA平台的银行家算法实现 2. 实验目的 （1）理解利用银行家算法避免死锁的问题； （2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。 （3）理解和掌握安全序列、安全性算法。 3. 实验内容 银行家算法： 银行家算法最初级原为银行系统设计，以确保银行在发放现金贷款时，不会发生...
Java实现的银行家算法：避免死锁策略详解
最后，报告总结了整个设计过程，强调了银行家算法在解决死锁问题上的有效性，并回顾了所使用的关键词，如安全状态、安全序列、银行家算法和安全性算法等。整篇报告结构清晰，涵盖了从理论到实践的完整过程，为读者...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值