江苏龙网

  1. 主页 > 生活百科 > >

内存飙升，罪魁祸首竟是死锁，这样检测和处理减少一半加班时间( 四 )

死锁

此方法一定要记得调用unlock释放锁，同样可以解决死锁问题，因为不会像 synchronized 一样无脑等待，而是非常机智，如果拿不到就不要了，就好比追一个女孩子，追了三年还不行就放弃吧，而synchronized就是永不言弃，等到天荒地老，非常痴情 。倾我半世阳光,许你天荒地老

你是不有更好的解决方案，赶紧掏出来唠唠吧！
银行家算法中避免死锁思维银行家算法是一种最有代表性的避免死锁的算法 。又被称为资源分配拒绝法 。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若此次分配不会导致系统进入不安全状态，则将资源分配给线程，否则进程等待
银行家算法中的数据结构
1、可利用资源向量Available 是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目 。如果Available[j]=K，则表示系统中现有Rj类资源K个 。
2、最大需求矩阵Max 这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求 。如果Max[i,j]=K，则表示进程i需要Rj类资源的最大数目为K 。
3、分配矩阵Allocation 这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数 。如果Allocation[i,j]=K，则表示进程i当前已分得Rj类资源的数目为K 。
4、需求矩阵Need 这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数 。如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务 。Need[i,j]=Max[i,j]-Allocation[i,j]
操作系统的两种状态
安全序列：是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和 。
1、安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态 。安全状态一定是没有死锁发生 。
2、不安全状态：不存在一个安全序列 。不安全状态不一定导致死锁 。
示例 
内存飙升，罪魁祸首竟是死锁，这样检测和处理减少一半加班时间

文章插图
 
首先判断一下当前的安全序列： 当前状态，可利用资源向量有 1 6 2 2
1、P0： 已分配 0 0 3 2，还需要 0 0 1 2，当前可利用资源 1 6 2 2足够分配给P0； Process Allocation Need Available（Available-Need） Available+Allocation P0 0 0 4 4 0 0 0 0 1 6 1 0 1 6 5 4 P0分配成功：进入安全序列，分配完成后，将资源还给可利用资源
2、P1：已分配1 0 0 0，还需要 1 7 5 0，当前可利用资源 1 6 5 4不够分配给P1； P1分配失败
3、P2： 已分配1 3 5 4，还需要 2 3 5 6，当前可利用资源 1 6 5 4不够分配给P2； P2分配失败
4、P3： 已分配 0 3 3 2，还需要 0 6 5 2，当前可利用资源 1 6 5 4足够分配给P3； Process Allocation Need Available（Available-Need） Available+Allocation P3 0 9 8 4 0 0 0 0 1 0 0 2 1 9 8 6 P3分配成功，进入安全序列，分配完成后，将资源还给可利用资源
5、P4： 已分配 0 0 1 4，还需要 0 6 5 6，当前可利用资源 1 9 8 6足够分配给P4； Process Allocation Need Available（Available-Need） Available+Allocation P4 0 6 6 10 0 0 0 0 1 3 3 0 1 9 9 10 P4分配成功，进入安全序列，分配完成后，将资源还给可利用资源
6、P1： 已分配 1 0 0 0，还需要 1 7 5 0，当前可利用资源 1 9 9 10足够分配给P1； Process Allocation Need Available（Available-Need） Available+Allocation P1 2 7 5 0 0 0 0 0 0 2 4 10 2 9 9 10 P1分配成功，进入安全序列，分配完成后，将资源还给可利用资源
7、P2： 已分配 1 3 5 4，还需要 2 3 5 6，当前可利用资源 2 9 9 10足够分配给P2； Process Allocation Need Available（Available-Need） Available+Allocation P2 3 6 10 10 0 0 0 0 0 6 4 4 3 12 14 14 P4分配成功，进入安全序列，分配完成后，将资源还给可利用资源
所以：当前的安全序列为： p0-p3-p4-p1-p2
如果在未分配的时候：p2请求 1 2 2 2，从资源池里给他分配，请问可以分配吗？
答： 如果满足了P2的请求1 2 2 2 的话，要从可利用资源Available 1 6 2 2 中减去1 2 2 2，此时可利用资源为0 4 0 0，纵观全局，如果满足了P2的请求，那么别的进程的需求都不能满足，导致资源不够分配，所以P2的请求不可以分配
Java代码实现银行家算法import java.util.Scanner;public class Banker {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,0,0},{3,0,2},{2,1,1},{0,0,2}};//每个进程目前拥有的资源数int need[][] = new int[][]{{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//每个进程需要的资源数void showData() {//展示数据输出每个进程的相关数System.out.println("进程号MaxAllNeed");System.out.println("ABCABCABC");for(int i = 0;i<5;i++){System.out.print(i+"");for(int m = 0;m<3;m++) System.out.print(max[i][m]+"");for(int m = 0;m<3;m++) System.out.print(allocation[i][m]+"");for(int m = 0;m<3;m++) System.out.print(need[i][m]+"");System.out.println();}}boolean change(int inRequestNum,int inRequest[])//分配数据{int requestNum = inRequestNum;int request[] = inRequest;// for(int i=0;i<3;i++)System.out.println("修改前available"+available[i]);if(!(request[0]<=need[requestNum][0]&&request[1]<=need[requestNum][1]&&request[2]<=need[requestNum][2])){//request[0]<=need[requestNum][0]//request[1]<=need[requestNum][1]//request[2]<=need[requestNum][2]//每一类请求资源小于当前线程need的资源数System.out.println("请求的资源数超过了所需要的最大值，分配错误");return false;}if((request[0]<=available[0]&&request[1]<=available[1]&&request[2]<=available[2])==false){//当前线程的每一类请求资源小于等于资源池对应资源的数量System.out.println("尚无足够资源分配，必须等待");return false;}for(int i = 0;i<3;i++)//试分配数据给请求的线程{available[i] = available[i]-request[i];//资源池的每类资源减去每类请求资源数量allocation[requestNum][i] = allocation[requestNum][i] + request[i];//当前线程allocation中每类资源加上每类资源请求数量need[requestNum][i] = need[requestNum][i] - request[i];//当前线程need中每类资源数量减去每类资源的请求数量}// for(int i=0;i<3;i++)System.out.println("修改后available"+available[i]);boolean flag = checkSafe(available[0],available[1],available[2]);//进行安全性检查并返回是否安全// System.out.println("安全性检查后"+flag);if(flag==true){System.out.println("能够安全分配");return true;}else//不能通过安全性检查 恢复到未分配前的数据{System.out.println("不能够安全分配");for(int i = 0;i<3;i++){available[i] = available[i]+request[i];allocation[requestNum][i] = allocation[requestNum][i] - request[i];need[requestNum][i] = need[requestNum][i] + request[i];}return false;}}boolean checkSafe(int a,int b,int c)//安全性检查{int work[] = new int[3];work[0] = a;work[1] = b;work[2] = c;int i=0;boolean finish[] = new boolean[5];while(i<5)//寻找一个能够满足的认为完成后才去执行下一进程{if(finish[i]==false&&need[i][0]<=work[0]&&need[i][1]<=work[1]&&need[i][2]<=work[2]){//找到满足的修改work值，然后i=0，重新从开始的为分配的中寻找System.out.println("分配成功的是"+i);for(int m = 0;m<3;m++)work[m] =work[m] + allocation[i][m];finish[i] = true;i=0;}else//如果没有找到直接i++i++;}for(i=0;i<5;i++)//通过finish数组判断是否都可以分配{if(finish[i]==false)return false;}return true;}public static void main(String[] args){Banker bank = new Banker();bank.showData();//请求线程资源存放的数组int request[] =new int[3];int requestNum;String source[] = new String[]{"A","B","C"};Scanner s = new Scanner(System.in);String choice = new String();while(true)//循环进行分配{System.out.println("请输入要请求的进程号（0--4）：");requestNum = s.nextInt();System.out.print("请输入请求的资源数目");for(int i = 0;i<3;i++){System.out.println(source[i]+"资源的数目：");request[i] = s.nextInt();}bank.change(requestNum, request);System.out.println("是否再请求分配(y/n)");choice = s.next();if(choice.equals("n"))break;}}}


推荐阅读


上一篇：没有了

下一篇：分布式锁主动续期的入门级实现