OS-银行家算法简单实现

最新推荐文章于 2020-06-17 19:13:43 发布

竹鼠商人

最新推荐文章于 2020-06-17 19:13:43 发布

阅读量207

点赞数

分类专栏： OS编程

本文链接：https://blog.csdn.net/qq_40604099/article/details/102995698

版权

OS编程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

首先，基本数据我们需要一个存储，这里选择使用数组存储

//5进程3资源，如果n进程m资源数组实例化放到main里即可
		Max[][]=new int[5][3],//最大资源数
		Allocation[][]=new int[5][3],//当前占用资源数
		Need[][]=new int[5][3],//仍需要资源数
		Availables[]=new int[3],//系统可提供资源数
		Request[]=new int[3],//请求资源数
		Work[]=new int[3]//当前可提供资源

如何输出安全序列

输出一个序列，首先应该想到的是深搜，我这里选择深搜输出安全序列，每搜到底部就把深搜路径输出，这样可以把所有安全序列都输出，如果只需要一个安全序列，那么打个标记，如果已经搜到了就直接回溯即可

public static void bfs(int n) {
		if(n==5) {//如果搜了5此以上，说明已经搜到底部，那么输出line存储的路径并回溯
			for(int i=0;i<5;i++)
				System.out.print(line[i]+" ");
			System.out.print("\n");
			isfind=true;
			return ;
		}
		//没搜到底部，则继续深搜下去
		for(int i=0;i<5;i++) {
		//当前资源work大于需要的need并且flag违背标记说明上层递归未占用，则标记且占用
			if(Work[0]>=Need[i][0]&&Work[1]>=Need[i][1]&&Work[2]>=Need[i][2]&&!flag[i]) {
				Work[0]+=Allocation[i][0];Work[1]+=Allocation[i][1];Work[2]+=Allocation[i][2];
				flag[i]=true;
				line[n]="P"+i;
				bfs(n+1);//继续递归到下一层
				//递归结束回溯，返还资源
				flag[i]=false;
				Work[0]-=Allocation[i][0];Work[1]-=Allocation[i][1];Work[2]-=Allocation[i][2];
			}
		}
	}

main方法实现

首先需要输入所有进程的Max数和Allocation数，根据这两个计算所需资源数Need

for(int i=0;i<5;i++) {
			//输入Max
			System.out.println("请输入P"+i+"的三个Max值");
			for(int j=0;j<3;j++)
				Max[i][j]=input.nextInt();
			//输入Allocation
			System.out.println("请输入P"+i+"的三个Allocation值");
			for(int j=0;j<3;j++)
				Allocation[i][j]=input.nextInt();
			//计算Need
			for(int j=0;j<3;j++)
				Need[i][j]=Max[i][j]-Allocation[i][j];
		}

然后输入系统可提供的资源数Availables，把Availables赋值给work数组计算T0时刻安全序列

Work=Availables.clone();
		System.out.println("T0时刻安全序列为：");
		bfs(0);

接下来就是死循环了，每次循环都输入所请求资源的进程n，以及请求资源数Request
1.判断是否符合Requsst<=Need[n]
2.判断是否符合Requset<=Availables

//①②
			boolean con=false;
			for(int i=0;i<3;i++) {
				Request[i]=input.nextInt();
				if(Request[i]>Need[n][i]||Request[i]>Availables[i]) {
//					System.out.println("请求数大于资源数！");
					con=true;
					continue;
				}
			}
			if(con) {
				System.out.println("请求数大于资源数！");
				continue;
			}

如果符合上两步则给n进程改变当前状态

for(int i=0;i<3;i++) {
				Work[i]=Availables[i]-Request[i];
				Need[n][i]-=Request[i];
				Allocation[n][i]+=Request[i];
			}

然后调用bfs求安全序列
如果找到则把Availables的状态减去Requsst
没找到则回退n进程的状态

if(!isfind) {//没找到回退
				System.out.println("无安全序列！");
				for(int i=0;i<3;i++) {
//					Work[i]=Availables[i]-Request[i];
					Need[n][i]+=Request[i];
					Allocation[n][i]-=Request[i];
				}
			}else {
				for(int i=0;i<3;i++)
					Availables[i]-=Request[i];
			}

最后是完整代码和测试数据

package ch01;

import java.util.Scanner;

public class Yin_Hang_jia {
	public static int 
		Max[][]=new int[5][3],
		Allocation[][]=new int[5][3],
		Need[][]=new int[5][3],
		Availables[]=new int[3],
		Request[]=new int[3],
		Work[]=new int[3];
	public static boolean flag[]=new boolean[5],isfind=false;
	public static String line[]=new String[5];//安全性序列
	public static Scanner input=new Scanner(System.in);
	public static void main(String[] args) {
		for(int i=0;i<5;i++) {
			//输入Max
			System.out.println("请输入P"+i+"的三个Max值");
			for(int j=0;j<3;j++)
				Max[i][j]=input.nextInt();
			//输入Allocation
			System.out.println("请输入P"+i+"的三个Allocation值");
			for(int j=0;j<3;j++)
				Allocation[i][j]=input.nextInt();
			//计算Need
			for(int j=0;j<3;j++)
				Need[i][j]=Max[i][j]-Allocation[i][j];
		}
		System.out.println("请输入Available的初始值");
		for(int j=0;j<3;j++)
			Availables[j]=input.nextInt();
		Work=Availables.clone();
		System.out.println("T0时刻安全序列为：");
		bfs(0);
		
		while(true) {
			System.out.println("请输入为那个进程请求资源：0，1，2，3");
			int n=input.nextInt();
			System.out.println("请输入请求资源数：");
			//①②
			boolean con=false;
			for(int i=0;i<3;i++) {
				Request[i]=input.nextInt();
				if(Request[i]>Need[n][i]||Request[i]>Availables[i]) {
//					System.out.println("请求数大于资源数！");
					con=true;
					continue;
				}
			}
			if(con) {
				System.out.println("请求数大于资源数！");
				continue;
			}
			isfind=false;
			for(int i=0;i<3;i++) {
				Work[i]=Availables[i]-Request[i];
				Need[n][i]-=Request[i];
				Allocation[n][i]+=Request[i];
			}
			bfs(0);
			if(!isfind) {//没找到回退
				System.out.println("无安全序列！");
				for(int i=0;i<3;i++) {
//					Work[i]=Availables[i]-Request[i];
					Need[n][i]+=Request[i];
					Allocation[n][i]-=Request[i];
				}
			}else {
				for(int i=0;i<3;i++)
					Availables[i]-=Request[i];
			}
		}
	}
	public static void bfs(int n) {
//		System.out.println("n"+n+"  work"+Work[0]+" "+Work[1]+" "+Work[2]);
		if(n==5) {
			for(int i=0;i<5;i++)
				System.out.print(line[i]+" ");
			System.out.print("\n");
			isfind=true;n
			return ;
		}
		for(int i=0;i<5;i++) {
			if(Work[0]>=Need[i][0]&&Work[1]>=Need[i][1]&&Work[2]>=Need[i][2]&&!flag[i]) {
//				System.out.println(i+"_"+Need[i][0]+" "+Need[i][1]+" "+Need[i][2]+" ");
				Work[0]+=Allocation[i][0];Work[1]+=Allocation[i][1];Work[2]+=Allocation[i][2];
				flag[i]=true;
				line[n]="P"+i;
				bfs(n+1);
				flag[i]=false;
				Work[0]-=Allocation[i][0];Work[1]-=Allocation[i][1];Work[2]-=Allocation[i][2];
			}
		}
	}
}
/*
7 5 3
0 1 0
3 2 2
2 0 0
9 0 2
3 0 2
2 2 2
2 1 1
4 3 3
0 0 2
3 3 2

1
1 0 2
4
3 3 0
0
0 2 0

*/

n进程m资源的

package ch01;

import java.util.Scanner;

public class Yinhangjia2 {
	public static int
		Max[][],
		Allocation[][],
		Need[][],
		Availables[],
		Request[],
		Work[];
	public static boolean flag[],isfind=false;
	public static String line[];
	public static Scanner input=new Scanner(System.in);
	public static int n,m;
	public static void main(String[]args) {
		System.out.println("请输入进程数和资源数");
		n=input.nextInt();
		m=input.nextInt();
		//实例化
		Max=new int[n][m];
		Allocation=new int[n][m];
		Need=new int[n][m];
		Availables=new int[m];
		Request=new int[m];
		Work=new int[m];
		flag=new boolean[n];
		line=new String[n];
		//输入数据
		for(int i=0;i<n;i++) {
			System.out.println("请输入P"+i+"的"+m+"个Max值");
			for(int j=0;j<m;j++)
				Max[i][j]=input.nextInt();
			System.out.println("请输入P"+i+"的"+m+"个Allocation值");
			for(int j=0;j<m;j++)
				Allocation[i][j]=input.nextInt();
			for(int j=0;j<m;j++)
				Need[i][j]=Max[i][j]-Allocation[i][j];
		}
		System.out.println("请输入"+m+"个系统资源数");
		for(int j=0;j<m;j++)
			Availables[j]=input.nextInt();
		Work=Availables.clone();
		System.out.println("T0时刻安全序列为：");
		bfs(0);
		while(true) {
			System.out.println("请输入请求资源的进程数");
			int N_=input.nextInt();
			System.out.println("请输入请求资源数");
			//判断是否可分配资源
			boolean temp=false;
			for(int i=0;i<m;i++) {
				Request[i]=input.nextInt();
				if(Request[i]>Need[N_][i]||Request[i]>Availables[i]) {
					temp=true;
					continue;
				}
			}
			//请求数大于资源数
			if(temp) {
				System.out.println("请求资源数大于当前资源书无法分配资源");
				continue;
			}
			for(int i=0;i<m;i++) {
				Work[i]=Availables[i]-Request[i];
				Need[N_][i]-=Request[i];
				Allocation[N_][i]+=Request[i];
			}
			bfs(0);
			if(!isfind) {
				System.out.println("无安全序列!");
				//返还资源
				for(int i=0;i<m;i++) {
					Need[N_][i]+=Request[i];
					Allocation[N_][i]-=Request[i];
				}
			}else {
				for(int i=0;i<m;i++)
					Availables[i]-=Request[i];
			}
		}
	}
	public static void bfs(int N) {
		if(N==n) {
			for(int i=0;i<n;i++)
				System.out.print(line[i]+" ");
			System.out.print("\n");
			isfind=true;
			return ;
		}
		for(int i=0;i<n;i++) {
			
			boolean temp=true;
			for(int j=0;j<m;j++)
				if(Work[j]<Need[i][j]||flag[i])
					temp=false;
			if(temp) {
				for(int j=0;j<m;j++) {
					Work[j]+=Allocation[i][j];
				}
				flag[i]=true;
				line[N]="P"+i;
				bfs(N+1);
				flag[i]=false;
				for(int j=0;j<m;j++) {
					Work[j]-=Allocation[i][j];
				}
			}
		}
	}
}

竹鼠商人

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
OS-银行家算法简单实现

首先，基本数据我们需要一个存储，这里选择使用数组存储//5进程3资源，如果n进程m资源数组实例化放到main里即可 Max[][]=new int[5][3],//最大资源数 Allocation[][]=new int[5][3],//当前占用资源数 Need[][]=new int[5][3],//仍需要资源数 Availables[]=new int[3],//系统可提供资...
复制链接

扫一扫

专栏目录