银行家算法程序
Ⅰ 银行家算法
什么是银行家算法：
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
安全状态
如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态
不存在一个安全序列。不安全状态不一定导致死锁。
原理：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全,银行家规定:
(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;
(2) 顾客可以分歧贷款,但贷款的总数不能超过最大需求量;
(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
(4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金.
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
程序举例：
已知进程{P0,P1,P2,P3,P4}，有三类系统资源A、B、C的数量分别为10、5、7，在T0时刻的资源
（1）若进程P1请求资源，发出请求向量Request1（1，0，2），编写程序用银行家算法判断系统能否将资源分配给它；
（2）若进程P2提出请求Request(0，1，0)，用银行家算法程序验证系统能否将资源分配给它。
程序代码：
P1进程提出的请求，可以分配。
P2进程不能分配，因为请求的B类资源超过了它的最大值。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 50
void main()
{
unsigned int Available[MAXSIZE]; //可利用资源向量
unsigned int Max[MAXSIZE][MAXSIZE]; //最大需求矩阵
unsigned int Allocation[MAXSIZE][MAXSIZE]; //已分配矩阵
unsigned int Need[MAXSIZE][MAXSIZE]; //需求矩阵
unsigned int Request[MAXSIZE]; //请求向量
unsigned int Work[MAXSIZE]; //工作向量
bool Finish[MAXSIZE]; //是否有足够资源分配给进程,使之运行完成
unsigned int SafeSequence[MAXSIZE]; //安全序列
int i,j;
int p; //请求资源的进程的下标
int temp = 0; //安全序列下标
int total = 0;
int N;
int M;
printf("请输入进程数N=");
scanf("%d",&N);
printf("请输入资源种类数M=");
scanf("%d",&M);
//用户输入数据,初始化Available数组
printf("初始化可用资源数组:\n");
for(i=0; i<M; i++)
{
printf("\t%c类资源:",65+i);
scanf("%d",&Available[i]);
}
//用户输入数据,初始化Max数组
printf("初始化最大需求数组:\n");
for(i=0; i<N; i++)
{
printf("\tP%d进程最大需要\n",i);
for(j=0; j<M; j++)
{
printf("\t\t%c类资源:",65+j);
scanf("%d",&Max[i][j]);
}
}
//用户输入数据,初始化Allocation数组
printf("初始化已分配资源数组:\n");
for(i=0; i<N; i++)
{
printf("\tP%d进程已分配\n",i);
for(j=0; j<M; j++)
{
printf("\t\t%c类资源:",65+j);
scanf("%d",&Allocation[i][j]);
}
}
//初始化Need数组
for(i=0; i<N; i++)
for(j=0; j<M; j++)
{
Need[i][j] = Max[i][j] - Allocation[i][j];
}
//进程发出资源请求后检查
do
{
printf("资源请求:\n");
printf("\t输入请求资源的进程下标:");
scanf("%d",&p);
printf("\t进程P%d请求\n",p);
//初始化请求向量
for(i=0; i<M; i++)
{
printf("\t\t%c类资源:",65+i);
scanf("%d",&Request[i]);
}
for(i=0; i<M; i++) //检查Request <= Need ?
if(Request[i] > Need[p][i])
{
printf("\t请求的%c类资源数超过它所宣布的最大值!\n",65+i);
break;
}
if(i == M) //通过上层检查,继续检查Request <= Available ?
{
for(i=0; i<M; i++)
if(Request[i] > Available[i])
{
printf("\t尚无足够%c类资源,P%d须等待!\n",65+i,p);
break;
}
}
if(i == M) //尝试分配
{
for(i=0; i<M; i++)
{
Available[i] -= Request[i];
Allocation[p][i] += Request[i];
Need[p][i] -= Request[i];
}
}
}while(i<M);
//初始化Work,Finish向量
for(i=0; i<M; i++)
{
Work[i] = Available[i];
}
for(i=0; i<N; i++)
{
Finish[i] = false;
}
//安全性算法
do
{
total = temp;
for(i=0; i<N; i++)
{
if(Finish[i] == false)
{
for(j=0; j<M; j++)
if(Need[i][j] > Work[j])
{
break;
}
if(j == M) //各类资源都满足Need <= Work
{
for(j=0; j<M; j++)
{
Work[j] += Allocation[i][j]; //释放资源
}
Finish[i] = true;
SafeSequence[temp++] = i; //加入安全序列
}
}
}
}while(total != temp); //所有进程检查一遍之后，如果安全序列有变化，则进行下一轮
//否则说明所有的Finish都为true,或者因没有安全序列退出循环
if(temp == N)
{
printf("安全序列:");
for(temp=0; temp<N; temp++)
{
printf("P%d ",SafeSequence[temp]);
}
}
else
{
printf("系统处于不安全状态!不能分配!\n");
}
getchar();
getchar();
}
这个程序还行，输入有点麻烦，我自己编写的是用文件输入系统描述信息的，但是缺少说明，怕你搞不明白。希望对你有所帮助！
Ⅱ 钬滈摱琛屽剁畻娉旷▼搴忥纴鍏堟潵鍏堟湇锷¤皟搴︾畻娉曪纴瀛桦偍绠＄悊镄勬ā𨰾熷疄鐜扳
-
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<iomanip>
#include<conio.h>
using namespace std;
const int MAX_P=20;
const int MAXA=10; //瀹氢箟A绫昏祫婧愮殑鏁伴噺
const int MAXB=5;
const int MAXC=7;
typedef struct node{
int a;
int b;
int c;
int remain_a;
int remain_b;
int remain_c;
}bank;
typedef struct node1{
char name[20];
int a;
int b;
int c;
int need_a;
int need_b;
int need_c;
}process;
bank banker;
process processes[MAX_P];
int quantity;
//鍒濆嫔寲鍑芥暟
void initial()
{
int i;
banker.a=MAXA;
banker.b=MAXB;
banker.c=MAXC;
banker.remain_a=MAXA;
banker.remain_b=MAXB;
banker.remain_c=MAXC;
for(i=0;i<MAX_P;i++){
strcpy(processes[i].name,"");
processes[i].a=0;
processes[i].b=0;
processes[i].c=0;
processes[i].need_a=0;
processes[i].need_b=0;
processes[i].need_c=0;
}
}
//鏂板姞浣滀笟
void add()
{
char name[20];
int flag=0;
int t;
int need_a,need_b,need_c;
int i;
cout<<endl;
cout<<"鏂板姞浣滀笟"<<endl;
cout<<"铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛"<<endl;
cout<<"璇疯緭鍏ユ柊锷犱綔涓氩悕:";
cin>>name;
for(i=0;i<quantity;i++){
if(!strcmp(processes[i].name,name)){
flag=1;
break;
}
}
if(flag){
cout<<"阌栾,浣滀笟宸插瓨鍦"<<endl;
}
else{
cout<<"链浣滀笟镓闇A绫昏祫婧:";
cin>>need_a;
cout<<"链浣滀笟镓闇B绫昏祫婧:";
cin>>need_b;
cout<<"链浣滀笟镓闇C绫昏祫婧:";
cin>>need_c;
t=1;
cout<<need_a<<banker.remain_a;
if(need_a>banker.remain_a){
cout<<"阌栾,镓闇A绫昏祫婧愬ぇ浜庨摱琛屽舵墍鍓〢绫昏祫婧"<<endl;
t=0;
}
if(need_b>banker.remain_b){
cout<<"阌栾,镓闇B绫昏祫婧愬ぇ浜庨摱琛屽舵墍鍓〣绫昏祫婧"<<endl;
t=0;
}
if(need_c>banker.remain_c){
cout<<"阌栾,镓闇C绫昏祫婧愬ぇ浜庨摱琛屽舵墍鍓〤绫昏祫婧"<<endl;
t=0;
}
if(t){
strcpy(processes[quantity].name,name);
processes[quantity].need_a=need_a;
processes[quantity].need_b=need_b;
processes[quantity].need_c=need_c;
quantity++;
cout<<"鏂板姞浣滀笟鎴愬姛"<<endl;
}
else{
cout<<"鏂板姞浣滀笟澶辫触"<<endl;
}
}
}
//涓轰綔涓氱敌璇疯祫婧
void bid()
{
char name[20];
int i,p;
int a,b,c;
int flag;
cout<<endl<<"涓轰綔涓氱敌璇疯祫婧"<<endl;
cout<<"铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛"<<endl;
cout<<"瑕佺敌璇疯祫婧愮殑浣滀笟钖:";
cin>>name;
p=-1;
for(i=0;i<quantity;i++){
if(!strcmp(processes[i].name,name)){
p=i;
break;
}
}
if(p!=-1){
cout<<"璇ヤ綔涓氲佺敌璇禀绫昏祫婧愭暟閲:";
cin>>a;
cout<<"璇ヤ綔涓氲佺敌璇稡绫昏祫婧愭暟閲:";
cin>>b;
cout<<"璇ヤ綔涓氲佺敌璇稢绫昏祫婧愭暟閲:";
cin>>c;
flag=1;
if((a>banker.remain_a)||(a>processes[p].need_a-processes[p].a)){
cout<<"阌栾,镓鐢宠禀绫昏祫婧愬ぇ浜庨摱琛屽舵墍鍓〢绫昏祫婧愭垨璇ヨ繘绋嬭缮闇鏁伴噺"<<endl;
flag=0;
}
if((b>banker.remain_b)||(b>processes[p].need_b-processes[p].b)){
cout<<"阌栾,镓鐢宠稡绫昏祫婧愬ぇ浜庨摱琛屽舵墍鍓〣绫昏祫婧愭垨璇ヨ繘绋嬭缮闇鏁伴噺"<<endl;
flag=0;
}
if((c>banker.remain_c)||(c>processes[p].need_c-processes[p].c)){
cout<<"阌栾,镓鐢宠稢绫昏祫婧愬ぇ浜庨摱琛屽舵墍鍓〤绫昏祫婧愭垨璇ヨ繘绋嬭缮闇鏁伴噺"<<endl;
flag=0;
}
if(flag){
banker.remain_a-=a;
banker.remain_b-=b;
banker.remain_c-=c;
processes[p].a+=a;
processes[p].b+=b;
processes[p].c+=c;
cout<<"涓轰綔涓氱敌璇疯祫婧愭垚锷"<<endl;
}
else{
cout<<"涓轰綔涓氱敌璇疯祫婧愬け璐"<<endl;
}
}
else{
cout<<"璇ヤ綔涓氢笉瀛桦湪"<<endl;
}
}
//鎾ゆ秷浣滀笟
void finished()
{
char name[20];
int i,p;
cout<<endl<<"鎾ゆ秷浣滀笟"<<endl;
cout<<"铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛"<<endl;
cout<<"瑕佹挙娑堜綔涓氩悕:";
cin>>name;
p=-1;
for(i=0;i<quantity;i++){
if(!strcmp(processes[i].name,name)){
p=i;
break;
}
}
if(p!=-1){
banker.remain_a+=processes[p].a;
banker.remain_b+=processes[p].b;
banker.remain_c+=processes[p].c;
for(i=p;i<quantity-1;i++){
processes[i]=processes[i+1];
}
strcpy(processes[quantity-1].name,"");
processes[quantity-1].a=0;
processes[quantity-1].b=0;
processes[quantity-1].c=0;
processes[quantity-1].need_a=0;
processes[quantity-1].need_b=0;
processes[quantity-1].need_c=0;
quantity--;
cout<<"鎾ゆ秷浣滀笟鎴愬姛"<<endl;
}
else{
cout<<"鎾ゆ秷浣滀笟澶辫触"<<endl;
}
}
//镆ョ湅璧勬簮𨱍呭喌
void view()
{
int i;
cout<<endl<<"镆ョ湅璧勬簮𨱍呭喌"<<endl;
cout<<"铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛"<<endl;
cout<<"阈惰屽舵墍鍓╄祫婧(鍓╀綑璧勬簮/镐诲叡璧勬簮)"<<endl;
cout<<"A绫:"<<banker.remain_a<<"/"<<banker.a;
cout<<" B绫:"<<banker.remain_b<<"/"<<banker.b;
cout<<" C绫:"<<banker.remain_c<<"/"<<banker.c;
cout<<endl<<endl<<"浣滀笟鍗犵敤𨱍呭喌(宸插崰鐢ㄨ祫婧/镓闇璧勬簮)"<<endl<<endl;
if(quantity>0){
for(i=0;i<quantity;i++){
cout<<"浣滀笟钖:"<<processes[i].name<<endl;
cout<<"A绫:"<<processes[i].a<<"/"<<processes[i].need_a;
cout<<" B绫:"<<processes[i].b<<"/"<<processes[i].need_b;
cout<<" C绫:"<<processes[i].c<<"/"<<processes[i].need_c;
cout<<endl;
}
}
else{
cout<<"褰揿墠娌℃湁浣滀笟"<<endl;
}
}
//鏄剧ず鐗堟潈淇℃伅鍑芥暟
void version()
{
cout<<endl<<endl;
cout<<" 铍忊挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍"<<endl;
cout<<" 铍 阈 琛 瀹 绠 娉 铍"<<endl;
cout<<" 铍犫斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺斺敤"<<endl;
cout<<" 铍 (c)All Right Reserved Neo 铍"<<endl;
cout<<" 铍 [email protected] 铍"<<endl;
cout<<" 铍 version 2004 build 1122 铍"<<endl;
cout<<" 铍椻挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍"<<endl;
cout<<endl<<endl;
}
int main(void)
{
int chioce;
int flag=1;
initial();
version();
while(flag){
cout<<"铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛铍佲挛"<<endl;
cout<<"1.鏂板姞浣滀笟 2.涓轰綔涓氱敌璇疯祫婧 3.鎾ゆ秷浣滀笟"<<endl;
cout<<"4.镆ョ湅璧勬簮𨱍呭喌 0.阃鍑虹郴缁"<<endl;
cout<<"璇烽夋嫨:";
cin>>chioce;
switch(chioce){
case 1:
add();
break;
case 2:
bid();
break;
case 3:
finished();
break;
case 4:
view();
break;
case 0:
flag=0;
break;
default:
cout<<"阃夋嫨阌栾"<<endl<<endl;
}
}
return 0;
}
Ⅲ 银行家算法是如何实现的
银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。
�7�4 与预防死锁的几种方法相比较，限制条件少，资源利用程度提高了。
�7�4 缺点：该算法要求客户数保持固定不变，这在多道程序系统中是难以做到的；该算法保证所有客户在有限的时间内得到满足，但实时客户要求快速响应，所以要考虑这个因素；由于要寻找一个安全序列，实际上增加了系统的开销.
Banker algorithm 最重要的一点是：保证操作系统的安全状态！这也是操作系统判断是否分配给一个进程资源的标准！那什么是安全状态？举个小例子，进程 P 需要申请 8 个资源（假设都是一样的），已经申请了 5 个资源，还差 3 个资源。若这个时候操作系统还剩下 2 个资源。很显然，这个时候操作系统无论如何都不能再分配资源给进程 P 了，因为即使全部给了他也不够，还很可能会造成死锁。若这个时候操作系统还有 3 个资源，无论 P 这一次申请几个资源，操作系统都可以满足他，因为操作系统可以保证 P 不死锁，只要他不把剩余的资源分配给别人，进程 P 就一定能顺利完成任务。 为什么银行家算法是可行的呢？这里需要严格的证明一下。不管任何时候，操作系统分配资源的时候都可以保证当前接受资源的进程不会陷入死锁，因为操作系统总是可以满足该进程需要的资源的。假设有 n 个进程 {p1, p2, p3, … pn} ，最后一个分配到资源的是 pi ， pi 还需要 mi 个资源，假设此时操作系统还有 m 个资源剩余。那么很显然 m>=mi ！而且如果之后操作系统又把资源分配给其他进程了，假设是 pj ， pj 还需要 mj 个资源，同理可知 m>=mj ！也就是说在所有的进程中，还需要的资源数总是有小于 m 的！这样就可以保证资源数永远不会为 0 ，即使可能暂时性为 0 。另外，还需要保证资源数不会减少！而且，所有已经分配到资源的进程总有一天会归还它所拥有的资源！根据操作系统再分配的时候的状态即可判定。
Ⅳ 求：用java语言编写的银行家算法的源代码
import java.util.*;
class ThreadTest {
static int type = 4, num = 10; //定义资源数目和线程数目
static int[] resource = new int[type]; //系统资源总数
//static int[] Resource = 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], //申请资源量
Resource = 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);
}
}
else
tryRequest();
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++) //防止随机申请资源全为0
if(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++) {
//复制资源量并减去需求量到一个副本上
Resource[i] = resource[i];
Resource[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] = Resource[i];
allocation[i] += request[i];
need[i] -= request[i];
}
System.out.println(getName() + " request succeed!");
}
else
System.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] = Resource[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!!!---");
}
}
Ⅳ 银行家算法C++描述
#include <iostream>
#include <string>
#define M 3 //资源的种类数
#define N 5 //进程的个数
void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]); //统一的输出格式
bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);
bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);
int main()
{
int i,j;
//当前可用每类资源的资源数
int iAvailable[M]={3,3,2};
//系统中N个进程中的每一个进程对M类资源的最大需求
int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
//iNeed[N][M]每一个进程尚需的各类资源数
//iAllocation[N][M]为系统中每一类资源当前已分配给每一进程的资源数
int iNeed[N][M],iAllocation[N][M]={{0,1,1},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
//进程名
char cName[N]={'a','b','c','d','e'};
bool bExitFlag=true; //退出标记
char ch; //接收选择是否继续提出申请时传进来的值
bool bSafe; //存放安全与否的标志
//计算iNeed[N][M]的值
for(i=0;i<N;i++)
for(j=0;j<M;j++)
iNeed[i][j]=iMax[i][j]-iAllocation[i][j];
//输出初始值
output(iMax,iAllocation,iNeed,iAvailable,cName);
//判断当前状态是否安全
bSafe=safety(iAllocation,iNeed,iAvailable,cName);
//是否继续提出申请
while(bExitFlag)
{
cout<<"\n"<<"继续提出申请？\ny为是；n为否。\n";
cin>>ch;
switch(ch)
{
case 'y':
//cout<<"调用银行家算法";
bSafe=banker(iAllocation,iNeed,iAvailable,cName);
if (bSafe) //安全，则输出变化后的数据
output(iMax,iAllocation,iNeed,iAvailable,cName);
break;
case 'n':
cout<<"退出。\n";
bExitFlag=false;
break;
default:
cout<<"输入有误，请重新输入：\n";
}
}
}
//输出
void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
int i,j;
cout<<"\n\t Max \tAllocation\t Need \t Available"<<endl;
cout<<"\tA B C\tA B C\tA B C\t A B C"<<endl;
for(i=0;i<N;i++)
{
cout<<cName[i]<<"\t";
for(j=0;j<M;j++)
cout<<iMax[i][j]<<" ";
cout<<"\t";
for(j=0;j<M;j++)
cout<<iAllocation[i][j]<<" ";
cout<<"\t";
for(j=0;j<M;j++)
cout<<iNeed[i][j]<<" ";
cout<<"\t";
cout<<" ";
//Available只需要输出一次
if (i==0)
for(j=0;j<M;j++)
cout<<iAvailable[j]<<" ";
cout<<endl;
}
}
//安全性算法，进行安全性检查；安全返回true，并且输出安全序列，不安全返回false，并输出不安全的提示；
bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
}
//定位ch对应的进程名在数组中的位置
//没找见返回－1，否则返回数组下标
int locate(char cName[N],char ch)
{
int i;
for(i=0;i<N;i++)
if (cName[i]==ch) //找到
return i;
//未找到
return -1;
}
//提出申请,返回提出申请的进程名对应的下标
int request(char cName[N],int iRequest[M])
{
int i,loc;
char ch;
bool bFlag=true;
//判断输入的进程名是否有误
while(bFlag)
{
//输出进程名
for(i=0;i<N;i++)
cout<<cName[i]<<"\t";
//输入提出申请的进程名
cout<<"\n输入提出资源申请的进程名：\n";
cin>>ch;
//定位ch对应的进程名在进程名数组中的位置
loc=locate(cName,ch);
//没找到，重新输入
if (loc==-1)
cout<<"\n您输入的进程名有误！请重新输入";
//找到，退出循环
else
bFlag=false;
}
//输入提出申请的资源数
cout<<"输入申请各类资源的数量：\n";
for(i=0;i<M;i++)
cin>>iRequest[i];
//返回提出申请的进程名对应的下标
return loc;
}
bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
}
这个是c++的 我的报告