黄毅然的JAVA学习（七）

本文主要是介绍黄毅然的JAVA学习（七），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

银行家算法的代码实现

黄毅然已经很久没有更过CSDN了
银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。
在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。

代码实现

定义数据结构

public class pro {
	int finish=0;                //完成标志位
	int[] max=new int[3];        //资源用量
	int[] allocation=new int[3]; //已分配
	int[] need=new int[3];       //需求量
}

主函数及相关操作

import java.util.Scanner;
public class OS_1 
{
	public static void printline(int[] num) 
	{
		System.out.print("执行顺序如下：\t");
        for(int i : num)
        {
            System.out.printf("%d\t", i);
        }
        System.out.println('\n');
    }
	public static void main(String[] args)
	{
		int i,j,n;
		boolean s1=true;
		Scanner input=new Scanner(System.in);
		int[] work=new int[3];
		System.out.print("可分配变量：\n");
		for(i=0;i<3;i++)
			work[i]=input.nextInt();
		System.out.print("\n进程数：\n");
		n=input.nextInt();
		System.out.print("\n");
		int[] line=new int[n];
		for(i=0;i<n;i++)                                  //====================================================//
		{                                                 
			line[i]=-1;                                  
		}
		pro[] process=new pro[n];                                          //创建pro类的process
		for(i=0;i<n;i++)
			process[i]=new pro();
		System.out.print("WDNMD\n");	                                   //输入max,allocation,need
		for(i=0;i<n;i++){
			System.out.printf("进程%d\n",i);
			System.out.print("最大：\t");
			for(j=0;j<3;j++) 
				process[i].max[j]=input.nextInt();
			System.out.print("已分配：\t");
			for(j=0;j<3;j++)
				process[i].allocation[j]=input.nextInt();
			System.out.print("需求量：\t");
			for(j=0;j<3;j++)
				process[i].need[j]=input.nextInt();           //=====================================================//
		}
		input.close();
		
		int m=0,sum=0,count=0,yourmom=1;
		while(yourmom==1)                                     //控制循环，由于需要一直寻找可用进程，只要yourmom还在一直继续
		{
			s1=false;
			m=m%n;                                           //求余操作，确定下标，定位到当前进程
			if(sum==n)
			{
				System.out.print("\n白给");                   //sum会记录每一次不成功的操作，对每一个操作的尝试失败后sum将等于进程数n,结束所有操作
				break;
			}
			if(count==n)
			{
				printline(line);                            //count记录进程顺序数组下标，最后一次完成成功的操作后，count将等于进程数，输出进程执行序列
				break;
			}
			if(process[m].finish==1)
			{                                               //若该进程被执行，跳过对该进程的尝试
				m++;
				sum++;
				continue;
			}
			else
			{
				for(i=0;i<3;i++)                                          //银行家算法核心//
					if(process[m].need[i]>work[i])         //=============================================//，
					{
						sum++;
						s1=true;                           //若资源无法满足进程，sum+1,结束对该进程的尝试
						m++;
						break;
					}
				if(s1) continue;                           //跳出循环
				process[m].finish=1;
				for(i=0;i<3;i++)
					work[i]=work[i]+process[m].allocation[i];//分配并回收资源
				line[count]=m;                            //记录进程顺序
				count++;
				sum=0;                                    //重置失败尝试次数
			}
			m++;
		}                                                 //================================================//
	}
}

有缘再见！

这篇关于黄毅然的JAVA学习（七）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！