最近没什么写日记，想写，但是对于感情方面的写多了没意思，变得庸俗。于是，我决定来一个科学的日志。下面就写写我在操作系统那门课中的一个实验：银行家算法。自从学了java，在我对游戏和网络情有独钟的基础上，我抛弃了c语言，因此，这个实验我是用java来编写的。线程我没学，所以就简单地写几个输入，然后得出结果。
银行家算法大家懂吗？我想，我们学院的都应该懂的。简单地来讲，就是假设系统有n种资源，每种资源有m个数量。又假设有k个进程。如果某进程要取得一些资源则系统首先测试是否满足资源请求要求，如果满足，则尝试分配，接着就判断分配后系统有没有发生死锁，有，就还原，没有就继续。如果某进程要求进入内存，则系统要判断所有进程的请求资源数有没有超过可用资源，有则不许建立，没有就可以建立该进程。
花了几个小时（其实大概一个小时就能搞定，不过可能困的原因，有两个错误没有看出来。我在此要提醒大家，编写程序的格式非常重要，不然检查错误是在很难。），终于写完程序和报告。下面就贴上我的代码吧。
/*
* 操作系统实验：
* 《银行家算法》本程序参考课本的例子，资源种数为3.如果要求更多可作相应更改。
*/
/**
*
* @author Kevin 华南农业大学
*/
//银行家算法，此为Banker类。
import java.util.ArrayList;
import java.util.Random;
public class Banker {
static int[] available = {10,5,7}; //各个资源可用的数量。
static ArrayList processM = new ArrayList(); //线性表，里面装的是进程。
public static void main(String[] args){ //主函数，调试用。
Process p1 = new Process(7,5,3);
Process p2 = new Process(3,2,2);
Process p3 = new Process(9,0,2);
Process p4 = new Process(2,2,2);
Process p5 = new Process(4,3,3);
processM.add(p1);
processM.add(p2);
processM.add(p3);
processM.add(p4);
processM.add(p5);
while(!p1.isOK() || !p2.isOK() || !p3.isOK() || !p4.isOK() || !p5.isOK()){ //进程都还有没满足的就继续申请。
p1 = (Process)processM.get(0);
p2 = (Process)processM.get(1);
p3 = (Process)processM.get(2);
p4 = (Process)processM.get(3);
p5 = (Process)processM.get(4);
if(!p1.isOK())
allocation(p1.request(),p1,0); //申请资源，以下同。
if(!p2.isOK())
allocation(p2.request(),p2,1);
if(!p3.isOK())
allocation(p3.request(),p3,2);
if(!p4.isOK())
allocation(p4.request(),p4,3);
if(!p5.isOK())
allocation(p5.request(),p5,4);
}
}
public static boolean allocation(int[] rq ,Process process,int n){ //进程请求分配函数，
if(process.have[0] + rq[0] > process.claim[0] || process.have[1] + rq[1] > process.claim[1] || process.have[2] + rq[2] > process.claim[2]){
System.out.println("申请失败。"+ (n+1)); //如果请求的资源比最大需求大，则申请失败。
return false;
}
else{
if(rq[0] > available[0] || rq[0] > available[0] || rq[0] > available[0]){
//如果要求的资源暂时不够，则先挂起。
}
else{
process.have[0] = process.have[0] + rq[0];
process.have[1] = process.have[1] + rq[1];
process.have[2] = process.have[2] + rq[2];
available[0] = available[0]-rq[0];
available[1] = available[1]-rq[1];
available[2] = available[2]-rq[2];
processM.add(n, process);
processM.remove(n+1);
}
if(safe()){ //如果安全，则分配成功。
System.out.println("申请成功。"+"进程"+ (n+1)+"已获得资源分别为："+ process.have[0]+" "+process.have[1]+" "+process.have[2]);
return true;
//如果安全，那资源被该进程利用。
}
else{
process.have[0] = process.have[0] - rq[0];
process.have[1] = process.have[1] - rq[1];
process.have[2] = process.have[2] - rq[2];
available[0] = available[0]+ rq[0];
available[1] = available[1]+ rq[1];
available[2] = available[2]+ rq[2];
processM.add(n, process);
processM.remove(n+1);
System.out.println("申请失败。" + (n+1)); //不安全，则申请失败.
return false;
//如果不安全，则还原，并且挂起该进程。
}
}
}
public static boolean safe(){ //判断分配后是否安全。
ArrayList rest = new ArrayList(processM);
Process test ;
int num = rest.size();
int found = num*num;
while(found > 0 && !rest.isEmpty()){
test = (Process)rest.remove(0);
if(test.claim[0] - test.have[0] <= available[0] && test.claim[1] - test.have[1] <= available[1] && test.claim[2] - test.have[2] <= available[2] ){
available[0] = available[0] + test.have[0];
available[1] = available[1] + test.have[1];
available[2] = available[2] + test.have[2];
}
else {
rest.add(test);
}
found--;
}
if(rest.isEmpty()){
return true;
}
else
return false;
}
}
class Process{ //此类为进程类，描述的是一个进程。
int[] claim =new int[3]; //这个进程需要的资源数。
int[] have = new int[3];
public Process(int n1,int n2,int n3){ //初始化进程
claim[0] = n1;
claim[1] = n2;
claim[2] = n3;
have[0] = 0;
have[1] = 0;
have[2] = 0;
}
public boolean isOK(){ //判断这个进程得到满足没有。
if(have[0] == claim[0] && have[1] == claim[1] && have[2] == claim[2]){
return true;
}
else return false;
}
public int[] request(){ //这个函数随机生成3个数，作为某个进程的请求。
Random random = new Random(); //实例化随机对象。
int[] num = new int[3];
num[0] = random.nextInt(10);
System.out.println(num[0]);
num[1] = random.nextInt(10);
System.out.println(num[1]);
num[2] = random.nextInt(10);
System.out.println(num[2]);
return num;
}
}
参考资料：http://user.qzone.qq.com/441317618
本回答被网友采纳