操作系统 预防进程死锁的银行家算法 java版
避免死锁之银行家算法
避免死锁之银行家算法分类：Operating System2013-12-28 01:14 922人阅读评论(0) 收藏举报目录(?)[+]上篇博客中进程管理之死锁我们讲到了进程管理中死锁的各种问题，其中留下了死锁避免算法中著名的银行家算法没讲，下面就为大家详细解读。
1.安全序列讲银行家算法之前，我们首先引入安全序列的定义：所谓系统是安全的，是指系统中的所有进程能够按照某一种次序分配资源，并且依次地运行完毕，这种进程序列{P1，P2，...，Pn}就是安全序列。
如果存在这样一个安全序列，则系统是安全的；如果系统不存在这样一个安全序列，则系统是不安全的。
安全序列{P1，P2，...，Pn}是这样组成的：若对于每一个进程Pi，它需要的附加资源可以被系统中当前可用资源加上所有进程Pj当前占有资源之和所满足，则{P1，P2，...，Pn}为一个安全序列，这时系统处于安全状态，不会进入死锁状态。
虽然存在安全序列时一定不会有死锁发生，但是系统进入不安全状态（四个死锁的必要条件同时发生）也未必会产生死锁。
当然，产生死锁后，系统一定处于不安全状态。
2.银行家算法(为了熟悉英语请原谅我借用wiki上的文字来描述)For the Banker's algorithm to work, it needs to know three things:∙How much of each resource each process could possibly request[CLAIMS]∙How much of each resource each process is currently holding[ALLOCATED]∙How much of each resource the system currently has available[AVAILABLE]Resources may be allocated to a process only if it satisfies the following conditions:∙request ≤ max, else set error condition as process has crossed maximum claim made by it.∙request ≤ available, else process waits until resources are available.Basic data structures to be maintained to implement the Banker's Algorithm:∙Available: A vector of length m indicates the number of available resources of each type. If Available[j] = k, there are kinstances of resource type Rj available.∙Max: An n×m matrix defines the maximum demand of each process. If Max[i,j] = k, then Pi may request at most k instances of resource type Rj.∙Allocation: An n×m matrix defines the number of resources of each type currently allocated to each process. If Allocation[i,j] = k, then process Pi is currently allocated k instance of resourcetype Rj.∙Need: An n×m matrix indicates the remaining resource need of each process. If Need[i,j] = k, then Pi may need k moreinstances of resource type Rj to complete task.Note: Need[i,j] = Max[i,j] - Allocation[i,j].∙银行家算法:设进程i提出请求Request[j]，则银行家算法按如下规则进行判断。
操作系统银行家算法(避免死锁)实验报告
操作系统实验：银行家算法姓名：李天玮班级：软工1101 学号：201126630117 实验内容：在windows系统中实现银行家算法程序。
实现银行家算法所用的数据结构：假设有5个进程3类资源，则有如下数据结构：1.MAX[5，3] 5个进程对3类资源的最大需求量。
2.A V AILABLE[3]系统可用资源数。
3.ALLOCATION[5,3]5个进程已经得到3类资源的资源量。
4.NEED[5,3]5个进程还需要3类资源的资源量。
银行家算法：设进程1提出请求Request[N]，则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[1,N],则转（2）；否则，出错。
(2)如果Request[N]<=A V ALIABLE，则转（3）；否则，出错。
(3)系统试探非配资源，修改相关数据。
A V ALIABLE=A V ALIABLE-REQUESTALLOCATION=ALLOCA TION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
安全性检查：（1）设置两个工作向量WORK=A V AILABLE；FINISH[M]=FALSE.（2）从晋城集合中找到一个满足下述条件的进程，FINISH[i]=FALSENEED<=WORK如找到，执行（3）；否则，执行（4）。
（3）设进程获得资源，可顺利执行，直至完成，从而释放资源。
WORK=WORK+ALLOCATIONFINISH[i]=TRUEGOTO（2）（4）如所有进程FINISH[M]=TRUE，则表示安全；否则系统不安全。
1.用init（）函数对于数据的初始化关键代码：#define M 5#define N 3void init(){cout<<"请输入5个进程对3类资源最大资源需求量:"<<endl;for(int i=0;i<M;i++){for(int j=0;j<N;j++){cin>>MAX[i][j];}//cout<<endl;}cout<<"请输入系统可用的资哩源数:"<<endl;for(int j=0;j<N;j++){cin>>AVAILABLE[j];}cout<<"请输入5个进程已经-的到的3类资源的资源量:"<<endl;for(int i=0;i<M;i++){for(int j=0;j<N;j++){cin>>ALLOCATION[i][j];}//cout<<endl;}cout<<"请?输?入?5个?进?程ì还1需è要癮3类え?资哩?源′的?资哩?源′量?:"<<endl;for(int i=0;i<M;i++){for(int j=0;j<N;j++){cin>>NEED[i][j];}//cout<<endl;}}// Stack around the variable 'AVAILABLE' was corrupted.显示数据详细信息进行测试输入一号进程号，并给需要申请资源设定为{1,0,2}检验错误输入时候的报错信息检验当再次申请0号资源并申请资源数目为{0,2,0}时，系统提示系统不安全申请不成功。
操作系统 预防进程死锁的银行家算法 java版
实验三预防进程死锁的银行家算法1、实验目的通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
2、试验内容问题描述：设计程序模拟预防进程死锁的银行家算法的工作过程。
假设系统中有n个进程P1, … ,P n，有m类可分配的资源R1, … ,R m，在T0时刻，进程P i分配到的j类资源为Allocation ij个，它还需要j类资源Need ij个，系统目前剩余j类资源Work j个，现采用银行家算法进行进程资源分配预防死锁的发生。
3、程序要求：1）判断当前状态是否安全，如果安全给出安全序列；如果不安全给出理由。
2）对于下一个时刻T1，某个进程P k会提出请求Request(R1, … ,R m)，判断分配给P k进程请求的资源之后系统是否安全。
3）输入：进程个数n，资源种类m，T0时刻各个进程的资源分配情况（可以运行输入，也可以在程序中设置）；4）输出：如果安全，输出安全的进程序列，不安全则提示信息。
4、需求分析(1) 输入的形式和输入值的范围输入进程的数目输入资源的种类每个进程最多所需的各类资源数(Max[i][j])每个进程已经分配的各类资源数(Allocation[i][j])各个资源现有的数目（Available[][]）(2) 输出的形式如果安全，输出安全的进程序列，不安全则提示信息。
(3)测试用例5、调试分析通过本次实验可知，用银行家算法避免死锁就是在资源所能承受范围内给需要资源的进程分派所需资源，在分派资源时若请求资源超出所需资源或超出可得资源，则不合条件,则让当前进程等待换下一个进程,若可利用资源已经满足任何一个进程所需，则系统不安全并且系统不分配资源；在安全性检验时，若可利用资源已经满足任何一个进程所需，则系统不安全并且系统不分配资源。
免死锁属于事先预防的策略，在资源的动态分配过程中用某种方法去防止系统进入不安全状态，从而避免死锁发生。
java银行家算法代码实现
java银行家算法代码实现=================一、算法简介------银行家算法是一种用于避免系统发生死锁的算法，它通过分析系统资源分配情况，判断系统是否处于安全状态，从而避免死锁的发生。
Java银行家算法是一种基于Java语言的实现，它通过模拟系统资源分配情况，判断系统是否处于安全状态。
二、算法实现------以下是一个简单的Java银行家算法代码实现：```javapublicclassBankerAlgorithm{//资源数量和最大需求量privateint[]resource=newint[10];//例如：包括x，y，z三种资源，分别对应i-x1-x2-z...-xi-yi-zi...privateint[]maxDemand=newint[10];privateint[]available=newint[10];//当前可用资源数量privateint[]allocation=newint[10];//当前已分配资源数量privateint[]need=newint[10];//当前进程需求量privateint[]saved=newint[10];//已保存的安全序列中最后一个进程的资源需求量privateint[]process=newint[5];//进程集合，包括进程编号和进程所需资源量privateint[]processMax=newint[5];//进程最大需求量集合privateint[]systemSafe=0;//系统是否处于安全状态的标志位privateinttotalSystemSafe=0;//总共是否有足够资源可以安全运行的标志位//初始化资源分配信息publicvoidinitialize(int[][]allocationMatrix){for(inti=0;i<allocationMatrix.length;i++){process[i]=allocationMatrix[i][0];//进程编号processMax[i]=allocationMatrix[i][1];//进程最大需求量available[i]=allocationMatrix[i][2];//当前可用资源数量need[i]=allocationMatrix[i][3];//当前进程需求量maxDemand[i]=allocationMatrix[i][4];//当前进程最大需求量}systemSafe=true;//系统默认处于安全状态totalSystemSafe=true;//总共是否有足够资源可以安全运行的标志位默认设置为true}//检查系统是否处于安全状态，并返回检查结果和可能的执行序列（从开始到结束）publicboolean[]checkAndPrintSafePath(){intcurrentSystemSafe=false;//检查后的系统是否处于安全状态的标志位boolean[]safePath=newboolean[process.length];//安全序列for(inti=0;i<process.length;i++){if(need[i]<=available[i]){//如果当前进程需要的资源小于等于当前可用资源数量，则可以继续执行下去safePath[i]=true;//将当前进程标记为已执行过，并加入到安全序列中available[i]-=need[i];//将当前可用资源数量减去当前进程的已分配量，表示系统多出来的资源数量为已分配的减去需求的currentSystemSafe=true;//将当前系统的安全状态标记为true，因为已经有至少一个进程能够执行下去了}else{//如果当前进程需要的资源大于当前可用资源数量，则需要检查系统是否有足够的资源可以继续执行下去intavailableSum=0;//系统剩余的可用资源数量之和for(intj=0;j<process.length;j++){//将所有可用资源的数量累加起来availableSum+=available[j];}if(availableSum>=processMax[i]){//如果系统剩余的可用资源数量之和大于等于当前进程的最大需求量，则系统可以继续执行下去，否则需要重新分配资源并返回结果重新开始执行安全序列为null；如果为空说明不满足要求否则输出一个安全的执行序列，开始输出可执行的进程数以及所分配的资源和后续的系统安全状态标记等信息totalSystemSafe=false;//将当前系统安全状态的标志位置为false，因为此时不满足安全状态的要求，需要重新开始执行程序，且此次循环的完整性和执行性需要考虑已经完成过的安全序列重新考虑这些因素的修改可能会被重用）确保安全性序列不再更改）；再次输出完整的信息需要重新考虑这些因素以确保安全性序列不再更改）并返回结果；如果为true则说明系统已经处于安全状态并输出一个安全的执行序列；如果为false则说明。
银行家算法java代码
银行家算法java代码银行家算法是一种用于避免死锁的算法，它可以保证系统在分配资源时不会陷入死锁状态。
在操作系统中，银行家算法被广泛应用于进程调度和资源管理中。
本文将介绍银行家算法的原理和实现，并提供Java代码示例。
一、银行家算法原理银行家算法是基于资源分配图的理论基础上发展而来的。
资源分配图是描述进程和资源之间关系的一种图形表示方法。
在资源分配图中，每个进程和每个资源都表示为一个节点，进程需要的资源和已经被占用的资源之间连接一条边。
银行家算法通过模拟进程请求和释放资源的过程来判断是否会出现死锁。
当一个进程请求某些资源时，如果系统能够满足其请求，则该进程可以继续执行；否则，该进程必须等待直到有足够的资源可用。
当一个进程释放掉已经占用的某些资源时，系统会将这些资源重新分配给其他需要它们的进程。
为了避免死锁，银行家算法采取了预防措施：在分配任何一个新任务之前，先检查该任务所需求各类资料是否超过了系统现有的资料总量，如果超过了，则不予分配。
否则，再检查该任务所需求各类资料是否超过了系统现有的未分配资料总量，如果超过了，则不予分配。
二、银行家算法实现银行家算法的实现需要考虑以下几个方面：1.资源分配图的表示方法：可以使用邻接矩阵或邻接表来表示资源分配图。
2.进程请求和释放资源的模拟：可以使用数组来存储进程占用和需要的资源数量，并通过对数组的修改来模拟进程请求和释放资源的过程。
3.死锁检测：可以使用安全序列或银行家算法来判断是否会出现死锁。
下面是一个基于银行家算法实现的简单Java代码示例：public class BankerAlgorithm {// 进程数private int n;// 资源数private int m;// 各进程已占用资源数量private int[][] allocation;// 各进程尚需资源数量private int[][] need;// 系统剩余可用资源数量private int[] available;/*** 构造函数* @param n 进程数* @param m 资源数* @param allocation 各进程已占用资源数量* @param need 各进程尚需资源数量* @param available 系统剩余可用资源数量*/public BankerAlgorithm(int n, int m, int[][] allocation, int[][] need, int[] available) {this.n = n;this.m = m;this.allocation = allocation;this.need = need;this.available = available;}/*** 模拟进程请求资源* @param pid 进程ID* @param request 请求的资源数量* @return 是否满足请求*/public boolean requestResources(int pid, int[] request) { // 检查请求是否超过进程所需的资源数量for (int i = 0; i < m; i++) {if (request[i] > need[pid][i]) {return false;}}// 检查请求是否超过系统剩余的资源数量for (int i = 0; i < m; i++) {if (request[i] > available[i]) {return false;}}// 模拟进程占用资源的过程for (int i = 0; i < m; i++) {available[i] -= request[i];allocation[pid][i] += request[i];need[pid][i] -= request[i];}return true;}/*** 模拟进程释放资源* @param pid 进程ID* @param release 释放的资源数量*/public void releaseResources(int pid, int[] release) { // 模拟进程释放资源的过程for (int i = 0; i < m; i++) {available[i] += release[i];allocation[pid][i] -= release[i];need[pid][i] += release[i];}}/*** 判断系统是否安全* @return 是否安全*/public boolean isSafe() {// 初始化工作数组int[] work = new int[m];for (int i = 0; i < m; i++) {work[i] = available[i];}boolean[] finish = new boolean[n]; for (int i = 0; i < n; i++) {finish[i] = false;}// 查找可用的进程int count = 0;while (count < n) {boolean found = false;for (int i = 0; i < n; i++) {if (!finish[i]) {boolean canRun = true;for (int j = 0; j < m; j++) { if (need[i][j] > work[j]) { canRun = false;break;}}if (canRun) {finish[i] = true;found = true;count++;for (int j = 0; j < m; j++) {work[j] += allocation[i][j];}}}}if (!found) {return false;}}return true;}}三、总结银行家算法是一种重要的避免死锁的算法，它可以在系统分配资源时避免出现死锁状态。
操作系统课设(模拟实现银行家算法实现死锁避免)
计算机与信息工程系《计算机系统与系统软件》课程设计报告题目：模拟实现银行家算法实现死锁避免专业：信息管理与信息系统班级：信管082班学号：姓名：指导老师：2010年9 月9 日一、实验题目模拟实现银行家算法实现死锁避免二、目的：1、了解进程产生死锁的原因，了解为什么要进行死锁的避免。
2、掌握银行家算法的数据结构，了解算法的执行过程，加深对银行家算法的理解。
三、内容：模拟实现银行家算法实现死锁避免。
要求：初始数据（如系统在T0时刻的资源分配情况、每一种资源的总数量）从文本文件读入，文件中给出最大需求矩阵Max、分配矩阵Allocation，在程序中求得需求矩阵Need和可利用资源向量Available。
四、实验提示：1、整个银行家算法的思路。
先对用户提出的请求进行合法性检查，再进行预分配，利用安全性检查算法进行安全性检查。
2、算法用到的主要数据结构和C语言说明。
（1）、可利用资源向量INT A V AILABLE[M] M为资源的类型。
（2）、最大需求矩阵INT MAX[N][M] N为进程的数量。
（3）、已分配矩阵INT ALLOCA TION[N][M]（4）、还需求矩阵INT NEED[N][N]（5）、申请各类资源数量int Request[x]; //（6）、工作向量int Work[x];（7）、int Finish[y]; //表示系统是否有足够的资源分配给进程，0为否，非0为是3、银行家算法（主程序）（1）、系统初始化。
输入进程数量，资源种类，各进程已分配、还需求各资源数量，各资源可用数量等（2）、输入用户的请求三元组（I，J，K），为进程I申请K个J类资源。
（3）、检查用户的请求是否小于还需求的数量，条件是K<=NEED[I,J]。
如果条件不符则提示重新输入，即不允许索取大于需求量（4）、检查用户的请求是否小于系统中的可利用资源数量，条件是K<=A V ALIABLE[I,J]。
银行家算法例题具体步骤
银行家算法例题具体步骤
银行家算法是一种避免死锁的著名算法，主要应用于避免操作系统中的死锁问题。
以下是使用银行家算法解决死锁问题的一个具体例子：假设系统中有三种类型的资源（A、B、C）和五个进程（P1，P2，P3，P4，P5），A资源的数量是17，B资源的数量是6，C资源的数量为19。
首先，我们需要确定各进程对各类资源的最大需求量。
在这个例子中，我们已经知道P1需要（0、0、6），P2需要（1、0、0），P3需要（0、1、2），P4需要（3、4、7），P5需要（0、3、5）。
然后，我们需要计算每个进程已分配的资源向量和当前资源剩余向量。
这些向量通常可以通过系统当前的资源分配情况进行计算。
接下来，我们需要判断系统当前是否处于安全状态。
如果系统处于安全状态，则意味着系统能够满足所有进程的请求而不会发生死锁。
否则，系统处于不安全状态，需要采取措施避免死锁的发生。
具体来说，我们可以使用银行家算法来计算安全序列。
安全序列是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
在这个例子中，存在一个安全序列：P1-P3-P2-P4-P5。
这意味着按照这个序列执行进程是安全的，不会发生死锁。
如果系统处于不安全状态，则需要重新调整资源分配或者采取其他措施来避免死锁的发生。
需要注意的是，银行家算法是一种理论上的算法，实际应用中还需要
考虑其他因素，比如资源的动态分配和请求的实时性等。
因此，在实际应用中需要根据具体情况进行调整和改进。
计算机操作系统课程设计(JAVA语言)计算机操作系统银行家算法实现
操作系统课程设计报告题目：银行家算法的设计与实现院（系）：计算机科学与工程学院专业：信息对抗专业班级：班学生：学号：指导教师：2011年12月基于计算机操作系统银行家算法实现摘要此次课程设计的主要内容是模拟实现资源分配。
同时要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生具体用银行家算法实现资源分配。
要求如下：(1) 设计一个3个并发进程共享3类不同资源的系统，进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源。
(2) 设计用银行家算法和随机分配算法，实现资源分配的两个资源分配程序，应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况。
(3) 确定一组各进程依次申请资源数的序列，在相同的情况下分别运行上述两种资源分配程序，观察运行结果。
银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
死锁的产生，必须同时满足四个条件，即一个资源每次只能由一个进程占用：第二个为等待条件，即一个进程请求资源不能满足时，它必须等待，但它仍继续保持已得到的所有其他资源：第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一个进程所持有的资源。
防止死锁的机构只能确保上述四个条件之一不出现，则系统就不会发生死锁。
通过这个算法可用解决生活中的实际问题,如银行贷款等. 通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升.关键词：死锁；安全状态；安全序列；银行家算法；安全性检查目录1 概述 (3)1.1设计目的 (3)1.2开发环境 (3)2 需求分析 (4)2.1死锁概念 (4)2.2死锁的结论 (4)2.3资源分类 (4)2.4产生死锁的必要条件 (4)2.5死锁的解决方案 (4)2.5.1产生死锁的例子 (4)2.5.2死锁预防 (5)2.5.3安全状态与不安全状态 (5)3 数据结构分析设计 (6)3.1可利用资源向量矩阵available[ ] (6)3.2最大需求矩阵max[ ][ ] (6)3.3分配矩阵allocation[ ][ ] (6)3.4需求矩阵need[ ][ ] (6)4 算法的实现 (7)4.1初始化 (7)4.2银行家算法 (7)4.3安全性检查算法 (7)4.4各算法流程图 (8)5 测试与实例分析 (10)6 心得体会 (14)7.参考文献与源程序清单(附录) (15)1概述1.1设计目的银行家算法是一种最有代表性的避免死锁的算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三预防进程死锁的银行家算法1、实验目的通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
2、试验内容问题描述：设计程序模拟预防进程死锁的银行家算法的工作过程。
假设系统中有n个进程P1, … ,P n，有m类可分配的资源R1, … ,R m，在T0时刻，进程P i分配到的j类资源为Allocation ij个，它还需要j类资源Need ij个，系统目前剩余j类资源Work j个，现采用银行家算法进行进程资源分配预防死锁的发生。
3、程序要求：1）判断当前状态是否安全，如果安全给出安全序列；如果不安全给出理由。
2）对于下一个时刻T1，某个进程P k会提出请求Request(R1, … ,R m)，判断分配给P k进程请求的资源之后系统是否安全。
3）输入：进程个数n，资源种类m，T0时刻各个进程的资源分配情况（可以运行输入，也可以在程序中设置）；4）输出：如果安全，输出安全的进程序列，不安全则提示信息。
4、需求分析(1) 输入的形式和输入值的范围输入进程的数目输入资源的种类每个进程最多所需的各类资源数(Max[i][j])每个进程已经分配的各类资源数(Allocation[i][j])各个资源现有的数目（Available[][]）(2) 输出的形式如果安全，输出安全的进程序列，不安全则提示信息。
(3)测试用例5、调试分析通过本次实验可知，用银行家算法避免死锁就是在资源所能承受范围内给需要资源的进程分派所需资源，在分派资源时若请求资源超出所需资源或超出可得资源，则不合条件,则让当前进程等待换下一个进程,若可利用资源已经满足任何一个进程所需，则系统不安全并且系统不分配资源；在安全性检验时，若可利用资源已经满足任何一个进程所需，则系统不安全并且系统不分配资源。
免死锁属于事先预防的策略，在资源的动态分配过程中用某种方法去防止系统进入不安全状态，从而避免死锁发生。
6、测试结果输入进程数,资源数,最大需求矩阵,分配矩阵,可利用资源向量,对进程的资源请求向量输出:7、附录(java)package experiment;import java.io.BufferedInputStream;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.util.Scanner;public class C_Bank {// 允许的最大进程数private static int MaxNumber = 100;// 真正的进程数public static int realNum;// ???????????public static int l=0;// 资源的种类public static int resourceKind;// 可利用资源数组private static int Available[] = new int[MaxNumber];// 最大需求矩阵private static int Max[][] = new int[MaxNumber][MaxNumber];// 已分配矩阵private static int Allocation[][] = new int[MaxNumber][MaxNumber];// 需求矩阵private static int Need[][] = new int[MaxNumber][MaxNumber];// 请求向量private static int Request[][] = new int[MaxNumber][MaxNumber];// 表示系统是否有足够的资源分配给进程private static boolean Finish[] = new boolean[MaxNumber];//当前可利用资源private static int Work[] = new int[MaxNumber];// 安全序列private static int p[] = new int[MaxNumber];//for循环中使用private static int i;private static int j;private static int k;public static Scanner stdin;public static void main(String args[]) throws FileNotFoundException { // 输入realNum,resourceKind,Max[i][j],Allocation[i][j],Allocation[i][j]，获得Need[i][j] input();// 安全性算法//safe();//进程请求request();}public static void input() throws FileNotFoundException {BufferedInputStream in = new BufferedInputStream(new FileInputStream( "./file/03"));System.setIn(in);stdin = new Scanner(System.in);// 输入进程的数目realNum = stdin.nextInt();// 输入资源的种类resourceKind = stdin.nextInt();// 输入每个进程最多所需的各类资源数(Max[i][j])for (i = 0; i < realNum; i++) {for (j = 0; j < resourceKind; j++) {Max[i][j] = stdin.nextInt();}}// 输入每个进程已经分配的各类资源数(Allocation[i][j]),并获得Need[i][j]for (i = 0; i < realNum; i++) {for (j = 0; j < resourceKind; j++) {Allocation[i][j] = stdin.nextInt();Need[i][j] = Max[i][j] - Allocation[i][j];}}// 请输入各个资源现有的数目for (i = 0; i < resourceKind; i++)Available[i] = stdin.nextInt();}// 安全性算法public static boolean safe(){//Work[]赋初值for(i=0 ; i<resourceKind ; i++){Work[i]=Available[i];}//Finish[]赋初值for(i=0 ; i<realNum ; i++){Finish[i]=false;}for(i=0 ; i<realNum ; i++){if(Finish[i] == true){continue;}else{for(j=0 ; j<resourceKind ; j++){if(Need[i][j]>Work[j])break;}if(j==resourceKind) //满足了Need[][]<=Work[][]{Finish[i]=true;for(k=0 ; k<resourceKind ; k++){Work[k] = Work[k] + Allocation[i][k];}p[l++]=i;i=-1;}else{continue;}}if(l==realNum){ //Finish[]都是true,输出安全序列System.out.println("系统是安全的");System.out.println("系统安全序列是:");for(i=0;i<l;i++){System.out.print(p[i]);if(i != l-1)System.out.print("-->");}System.out.print("\n");return true;}}return false;}//进程请求public static void request(){//输入要申请的资源的进程号(第一个进程号为0,第二个进程号为1,以此类推)k = stdin.nextInt();//输入进程所请求的各个资源的数量for(i=0 ; i<resourceKind ; i++){Request[k][i] = stdin.nextInt();}for(i=0 ; i<resourceKind ; i++){if(Request[k][i] > Need[k][i]){System.out.println("所请求资源超过进程的需求量!");;return ;}if(Request[k][i] > Available[i]){System.out.println("所请求资源数量超过系统所有的资源数!");return ;}}for(i=0 ; i<resourceKind ; i++){Available[i] -= Request[k][i];Allocation[k][i] += Request[k][i];Need[k][i] -= Request[k][i];}if(safe()){System.out.println("同意分配请求~~~");}else{System.out.println("SORRY~~~~~你的请求被拒绝~~~");for(i=0 ; i<resourceKind ; i++){Available[i] = Available[i] + Request[k][i];Allocation[k][i] = Allocation[k][i] - Request[k][i];Need[k][i] = Need[k][i] + Request[k][i];}}for(i=0 ; i<realNum ; i++){Finish[i]=false;}}}。