银行家算法

1.题目

银行家算法

#define  n  5  //进程个数
#define  m  3  //资源种类
int   Available[m],Alloc[n][m],Need[n][m];
main()
{
int request[m];
input();
    while(1)
    {
        read_req(); 
        if(请求结束)  break;
        (1)if(!(requesti<=Needi))  表示非法请求；
        (2)if(!(requesti<=Available))  则Pi阻塞；
(3)试探性分配
Available=Available - Requesti;
           Alloci=Alloci+Requesti;
           Needi=Needi-Requesti;
       (4)若新状态安全，则实际分配资源给Pi,否则取消试探性分配。
     }
}

安全状态判别算法：

• 设置Finish=(false,…,false) work=Available
• 循环查找满足下列条件的进程pi //最多循环n次
  Finish[i]=false且Needi<=work
• 若找到则 Finish[i]=true;work=work+Alloci; 转(2)
• 若Finish=(true,…,true) 则安全，否则不安全。
  测试数据：m=3:种类型的资源（A,B,C）进程个数n=5
  Available=(2,3,3);
  已分配资源数量 资源需求量
  A B C A B C
  P1 2 1 2 3 4 7
  P2 4 0 2 1 3 4
  P3 3 0 5 0 0 3
  P4 2 0 4 2 2 1
  P5 3 1 4 1 1 0
  请求序列如下：
  a.进程P2请求资源（0，3，4）
  b.进程P4请求资源（1，0，1）
  c.进程P1请求资源（2，0，1）
  d.进程P3请求资源（0，0，2）

2.程序设计

首先是定义并初始化各个变量，包括空余资源、已分配资源、还需要的资源以及请求的资源，接下来是一个Display函数，负责将进程的各类资源信息输出显示在屏幕上，然后就是一个分配资源函数Distribute()，其主体如available[j]-=request[j];alloc[i][j]+=
request[j];need[i][j]-=request[j];主要是对资源的更新，后面的恢复资源函数Restore和这个基本相同，差别只是运算符相反。
后面就是安全状态算法，检查预分配后的资源序列是否安全，返回bool值。首先是将finish[n]全部设置为false,然后在循环for(j=0;j<m;j++)里首先将可利用资源数赋值给work，利用do-while语句首先判断分配资源的进程是否可以执行完毕，若可以，则将分配给该进程的所有资源返回work，并继续寻找可以执行完毕的安全序列，若找到则finish即为true，然后利用循环判断所有finish是否都为true，若是则系统安全，准许分配，返回true，否则系统不安全，不予分配返回false。
然后就是算法执行的主体：该算法放在一个大循环里面，方便连续多次资源的申请。首先初始化各个所需变量，用户输入申请资源的进程号以及该进程的各类资源数，然后利用循环依次判断申请的资源是否大于进程所需量以及是否大于系统资源剩余量，若符合条件，则首先预分配资源，然后调用安全算法检查预分配资源后的序列是否安全，若不安全则恢复资源数并显示各个资源信息，若安全则首先判断进程是否获得全部所需资源，即运行完成，则释放全部占有资源，否则直接输出显示资源信息即可。在完成分配资源之后，判断所有进程是否已获得全部资源，若是则直接退出大循环，没必要再分配资源了，否则询问是否继续分配资源，若是则再次循环执行上面的步骤，否则直接break循环。
最后就是主函数，很简单，首先利用函数Display显示资源信息，然后执行银行家算法主体即可，至此，算法结束。

3.测试结果

4.源码

//操作系统上机之银行家算法
#include <iostream>
#define n 5    //进程个数 
#define m 3    //资源种类 
using namespace std;

int available[m]={2,3,3};                                 //空余资源 
int alloc[n][m]={{2,1,2},{4,0,2},{3,0,5},{2,0,4},{3,1,4}};//已分配资源 
int need[n][m]={{3,4,7},{1,3,4},{0,0,3},{2,2,1},{1,1,0}}; //还需要的资源 
int request[m];                                           //请求的资源 

void Display()                                            //输出显示资源 
{
	int i,j;
	cout<<"\t\t    可利用的资源量\n";
	cout<<"\t\t    A     B     C\n";
	cout<<"\t\t    ";
	for(i=0;i<m;i++)
	{
		cout<<available[i]<<"     ";
	}
	cout<<"\n\t  已分配的资源量     还需要的资源量\n";
	cout<<"\tA      B      C      A      B      C\n";
   	for(i=0;i<n;i++)
   	{
   		cout<<"P"<<i+1;
   	    for(j=0;j<m;j++)
   	    {
   	    	cout<<"      "<<alloc[i][j];
		}
		for(j=0;j<m;j++)
   	    {
   	    	cout<<"      "<<need[i][j];
		}
		cout<<endl;
    }
    cout<<endl;
}


void Distribute(int i)                 //分配资源 
{
	int j;
	for(j=0;j<m;j++)
	{
		available[j]-=request[j];
		alloc[i][j]+=request[j];
		need[i][j]-=request[j];
	}
}


void Restore(int i)                    //恢复资源 
{
	int j;
	for(j=0;j<m;j++)
	{
		available[j]+=request[j];
		alloc[i][j]-=request[j];
		need[i][j]+=request[j];
	}
}


bool Check(int p)                       //检查是否安全
{ 
    int work,finish[n];
    int i,j,k=0;
    
    for(i=0;i<n;i++)                   //初始化 
	{
		finish[i]=false;
	}
    for(j=0;j<m;j++)
    {
        work=available[j];
        i=p;
        do
        {
            if(finish[i]==false&&need[i][j]<=work)
            {
                work+=alloc[i][j];
                finish[i]=true;
                i=0;
            }
            else
            {
				i++;
            }
        }while(i<n);
        
        for(i=0;i<n;i++)
        {
        	if(finish[i]==false)
            {
               cout<<"系统不安全!资源申请失败!"<<endl;
               return false;
            }
		}
    }
    cout<<"系统安全！资源申请成功！"<<endl;
    return true;
}


void Banker()//算法主体
{
	while(1)
	{
		int P,i,j,flag2=0,flag3=0;
	    char flag1='y',flag4;
	    char resource[3]={'A','B','C'};
		cout<<"请输入您想申请资源的进程号（P1-P"<<n<<"）P";//输入申请资源 
		cin>>P;
		cout<<"请依次输入要申请的ABC类资源量：";
	    for(j=0;j<m;j++)
	    {
	        cin>>request[j];
		}
		
		for(j=0;j<m;j++)                                  //判断申请是否合理 
		{
			if(request[j]>need[P-1][j])
			{
				cout<<"申请不合理！申请的"<<resource[j]<<"资源量大于所需量！\n";
				flag1='n';
			}
	    }
	    for(j=0;j<m;j++)
		{
			if(request[j]>available[j])
			{
				cout<<"申请不合理！申请的"<<resource[j]<<"资源量大于剩余量！\n";
				flag1='n';
			}
		}
		cout<<endl; 
		
		if(flag1=='y')
		{
			Distribute(P-1);     //预分配资源 
			if(Check(P-1)==false)//检查是否安全 
			{
				Restore(P-1);    //资源申请失败,恢复预分配的资源 
				Display();
			}
			else                 //资源申请成功
			{
				for(j=0;j<m;j++) //进程若获得全部所需资源，运行完成，释放全部占有资源
				{
					if(need[P-1][j]==0)
					{
						flag2++;
					}
				}
				if(flag2==m)
				{
					for(j=0;j<m;j++)
					{
						available[j]+=alloc[P-1][j];
					}
				}
				Display();
			}
		}
		
		for(i=0;i<n;i++)       //若所有进程已获得全部资源，则直接退出程序 
		{
			for(j=0;j<m;j++)
			{
				if(need[i][j]==0)
				{
					flag3++;
				}
			}
		}
		if(flag3==n*m)
		{
			cout<<"所有进程已获得它们所需的全部资源";
			break;          //退出大循环 
		}
		
		cout<<"是否继续分配资源？（Y/N）";
		cin>>flag4;
		if(flag4=='n'||flag4=='N')
		{
			cout<<"感谢使用！\n";
			system("pause");
			break;
		}
	}
}


int main(void)
{
	Display();
	Banker();
	return 0;
}