C++实现计算机操作系统银行家算法
2010-11-11 11:37
337 查看
/*==========================================
程序功能：实现银行家算法(假设进程和资源的初始状态为安全)
程序编写：sunxden
编写日期:2010-11-11
编译环境: Windows 7, VC++ 2005 SP6
==========================================*/
/*
此程序存在的不足：
1.进程初始状态是否安全判断过后，如果不安全，在主函数里面少了对应的处理方法，比如说重新输入机制。
2.当某一进程请求资源后存在安全序列，如何输出各进程的资源状况没有相应的实现模块。
请有心读者自行完善。
*/
#include<iostream>
#include<cstdlib>
using namespace std;
//定义银行家算法必要的数据结构
struct MD
{
int *Available;
int **Max;
int **Need;
int **Allocation;
};
//函数声明
void Memory_allocated(int ,int ,struct MD *); // 内存分配
void Initializated(int , int , struct MD* ); // 对结构体里面的数组进行初始化
void Intial_status_is_safe(int ,int ,struct MD* ); // 进程初始状态是否安全
void Banker_alogrithm(int , int ,int , int * ,struct MD *); //银行家算法实现
void Memory_freed(int ,int , struct MD *); // 内存释放
void Menu();
int main()
{
char ch('c');
int p , r ,flag(0),*request; // flag为进程标识, request 为资源请求向量
cout<<"请输入进程数和资源数: ";
cin>>p>>r;
if(0 == p || 0 == r)
{
cout<<"进程数或者资源数不等于0 !"<<endl;
exit(1);
}
struct MD *MatrixData = new struct MD; // 定义结构体变量的名字 MatrixData，并分配内存
request = new int [r];
Memory_allocated(p,r,MatrixData);
Initializated(p,r,MatrixData);
Intial_status_is_safe(p, r, MatrixData);
// 用循环实现菜单功能
while(ch != 'e')
{
switch(ch)
{
case 'c':
{
cout<<"请输入即将请求的资源进程号(0 - "<<p-1<<"): ";
cin>>flag;
cout<<"请输入请求向量request["<<r<<"]: ";
for(int i = 0; i < r; i++)
{
cin>>request[i];
}
Banker_alogrithm(p,r,flag,request,MatrixData);
break;
}
case 'e': break;
default:
cout<<"输入非法, 请重新输入。"<<endl;
}
Menu();
cout<<"请选择操作: ";
while((ch=getchar())!='/n'&& ch!=EOF); //消除缓冲区控制字符的影响
ch=getchar();
}
Memory_freed(p,r,MatrixData);
delete[] request;
delete MatrixData;
MatrixData=NULL; //将指针置空
system("pause");
return 0;
}
void Menu()
{
cout<<endl;
cout<<"/t*****==============OPRATE MENU==================*****"<<endl;
cout<<"/t* *"<<endl;
cout<<"/t* c-continue e-exit *"<<endl;
cout<<"/t*****===========================================*****"<<endl;
}
void Memory_allocated(int n,int m,struct MD *matrix_data)
{
matrix_data->Available = new int [m];
matrix_data->Allocation = new int *
;
matrix_data->Max = new int *
;
matrix_data->Need = new int *
;
for(int i = 0; i < n; i++)
{
matrix_data->Allocation[i]= new int [m];
matrix_data->Max[i] = new int [m];
matrix_data->Need[i] = new int [m];
}
}
void Initializated(int n, int m, struct MD *matrix_data)
{
int i(0),j(0);
cout<<"初始化最大资源需求矩阵Max["<<n<<"]["<<m<<"] :"<<endl;
for(i = 0; i < n; i++)
for(j = 0; j < m; j++)
cin>>matrix_data->Max[i][j];
cout<<"初始化资源分配矩阵Allocation["<<n<<"]["<<m<<"] :"<<endl;
for(i = 0; i < n; i++ )
for(j = 0; j < m; j++)
cin>>matrix_data->Allocation[i][j];
cout<<"初始化资源需求矩阵Need["<<n<<"]["<<m<<"] :"<<endl;
for(i = 0; i < n; i++)
{
for(j = 0; j < m; j++)
{
matrix_data->Need[i][j]=matrix_data->Max[i][j] - matrix_data->Allocation[i][j];
cout<<matrix_data->Need[i][j]<<" ";
}
cout<<"/n";
}
cout<<"初始化可利用资源向量Available["<<m<<"] : "<<endl;
for(i = 0; i < m; i++)
cin>>matrix_data->Available[i];
}
void Intial_status_is_safe(int n,int m,struct MD* matrix_data)
{
int flag; // 标识进程初始状态的变量
for(int i = 0; i < n; i++)
{
flag = 1;
for( int j = 0; j < m; j++)
{
//初始状态的可利用资源available[*]是否 >= 任一个进程需求资源need[*][*],是则为安全状态(flag=1);否则不安全(flag=0)
if(matrix_data->Available[j] < matrix_data->Need[i][j])
flag = 0;
}
if( 1 == flag)
{
cout<<"进程的初始状态安全。"<<endl;
break;
}
}
if(0 == flag )
cout<<"进程的初始状态不安全。"<<endl;
}
// 请求资源向量request[*]是否小于或等于需求资源need[*][*]，是则返回1;否则返回0
int Request_less_or_equal_need(int m, int f,int *req, struct MD *matrix_data)
{
for(int i = 0; i < m; i++)
if(req[i] > matrix_data->Need[f][i])
{
return 0;
break;
}
return 1;
}
// 请求资源request[*]是否小于或者等于可利用资源available[*], 是则返回1;否则返回0
int Request_less_or_equal_available(int m, int f, int *req, struct MD *matrix_data)
{
for(int i = 0; i < m; i++)
if(req[i] > matrix_data->Available[i])
{
return 0;
break;
}
return 1;
}
// 试着给请求资源的进程分配资源
void Try_to_allocated_resources(int m, int f, int *req, struct MD *matrix_data)
{
for(int i = 0; i < m; i++)
{
matrix_data->Available[i] = matrix_data->Available[i] - req[i];
matrix_data->Allocation[f][i] = matrix_data->Allocation[f][i] + req[i];
matrix_data->Need[f][i] = matrix_data->Need[f][i] - req[i];
}
}
//试着分配资源后，判断进程是否存在安全序列
int Is_security_or_not(int n,int m,int f,struct MD *matrix_data,int *work,bool *finish,int *order)
{
int i(0), j(0), flag ; // flag变量标识某一进程安全
for(i = 0; i < m; i++)
work[i] = matrix_data->Available[i]; // work为工作向量, work[*] = availabe[*]
for(i = f; i < n ;i++)
{
// finish[i]=false时，才判断是否为安全进程
if(false == finish[i])
{
flag = 0;
for(j = 0; j < m; j++)
{
// 在进程 i 中，若需求资源need[i][*] > 工作向量work[*],则flag=1，表示此进程暂时不能保证安全，需下次判断。
if( matrix_data->Need[i][j] > work[j])
{
flag = 1;
break;
}
}
if(0 == flag)
{
for(j = 0; j < m; j++)
{
work[j] = work[j] + matrix_data->Allocation[i][j];
}
finish[i] = true;
*order++ = i; //将安全的进程号依次存入数组order中，便天安全序列的输出
i = -1; //置i的值为-1，然后执行for循环条件3: i++ 后，i=0。
}
}
}
//执行完毕后,flag要么 = 1, 要么 = 0
if(1 == flag)
return 0;
else
return 1;
}
//若为不安全资源请求，则恢复资源状态，取消资源试分配的影响
void Restore(int m,int f, int *req,struct MD *matrix_data)
{
for(int i = 0; i < m; i++)
{
matrix_data->Available[i] = matrix_data->Available[i] + req[i];
matrix_data->Allocation[f][i] = matrix_data->Allocation[f][i] - req[i];
matrix_data->Need[f][i] = matrix_data->Need[f][i] + req[i];
}
}
void Memory_freed(int n,int m, struct MD *matrix_data)
{
for(int i = 0; i < n; i++)
{
delete [] matrix_data->Max[i];
delete [] matrix_data->Allocation[i];
delete [] matrix_data->Need[i];
}
delete [] matrix_data->Available;
delete [] matrix_data->Allocation;
delete [] matrix_data->Max;
delete [] matrix_data->Need;
}
void Banker_alogrithm(int n, int m,int f, int *req ,struct MD *matrix_data)
{
int i(0);
int *Work = new int[m]; //工作向量
bool *Finish = new bool
; //finish[*] 标识进程是否安全
int *Order = new int
; //记录安全进程序列
for(i = 0; i < n; i++)
{
Finish[i] = false;
Order[i] = 0;
}
if(Request_less_or_equal_need(m,f,req,matrix_data))
{
if(Request_less_or_equal_available(m,f,req,matrix_data))
{
Try_to_allocated_resources(m,f,req,matrix_data);
if(Is_security_or_not(n,m,f,matrix_data,Work,Finish,Order))
{
cout<<"进程存在安全序列: ";
for(i = 0; i < n; i++)
{
cout<<"P"<<Order[i]<<" ";
}
cout<<", 系统己分配进程P"<<f<<"请求资源。"<<endl;
}
else
{
cout<<"系统进入不安全状态，不分配请求资源。"<<endl;
Restore(m,f,req,matrix_data);
}
}
else
{
cout<<"没有足够的资源可以分配, 进程P"<<f<<"需要等待, ";
cout<<"资源请求向量request["<<m<<"]=";
for(i = 0; i < m; i++)
cout<<req[i]<<" ";
cout<<"中某一项超过进程可利用资源Available["<<f<<"]["<<m<<"]=";
for(i = 0; i < m; i++)
cout<<matrix_data->Available[i]<<" ";
cout<<endl;
}
}
else
{
cout<<"数据错误。资源请求向量request["<<m<<"]=";
for(i = 0; i < m; i++)
cout<<req[i]<<" ";
cout<<"中某一项超过进程所需资源Need["<<f<<"]["<<m<<"]=";
for(i = 0; i < m; i++)
cout<<matrix_data->Need[f][i]<<" ";
cout<<endl;
}
// 释放分配的内存
delete[] Work;
delete[] Finish;
delete[] Order;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- c++ 计算机操作系统虚拟页式存储管理系统仿真实现
- 计算机操作系统调度算法，C++实现FSFS，SJF，RR，多级反馈队列算法
- 操作系统: 银行家算法的分析和代码实现(c++语言)
- [算法]操作系统进程通信(预防死锁)算法 Dijkstra银行家算法 C语言实现
- c++内存模型------计算机系统核心概念及软硬件实现
- 银行家算法（操作系统）（c++）
- NetTime——c++实现计算机时间与网络时间的更新
- CPU位数、操作系统位数、计算机字长、C/C++基本数据类型长度
- java为什么可以实现跨平台（即实现一次编译，到处执行，此处的平台主要指不同的操作系统），而C/C++却不行？
- C语言实现 操作系统 银行家算法
- 计算机操作系统笔记――进程及其实现
- C++实现操作系统调度算法（FSFS，SJF，RR，多级反馈队列算法）
- 【计算机网络实验二】crc编码（c++）实现
- 操作系统: 二级目录文件系统的实现(c/c++语言)
- 操作系统-------进程调度算法(C++实现)
- C++ 实现计算机程序的实现及其细节处理
- 银行家算法:c++实现
- 银行家算法的C++实现
- VC++实现 操作系统 死锁的避免--银行家算法
- 银行家算法---C++实现