2021-03-03 Java代码模拟银行家算法

最新推荐文章于 2023-10-14 11:06:17 发布
最新推荐文章于 2023-10-14 11:06:17 发布
阅读量419 收藏 7
点赞数
分类专栏： 银行家算法 文章标签： windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mao_yanga/article/details/114327351
版权

Java代码模拟操作系统银行家算法

实验题目

模拟使用银行家算法判断系统的状态。

目的

银行家算法是操作系统中避免死锁的算法，本实验通过对银行家算法的模拟，加强学生对该算法的理解与应用。

模拟环境

硬件：pc 机及其兼容机。
软件：Windows OS，MS—DOS OS，Turbo C 或 C++、VC++等

内容

1.建立 T0 时刻的资源分配表，初始化。
2.设计银行家算法，输入一个进程的资源请求，按银行家算法步骤进行检查。
3.设计安全性算法，检查某时系统是否安全。
4.设计显示函数，显示资源分配表，安全分配序列。

算法流程图

Created with Raphaël 2.2.0 初始化T0时刻资源分配表 资源申请 读入一个进程的申请 按银行家算法检查 利用安全算法检查此时是否安全 安全？ 输出安全序列 显示：此次资源请求成功 修改资源分配表 结束 yes no

程序清单

import java.util.Scanner;

import java.util.Scanner;

/** 银行家算法主体类: */
public class Bank 
{
	/** 分配资源的方法:将进程的资源请求进行处理 */
	public void BankAlgorithm() 
	{
		/** 初始化系统已有的资源 + 五个进程的当前信息 */
		// 五个进程对象(输入每个进程对象的名称\所需的最大资源\已分配的资源\还需要的资源)
		Processor processor[] = new Processor[5];
		/** 第一组测试数据: */
		processor[0] = new Processor("P0", 5, 7, 3, 1, 0, 0, 4, 7, 3);
		processor[1] = new Processor("P1", 2, 3, 2, 0, 2, 0, 2, 1, 2);
		processor[2] = new Processor("P2", 0, 9, 2, 0, 3, 2, 0, 6, 0);
		processor[3] = new Processor("P3", 2, 2, 2, 1, 2, 1, 1, 0, 1);
		processor[4] = new Processor("P4", 3, 4, 3, 0, 0, 2, 3, 4, 1);
		
		/** 第二组测试数据: 
		processor[0] = new Processor("P0", 5, 7, 3, 1, 0, 0, 4, 7, 3);
		processor[1] = new Processor("P1", 2, 3, 2, 0, 2, 0, 2, 1, 2);
		processor[2] = new Processor("P2", 0, 9, 2, 0, 3, 2, 0, 6, 0);
		processor[3] = new Processor("P3", 2, 2, 2, 1, 2, 1, 1, 0, 1);
		processor[4] = new Processor("P4", 3, 4, 3, 3, 3, 3, 0, 1, 0);*/
		

		// 一个资源对象(表示当系统拥有的资源)
		Sources sources = new Sources(3, 3, 2);

		System.out.println("当前系统可分配资源为:");
		System.out.println("A: " + sources.A + "\tB: " + sources.B + "\tC: " + sources.C);
		System.out.println("----------------------------进程状态" + "------------------------------");
		System.out.println("P(进程号)" + "\t" + "Max(所需最大资源)" + "\t" + "Allocation(已分配资源)" + "\t" + "Need(还需要的资源数量)");
		System.out.println("" + "\t" + "A B C" + "\t\t" + "A B C" + "\t\t\t" + "A B C");
		for (int i = 0; i < 5; i++)
		{
			processor[i].ShowProcessor();
		}
		System.out.println("-----------------------------------------------------------------\n");

		while (true)
		{
			System.out.println("开始进程资源分配:");

			// 输入要请求的进程号及其要请求的资源数目
			Scanner scan = new Scanner(System.in);
			System.out.println("请输入要请求的进程号(0-4): ");
			int RequestProcessorNum = scan.nextInt();
			System.out.println("请输入要为该进程请求的资源数目(A、B、C): ");
			int a, b, c;
			a = scan.nextInt();
			b = scan.nextInt();
			c = scan.nextInt();
			Sources RequestSources = new Sources(a, b, c);

			// 当初始时第一个进程请求完毕后，需要做判断和改值
			// 1.判断是不是保证请求的每个资源数量是小于等于该进程还需要的资源数量的
			if (RequestSources.A > processor[RequestProcessorNum].need.A
					|| RequestSources.B > processor[RequestProcessorNum].need.B
					|| RequestSources.C > processor[RequestProcessorNum].need.C) {
				System.out.println("出现错误: 请求的资源超过了该进程所需要的资源");
				System.out.println("退出系统");
				System.exit(-1);
			}
			// 2.判断请求的资源是不是小于等于当前所拥有的资源
			if (RequestSources.A > sources.A || RequestSources.B > sources.B || RequestSources.C > sources.C) {
				System.out.println("出现错误: 请求的资源超过了系统此时拥有的资源");
				System.out.println("退出系统(等待其他进程释放资源)");
				System.exit(-1);
			}

			// 工作资源(实时记录当前系统资源数量)
			Sources Work = new Sources(3,3,2);

			//因为已经有进程请求了分配资源，假设可以进行这次的资源请求，所以需要改值
			processor[RequestProcessorNum].allocation.A += RequestSources.A;
			processor[RequestProcessorNum].allocation.B += RequestSources.B;
			processor[RequestProcessorNum].allocation.C += RequestSources.C;
			processor[RequestProcessorNum].need.A -= RequestSources.A;
			processor[RequestProcessorNum].need.B -= RequestSources.B;
			processor[RequestProcessorNum].need.C -= RequestSources.C;
			Work.A -= RequestSources.A;
			Work.B -= RequestSources.B;
			Work.C -= RequestSources.C;
			
			//已经做出了资源请求并且改了值，判断是不是存在安全序列
			boolean isExistSafeQueue = true;
			String[] safeQueue = new String[5];
			int index = 0;
			while (true) 
			{
				boolean find = false;
				for (int i = 0; i < 5; i++) 
				{
					if (processor[i].Finish == false)// 该进程没有分配资源
					{
						boolean flag = true;// 看系统当前资源是不是>=该进程需要的资源
						if (Work.A < processor[i].need.A) 
						{
							flag = false;
						}
						if (Work.B < processor[i].need.B) 
						{
							flag = false;
						}
						if (Work.C < processor[i].need.C) 
						{
							flag = false;
						}
						if (flag == true)
						{
							//System.out.println("此时进程"+i+"可以被分配资源"); 
							
							// 满足三个资源的条件，可以进行资源的分配，当前系统的资源要+上该进程释放的资源
							Work.A += processor[i].allocation.A;
							Work.B += processor[i].allocation.B;
							Work.C += processor[i].allocation.C;

							//System.out.println("分配资源后work数组等于="+Work.A+","+Work.B+","+Work.C);
							
							processor[i].Finish = true;
							
							// 安全序列中加入这个进程
							safeQueue[index++] = "P" + i;

							// 标记find
							find = true;
						}
					}
				}
				if (find == false) 
				{
					for (int i = 0; i < 5; i++) 
					{
						if (processor[i].Finish == false)
						{
							isExistSafeQueue = false;
							System.out.println("出现进程之间的死锁，也就是找不到安全序列");
							break;
						}
					}
					break;
				}
			}
			// 如果存在安全序列
			if (isExistSafeQueue == true) 
			{
				System.out.println("能够对进程安全分配资源");
				System.out.println("安全序列如下:");
				for (int i = 0; i < 5; i++) 
				{
					System.out.print(safeQueue[i] + " ");
				}
				System.out.println();

				//已经判断能够形成安全序列，表示该进程的资源请求成功，此时不需要改变进程的值只要改变sources的值解
				sources.A -= RequestSources.A;
				sources.B -= RequestSources.B;
				sources.C -= RequestSources.C; 
				
				System.out.println("\n系统分配资源后:");
				System.out.println("当前系统可分配资源为:");
				System.out.println("A: " + sources.A + "\tB: " + sources.B + "\tC: " + sources.C);
				System.out.println("----------------------------进程状态" + "------------------------------");
				System.out.println(
						"P(进程号)" + "\t" + "Max(所需最大资源)" + "\t" + "Allocation(已分配资源)" + "\t" + "Need(还需要的资源数量)");
				System.out.println("   " + "\t" + "A B C" + "\t\t" + "A B C" + "\t\t\t" + "A B C");
				for (int i = 0; i < 5; i++)
				{
					processor[i].ShowProcessor();
				}
				System.out.println("-----------------------------------------------------------------\n");

			} 
			else 
			{
				System.out.println("不能够对进程进行安全的资源分配");
				
				//已经判断不能够形成安全序列，表示该进程的资源请求失败，因为之前已经修改了值，所以要改回来
				processor[RequestProcessorNum].allocation.A -= RequestSources.A;
				processor[RequestProcessorNum].allocation.B -= RequestSources.B;
				processor[RequestProcessorNum].allocation.C -= RequestSources.C;
				processor[RequestProcessorNum].need.A += RequestSources.A;
				processor[RequestProcessorNum].need.B += RequestSources.B;
				processor[RequestProcessorNum].need.C += RequestSources.C;
				
				System.out.println("当前系统可分配资源为:");
				System.out.println("A: " + sources.A + "\tB: " + sources.B + "\tC: " + sources.C);
				System.out.println("----------------------------进程状态" + "------------------------------");
				System.out.println(
						"P(进程号)" + "\t" + "Max(所需最大资源)" + "\t" + "Allocation(已分配资源)" + "\t" + "Need(还需要的资源数量)");
				System.out.println("   " + "\t" + "A B C" + "\t\t" + "A B C" + "\t\t\t" + "A B C");
				for (int i = 0; i < 5; i++)
				{
					processor[i].ShowProcessor();
				}
				System.out.println("-----------------------------------------------------------------\n");
				
			}
	
			System.out.println("是否还需要测试该算法(yes/no):");
			String ask = scan.next();
			if (ask.equals("no")) 
			{
				break;
			}
		}
	}
}

package com.mao.bank;



/** 用于测试和调试银行家算法 */
public class Main {
    public static void main(String[] args) {

        /** 开始调用银行家算法进行资源请求(判断是不是能形成一个安全序列) */
        //银行家对象
        Bank banker = new Bank();

        //通过对象调用银行家算法
        banker.BankAlgorithm();
    }
}

package com.mao.bank;

public class Processor {
	
  	/** 四个字段 */
	private String name;//进程名字
	Sources max;//进程所需要的最大资源
	Sources allocation;//当前进程已经分配的资源数
	Sources need;//当前进程还需要多少资源(max-allocation)
	public boolean Finish = false;//判断进程是否结束
	
	public Processor(String name, int max_a,int max_b,int max_c,int all_a,int all_b,int all_c,int need_a,int need_b,int need_c) 
	{
		this.name = name;
		max = new Sources(max_a,max_b,max_c);
		allocation = new Sources(all_a,all_b,all_c);
		need = new Sources(need_a,need_b,need_c);
	}
	
	public void ShowProcessor()
	{
		//打印出进程的信息
		System.out.println(name+"\t"+max.toString()+"\t\t"+allocation.toString()+"\t\t\t"+need.toString());
	}
}


package com.mao.bank;

/** 资源类 */
public class Sources {

	/** 三个字段分别表示A.B.C这三类资源 */
	public int A;
	public int B;
	public int C;

	public Sources() {
	}
	
	public Sources(int A,int B,int C) {
		this.A = A;
		this.B = B;
		this.C = C;
	}
	
	public String toString()
	{
		//打印出资源信息
		return A+" "+B+" "+C;
	}
}
Davia Mao
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java实现银行家算法代码
10-18
用java实现银行家调度算法，避免进程死锁！
JAVA操作系统课设作业银行家算法图形化模拟程序
01-10
**JAVA操作系统课设作业银行家算法图形化模拟程序** 银行家算法是一种著名的避免死锁的策略，由艾兹格·迪杰斯特拉在1965年提出。它主要用于操作系统中资源分配，确保系统能够避免资源饥饿和系统崩溃。在这个JAVA16...
Java实现银行家算法
blogfeifei
10-24 495
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。 下面是用Java实现银行家算法的代码： import java.util.Scanner; public class Banker {int available[] = new int[]{3,3,...
银行家算法java简单实现代码
qq_40844989的博客
08-04 819
银行家算法 参考 https://blog.csdn.net/qq_33414271/article/details/80245715 《一句话+一张图说清楚——银行家算法》土豆洋芋山药蛋 简介 当一个进程申请使用资源的时候，银行家算法通过先 试探 分配给该进程资源，然后通过安全性算法判断分配后的系统是否处于安全状态，若不安全则试探分配作废，让该进程继续等待。 例题 Process：进程名 Al...
银行家算法（Java实现）
黑马程序员广州中心的专栏
05-15 224
这里参考了：http://mp.weixin.qq.com/s?__biz= ... 6oZ#wechat_redirecthttp://blog.sina.com.cn/s/blog_7a4d0df90100zr6x.html 并针对Java实现需要对内容进行了修改。 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。我们可
银行家算法的java模拟实现
qq_42831939的博客
01-02 717
import java.awt.*; import java.awt.event.*; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; imp...
Java语言的银行家算法.doc-综合文档
05-22
在Java程序中，首先初始化所有进程和资源的状态，然后模拟进程的运行，每次进程请求资源时调用银行家算法进行检查。如果安全，则分配资源，更新系统状态；如果不安全，进程进入等待队列。同时，需要设计用户界面或...
Java语言的银行家算法.rar-综合文档
05-10
银行家算法的核心是模拟银行家对贷款的审批过程，确保不会因为过度发放贷款导致无法偿还的情况发生。在计算机系统中，这对应于分配系统资源（如内存、磁盘空间、CPU时间等）时，确保系统安全，避免资源耗尽导致的...
Java编程模拟银行家算法源代码
01-14
以下是Java编程模拟银行家算法的源代码，它包含了完整的实现，并且有详细的注释，非常适合作为实验报告的源代码使用。这段代码可以帮助大家理解银行家算法的原理和实现细节，以及如何在Java中实现这一算法。通过阅读...
java银行家算法：操作系统银行家算法模拟 模拟银行家算法
最新发布
05-09
在Java中实现银行家算法，需要定义数据结构来表示进程、资源类、资源需求和当前分配，然后编写方法来模拟请求、分配、释放资源的过程。`bank.java`文件很可能包含了这样的实现代码，其中可能包含以下关键部分： - `...
银行家算法java源代码
06-12
银行家算法java源代码 设计五个进程{P0，P1，P2，P3，P4}共享三类资源{A，B，C}的系统，{A，B，C}的资源数量分别为10，5，7。进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源
银行家算法Java源码
03-11
死锁避免----银行家算法的模拟实现，掌握银行家算法，了解资源在进程并发执行中的资源分配策略。 数字有系统随机产生，分配资源看系统能不能执行。
用Java写的模拟银行家算法源程序
01-04
用Java写的模拟银行家算法程序源代码，可以实现资源分配，安全系列检查等功能。可以随意输入进程数和资源数，可以重新申请资源，并以界面形式输出相关数据。
计算机操作系统银行家算法java代码
01-03
计算机操作系统银行家算法java代码，
银行家算法 详细java源代码
12-15
这是关于操作系统的银行家算法的一个java程序
Java编写银行家算法模拟程序
weixin_50168558的博客
04-26 2101
目录 前言 一、思路 二、代码 总结 前言 编写一个银行家算法的模拟程序。改程序应该能够循环检查每一个提出请求的银行客户，并且能判断这一请求是否安全。请把有关请求和相应决定的列表输出到一个文件夹中。 一、思路 按照流程图实现即可 二、代码 import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class Banker { static int n, m, k;
银行家算法java
墨染白筝
11-13 1001
这是第一次做的，不能重新申请资源，只能一次判断是否存在安全序列。 并且只能输出一种安全序列，即按进程数字最小的排。 暂时没有想到如果全部不满足分配应该如何退出死循环。 下面是代码：public class Main { public static void main(String[] args) { //五个进程已经分配的资源 int[][] p_Allo
Java银行家算法
hwq1987的专栏
01-01 1069
package 银行家算法; import javax.swing.JOptionPane; public class Bank { // 每个进程所需要的最大资源数 public static int MAX[][] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 }, { 2, 2, 2 }, { 4, 3, 3 } }; // 系统
JAVA-银行家算法
m0_60469045的博客
10-14 2015
在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。安全序列：指一个进程序列{p1,......,pn}是安全的，即对于每一个进程pi（1<= i<=n）,它以后尚需要的资源量不超过系统当前剩余资源量与所有进程pj(j<i)当前占有资源量之和。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值