java银行家算法代码实现

合集下载

操作系统银行家算法源代码

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class mybanker extends JFrame implements ActionListener{JTable table1;Object[][] data;JPanel p0,p1,p11,p12,p13,p14,p2,p3,p31,p32,p33,p34,p4;JLabel t1,t2,t3,t4,t5,t6,t7,t8,t9;//t10输出安全序列省去JButton b1,b2,b3,b6,b5;TextField text01,text02,text03,text5,text6;JTextField[] text1,text2,text3,text4;JTextArea text7;String s1,s2=new String();int M,N,i,j,count=0,flag=0;int[][] Max,Need,Allocation;int[] Available,Work,Request,Temp;public mybanker(){super("banker");p0=new JPanel();p1=new JPanel();p11=new JPanel();p12=new JPanel();p13=new JPanel();p14=new JPanel();p2=new JPanel();p3=new JPanel();p31=new JPanel();p32=new JPanel();p33=new JPanel();p34=new JPanel();p4=new JPanel();p0.setLayout(new GridLayout(4,1));p1.setLayout(new GridLayout(4,1));p3.setLayout(new GridLayout(4,1));p1.add(p11);p1.add(p12);p1.add(p13);p1.add(p14);p3.add(p31);p3.add(p32);p3.add(p33);p3.add(p34);p0.add(p1);p0.add(p2);p0.add(p3);p0.add(p4);t1=new JLabel("进程数");t2=new JLabel("资源数");t3=new JLabel("进程号");t4=new JLabel("已分配资资源:"); t5=new JLabel("资源最大需求:"); t6=new JLabel("可用资源:");t7=new JLabel("请求资源进程号"); t8=new JLabel("请求资源为");t9=new JLabel("安全检测");//t10=new JLabel("安全序列");b1=new JButton("确定");b2=new JButton("添加");b3=new JButton("确定");b5=new JButton("请求");b6=new JButton("安全检测");text1=new JTextField[6];text2=new JTextField[6];text3=new JTextField[6];text4=new JTextField[6];for(int i=0;i<6;i++){text1[i]=new JTextField(4);text2[i]=new JTextField(4);text3[i]=new JTextField(4);text4[i]=new JTextField(4);}text01=new TextField(4);text02=new TextField(4);text03=new TextField(4);text5=new TextField(4);text6=new TextField(50);String[] columnNames1= {"进程号", "资源最大需求","已分配的资源","需要的资源","可利用的资源"};data =new Object[100][5];table1 = new JTable (data, columnNames1);table1.setPreferredScrollableViewportSize(new Dimension(550, 100));table1.setRowHeight (20);table1.doLayout ();JScrollPane pane1 = new JScrollPane (table1);text7 = new JTextArea("",6,40);JScrollPane pane2 = new JScrollPane(text7);text7.setEditable(false);p11.add(t1);p11.add(text01);p11.add(t2);p11.add(text02);p11.add(b1);p12.add(t3);p12.add(text03);p12.add(b2);p13.add(t4);for(int i=0;i<6;i++)p13.add(text1[i]);p14.add(t5);for(int i=0;i<6;i++)p14.add(text2[i]);p2.add (pane1);p31.add(t6);for(int i=0;i<6;i++)p31.add(text3[i]);p31.add(b3);p32.add(t7);p32.add(text5);p32.add(t8);for(int i=0;i<6;i++)p32.add(text4[i]);p33.add(b6);p33.add(b5);p34.add(t9);p34.add(text6);//p4.add(t10);p4.add(pane2);b1.addActionListener(this);b2.addActionListener(this);b3.addActionListener(this);b5.addActionListener(this);b6.addActionListener(this);p0.setBackground (Color.lightGray);setContentPane (p0);this.setVisible(true);this.pack();//setSize(600,600);}public void diguisafe(int k,int n) //递归求解安全序列函数{int m,a;if(k==n){for(int j=0;j<N;j++)Work[j] = Available[j];if(safe()==1){for(a=0;a<M-1;a++)s1 += Temp[a]+"->";s1 +=Temp[a]+""+"\n";count++;for(int j=0;j<N;j++)Work[j] = Available[j];}}elsefor(int i=k;i<=n;i++) //n全排列{m=Temp[k];Temp[k]=Temp[i];Temp[i]=m;diguisafe(k+1,n);m=Temp[k];Temp[k]=Temp[i];Temp[i]=m;}}public int safe()//求是否安全序列{int i;for(i=0;i<M;i++){if(Small(Temp[i]-1)==1){CountWork(Temp[i]-1);continue;}else break;}if(i==M) return 1;else return 0;}public void CountWork(int i)//计算工作向量函数{for(int j=0;j<N;j++)Work[j] = Work[j]+Allocation[i][j];}public int Small(int i)//判断是否满足需求函数{int flag=0;for(int j=0;j<N;j++){if(Need[i][j]<=Work[j]) flag=1;else{flag=0;break;}}return flag;}public int Req_need()//判断是否满足需要资源函数{int flag=0;for(int i=0;i<N;i++){if(Need[j-1][i]>=Request[i]) flag=1;else{flag=0;break;}}return flag;}public int Req_ava()//判断是否满足可用资源函数{int flag=0;for(int i=0;i<N;i++){if(Available[i]>=Request[i]) flag=1;else{flag=0;break;}}return flag;}public void Changedata()//预分配函数{String s_available=new String();for(int i=0;i<N;i++){Available[i] = Available[i]-Request[i];Allocation[j-1][i] = Allocation[j-1][i]+Request[i];Need[j-1][i] = Need[j-1][i]-Request[i];s_available += Available[j]+" ";}data[0][4] = s_available;table1.repaint();text6.setText("");text7.setText("");}public void qingqiu()//资源请求函数{count=0;if(Req_need()==1&&Req_ava()==1) //不满足需求{Changedata(); //预分配}else{s2 ="不能分配";text6.setText(s2);}}public void actionPerformed(ActionEvent e){if(e.getSource()==b1){M = Integer.parseInt(text01.getText());N = Integer.parseInt(text02.getText());Max = new int[M][N];Allocation = new int[M][N];Need = new int[M][N];Available = new int[N];Request = new int[N];Work = new int[N];Temp = new int[M];}if(e.getSource()==b2){i = Integer.parseInt(text03.getText());int max,allocation;String s_max,s_need,s_allocation;s_max = new String();s_need = new String();s_allocation = new String();for(j=0;j<N;j++){allocation = Integer.parseInt(text1[j].getText());max = Integer.parseInt(text2[j].getText());Max[i-1][j] = max;Allocation[i-1][j] = allocation;Need[i-1][j] = Max[i-1][j]-Allocation[i-1][j];}Temp[i-1] = i;for(int j=0;j<N;j++){s_max += Max[i-1][j]+" ";s_allocation += Allocation[i-1][j]+" ";s_need += Need[i-1][j]+" ";}data[i-1][0] = ""+i;data[i-1][1] = s_max;data[i-1][2] = s_allocation;data[i-1][3] = s_need;table1.repaint();}if(e.getSource()==b3){int available;String s_available=new String();for(int j=0;j<N;j++){available = Integer.parseInt(text3[j].getText());Available[j] = available;s_available += Available[j]+" ";}data[0][4] = s_available;table1.repaint();}if(e.getSource()==b5){flag =1; //请求int request;text6.setText("");text7.setText("");j=Integer.parseInt(text5.getText());for(int i=0;i<N;i++){request = Integer.parseInt(text4[i].getText());Request[i] = request;}qingqiu();}if(e.getSource()==b6) //安全序列{s1=new String();count=0;diguisafe(0,M-1);if(count==0&&flag==0){s2 ="系统处于不安全状态，不能请求";}else if(count==0&&flag==1){s2 ="系统处于不安全状态，不能分配";}elses2="有"+count+"个安全序列,";text7.setText(s1);text6.setText(s2);flag =0;}/*if(e.getSource()==b4) //清空{count = 0;s1 ="";s2 ="";text6.setText(s1);text7.setText(s2);text01.setText("");text02.setText("");text03.setText("");text05.setText("");this.repaint();}*/}public static void main (String[] args){new mybanker();}}。

银行家算法

import java.util.*;class ThreadTest {static int type = 4, num = 10; //定义资源数目和线程数目static int[] resource = new int[type]; //系统资源总数//static int[] copyResource = new int[type]; //副本static Random rand = new Random();static Bank[] bank = new Bank[num]; //线程组Bank temp = new Bank();public void init() {//初始化组中每个线程，随机填充系统资源总数for(int i = 0; i < type; i++)resource[i] = rand.nextInt(10) + 80;System.out.print("Resource:");for(int i = 0; i < type; i++)System.out.print(" " + resource[i]);System.out.println("");for(int i = 0; i < bank.length; i++)bank[i] = new Bank("#" + i);}public ThreadTest4() {init();}class Bank extends Thread {//银行家算法避免死锁public int[]max = new int[type], //总共需求量need = new int[type], //尚需资源量allocation = new int[type]; //已分配量private int[]request = new int[type], //申请资源量copyResource = new int[type]; //资源副本private boolean isFinish = false; //线程是否完成int[][] table = new int[bank.length][type*4]; //二维资源分配表private void init() {// 随机填充总共、尚需、已分配量synchronized(resource) {for(int i = 0; i < type; i++) {max[i] = rand.nextInt(5) + 10;need[i] = rand.nextInt(10);allocation[i] = max[i] - need[i];resource[i] -= allocation[i]; //从系统资源中减去已分配的}printer();for(int i = 0; i < type; i++) {if(resource[i] < 0) {//若出现已分配量超出系统资源总数的错误则退出System.out.println("The summation of Threads' allocations is out of range!");System.exit(1);}}}}public Bank(String s) {setName(s);init();start();}public Bank() {//none}public void run() {try {sleep(rand.nextInt(2000));}catch(InterruptedException e) {throw new RuntimeException(e);}while(true) {//程序没有完成时一直不断申请资源if(askFor() == false) {try {sleep(1000);}catch(InterruptedException e) {throw new RuntimeException(e);}}elsetryRequest();if(noNeed() == true)break;}//休眠一段时间模拟程序运行try {sleep(1000);}catch(InterruptedException e) {throw new RuntimeException(e);}System.out.println(getName() + " finish!"); synchronized(resource) {//运行结束释放占有资源for(int i = 0; i < type; i++) {resource[i] += allocation[i];need[i] = allocation[i] = max[i] = 0;}}}private void printer() {//打印当前资源信息System.out.print(getName() + " Max:");for(int i = 0; i < type; i++)System.out.print(" " + max[i]);System.out.print(" Allocation:");for(int i = 0; i < type; i++)System.out.print(" " + allocation[i]);System.out.print(" Need:");for(int i = 0; i < type; i++)System.out.print(" " + need[i]);System.out.print(" Available:");for(int i = 0; i < type; i++)System.out.print(" " + resource[i]);System.out.println("");}private boolean askFor() {//随机产生申请资源量并检测是否超标boolean canAsk = false;for(int i = 0; i < type; i++) {request[i] = rand.nextInt(20);//防止申请量超过所需量if(request[i] > need[i])request[i] = need[i];}for(int i = 0; i < type; i++) //防止随机申请资源全为0if(request[i] > 0)canAsk = true;synchronized(resource) {//锁住可供资源检查是否超标for(int i = 0; i < type; i++) {if(request[i] > resource[i])//如果申请资源超过可供资源则等待一段时间后重新申请return false;}}return canAsk;}private void tryRequest() {//创建副本尝试分配请求synchronized(resource) {for(int i = 0; i < type; i++)//依然要防止请求量超出范围if(request[i] > resource[i])return;for(int i = 0; i < type; i++) {//复制资源量并减去需求量到一个副本上copyResource[i] = resource[i];copyResource[i] -= request[i];}System.out.print(getName() + " ask for:");for(int i = 0; i < type; i++)System.out.print(" " + request[i]);System.out.println("");if(checkSafe() == true) {//如果检查安全则将副本值赋给资源量并修改占有量和需求量for(int i = 0; i < type; i++) {resource[i] = copyResource[i];allocation[i] += request[i];need[i] -= request[i];}System.out.println(getName() + " request succeed!");}elseSystem.out.println(getName() + " request fail!");}}private boolean checkSafe() {//银行家算法检查安全性synchronized(bank) {//将线程资源信息放入二维资源分配表检查安全性，0~type可用资源／type~type*2所需资源／type*2~type*3占有资源／type*3~-1可用+占用资源for(int i = 0; i < bank.length; i++) {for(int j = type; j < type*2; j++) {table[i][j] = bank[i].need[j%type];}for(int j = type*2; j < type*3; j++) {table[i][j] = bank[i].allocation[j%type];}}//冒泡排序按需求资源从小到大排for(int i = 0; i < bank.length; i++) {for(int j = i; j < bank.length-1; j++) {sort(j, 4);}}//进行此时刻的安全性检查for(int i = 0; i < type; i++) {table[0][i] = copyResource[i];table[0][i+type*3] = table[0][i] + table[0][i+type*2];if(table[0][i+type*3] < table[1][i+type])return false;}for(int j = 1; j < bank.length-1; j++) {for(int k = 0; k < type; k++) {table[j][k] = table[j-1][k+type*3];table[j][k+type*3] = table[j][k] + table[j][k+type*2];if(table[j][k+type*3] < table[j+1][k+type])return false;}}}return true;}private void sort(int j, int k) {//递归冒泡排序int tempNum;if(table[j][k] > table[j+1][k]) {for(int i = type; i < type*2; i++) {tempNum = table[j][i];table[j][i] = table[j+1][i];table[j+1][i] = tempNum;}/*temp = bank[j];bank[j] = bank[j+1];bank[j+1] = temp;*/}else if(table[j][k] == table[j+1][k] && k < type*2) //此资源量相同时递归下一个资源量排序并且防止超出范围sort(j, k+1);}private boolean noNeed() {//是否还需要资源boolean finish = true;for(int i = 0; i < type; i++) {if(need[i] != 0) {finish = false;break;}}return finish;}}public static void main(String[] args) {ThreadTest t = new ThreadTest();//后台线程，设定程序运行多长时间后自动结束new Timeout(30000, "---Stop!!!---");}}。

操作系统——银行家算法（java实现）

操作系统——银⾏家算法（java实现）1.数据结构1. 可利⽤的资源向量Available：⼀个含有m个元素的数组，其中每⼀个元素代表⼀类可利拥的资源数⽬，其初始值是系统中所配置的该类全部可⽤资源数⽬，其数值随该类资源的分配改变⽽改变。

如果Available[j]=K，则表⽰系统中现有R j类资源K个。

2. 最⼤需求矩阵Max：⼀个n×m的矩阵，它定义了系统中n个进程中的每⼀个进程对m类资源的最⼤需求。

如果Max[i,j]=K，则表⽰进程i需要R j类资源的最⼤数⽬为K。

3. 分配矩阵Allocation：⼀个n×m的矩阵，它定义了系统中每⼀类资源当前已分配给每⼀进程的资源数。

如果Allocation[i,j]=K，则表⽰进程i当前已分得R j类资源的数⽬为K。

4. 需求矩阵Need：⼀个n×m的矩阵，⽤以表⽰每⼀个进程尚需的各类资源数。

如果Need[i,j]=K，则表⽰进程i还需要R j类资源K个⽅能完成其任务。

Need[i,j]=Max[i,j]-Allocation[i,j]2.银⾏家算法在避免死锁的⽅法中，所施加的限制条件较弱，有可能获得令⼈满意的系统性能。

在该⽅法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发⽣死锁。

银⾏家算法的基本思想是分配资源之前，判断系统是否是安全的；若是，才分配。

它是最具有代表性的避免死锁的算法。

设进程cusneed提出请求REQUEST [i]，则银⾏家算法按如下规则进⾏判断。

(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转（2)；否则，出错。

(2)如果REQUEST [cusneed] [i]<= AVAILABLE[i]，则转（3)；否则，等待。

(3)系统试探分配资源，修改相关数据：AVAILABLE[i]-=REQUEST[cusneed][i];ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];NEED[cusneed][i]-=REQUEST[cusneed][i];(4)系统执⾏安全性检查，如安全，则分配成⽴；否则试探险性分配作废，系统恢复原状，进程等待。

操作系统课程设计报告银行家算法的设计与实现(java语言)

操作系统课程设计报告-银行家算法的设计与实现(JAVA语言)操作系统课程设计题目院系专业班级学生学号指导教师年月基于计算机此次课程设计的主要内容是模拟实现资源分配同时要求编写和调试一个系统动态分配资源的简单模拟程序观察死锁产生的条件并使用适当的算法有效的防止和避免死锁的发生具体用银行家算法实现资源分配要求如下1 设计一个3个并发进程共享3类不同资源的系统进程可动态地申请资源和释放资源系统按各进程的申请动态地分配资源2 设计用银行家算法和随机分配算法实现资源分配的两个资源分配程序应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况3 确定一组各进程依次申请资源数的序列在相同的情况下分别运行上述两种资源分配程序观察运行结果银行家算法是避免死锁的一种重要方法本实验要求用高级语言编写和调试一个简单的银行家算法程序加深了解有关资源申请避免死锁等概念并体会和了解死锁和避免死锁的具体实施方法死锁的产生必须同时满足四个条件即一个资源每次只能由一个进程占用第二个为等待条件即一个进程请求资源不能满足时它必须等待但它仍继续保持已得到的所有其他资源第四个为循环等待条件系统中存在若干个循环等待的进程即其中每一个进程分别等待它前一个进程所持有的资源防止死锁的机构只能确保上述四个条件之一不出现则系统就不会发生死锁通过这个算法可用解决生活中的实际问题如银行贷款等通过对这个算法的设计让学生能够对书本知识有更深的理解在操作和其它方面有更高的提升关键词死锁安全状态安全序列银行家算法安全性检查目录1 概述 311设计目的 312开发环境 32 需求分析 421死锁概念 422死锁的结论 423资源分类 424产生死锁的必要条件 425死锁的解决方案 4com锁的例子 4com防 5com态与不安全状态 53 数据结构分析设计 631可利用资源向量矩阵available[ ] 6 32最大需求矩阵[ ][ ] 633分配矩阵allocation[ ][ ] 634需求矩阵need[ ][ ] 64 算法的实现 741初始化 742银行家算法 743安全性检查算法 744各算法流程图 85 测试与实例分析 106 心得体会 147参考文献与源程序清单附录 15概述11设计目的银行家算法是一种最有代表性的避免死锁的算法把操作系统看作是银行家操作系统管理的资源相当于银行家管理的资金进程向操作系统请求分配资源相当于用户向银行家贷款操作系统按照银行家制定的规则为进程分配资源当进程首次申请资源时要测试该进程对资源的最大需求量如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源否则就推迟分配当进程在执行中继续申请资源时先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量若超过则拒绝分配资源若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量若能满足则按当前的申请量分配资源否则也要推迟分配本次课程设计通过用JAVA语言编写和调试实现银行家算法的程序达到进一步掌握银行家算法理解系统产生死锁的原因以及系统避免死锁的方法增强理论联系实际的能力的目的12开发环境操作系统Windows XP编译工具Myeclipse86生成文件×××java源代码文件和×××class编译文件2 需求分析21死锁概念死锁就是指多个进程在运行中因争夺资源而造成的一种僵局当进程出于这种僵持状态时若无外力作用它们都将无法再向前推进22死锁的结论产生死锁的原因是竞争资源和进程间推进顺序不当处理死锁的基本方法是①预防死锁②避免思索③检测死锁④解除死锁23资源分类1可剥夺性资源某些进程在获得此类资源后该资源可以再被其他进程或系统剥夺CPU和内存均属于可剥夺性资源2不可剥夺性资源当系统把这类资源分配给进程后再不能强行回收只能在进程用完后自动释放如磁带机打印机3非剥夺性资源在系统中所配置的非剥夺性资源由于它们的数量不能满足诸进程运行的需要会使进程在运行构成中因争夺这些资源而陷入僵局4临时性资源它是指由一个进程产生被另一个进程使用一短暂时间后便无用的资源也称之为消耗性资源24产生死锁的必要条件1互斥条件进程对它所分配到的资源进行排他性使用即在一段时间内某资源由一个进程占有如果此时还有其它进程请求该资源则请求者只能等待直至占有该资源的进程用毕释放2请求和保持条件进程已经保持了至少一个资源但又提出新的资源请求而该资源又被其他进程占有此时请求进程阻塞但又对自己获得的其他资源保持不放3不剥夺条件进程已经获得的资源在未使用完之前不能被剥夺只有在使用完是由自己释放4环路等待条件发生死锁时必然存在一个进程--资源的环形链25死锁的解决方案com锁的例子该例子是由于进程推进顺序非法引发的死锁进程P1 和P2并发执行如果按顺序①执行P1RequestR1P1RequestR2P1ReleaseR1P1ReleaseR2P2RequestR2P2RequestR1P2R eleaseR2P2ReleaseR1两个进程可顺利完成如果按曲线②执行P1 和P2将进入不安全区DP1保持了资源R1P2保持了R2接下来P2将申请不到R1P1申请不到R2系统处于不安全状态往前推进将发生死锁图3-15com防预防死锁的方法是使产生死锁的四个必要条件中的234条件之一不能成立即1摒弃请求和保持条件系统规定所有进程在开始运行之前都必须一次性申请其在整个运行过程中所需的全部资源使该进程再整个运行过程中不会提出资源请求因而摒弃了请求条件又由于进程在等待期间没有占有任何资源所以也摒弃了保持条件2摒弃不剥夺条件系统规定进程逐个提出对资源的要求当一个已经保持了某些资源的进程再提出新的资源请求而未被满足时必须释放已经保持的所有资源待以后需要是在再重新申请3摒弃环路等待条件系统规定所有资源按类型进行线性排队并赋予不同的序号所有进程对资源的请求都必须严格按资源序号递增的顺序提出com态与不安全状态在避免死锁的方法中允许进程动态地申请资源但系统在进行资源分配之前应先计算此次资源分配的安全性若此次分配不会导致系统进入不安全状态则将资源分配给进程否则令进程等待所谓安全状态是指系统能按某种进程顺序P1 P2 P3Pn来为每个进程分配所需资源直至满足每个进程对资源的最大需求是每个进曾都可以顺利完成如果系统找不到这样一个序列系统就处于不安全状态虽然并非所有的不安全状态都是死锁状态但当系统进入不安全状态后便可能进入死锁状态只要系统处于安全状态系统便可以避免进入不安全状态因此避免死锁的实质在于系统在进行资源分配时如何使系统不进入不安全状态安全序列一个进程序列 P1Pn 是安全的如果对于每一个进程Pi 1≤i≤n它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj j i 当前占有资源量之和银行家算发就是用具避免死锁的一个有效方法3 数据结构分析设计31可利用资源向量矩阵available[ ]这是一个含有m个元素的数组其中的每一个元素代表一类可利用的资源数目其初始值是系统中所配置的该类全部可用资源的数目其数值随该类资源的分配和回收而动态地改变如果available [j] K则表示系统中现有R类资源K个32最大需求矩阵[ ][ ]这是一个nm的矩阵用以表示每一个进程对m类资源的最大需求如果[ij] K 则表示进程i需要R类资源的数目为K33分配矩阵allocation[ ][ ]这也是一个nm的矩阵它定义了系统中每一类资源当前已分配给每一进程的资源数如果allocation [ij] K则表示进程i当前已分得R类资源的数目为K 34需求矩阵need[ ][ ]这也是一个nm的矩阵用以表示每一个进程尚需的各类资源数如果need [ij] K则表示进程i还需要R类资源K个才能完成其任务上述矩阵存在下述关系need[ij] [ij]－ allocation[ij]4 算法的实现41初始化1创建available[]数组用以存放系统中可用的资源数目2创建[][]数组用以存放各个进程对各类资源的最大需求数目3创建allocation[][]数组用以存放各个进程已经分得的各类资源数目 4创建need[][]数组用以存放各个进程还需要的各类资源数目5创建 allocation1[][]need1[][]available1[]用以存放系统试分配资源前系统资源分配情况42银行家算法设Requesti是进程Pi的请求向量Requesti K表示进程Pi需要K个j类资源Pi发出资源请求后按下列步骤进行检查1如果requesti[j]≤need[ij]转向步骤②否则报错所需要的资源数已超过它所宣布的最大值2如果requesti[j]≤available[j]转向步骤③否则报错尚无足够资源Pi需等待3尝试将资源分配给进程Pi并修改下面数据结构中的数值available[j] available[j]-raquesti[j]allocation[ij] allocation[ij]raquesti[j]need[ij] need[ij]-raquesti[j]4 执行安全性算法检查此次资源分配后系统是否出于安全状态若安全才正式将资源分配给进程Pi已完成本次分配否则将本次试探分配作废恢复原来的资源分配状态让Pi等待43安全性检查算法1设置两个向量一工作向量work表示系统可提供给进程继续运行所需的各类资源数目执行安全性算法开始时work available二finish标志表示系统是否有足够的资源分配给进程使之运行完成初始化finish[i] false有足够资源分配给进程时令finish[i] true2从进程集合中找到一个能满足下述条件的进程finish[i] falseNeed[ij]≤work[j]找到执行步骤③否则执行步骤④3当进程Pi获得资源后可顺利执行直至完成并释放出分配给它的资源故应执行Work[j] work[i]allocation[ij]Finish[i] trueGo to step ②4如果所有进程的finish[i] true都满足则表示系统处于安全状态否则系统处于不安全状态44各算法流程图1初始化算法流程2银行家算法流程图5 测试与实例分析1下列状态是否安全四个进程共享12个同类资源资源进程A B C AllocationA B C NeedA B C Available A B C P03 2 21 0 02 2 22 1 2P16 1 34 1 12 0 2P23 1 42 1 11 0 3P34 2 20 0 24 2 0利用银行家算法程序进行检测打开程序输入上述数据初始化数据后显示进行安全检测经检查系统为安全状态存在安全序列p1 p2 p3 p02考虑下列系统状态系统是否安全若安全就给出所有的安全序列如果此时p0和p1均提出资源请求Request 101 能否立即给予满足解继续执行银行家算法程序1P0申请资源101申请不成功系统不为其分配资源继续执行银行家算法程序2P1申请资源101申请成功存在安全序列p1 p2 p3 p0所以对p2来说能得到立即满足如果此刻P2继续请求资源Reques101则就有系统将资源试分给P1则可用资源数变为111然后继续试分配给p0 Request 101 它小于Avalable可以分配但分配后很明显找不到一个安全序列发现系统处于不安全状态不能分配给它于是回收资源系统的可用资源恢复到1116 心得体会通过一个周的课程设计虽然理解起来很容易但想用算法具体去实现它还是有一定的难度虽然做起来比较吃力但当我通过自己亲手做出来时使我更加加深了对银行家算法的理解掌握了银行家算法避免死锁的过程和方法理解了死锁产生的原因和条件以及避免死锁的方法并且还巩固了JAVA知识掌握了用JAVA实现银行家算法的方法所编写程序基本实现了银行家算法的功能并在其基础上考虑了输出显示格式的美观性使界面尽可能友好并且在编程时将主要的操作都封装在方法中如输入进程和资源信息放在了一个构造方法public TheBanker 中进行安全性检测的方法Security_check 进行申请资源的方法checkRequest 打印当前各资源的方法print 这样使程序可读性增强使程序更加清晰明了当然由于JAVA学的也就是些基础平时的不常联系使得我实际操作能力的很欠缺我在编写和调试过程中遇到了许多的问题通过网上查询资料翻阅课本向同学请教多次调试等方法逐渐解决了大部分问题这次课程设计非常有意义它让我收获很多不仅掌握了课本所学的知识也巩固了JAVA的相关知识7 参考文献与源程序清单汤子瀛哲凤屏汤小丹计算机操作系统西安电子科技大学出版社20062 美威尔顿麦可匹克 Java入门经典第3版施宏斌译北京清华大学出版社2009 美 Bruce Eckel Java编程思想陈昊鹏译北京机械工业出版社2007 import comnerpublic class TestBankerpublic static void main String[] argsSycomtln "-----操作系统银行家算法-------"TheBanker tb new TheBankerboolean flag truewhile flagSycomtln "1死锁避免检验是否安全"Sycomtln "2死锁检测"Sycomtln "3退出"Sycomtln "Sycomtln "请选择"Scanner input new Scanner Systemin int num inputnextIntswitch numcase 1tbSecurity_checkflag truebreakcase 2tbcheckRequest 死锁检测flag truebreakcase 3Sycomtln "谢谢使用再见"flag falsebreakimport comnerpublic class TheBankerint m 进程个数int n 每个进程的资源个数int[][] 最大需求矩阵int[][] allocation 以分配的资源已占有的资源int[][] need 需求的资源int[] available 可利用的资源int[] p 记录安全序列boolean[] finish 标志一个进程是否完成true 表示完成 false 表示未完成Scanner input new Scanner Systeminpublic TheBankerSycomtln "请输入系统中的进程数"m inputnextIntSycomtln "请输入进程的资源类型数"n inputnextIntnew int[m][n]allocation new int[m][n]need new int[m][n]available new int[n]finish new boolean[m]Sycomtln "请输入一个"m"行"n"列的各进程的最大需求量"for int i 0i lengthi 依次输入进程的各个最大资源数Sycomtln "请输入第p " i1 " 进程的"for int j 0j [i]lengthj[i][j] inputnextIntSycomtln "请输入一个"m"行"n"列的各进程的各占有量"for int i 0i allocationlengthi 依次输入进程的各个占有资源数Sycomtln "请输入第p " i1 " 进程中的Alloction"for int j 0j allocation[i]lengthjallocation[i][j] inputnextIntfor int i 0i needlengthi 计算出各个进程需求的资源数 for int j 0j need[i]lengthjneed[i][j] [i][j] - allocation[i][j]Sycomtln "请输入可用资源数Avallable" 输入进程的可用资源数for int i 0i niavailable[i] inputnextIntSycomtln "初始化结果为下表"print显示列表public void printSycomtln "Sycomtln "\t\tAllocation\tNeed\tAvalable"Sycomtln "\tA B C\tA B C\t\tA B C\tA B C"for int i 0i miSycomt "P "i" "Sycomt " "for int j 0j njSycomt [i][j]" "Sycomt "\t"for int j 0j njSycomt allocation[i][j]" "Sycomt "\t\t"for int j 0j njSycomt need[i][j]" "Sycomt "\t"if i 0for int j 0j njSycomt available[j]" "SycomtlnSycomtln "public boolean Security_checkint[] work new int[n]for int i 0i niwork[i] available[i] 把available的值赋给workfinish new boolean[m]for int i 0 i m i 开始把进程全部置未分配状态都为falsefinish[i] falseint num 0 对每个进程都要把所有资源都进行比较int num1 0int count 0 记录可以分配的序列int count1 0 记录所有序列是否分配p new int[m] 找到安全序列while num1 mfor int i 0i miif finish[i] false 判断finish的状态如果为true说明刚才已经找到不需要重复for int j 0j njif need[i][j] work[j] 比较一个进程的各种资源是否满足条件numif num n 如果一个进程所有资源都满足条件need work则找到了一个进程满足for int k 0k nkwork[k] work[k] allocation[i][k]finish[i] true 找到一个进程满足p[count] i 记录找到的是第几个进程num 0 必须把它清零重新来找下个资源种类的每种是否都满足条件num1记录有多少个序列for int i 0i miif finish[i] truecount1 检测是否所有的进程最后都是trueif count1 m 如果序列里面总数等于总共有多少程序就找到了安全的序列并且输出反之没有找到Sycomtln "存在一个安全序列安全序列为"for int i 0i miif i m-1Sycomt "P"p[i]"-- "elseSycomtln "P"p[i]Sycomtln "return trueelseSycomtln "没有找到一个安全序列系统处于不安全状态"return falsepublic void checkRequestint process 0 记录输入的是第几个进程int count2 0 记录试分配过程中满足条件的个数boolean flag true 主要防止输入的数字已经超出了本来process数量则要求重新输入Sycomtln "请输入要申请的第几个进程注意进程p下标是从0开始的"while flagprocess inputnextIntif process mflag trueSycomtln "输入超出了本来进程的范围请重新输入"elseflag falseSycomtln "第"process"个进程提出请求"int[] request new int[n]Sycomtln "输入要请求的资源Request"for int i 0i nirequest[i] inputnextInt判断是否可以分配for int i 0i niif request[i] need[process-1][i] request[i] available[i]count2 判断是否每个进程的所有资源都满足试分配的要求并记录if count2 n 如果每一种资源都满足要求则可以进程请求试分配for int j 0j njallocation[process-1][j] request[j] 注意数组下标是从0开始的need[process-1][j] - request[j]available[j] - request[j]Sycomtln "试分配如下-------- "print 打印试分配的结果Sycomtln "进行安全性判断"flag Security_check 判断是否为安全序列if flag false 如果是分配后不能找到一个安全序列则返回不进行分配for int j 0j njallocation[process-1][j] - request[j] 注意数组下标是从0开始的need[process-1][j] request[j]available[j] request[j]elseSycomtln "不能进行试分配也就找不到安全序列"西安工业大学课程设计1。

银行家算法的设计与实现(JAVA语言).doc

银行家算法的设计与实现(JAVA语言).doc淘豆网网友近日为您收集整理了关于操作系统课程设计报告-银行家算法的设计与实现(java语言)的文档,希望对您的工作和学习有所帮助.以下是文档介绍:操作系统课程设计报告题目:银行家算法的设计与实现院(系):计算机科学与工程学院专业:信息对抗专业班级:学生:学号:指导教师:2011年12月1基于计算机操作系统银行家算法实现摘要此次课程设计的主要内容是模拟实现资源分配.同时要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生具体用银行家算法实现资源分配.要求如下:(1)设计一个3个并发进程共享3类不同资源的系统,进程可动态地申请资源和释放资源,系统按各进程的申请动态地分配资源.(2)设计用银行家算法和随机分配算法,实现资源分配的两个资源分配程序,应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况.(3)确定一组各进程依次申请资源数的序列,在相同的情况下分别运行上述两种资源分配程序,观察运行结果.银行家算法是避免死锁的一种重要方法,本实验要求用高级语言编写和调试一个简单的银行家算法程序.加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法.死锁的产生,必须同时满足四个条件,即一个资源每次只能由一个进程占用:第二个为等待条件,即一个进程请求资源不能满足时,它必须等待,但它仍继续保持已得到的所有其他资源:第四个为循环等待条件,系统中存在若干个循环等待的进程,即其中每一个进程分别等待它前一个进程所持有的资源.防止死锁的机构只能确保上述四个条件之一不出现,则系统就不会发生死锁.通过这个算法可用解决生活中的实际问题,如银行贷款等.通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升.关键词:死锁;安全状态;安全序列;银行家算法;安全性检查2目录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)31概述1.1设计目的银行家算法是一种最有代表性的避免死锁的算法.把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款.操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配.当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量.若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配.本次课程设计通过用java语言编写和调试实现银行家算法的程序,达到进一步掌握银行家算法,理解系统产生死锁的原因以及系统避免死锁的方法,增强理论联系实际的能力的目的.1.2开发环境操作系统:windowsxp编译工具:myeclipse8.6生成文件:×××.java源代码文件和×××.class编译文件42需求分析2.1死锁概念死锁就是指多个进程在运行中因争夺资源而造成的一种僵局,当进程出于这种僵持状态时,若无外力作用,它们都将无法再向前推进.2.2死锁的结论产生死锁的原因是:竞争资源和进程间推进顺序不当.处理死锁的基本方法是:①预防死锁②避免思索③检测死锁④解除死锁2.3资源分类1.可剥夺性资源,某些进程在获得此类资源后,该资源可以再被其他进程或系统剥夺.cpu和内存均属于可剥夺性资源.2.不可剥夺性资源,当系统把这类资源分配给进程后,再不能强行回收,只能在进程用完后自动释放,如磁带机,打印机.3.非剥夺性资源,在系统中所配置的非剥夺性资源,由于它们的数量不能满足诸进程运行的需要,会使进程在运行构成中,因争夺这些资源而陷入僵局.4.临时性资源,它是指由一个进程产生,被另一个进程使用一短暂时间后便无用的资源,也称之为消耗性资源..2.4产生死锁的必要条件1.互斥条件:进程对它所分配到的资源进行排他性使用,即在一段时间内某资源由一个进程占有.如果此时还有其它进程请求该资源,则请求者只能等待,直至占有该资源的进程用毕释放.2.请求和保持条件:进程已经保持了至少一个资源,但又提出新的资源请求,而该资源又被其他进程占有,此时请求进程阻塞,但又对自己获得的其他资源保持不放.3.不剥夺条件:进程已经获得的资源,在未使用完之前,不能被剥夺,只有在使用完是由自己释放.4.环路等待条件:发生死锁时,必然存在一个进程--资源的环形链.2.5死锁的解决方案2.5.1产生死锁的例子5该例子是由于进程推进顺序非法引发的死锁:进程p1和p2并发执行,如果按顺序①执行:p1:request(r1)——p1:request(r2)——p1:release(r1)——p1:release(r2)——p2:request(r2)——p2:request(r1)——p2:release(r2)——p2:release(r1),两个进程可顺利完成.如果按曲线②执行:p1和p2将进入不安全区d,p1保持了资源r1,p2保持了r2,接下来p2将申请不到r1,p1申请不到r2,系统处于不安全状态,往前推进将发生死锁.图3-152.5.2死锁预防预防死锁的方法是使产生死锁的四个必要条件中的2、3、4条件之一不能成立.即:1、摒弃“请求和保持”条件.系统规定所有进程在开始运行之前,都必须一次性申请其在整个运行过程中所需的全部资源.使该进程再整个运行过程中不会提出资源请求,因而摒弃了请求条件.又由于进程在等待期间没有占有任何资源,所以也摒弃了保持条件.2、摒弃“不剥夺”条件.系统规定,进程逐个提出对资源的要求,当一个已经保持了某些资源的进程,再提出新的资源请求而未被满足时,必须释放已经保持的所有资源,待以后需要是在再重新申请.3、摒弃“环路等待”条件.系统规定所有资源按类型进行线性排队,并赋予不同的序号.所有进程对资源的请求都必须严格按资源序号递增的顺序提出.2.5.3安全状态与不安全状态在避免死锁的方法中,允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次资源分配的安全性.若此次分配不会导致系统进入不安全状态,6则将资源分配给进程;否则,令进程等待所谓安全状态是指,系统能按某种进程顺序(p1,p2,p3,…,pn),来为每个进程分配所需资源,直至满足每个进程对资源的最大需求,是每个进曾都可以顺利完成.如果系统找不到这样一个序列,系统就处于不安全状态.虽然并非所有的不安全状态都是死锁状态,但当系统进入不安全状态后,便可能进入死锁状态.只要系统处于安全状态,系统便可以避免进入不安全状态.因此,避免死锁的实质在于:系统在进行资源分配时,如何使系统不进入不安全状态安全序列:一个进程序列{p1,…,pn}是安全的,如果对于每一个进程pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程pj(j<i)当前占有资源量之和.银行家算发就是用具避免死锁的一个有效方法3数据结构分析设计3.1可利用资源向量矩阵available[]这是一个含有m个元素的数组,其中的每一个元素代表一类可利用的资源数目,其初始值是系统中所配置的该类全部可用资源的数目,其数值随该类资源的分配和回收而动态地改变.如果available[j]=k,则表示系统中现有r类资源k个3.2最大需求矩阵max[][]这是一个n*m的矩阵,用以表示每一个进程对m类资源的最大需求.如果max[i,j]=k,则表示进程i需要r类资源的数目为k.3.3分配矩阵allocation[][]这也是一个n*m的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数.如果allocation[i,j]=k,则表示进程i当前已分得r类资源的数目为k.3.4需求矩阵need[][]这也是一个n*m的矩阵,用以表示每一个进程尚需的各类资源数.如果need[i,j]=k,则表示进程i还需要r类资源k个,才能完成其任务.上述矩阵存在下述关系:7need[i,j]=max[i,j]﹣allocation[i,j]4算法的实现4.1初始化1.创建available[]数组,用以存放系统中可用的资源数目;2.创建max[][]数组,用以存放各个进程对各类资源的最大需求数目;3.创建allocation[][]数组,用以存放各个进程已经分得的各类资源数目;4.创建need[][]数组,用以存放各个进程还需要的各类资源数目;5.创建allocation1[][];need1[][];available1[],用以存放系统试分配资源前系统资源分配情况;4.2银行家算法设requesti是进程pi的请求向量,requesti=k表示进程pi需要k个j类资源.pi 发出资源请求后,按下列步骤进行检查:1.如果req uesti[j]≤need[i,j],转向步骤②;否则报错,所需要的资源数已超过它所宣布的最大值;2.如果requesti[j]≤available[j],转向步骤③;否则报错,尚无足够资源pi需等待;3.尝试将资源分配给进程pi,并修改下面数据结构中的数值:available[j]:=available[j]-raquesti[j];allocation[i,j]:=allocation[i,j]+raquesti[j];ne ed[i,j]:=need[i,j]-raquesti[j];4.执行安全性算法,检查此次资源分配后,系统是否出于安全状态.若安全,才正式将资源分配给进程pi,已完成本次分配;否则,将本次试探分配作废,恢复原来的资源分配状态,让pi等待.4.3安全性检查算法1.设置两个向量:一、工作向量work:表示系统可提供给进程继续运行所需的各类资源数目,执行安全性算法开始时work:=available;二、finish标志:表示系统是否有足够的资源分配给进程,使之运行完成.初始化finish[i]:=false;有足够资源分配给进程时,令finish[i]:=true.2.从进程集合中找到一个能满足下述条件的进程8finish[i]=false;need[i,j]≤work[j];找到执行步骤③,否则执行步骤④3.当进程pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:work[j]:=work[i]+allocation[i,j];finish[i]:=true;gotoste p②;4.如果所有进程的finish[i]=true都满足,则表示系统处于安全状态;否则,系统处于不安全状态.4.4各算法流程图1.初始化算法流程:92.银行家算法流程图:播放器加载中,请稍候...系统无法检测到您的adobeflashplayer版本建议您在线安装最新版本的flashplayer在线安装。

银行家算法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;}}三、总结银行家算法是一种重要的避免死锁的算法，它可以在系统分配资源时避免出现死锁状态。

操作系统银行家算法

操作系统--银行家算法实验报告实验名称：银行家算法实现班级：姓名：学号：附源码：工具类SecurityUtility：package newideas;public class SecurityUtility {private int[][] max;private int[][] allocation;private int[][] need;private boolean[] finish;private int[] result;private int count = 0;private boolean flag = true;private int n;public void display(String str, int clumn, int row) { String[] temp = str.split(";");if (flag) {max = new int[clumn][row];allocation = new int[clumn][row];need = new int[clumn][row];finish = new boolean[clumn];for (int i = 0; i < finish.length; i++) {finish[i] = false;}result = new int[clumn];n = 0;flag = false;}for (int i = 0; i < 3; i++) {String[] inner = temp[i].split(",");for (int j = 0; j < inner.length; j++) {int result = Integer.parseInt(inner[j]);if (i == 0) {max[n][j] = result;} else if (i == 1) {allocation[n][j] = result;} else if (i == 2) {need[n][j] = result;}System.out.print("\t" + result);}}n++;}public boolean checked(int[] avaliable,int pn, int rn) {System.out.println("==================================================== ==========================================================");System.out.println("" + "\t\t" + " Work" + "\t"+ "\t" + " Need" + "\t"+ "\t" + "Allocation"+ "\t"+ "\t" + "Work+Allocation" + "\t");System.out.print("进程");for(int j = 0; j < 4; j++) {for (int i = 0; i < rn; i++) {System.out.print("\t" + (char)(65 + i));}}System.out.println("\t" + "Finish");for (int i = 0; i < need.length; i++) {int oldNum = count;int newNum = 0;if (!finish[i]) {for (int j = 0; j < need[i].length; j++) {if (avaliable[j] - need[i][j] < 0) {break;} else if (j == need[i].length - 1) {finish[i] = true;for (int j2 = 0; j2 < avaliable.length; j2++) {avaliable[j2] += allocation[i][j2];}result[count] = i;//System.out.println(i);count++;newNum = count;System.out.print("P" + i);for (int j3 = 0; j3 < 5; j3++) {boolean flag = true;for (int j2 = 0; j2 < rn; j2++) {switch(j3){case 0:System.out.print("\t" + avaliable[j2]);break;case 1:System.out.print("\t" + need[i][j2]);break;case 2:System.out.print("\t" + allocation[i][j2]);break;case 3:System.out.print("\t" + avaliable[j2]);break;case 4:if (flag) {System.out.print("\t" + finish[i]);flag = false;}break;}}}System.out.println();}}}if (i == need.length - 1 && count == 0) {return false;} else if (i == need.length - 1 && count != 0) {if (newNum > oldNum) {i = -1;}}}if (count == result.length) {System.out.println("==================================================== ==========================================================");System.out.println("++++++++++++++++++++++++++++++++++++++++++安全序列：" + performArray(result) + "+++++++++++++++++++++++++++++++++++++++++++++");System.out.println("==============================================================================================================");/*for (int i = 0; i < finish.length; i++) {System.out.println(finish[i]);}*/return true;} else return false;}public void performArray(int[][] a) {for (int i = 0; i < a.length; i++) {for (int j = 0; j < a[i].length; j++) {System.out.print(a[i][j]);}System.out.println();}}public String performArray(int[] a) {String s = "P";String str = "";for (int i = 0; i < a.length; i++) {str = str + s + a[i] +" ";}return str;}/*public boolean isEmpty(int[] a) {for (int i = 0; i < a.length; i++) {if (a[i] != 0) {return false;} else {return true;}}return true;}*//*public int contentElementNum(int[] a) {int num = 0;for (int i = 0; i < a.length; i++) {if (a[i] != 0) {num ++;}}return num;}*//*public void SecurtyChecked(String[] inputs) {max = new int[inputs.length];allocation = new int[inputs.length];need = new int[inputs.length];for (int i = 0; i < inputs.length; i++) {String[] temp = inputs[i].split(";");for (int j = 0; j < temp.length; j++) {max[0]}}}*/public int[] getResult() {return result;}public void setResult(int[] result) {this.result = result;}public void showResult(int pn, int rn) {System.out.println("==================================================== ==============================================");System.out.println("" + "\t\t" + " Work" + "\t"+ "\t" + " Need" + "\t"+ "\t" + "Allocation"+ "\t"+ "\t" + "Work+Allocation"+ "Finish" + "\t");System.out.print("进程");for(int j = 0; j < 4; j++) {for (int i = 0; i < rn; i++) {System.out.print("\t" + (char)(65 + i));}}}}窗体类BankerShow：package newideas;import java.awt.BorderLayout;import java.awt.Button;import java.awt.Color;import java.awt.Font;import java.awt.Frame;import java.awt.GridLayout;import bel;import java.awt.Panel;import java.awt.TextField;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;public class BankerShow extends Frame {private static final long serialVersionUID = 1L;private Label title;private Panel panel;private Panel component;private Panel operatePanel;private Label procedure;private TextField procedureNum;private Label resource;private TextField resourceNum;private Label avaliable;private TextField avaliableNum;private Label lab;private TextField inputs;private Button submit;private Button reset;private Button resetAll;private int count = 0;private int pn = 0;private int rn = 0;private boolean flag = true;private boolean flag2 = true;private Button check;private Label result;private int[] ava;private SecurityUtility su;public void launchFrame() {this.setTitle("Banker Alogrithm -- SecurityChecked");this.setBackground(Color.green);this.setLocation(250, 60);this.setSize(700, 400);this.setResizable(false);this.setVisible(true);this.setLayout(new BorderLayout());MyActionListener m = new MyActionListener();title = new Label("银行家算法：--安全性检查");title.setAlignment(Label.CENTER);title.setForeground(Color.blue);title.setFont(new Font("楷体", Font.BOLD, 45));this.add(title, BorderLayout.NORTH);panel = new Panel();panel.setBackground(Color.lightGray);panel.setFont(new Font("楷体", Font.BOLD, 18));panel.setLayout(new BorderLayout());this.add(panel, BorderLayout.CENTER);component = new Panel();component.setLayout(new GridLayout(3, 2));panel.add(component, BorderLayout.NORTH);operatePanel = new Panel();operatePanel.setLayout(null);panel.add(operatePanel, BorderLayout.CENTER);procedure = new Label("请输入系统将要处理的进程数：");procedureNum = new TextField("5");procedureNum.addActionListener(m);resource = new Label("请输入系统提供的资源种类数目：");resourceNum = new TextField("3");resourceNum.addActionListener(m);avaliable = new Label("请输入系统提供的各类资源数目：");avaliableNum = new TextField("3,3,2");avaliableNum.addActionListener(m);component.add(procedure);component.add(procedureNum);component.add(resource);component.add(resourceNum);component.add(avaliable);component.add(avaliableNum);lab = new Label("请输入每个进程的各类资源数同类用逗号隔开，不同类用分号隔开，点击提交：");lab.setLocation(0, 10);lab.setSize(680, 30);inputs = new TextField();inputs.setLocation(10, 60);inputs.setSize(240, 30);inputs.addActionListener(m);submit = new Button("提交");submit.setLocation(260, 60);submit.setSize(50, 30);submit.addActionListener(m);reset = new Button("重置");reset.setLocation(320, 60);reset.setSize(50, 30);reset.addActionListener(m);resetAll = new Button("全部重置");resetAll.setLocation(380, 60);resetAll.setSize(100, 30);resetAll.addActionListener(m);check = new Button("检测");check.setLocation(490, 60);check.setSize(50, 30);check.addActionListener(m);result = new Label();result.setForeground(Color.red);result.setLocation(10, 110);result.setSize(300, 30);operatePanel.add(lab);operatePanel.add(inputs);operatePanel.add(submit);operatePanel.add(reset);operatePanel.add(resetAll);operatePanel.add(check);operatePanel.add(result);this.addWindowListener(new WindowAdapter(){@Overridepublic void windowClosing(WindowEvent e) {System.exit(0);}});}class MyActionListener implements ActionListener {@Overridepublic void actionPerformed(ActionEvent e) {pn = Integer.parseInt(procedureNum.getText().trim());rn = Integer.parseInt(resourceNum.getText().trim());if(su == null) {su = new SecurityUtility();ava = new int[rn];}if (e.getSource() == submit && count < pn) {result.setText("系统当前状态，未检测，危险！！");String strr = inputs.getText().trim();if (strr.length() > rn * 4) {if(flag){for(int j = 0; j < 4; j++) {for (int i = 0; i < rn; i++) {System.out.print("\t" + (char)(65 + i));}}System.out.println();flag = false;}System.out.print("P" + count );su.display(strr, pn, rn);//System.out.println("P" + count + " " + input[count]);count ++;inputs.setText("");String str = avaliableNum.getText().trim();if (flag2) {String[] inner = str.split(",");for (int j = 0; j < inner.length; j++) {int result = Integer.parseInt(inner[j]);ava[j] = result;System.out.print("\t" + result);}flag2 = false;}System.out.println();}} else if (e.getSource() == reset) {inputs.setText("");} else if (e.getSource() == resetAll) {procedureNum.setText("");resourceNum.setText("");inputs.setText("");avaliableNum.setText("");count = 0;} else if (e.getSource() == check) {if (su.checked(ava, pn, rn)) {//String str = su.performArray(su.getResult());result.setText("系统当前状态，已检测，安全！！");} else {result.setText("系统当前状态，已检测，危险！！");}}}}public static void main(String[] args) {new BankerShow().launchFrame();System.out.println("==================================================== ==============================================");System.out.println("" + "\t\t" + " Max" + "\t"+ "\t" + " Allocation" + "\t"+ "\t" + "Need"+ "\t"+ "\t" + "Avaliable" + "\t");System.out.print("进程");}}。

银行家算法代码及运行结果

#include<iostream.h>#include<string.h>#include<stdio.h>#define False 0#define True 1int Max[100][100]={0};int Avaliable[100]={0};char Name[100]={0};int Allocation[100][100]={0};int Need[100][100]={0};int Request[100]={0};int Temp[100]={0};int Work[100]={0};int M=100;int N=100;//预定义void show()//显示资源矩阵{int i,j;cout<<"当前系统可用的资源[Avaliable]:"<<endl;for(i=0;i<N;i++){cout<<Name[i]<<" ";}cout<<endl;for (j=0;j<N;j++){cout<<Avaliable[j]<<" ";}//输出分配资源cout<<endl;cout<<" Max Allocation Need"<<endl;cout<<"进程名";for(j=0;j<3;j++){for(i=0;i<N;i++){cout<<Name[i]<<" ";}cout<<" ";}cout<<endl;for(i=0;i<M;i++){cout<<" "<<i<<" ";for(j=0;j<N;j++){cout<<Max[i][j]<<" ";}cout<<" ";for(j=0;j<N;j++){cout<<Allocation[i][j]<<" ";}cout<<" ";for(j=0;j<N;j++){cout<<Need[i][j]<<" ";}cout<<endl;}}int change(int i)//进行资源分配{int j;for (j=0;j<M;j++) {Avaliable[j]=Avaliable[j]-Request[j];Allocation[i][j]=Allocation[i][j]+Request[j];Need[i][j]=Need[i][j]-Request[j];}return 1;}int safe()//安全性算法{int i,k=0,m,a,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){a=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){a++;if(a==N){for(m=0;m<N;m++){Work[m]=Work[m]+Allocation[i][m];}//变分配数Finish[i]=True;Temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){cout<<"系统不安全!"<<endl;return -1;}}cout<<"系统是安全的!"<<endl;//如果安全，输出成功cout<<"分配的序列为:";for(i=0;i<M;i++){//输出运行进程数组cout<<Temp[i];if(i<M-1){cout<<"->";}}cout<<endl;return 0;}void share()//利用银行家算法对申请资源进行判定{char ch;int i=0,j=0;ch='y';cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";cin>>i;cout<<"请输入进程"<<i<<" 申请的资源:"<<endl;for(j=0;j<N;j++){cout<<Name[j]<<":";cin>>Request[j];}for (j=0;j<N;j++){if(Request[j]>Need[i][j]){//判断申请是否大于需求，若大于则出错cout<<"进程"<<i<<"申请的资源大于它需要的资源";cout<<" 分配不合理，不予分配！"<<endl;ch='n';break;}else {if(Request[j]>Avaliable[j]){//判断申请是否大于当前资源，若大于则出错cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";cout<<" 分配出错，不予分配!"<<endl;ch='n';break;}}}if(ch=='y') {change(i);//根据进程需求量变换资源show();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}void add(){//添加资源int n,flag;cout<<"请输入需要添加资源种类的数量:";cin>>n;flag=N;N=N+n;for(int i=0;i<n;i++){cout<<"名称:";cin>>Name[flag];cout<<"数量:";cin>>Avaliable[flag++];}show();safe();}void delR(){//删除资源char ming;int i,flag=1;cout<<"请输入需要删除的资源名称：";do{cin>>ming;for(i=0;i<N;i++)if(ming==Name[i]){flag=0;break;}if(i==N){cout<<"该资源名称不存在，请重新输入：";} }while(flag);for(int j=i;j<N-1;j++){Name[j]=Name[j+1];Avaliable[j]=Avaliable[j+1];}N=N-1;show();safe();}void changeR(){//修改资源cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(int i=0;i<N;i++){cout<<Name[i]<<":"<<Avaliable[i]<<endl;}cout<<"输入系统可用资源[Avaliable]:"<<endl;cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];cout<<"经修改后的系统可用资源为"<<endl;for (int k=0;k<N;k++){cout<<Name[k]<<":"<<Avaliable[k]<<endl;}show();safe();}void addP(){//添加作业int flag=M;M=M+1;cout<<"请输入该作业的最大需求量[Max]"<<endl;for(int i=0;i<N;i++){cout<<Name[i]<<":";cin>>Max[flag][i];Need[flag][i]=Max[flag][i]-Allocation[flag][i];}show();safe();}int main(){int i,j,number,choice,m,n,flag;char ming;cout<<"*****************资源管理系统的设计与实现*****************"<<endl;cout<<"请首先输入系统可供资源种类的数量:";cin>>n;N=n;for(i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>ming;Name[i]=ming;cout<<"资源的数量:";cin>>number;Avaliable[i]=number;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m; cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Max[i][j];}do{flag=0;cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j]){flag=1;}Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag){cout<<"申请的资源大于最大需求量，请重新输入!\n";} }while(flag);show();//显示各种资源safe();//用银行家算法判定安全性while(choice){cout<<"**************银行家算法的演示***************"<<endl;cout<<" 1:增加资源2:删除资源"<<endl;cout<<" 3:修改资源4:分配资源"<<endl;cout<<" 5:增加作业0:离开"<<endl;cout<<"*******************************************"<<endl;cout<<"请选择功能号：";cin>>choice;switch(choice){case 1: add();break;case 2: delR();break;case 3: changeR();break;case 4: share();break;case 5: addP();break;case 0: choice=0;break;default: cout<<"请正确选择功能号(0-5)!"<<endl;break;}}return 1;}。

用java编写的银行家算法

public void printSystemVariable() { System.out.println("此时资源分配量如下："); System.out.println("进程 "+" Max "+" Alloction "+" Need "+" Available "); for(int i=0;i<5;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(); } }
package 银行家算法; import java.util.Scanner; public class Banker { public static char[] Name = {'A', 'B', 'C'}; public static int[] Available = {3,3,2}; public int[][] Max = {{7,5,3},{3,2,2},{9,0,2}, {2,2,2},{4,3,3}}; public int[][] Alloction ={{0,1,0},{2,0,0}, {3,0,2},{2,1,1},{0,0,2}}; public int[][] Need = {{7,4,3},{1,2,2},{6,0,0}, {0,1,1},{4,3,1}}; public int[] Request = new int[3]; public int[] Work = new int[3]; int num = 0;//进程编号 Scanner in = new Scanner(System.in); public static void main(String[] args) { boolean Choose = true; String C; Scanner in = new Scanner(System.in); Banker T = new Banker(); System.out.println("银行家算法"); T.printSystemVariable(); T.SecurityAlgorithm(); while (Choose == true) { T.setRequest(); System.out.println("是否还要进行请求： y/n?"); C = in.nextLine(); if (C.endsWith("n")) { Choose = false; } } }

java银行家舍入法

Java银行家舍入法1. 引言在金融领域，精确的计算是至关重要的。

银行家舍入法（Banker’s rounding）是一种常用的舍入方法，用于处理金融计算中的小数位数。

本文将介绍Java中如何实现银行家舍入法，并提供示例代码和详细说明。

2. 银行家舍入法概述银行家舍入法是一种四舍六入五取偶的舍入方法。

其原理是：当需要舍入的数字恰好在两个舍入值的中间时，选择最接近的偶数作为舍入结果。

这种舍入方法可以减少舍入误差的累积，提高计算结果的准确性。

具体来说，银行家舍入法的规则如下： - 如果小数位数的下一位数字小于5，则向下舍入； - 如果小数位数的下一位数字大于5，则向上舍入； - 如果小数位数的下一位数字等于5，则根据小数位数的当前值判断舍入方向： - 如果小数位数的当前值为奇数，则向上舍入； - 如果小数位数的当前值为偶数，则向下舍入。

3. Java实现银行家舍入法Java中的BigDecimal类提供了强大的数值计算功能，并且支持银行家舍入法。

下面是实现银行家舍入法的Java代码示例：import java.math.BigDecimal;import java.math.RoundingMode;public class BankersRounding {public static double round(double value, int scale) {BigDecimal bd = new BigDecimal(Double.toString(value));bd = bd.setScale(scale, RoundingMode.HALF_EVEN);return bd.doubleValue();}public static void main(String[] args) {double value = 3.145;int scale = 2;double roundedValue = round(value, scale);System.out.println("原始值：" + value);System.out.println("舍入后的值：" + roundedValue);}}在上面的代码中，我们定义了一个round方法，接受一个double类型的值和一个表示小数位数的scale参数。

操作系统课程设计--银行家算法java实现、回溯与递归法实现银行家算法、

课程设计报告课程名称：操作系统课程设计姓名：樊廷峰指导教师：刘丽敏学院：信息科学与工程学院专业班级：物联网1402班2017年3月11日目录银行家算法 (1)一设计要求 (1)二设计思想 (1)2.1 银行家算法 (1)2.2 安全性算法 (1)三数据结构 (2)3.1 可利用资源向量Available (2)3.2 最大需求矩阵Max (2)3.3 分配矩阵Allocation (2)3.4 需求矩阵 (3)四总体设计 (3)4.1 输入量 (3)4.2 输出量 (3)4.3 部分界面 (4) (4)五详细设计 (5)5.1类Bank（主类） (5)5.2 类Request_or_Max（用于获取Request或Max表数据） (6)5.3 类Show（显示输出结果） (6)5.4 算法（寻找安全序列的方法：回溯法） (6)5.5 流程图 (8)六遇到的问题及解决方法 (11)6.1 问题一（空指针异常） (11)6.2 问题二（监听JTable数据跟新） (11)6.3 问题三（JTable中单元格数据的获取） (11)6.4 问题四（键盘输入的数据转化为数字） (11)七测试及结果 (11)7.1 初始界面 (12)7.2 输入资源数和进程数点击启动进程并按提示输入数据 (12)7.3 输入表Max和表Request里的数据 (14)7.4 若无请求进程，则点击安全序列按钮 (15)7.5 若有请求进程，则点击请求资源按钮并输入对应数据 (15)7.6 点击安全序列显示结果 (16)八总结 (16)九附录 (17)9.1 程序清单一（类Bank） (17)9.2 程序清单二（类Request_or_Max） (29)9.3 程序清单三（类Show） (31)十参考文献 (32)银行家算法一设计要求管理员可以把一定数量的作业供多个用户周转使用，为保证作业的安全，管理员规定：当一个用户对作业的最大需求量不超过管理员现有的资金就要接纳该用户；用户可以分期贷款，但贷款的总数不能超过最大需求量；当管理员现有的作业不能满足用户的所需数时，对用户的请求可以推迟支付，但总能使用户在有限的时间里得到请求。

计算机操作系统课程设计(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设计目的银行家算法是一种最有代表性的避免死锁的算法。

Java银行家算法

Java银⾏家算法实验存档，代码特别烂。

测试.javapackage operating.test;import operating.entity.bank.Bank;import operating.entity.bank.EngineeringTeam;public class TestBank {public static void main(String[] args) {Bank bank = new Bank(10);for (int i = 0; i != 3; ++i) {new Thread(new EngineeringTeam(5, bank)).start();}}}/银⾏.javapackage operating.entity.bank;import java.util.ArrayList;public class Bank {/*** ⼯程队数量*/private static final int NUM = 3;/*** 当前可⽤的资⾦数⽬*/private int available;/*** 已分配矩阵*/private int[] allocation = new int[NUM];/*** 需求矩阵*/private int[] need = new int[NUM];public Bank(int available) {this.available = available;}/*** 向银⾏借钱* @param id ⼯程队id* @param request ⼯程队需求资⾦* @return⼀个布尔值，如果借钱成功返回真，否则返回假*/public synchronized boolean borrow(int id, int request) {System.out.println("银⾏还剩 " + available + " 万元。

java银行家舍入法

Java银行家舍入法是一种四舍五入的方法，用于处理浮点数的舍入问题。

它通常用于金融和财务计算，以确保精确度和减少误差。

Java银行家舍入法的基本原理是在进行舍入操作时，将浮点数按照舍入方向（向上或向下）舍入到最接近的整数。

但是，如果舍入后的值与舍入前的值之间的差值小于0.5，则舍入后的值将保持不变。

在Java中，可以使用Math类的round()方法来实现银行家舍入法。

例如，要将一个浮点数向上舍入到最接近的整数，可以使用以下代码：
```java
double number = 3.14159;
long roundedNumber = Math.round(number);
System.out.println(roundedNumber); // 输出3
```
如果要将浮点数向下舍入到最接近的整数，则可以使用以下代码：
```java
double number = 3.61234;
long roundedNumber = Math.round(number * 10) / 10;
System.out.println(roundedNumber); // 输出3
```
在这个例子中，我们将原始数值乘以10，然后进行向上舍入操作。

最后，我们将结果除以10，以恢复原始数值的精度。

操作系统银行家算法的java编程实现

/*死锁避免与死锁检测模拟程序【银行家算法】网络工程06-3班学号：310609040308*/import java.util.*;public class TestTheBanker {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);TheBanker tb = new TheBanker();tb.deadlockAvoidance();//死锁避免int gate = 1;while(gate!=0){tb.deadlockDetection();//死锁检测System.out.println("如果您要继续分配资源请输入\"1\"，退出请输入\"0\"");System.out.print("您输入的值为：");gate = scanner.nextInt();System.out.println();}System.out.println("使用愉快！期待您下次使用！");}}class TheBanker{int m;int n;int[][] max;int[][] maxbak;//备份用int[][] allocation;int[][] allocationbak;//备份用int[][] need;int[][] needbak;//备份用int[] available;int[] availablebak;//备份用public TheBanker(){Scanner s = new Scanner(System.in);System.out.println("初始化==============");System.out.print("请依次输入系统中的【进程数】和【资源类型数】："); m = s.nextInt();n = s.nextInt();max =new int[m][n];maxbak = new int[m][n];allocation = new int[m][n];allocationbak = new int[m][n];need = new int[m][n];needbak = new int[m][n];available = new int[n];availablebak = new int[n];for(int i=0;i<max.length;i++){//初始化向量MAX、ALLOCATION、NEED、AVAILABLESystem.out.print("请依次输入第" + i + "进程的各资源数：");for(int j=0;j<max[i].length;j++){max[i][j] = s.nextInt();maxbak[i][j] = max[i][j];}}for(int i=0;i<allocation.length;i++){System.out.print("请依次输入第" + i + "进程中已分配资源的数量：");for(int j=0;j<allocation[i].length;j++){allocation[i][j] = s.nextInt();allocationbak[i][j] = allocation[i][j];}}for(int i=0;i<need.length;i++){for(int j=0;j<need[i].length;j++){need[i][j] = max[i][j] - allocation[i][j];needbak[i][j] = need[i][j];}}for(int i=0;i<available.length;i++){System.out.print("请输入系统中第" + i + "种资源的剩余量：");available[i] = s.nextInt();availablebak[i] = available[i];}System.out.println("初始化结果=============");System.out.println(" MAX ALLOCATION N EED AVAILABLE");for(int i=0;i<m;i++){System.out.print("P" + i + ": ");for(int j=0;j<n;j++){if(max[i][j]>9){//如果是两位数，控制格式，在数字前少输出一个" "。