精华内容
下载资源
问答
  • 操作系统 银行家算法(java)
    千次阅读 多人点赞
    2021-05-30 11:43:18

    操作系统 银行家算法(java)

    Bank.java

    import java.util.Scanner;
    
    
    public class Banker {
    
    	int[] Available = new int [3]; //限制该数组范围为大小为3
        int[][] Max;
        int[][] Alloction;
        int[][] Need;
        int[][] Request;
        int[] Work;
        
        int flag;
        
        int num = 0;//进程编号
        Scanner in = new Scanner(System.in);
    
        public Banker() {
            // Max={{6,3,2},{5,6,1},{2,3,2}};
    
        }
        public void count(int num){
        	flag=num;
        	Max = new int[flag][3];
        	Alloction = new int[flag][3];
        	Need = new int[flag][3];
        	Request = new int[flag][3];
        	Work = new int[3];
        }
        
        public void setSystemVariable(){//设置各初始系统变量,并判断是否处于安全状态。
            setMax();
            setAlloction();
            printSystemVariable();
            SecurityAlgorithm();
        }
    
        public void setMax() {//设置Max矩阵
            System.out.println("请设置各进程的最大需求矩阵Max:");
            for (int i = 0; i < flag; i++) {
                System.out.println("请输入进程P" + i + "的最大资源需求量:");
                for (int j = 0; j < 3; j++) {
                    Max[i][j] = in.nextInt();
                }
            }
        }
    
        public void setAlloction() {//设置已分配矩阵Alloction
            System.out.println("请设置请各进程分配矩阵Alloction:");
            for (int i = 0; i < flag; i++) {
                System.out.println("请输入进程P" + i + "的分配资源量:");
                for (int j = 0; j < 3; j++) {
                    Alloction[i][j] = in.nextInt();
                }
            }
            System.out.println("Available=Available-Alloction.");
            System.out.println("Need=Max-Alloction.");
            for (int i = 0; i < 3; i++) {//设置Alloction矩阵
            	System.out.println("请输入request:");
                //for (int j = 0; j < 3; j++) {
                    Available[i] = in.nextInt();
                //}
            }
            for (int i = 0; i < flag; i++) {//设置Need矩阵
                for (int j = 0; j < 3; j++) {
                    Need[i][j] = Max[i][j] - Alloction[i][j];
                }
            }
        }
    
        public void printSystemVariable(){
            System.out.println("此时资源分配量如下:");
            System.out.println("进程  "+"   Max   "+"   Alloction "+"    Need  "+"     Available ");
            for(int i=0;i<flag;i++){
                System.out.print("P"+i+"  ");
                for(int j=0;j<3;j++){
                   System.out.print(Max[i][j]+"  "); 
                }
                System.out.print("|  ");
                for(int j=0;j<3;j++){
                   System.out.print(Alloction[i][j]+"  "); 
                }
                System.out.print("|  ");
                for(int j=0;j<3;j++){
                   System.out.print(Need[i][j]+"  "); 
                }
                System.out.print("|  ");
                if(i==0){
                    for(int j=0;j<3;j++){
                        System.out.print(Available[j]+"  ");
                    }
                }
                System.out.println();
            }
        }
    
        public void setRequest() {//设置请求资源量Request
    
    
            System.out.println("请输入请求资源的进程编号:");
            num= in.nextInt();//设置全局变量进程编号num
            System.out.println("请输入请求各资源的数量:");
            for (int j = 0; j < 3; j++) {
                Request[num][j] = in.nextInt();
            }
            System.out.println("即进程P" + num + "对各资源请求Request:(" + Request[num][0] + "," + Request[num][1] + "," + Request[num][2] + ").");
    
            BankerAlgorithm();
        }
    
        public void BankerAlgorithm() {//银行家算法
            boolean T=true;
            int num1=0;
            boolean []panduanNeed = new boolean [flag];
            boolean []panduanAvailable = new boolean [flag];
            for (int k = 0; k < 3; k++) {
            	if(Request[num][k] <= Need[num][k]) panduanNeed[k]=true;
            	else panduanNeed[k] = false;
            	if (Request[num][k] <= Available[k]) panduanAvailable[k]=true;
            	else panduanAvailable[k] = false;	
            }
            for (int q = 0; q < 3; q++) {
            	//if (Request[num][0] <= Need[num][0] && Request[num][1] <= Need[num][1] && Request[num][2] <= Need[num][2]) {//判断Request是否小于Need
                    //if (Request[num][0] <= Available[0] && Request[num][1] <= Available[1] && Request[num][2] <= Available[2]) {//判断Request是否小于Alloction
                  if(panduanNeed[q]==true){
                	  if (panduanAvailable[q]==true) {
            			for (int i = 0; i < 3; i++) {
                            Available[i] -= Request[num][i];
                            Alloction[num][i] += Request[num][i];
                            Need[num][i] -= Request[num][i];
                        }
    
                    } else {
                        System.out.println("当前没有足够的资源可分配,进程P" + num + "需等待。");
                       T=false;
                    }
                }else {
                    System.out.println("进程P" + num + "请求已经超出最大需求量Need.");
                    T=false;
                }
    		}
            	
    		
             
    
           if(T==true){
            printSystemVariable(); 
            System.out.println("现在进入安全算法:");
            SecurityAlgorithm();
           }
        }
    
    
        public void SecurityAlgorithm() {//安全算法
        	boolean []panduanNeedWork = new boolean [flag];
            boolean[] Finish = new boolean [flag];//初始化Finish
            for (int i = 0; i < flag; i++) {
            	Finish[i] =false;
    		}
            int count = 0;//完成进程数
            int circle=0;//循环圈数
            int[] S=new int[flag];//安全序列
            for (int i = 0; i < 3; i++) {//设置工作向量
                Work[i] = Available[i];
            }
            boolean flag1 = true;
            while (count < flag) {
                if(flag1){
                    System.out.println("进程  "+"   Work  "+"   Alloction "+"    Need  "+"     Work+Alloction ");
                    flag1 = false;
                }
                for (int i = 0; i < flag; i++) {
                	
    //            	for (int q = 0; q < 3; q++) {
    //					if(Need[i][q]<=Work[q]) panduanNeedWork[q]=true;
    //		        	else panduanNeedWork[q] = false;
    //					}
    //            	int flagNeedWork=0;
    //            	for (int j = 0; j < 3; j++) {
    //					if (panduanNeedWork[j]==false) flagNeedWork=0;
    //					else flagNeedWork=1;
    //				}
                  //  if (Finish[i]==false&&flagNeedWork==1) {//判断条件
                    	if (Finish[i]==false&&Need[i][0]<=Work[0]&&Need[i][1]<=Work[1]&&Need[i][2]<=Work[2]){
                        System.out.print("P"+i+"  ");
                        for (int k = 0; k < 3; k++){
                            System.out.print(Work[k]+"  ");
                        }
                        System.out.print("|  ");
                        for (int j = 0; j<3;j++){
                        Work[j]+=Alloction[i][j];
                        }
                        Finish[i]=true;//当当前进程能满足时
                        S[count]=i;//设置当前序列排号
    
                        count++;//满足进程数加1
                        for(int j=0;j<3;j++){
                           System.out.print(Alloction[i][j]+"  "); 
                        }
                        System.out.print("|  ");
                        for(int j=0;j<3;j++){
                           System.out.print(Need[i][j]+"  "); 
                        }
                        System.out.print("|  ");
                        for(int j=0;j<3;j++){
                           System.out.print(Work[j]+"  "); 
                        }
                        System.out.println();
                    }
                    
                	
                }
                circle++;//循环圈数加1
    
                if(count==flag){//判断是否满足所有进程需要
                    System.out.print("此时存在一个安全序列:");
                    for (int i = 0; i<flag;i++){//输出安全序列
                        System.out.print("P"+S[i]+" ");
                    }
                    System.out.println("故当前可分配!");
                    break;//跳出循环
                }
                if(count<circle){//判断完成进程数是否小于循环圈数
                    count=5;
                    System.out.println("当前系统处于不安全状态,故不存在安全序列。");
                    break;//跳出循环
                }
            }
        }
    }
    
    

    BankTest.java 测试类

    
    import java.util.Scanner;
    
    public class BankTest {
    	public static void main(String[] args) {
    		boolean Choose = true;
            String C;
            Scanner in = new Scanner(System.in);
            Banker T = new Banker();
    //        System.out.println("这是一个三个进程,初始系统可用三类资源为{10,8,7}的银行家算法:");
            System.out.println("请输入进程的个数");
            int count =in.nextInt();
            T.count(count);
            T.setSystemVariable();
            while (Choose == true) {
                T.setRequest();
                System.out.println("您是否还要进行请求:y/n?");
                C = in.nextLine();
                if (C.endsWith("n")) {
                    Choose = false;
                }
            }
    	}
    }
    
    

    测试结果:

    在这里插入图片描述
    在这里插入图片描述

    更多相关内容
  • 操作系统银行家算法,C语言。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • 操作系统银行家算法

    2018-06-10 17:48:41
    简单模拟银行家算法,实现了银行家算法的模拟,具有小规模学习的作用
  • 操作系统 银行家算法的详细实验报告,里面附有代码,可运行,图形化界面展示算法过程
  • 操作系统死锁部分 银行家算法的相关习题 ,题目包括“ 某系统采用银行家算法分配三类资源A、B和C ......”
  • 【计算机专业】操作系统 银行家算法详解
  • 计算机操作系统银行家算法java代码,
  • 算法流程图,运行环境和编程工具,模块划分及关系,模板流程图,程序源代码,测试结果
  • 设计一个n个并发进程共享m个系统资源的程序以实现银行家算法。要求: 1) 简单的选择界面; 2) 能显示当前系统资源的占用和剩余情况。 3) 为进程分配资源,如果进程要求的资源大于系统剩余的资源,不与分配并且...
  • 银行家算法避免死锁,实现系统合理分配资源,加深对进程同步及死锁理解。
  • 操作系统-银行家算法

    2018-06-30 14:41:05
    操作系统银行家算法,可以直接运行,带注释,交作业非常方便
  • 银行家算法是一种用来避免操作系统死锁出现的有效算法,银行家算法,可以了解死锁的概念。死锁:是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都...
  • 是一个模拟银行家算法操作系统程序,采用JAVA16编写,有图形化界面GUI。包括对各种情况的检查安全序列、资源的分配和收回,m种资源n个进程,实时显示系统剩余资源量等
  • 实验五 银行家算法 一实验目的和要求 理解死锁概念银行家算法及安全检测算法 在Linux操作系统下用C++进行编程 利用C++设计实现银行家算法的基本过程 验证银行家算法对于避免死锁的作用 二实验方法内容 算法设计思路 ...
  • c语言实现操作系统作业银行家算法,算法不是很复杂相信理解了算法就可以写的出来。其实代码还有些不足,望自行下去改进。 使用方法:编译后运行程序,输入保存文件绝对路径,一般在txt下,查看文件结果
  • 操作系统银行家算法带简单界面
  • 操作系统作业内容全面下载就可交作业
  • 银行家算法资源分配模拟器C++源文件,用于大学操作系统实验课代码的参考。
  • 通过实例模拟银行家算法实现死锁预防,即输入实例数据后,能够使用银行家算法判断资源分配后是否存在安全序列。
  • 大三上学期的操作系统课程的实验作业,要求模拟实现银行家算法。代码格式良好,注释得当,可供有需要的人参考学习。
  • 代码主体非原创,测试中出现问题经过本人修改后上传,原资源来源:https://blog.csdn.net/houchaoqun_xmu/article/details/55540792 ...可以实现银行家算法检测安全序列避免死锁。此代码VS2010下可直接使用。
  • Request i 是进程Pi 的请求...4.系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。如果安全才正式将资源分配给进程Pi,以完成本次分配;否则,将试探分配作废,恢复原来的资源分配状态,让进程Pi等待。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,825
精华内容 11,130
关键字:

操作系统 银行家算法