操作系统实验：银行家算法

实现描述：

#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,否则取消试探性分配。
  }
}

安全状态判别算法：
(1)设置Finish=(false,...,false)  work=Available
(2)循环查找满足下列条件的进程pi //最多循环n次
    Finish[i]=false且Needi<=work
(3)若找到则Finish[i]=true;work=work+Alloci; 转(2)
(4)若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） 

C语言代码如下：

#include <stdio.h>
#define n 5 //进程个数
#define m 3 //资源种类
 
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_req(int *i, int *request)
{ //读取数据
   printf("Input process number:");
   scanf("%d", i); //此处为 i
   if (*i < 1)     //数据不合法则退出循环
      return 0;
   printf("Input resource request:");
   scanf("%d %d %d", &request[0], &request[1], &request[2]);
   return 1;
}
 
int judge(int i, int *request)
{//判断请求是否合法
   if (i > n)
   {
      printf("Invalid request!\n");
      return 0;
   }
 
   int k = 0;
   for (k; k < m; k++)
   {
      if (request[k] > Available[k])
      {
         printf("Process block!\n");
         return 0;
      }
 
      if (request[k] > Need[i][k])
      {
         printf("Illegal request!\n");
         return 0;
      }
   }
 
   return 1;
}
 
void security(int i, int *request)
{//判断安全性
   int k = 0;
   for (k = 0; k < m; k++)
   { //尝试分配
      Available[k] -= request[k];
      Alloc[i][k] += request[k];
      Need[i][k] -= request[k];
   }
   int finish[n] = {0, 0, 0, 0, 0};
   int work[m];
   for (k = 0; k < m; k++)
      work[k] = Available[k];
   int p = 0; //表示进程
   int pnum = 0;
   for (k = 0; p < n && pnum < n;)
   {
      if (finish[p] == 0)
         for (k = 0; k < m; k++)
            if (Need[p][k] > work[k])
               break; //循环中断表示不符合条件
      if (k == m)
      {
         finish[p] = 1;
         int c = 0;
         for (c = 0; c < m; c++)
            work[c] += Alloc[p][c];
         p = 0;
         pnum++;
      }
      else
         p++;
   }
 
   if (pnum < n)
   { //不安全
      printf("Process block!\n");
      for (k = 0; k < m; k++)
      { //取消分配
         Available[k] += request[k];
         Alloc[i][k] -= request[k];
         Need[i][k] += request[k];
      }
   }
   else
      printf("Allows allocation of resources!!!\n");
}
 
int main()
{
   int i = 0;
   int request[m] = {0, 0, 0};
   while (1)
   {
      if (request_req(&i, request) == 0)
         break;//输入数据不合法则退出循环
 
      if (judge(i - 1, request))
         security(i - 1, request);
   }
   printf("Press enter to continue...");
   getchar();
   return 0;
}

源码下载：https://github.com/toywish/OS/银行家算法