银行家算法模拟实现C++版

银行家算法是死锁避免的经典算法，其核心思想是：进程动态地申请资源，每次申请资源时系统都执行安全状态检查算法判断本次申请是否会造成系统处于不安全状态，如果不安全则阻塞进程；如果安全状态，则完成资源分配。 安全状态检查算法的思想是找到一个安全序列，使所有进程都能执行完毕。如果找到，则处于安全状态，否则为不安全状态。

#include“stdafx.h“
#include “string.h“ 
#include “iostream“ 
using std::cout;
using std::cin;
using std::endl;
#define M 4 //总进程数 
#define N 3 //总资源数 
#define FALSE 0 
#define TRUE 1 
//M个进程对N类资源最大资源需求量 
int MAX[M][N]={{867}{678}{452}{463}}; 
//系统可用资源数 
int AVAILABLE[N]={12109}; 
//M个进程已经得到N类资源的资源量 
int ALLOCATION[M][N]={{000}{000}{000}{000}}; 
//M个进程还需要N类资源的资源量 
int NEED[M][N]={{867}{678}{452}{463}}; 
int Request[N]={000}; 
void showdata（）; 
void changdata（int）; 
void backData（int）; 
bool IsNotSafe（int）;
void main（） 
{ 
int i=0;//进程i
int j=0;//资源j 
char flag=‘Y‘; 
 
 
showdata（）; 
while（flag==‘Y‘||flag==‘y‘） //while 1
{ 
     i=-100; //先赋值一个负数，在用户输入第i个进程数时，再改变其值
     while（i<0||i>=M） //while2
     { 
         cout<<“ 请输入需要申请资源的进程号（从0到“<         cin>>i; 
         if（i<0||i>=M）
         {
            cout<<“ 输入的进程号不存在，系统退出!“<            return;
         }
 
     } //end while2
 
    //第二步：输入进程i申请的资源数
     cout<<“ 请输入进程“<     for （j=0;j     { 
         cout<<“ 需要资源“<         cin>>Request[j]; 
         if（Request[j]>NEED[i][j]） 
         { 
              cout<<“ 进程“<              cout<<“申请不合理，出错!请重新选择!“<              flag=‘N‘; 
              break; 
         } 
         else 
         { 
              if（Request[j]>AVAILABLE[j]） 
              { 
                   cout<<“ 进程“<                   cout<<“由于可能会产生死锁，所以银行家算法不予分配，请重新输入!“<                   flag=‘N‘; 
                   break; //重新显示数据，（退回到原来的）
              } 
         }
     }//end for
     if（flag==‘Y‘||flag==‘y‘） 
     { 
         changdata（i）; 
         if（IsNotSafe（i）） 
         { 
              backData（i）; 
              showdata（）; 
         } 
         else 
              showdata（）; 
     } 
     else //flag=‘N‘
         showdata（）; 
         cout<         cout<<“ 是否继续银行家算法演示按‘Y‘或‘y‘键继续按‘N‘或‘n‘键退出演示: “; 
         cin>>flag; 
     } 
}
 
void showdata（） 
{ 
int ij; 
cout<<“ 系统可用的资源数为:“<cout<<“ “; 
for （j=0;jcout< 
cout<cout<<“ 各进程还需要的资源量:“<for （i=0;i{ 
cout<<“进程“<for （j=0;jcout<} 
cout<cout<<“ 各进程已经得到的资源量: “<for （i=0;i{ 
cout<<“进程“<for （j=0;jcout<} 
cout<}
 
void changdata（int k） 
{ 
     int j; 
     for （j=0;j     { 
         AVAILABLE[j]=AVAILABLE[j]-Request[j]; 
         ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j]; 
         NEED[k][j]=NEED[k][j]-Request[j]; 
     } 
} 
 
void backData（int k） 
{ 
     int j; 
     for （j=0;j     { 
         AVAILABL

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----

     文件          0  2011-04-07 13:42  Bank\Allocated_list.txt

     文件       5462  2011-04-07 13:59  Bank\Bank.cpp

     文件       4512  2011-04-07 13:41  Bank\Bank.dsp

     文件        516  2011-04-07 13:41  Bank\Bank.dsw

     文件      33792  2011-04-07 14:07  Bank\Bank.ncb

     文件      48640  2011-04-07 14:07  Bank\Bank.opt

     文件        242  2011-04-07 14:06  Bank\Bank.plg

     文件          0  2011-04-07 13:42  Bank\Initiate.txt

     文件       1196  2011-04-07 13:41  Bank\ReadMe.txt

     文件        291  2011-04-07 13:41  Bank\StdAfx.cpp

     文件        667  2011-04-07 13:41  Bank\StdAfx.h

     目录          0  2011-04-07 14:07  Bank

----------- ---------  ---------- -----  ----

                95318                    12