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

银行家算法

 

1. 实验目的与要求

1. 理解死锁的概念，掌握并会编写银行家算法与安全性检测算法；

2. 使用高级程序设计语言设计并实现银行家算法基本过程；

3. 验证银行家算法对于避免死锁的作用。

2. 实验平台

操作系统：Windows

注：可使用自己熟悉的语言设计编程，但需在实验报告中注明编译环境以及编辑工具。

3. 实验内容和要求

1. 定义并初始化进程及其资源数据结构

2. 提供一个用户界面，用户利用它可动态输入进程和资源种类等相关参数

3. 编制模拟银行家算法的程序，并以下面给出的例子验证所编写的程序的正确性。

 

设系统中有三种类型的资源（A,B,C）和五个进程（P0,P1,P2,P3,P4），A资源的数量为17，B资源的数量为5，C资源的数量为20。当前时刻系统状态如下所示。

 

进程 已占资源 最大需求数

资源种类 A B C A B C

P0 2 1 2 5 5 9

P1 4 0 2 5 3 6

P2 4 0 5 4 0 11

P3 2 0 4 4 2 5

P4 3 1 4 4 2 4

 

现在系统中A、B、C 3类资源分别还剩2、3、3个，请根据银行家算法完成以下问题：

1、 现在系统是否处于安全状态？若是，请给出安全序列。要求绘图粘贴到实验报告描述计算过程，并截图实验过程和结果验证程序正确性。

2、 如果现在进程P1请求资源（0、3、4），能否实现资源分配？为什么？实验报告附上计算过程，并截图实验过程和结果验证程序正确性。

3、若进程P3请求资源（2、0、1），能否实现资源分配？为什么？实验报告附上计算过程，并截图实验过程和结果验证程序正确性。

 

 

附：测试用例为

5 5 9
​
5 3 6
​
4 0 11
​
4 2 5
​
4 2 4

 

2 1 2      
​
4 0 2     
​
4 0 5    
​
2 0 4 
​
3 1 4

4. 实验报告

 

《计算机操作系统》课程机房上机实验报告
题目	银行家算法	姓名	波哥哥	日期:2020.6.29
实验环境	Dev C++
实验内容 与完成情况	提示：填写实验原理或核心思想，核心代码可附在实验报告之后
实验运行结果
出现的问题	安全序列不是按照正确的（编号从小到大）顺序输出
解决方案（列出遇到的问题和解决办法，列出没有解决的问题）	每输出一个之后break，退出此循环，再次执行总的操作

 

5. C语言代码

#include <stdio.h>
​
#include <stdlib.h>
​
 
​
#define UP 100
​
 
​
int flag_need = 1;
​
int row,col;
​
int Max[UP][UP],Allocation[UP][UP],Need[UP][UP],finish[UP] = {0},Available[UP],Work[UP],P[UP];
​
  
​
void init(){   
​
    printf("输入进程数:\n");
​
    scanf("%d",&row);
​
    printf("输入资源数:\n");
​
    scanf("%d",&col);
​
    printf("输入每个进程最多需要的资源数按照%d x %d矩阵输入:\n",row,col);
​
    for(int i = 0;i < row;i ++){
​
       for(int j = 0;j < col;j ++){
​
           scanf("%d",&Max[i][j]);
​
       }      
    }
​
    printf("输入每个进程已经分配的资源数按照%d x %d矩阵输入:\n",row,col);
​
    for(int i = 0;i < row;i ++){
​
       for(int j = 0;j < col;j ++){
​
           scanf("%d",&Allocation[i][j]);
​
           Need[i][j] = Max[i][j]-Allocation[i][j];
​
           if(Need[i][j] < 0){
​
              printf("进程P%d的R%d资源出错\n");
​
              flag_need = 0;
​
           }
​
       }      
​
    }
​
    printf("请输入现有各资源数:\n");
​
    for(int i = 0;i < col;i ++){
​
       scanf("%d",&Available[i]);
​
       Work[i] = Available[i];
​
    }   
​
}
​
 
​
void print(bool x){
​
    int k;
​
    if(x){
​
       printf("系统是安全的\n安全序列为:");
​
       for(k = 0;k < row - 1;k ++){
​
              printf("%d ->",P[k]);
​
           }
​
       printf("%d\n",P[k]);
​
    }
​
    else
​
       printf("系统不安全\n"); 
​
} 
​
 
​
bool isSafe(){ 
​
    int k = 0,len = 0,lastlen = 0;
​
    while(len < row){ 
​
       for(int i = 0;i < row;i ++){
​
           if(finish[i] != 1){
​
              k = 0;
​
              for (int j = 0;j < col;j ++){
​
                  if (Need[i][j] <= Work[j]) 
​
                     k ++;   
​
              }
​
              if (k == col) {
​
                  finish[i] = 1;
​
                  P[len] = i;//放进程安全序列 
​
                  
​
                  for(int j = 0;j < col;j ++){
​
                     Work[j] += Allocation[i][j];
​
                  }
​
/*************************************调试代码***************************************************
​
                  printf("Work:\n");
​
                  for (int j = 0;j < col;j ++){
​
                     printf("%d ",Work[j]);
​
                  }
​
                  printf("\n");
​
**********************************************************************************************/    
                  len ++;  //统计进程个数
​
                  break;
​
              }             
​
           }
​
       }
​
       //上一次循环长度与下一次相等，则出现不安全情况，进程未被完全访问 
​
       if (lastlen == len){
​
           break;
​
       }else{
​
           lastlen = len;
​
       }
​
    }
​
    if(len == row){
       return true;
​
    }
​
    else {
​
       return false;
​
    }
​
}
​
 
​
 
​
/********************************调试代码***********************************************************
​
void test(){
​
    printf("Need:\n");
​
    for (int i = 0;i < row;i ++){
​
       for (int j = 0;j < col;j ++){
​
           printf("%d ",Need[i][j]);
​
       }
​
      printf("\n");
​
    }
​
    printf("Allocation:\n");
​
    for (int i = 0;i < row;i ++){
       for (int j = 0;j < col;j ++){
​
           printf("%d ",Allocation[i][j]);
​
       }
​
       printf("\n");
​
    }
​
    printf("\n");
​
    printf("Work:\n");
​
    for (int j = 0;j < col;j ++){
​
       printf("%d ",Work[j]);
​
    }
​
    printf("\n");
​
    printf("\nAvailable:\n");
​
    for (int j = 0;j < col;j ++){
​
       printf("%d ",Available[j]);
​
    }
​
    
​
    printf("\n");
​
}
​
******************************************************************************************************/
​
int request(){
​
//   test();
​
    int j,reqProcessNum,reqResource[col];
​
   printf("输入要申请的资源的进程号:(第一个进程号为0,第二个进程号为1,以此类推.)\n");
​
    scanf("%d",&reqProcessNum);
​
    printf("请输入所请求的各资源数:\n");
​
    
​
    //更新Need Available重置Work finish 
​
    for (j = 0;j < col;j ++){
​
       scanf("%d",&reqResource[j]);
​
       if (reqResource[j] > Need[reqProcessNum][j] || reqResource[j] > Available[j]){
​
           printf("该进程请求资源数过大，不予分配"); 
​
           return 0;//请求数不合法 
​
       }
​
    }
​
    for(int i = 0;i < row;i ++){
​
       finish[i] = 0;
​
    }
​
    
​
    if(j == col){
​
       for(j = 0;j < col;j ++){
​
           Available[j] -= reqResource[j];
​
           Need[reqProcessNum][j] -= reqResource[j];
​
           Allocation[reqProcessNum][j] += reqResource[j];
​
           Work[j] = Available[j];
​
       }
​
    }
​
//   test();
​
    return 1;//请求数合法 
​
} 
​

​
int main (){
​
    init();
​
    print(isSafe());
​
    
​
    //请求数合法判断是否有安全序列  
​
    if(request()){
​
       print(isSafe()); 
​
    }
​
    return 0;
​
}