银行家算法C语言代码

#include

using namespace std;

const int PMAX = 5; //进程数
const int SMAX = 3; //资源数

int w = 0;

int Sort[PMAX] ;

int Available[SMAX] = {0}; //系统可用资源

int Max[PMAX][SMAX] = {0}; //各进程所需各类资源的最大需求

int Allocation[PMAX][SMAX] = {0}; //系统已分配资源

int Need[PMAX][SMAX] = {0}; //还需要资源

int Request[PMAX][SMAX] = {0}; //请求资源向量

int Work[SMAX] = {0}; //存放系统可提供资源 Work = Available

bool Finish[PMAX] = {false};

void Initial(); //初始化进程资源需求量 以及 进程总量

void ShowSource(); //显示资源矩阵

void SourceRequest(); //资源请求

void FreeSource(); // 资源释放

void ShowProcess(); // 显示已执行进程的顺序

void GrantSource(int i); // 进程i资源分配

bool IsSafe();

bool FindS(int i); //进程i已经是false 现在需要确认每个资源 是不是满足Need[i][j] <= Work[j]

int FindP(); //找到Finish是false的进程

bool FindSort(int i);// 进程i是否已执行

void Write()
{
FILE* fp = fopen("银行家算法.txt","w");

for(int i=0;i{
fprintf(fp,"%d ",Available[i]);
}

for(i=0;i{
for(int j=0;j{
fprintf(fp,"%d %d %d ",Max[i][j],Allocation[i][j],Need[i][j]);
}
}
fclose(fp);
}


void Read()
{
FILE* fp = fopen("银行家算法.txt","r");

for(int i=0;i{
fscanf(fp,"%d ",&Available[i]);
}

for(i=0;i{
for(int j=0;j{
fscanf(fp,"%d %d %d ",&Max[i][j],&Allocation[i][j],&Need[i][j]);
}
}
fclose(fp);
}




int main()
{
while(1)
{
int choice = 0;

cout<<"\n\t0 离开\n\t1 初始化\n\t2 资源请求\n\t3 释放资源\n\t4 显示资源\n\t5 写文件\n\t6 读文件\n\t7 已执行进程\n\n请选择：";

cin>>choice;

switch(choice)
{
case 0:
cout<<"bye!";
return 0;

case 1:
Initial();
break;

case 2:
SourceRequest();
break;

case 3:
FreeSource();
break;

case 4:
ShowSource();
break;

case 5:
Write();
break;

case 6:
Read();
break;

case 7:
ShowProcess();
break;

default:
cout<<"输入错误，请正确选择功能号（0-3)!";
system("pause");
system("cls");
}
}
}


void ShowProcess() // 显示已执行进程的顺序
{
for(int i=0;Sort[i]!=-1;i++)
{
cout<<"\n已执行进程: "<}
cout<}


void Initial() //初始化进程资源需求量 及 进程总量
{
for(int i=0;i{
cout<<"输入资源["<
cin>>Available[i];
}

cout<
int AvailableTemp[SMAX];

for(i=0;i{
AvailableTemp[i] = Available[i];
}

for(i=0;i{
Sort[i] = -1;

for(int j=0;j{
cout<<"输入进程["<

cin>>Max[i][j];

if(Max[i][j] > AvailableTemp[j])
{
cout<<"需要的资源大于资源总量，请重新输入\n";
--j;
continue;
}

cout<<"输入进程["<
cin>>Allocation[i][j];

if(Allocation[i][j] > AvailableTemp[j])
{
cout<<"已经拥有的资源大于资源总量，请重新输入\n";
--j;
continue;
}

Need[i][j] = Max[i][j] - Allocation[i][j];

Available[j] -= Allocation[i][j];
}
cout<}

cout<<"初始化成功 !\n";

system("pause");

system("cls");
}

void ShowSource() //显示资源矩阵
{
cout<<"\n系统目前可用的资源[Avaliable]:\n"<
for(int i=0;i{
cout<}

cout<<"\n\n未执行进程目前已得到的资源[Allocation]:"<
for(i=0;i{
cout<<"\n进程["<
for(int j=0;j{
cout<}
}

cout<<"\n\n未执行进程目前还需要的资源[Need]:"<
for(i=0;i{
cout<<"\n进程["<
for(int j=0;j{
cout<}
}

cout<<"\n\n";
}


void GrantSource(int i) // 进程i资源分配
{
for(int j=0;j{
Available[j] -= Request[i][j];

Allocation[i][j] += Request[i][j];

Need[i][j] -= Request[i][j];
}
}


void SourceRequest() //资源请求
{
int i;

cout<<"输入请求的进程序号，序号是0到"<
cin>>i;

if(i<0 || i>=PMAX)
{
cout<<"输入错误!\n";
system("pause");
system("cls");
return;
}

for(int j=0;j{
cout<<"输入对资源"<
cin>>Request[i][j];
}

//******************************************

for(j=0;j{
if(Request[i][j] > Need[i][j])
{
cout<<"请求量大于剩余需求量!\n";
return;
}
if(Request[i][j] > Available[j])
{
cout<<"请求量大于资源剩余量!\n";
return;
}
}

GrantSource(i); //试探着分配

bool bok = IsSafe();

if(bok)
{
cout<<"\n\n进程"<
Sort[w++] = i;
}
else
{
cout<<"\n\n进程"<
for(int j=0;j{
Available[j] += Request[i][j];

Allocation[i][j] -= Request[i][j];

Need[i][j] += Request[i][j];
}
}
}


void FreeSource() // 资源释放
{
int i;

cout<<"输入释放资源的进程序号，序号是0到"<
cin>>i;

if(i<0 || i>=PMAX)
{
cout<<"输入错误!\n";
system("pause");
system("cls");
return;
}

for(int j=0;j{
Available[j] += Allocation[i][j];

Allocation[i][j] = 0;

Need[i][j] = Max[i][j] = 0; //已经执行了 就不需要资源了
}
}


bool IsSafe()
{

for(int i=0;i{
Work[i] = Available[i];
}

for(i=0;i{
Finish[i] = false;
}

int n = -4;

while(1)
{
n = FindP();

if(n==-1 || n==-2)
{
break;
}
else
{
Finish[n] = true;

for(int j=0;j{
Work[j] += Allocation[i][j];
}
}
}

if(n == -1)
{
return true;// Finish已经全部是true
}

else //FindP() == -2
{
return false;
}
}

bool FindS(int i) //进程i已经是false 现在需要确认每个资源 是不是满足Need[i][j] <= Work[j]
{
int flag = 1;

for(int j=0;j{
if(Need[i][j] > Work[j])
{
flag = 0;
}
}
if(flag==0)
{
return false;
}
else
{
return true;
}
}

int FindP()//找到Finish是false的进程
{
int flag = 1;

for(int i=0;i{
if(Finish[i] == false && FindSort(i) == false)
{
flag = 0;

if(FindS(i)==true)
{
return i;
}
}
}
if(flag==1)
{
return -1; //全部是true 安全
}
else
{
return -2; // 不安全
}
}


bool FindSort(int i)// 进程i是否已执行
{
for(int j=0;j{
if(Sort[j] == i)
{
return true;
}
}
return false;
}