操作系统--银行家算法c语言代码

avatar 2017年04月06日13:50:26 1 14338 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此
直接上代码了，两个文件分别是main.c和banker.h

main.c
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include "banker.h"
  5. /*
  6. @author  WellsLiu
  7. @url     liuyanzhao.com 
  10. 测试数据 
  11. max        4 1 1 1 0 2 1 2 4 2 1 0 1 1 1 1 2 1 1 0
  12. allocation 3 0 1 1 0 1 0 0 1 1 1 0 1 1 0 1 0 0 0 0
  14. request测试 
  15. eg1:   1   1 0 1 0       failed         request > need
  16. eg2:   1   0 1 0 1       failed         request > avaliable
  17. eg3:   1   0 0 1 0    successful
  19. */
  20. void inputMax()
  21. {
  22.     int i;
  23.     printf("请输入最大需求矩阵\n");
  24.     for (i = 0; i < PROCESSES_NUMBER; i++)
  25.     {
  26.         scanf("%d%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C,&Max[i].D);
  27.     }
  29. }
  30. void inputAllocation()
  31. {
  32.     int i;
  33.     printf("请输入已分配资源数矩阵\n");
  34.     for (i = 0; i < PROCESSES_NUMBER; i++)
  35.     {
  36.         scanf("%d%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C,&Allocation[i].D);
  37.     }
  39. }
  41. void inputAllocaltion()
  42. {
  43.     int i;
  44.     printf("请输入已分配资源数矩阵\n");
  45.     for (i = 0; i < PROCESSES_NUMBER; i++)
  46.     {
  47.         scanf("%d%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C,&Allocation[i].D);
  48.     }
  49. }
  50. //试探分配
  51. void ProbeAlloc(int process,RESOURCE *res)
  52. {
  53.     Available.A -= res->A;
  54.     Available.B -= res->B;
  55.     Available.C -= res->C;
  56.     Available.D -= res->D;
  58.     Allocation[process].A += res->A;
  59.     Allocation[process].B += res->B;
  60.     Allocation[process].C += res->C;
  61.     Allocation[process].D += res->D;
  63.     Need[process].A -= res->A;
  64.     Need[process].B -= res->B;
  65.     Need[process].C -= res->C;
  66.     Need[process].D -= res->D;
  67. }
  69. //若试探分配后进入不安全状态，将分配回滚
  70. void RollBack(int process,RESOURCE *res)
  71. {
  72.     Available.A += res->A;
  73.     Available.B += res->B;
  74.     Available.C += res->C;
  75.     Available.D += res->D;
  77.     Allocation[process].A -= res->A;
  78.     Allocation[process].B -= res->B;
  79.     Allocation[process].C -= res->C;
  80.     Allocation[process].D -= res->D;
  82.     Need[process].A += res->A;
  83.     Need[process].B += res->B;
  84.     Need[process].C += res->C;
  85.     Need[process].D += res->D;
  86. }
  88. //安全性检查
  89. bool SafeCheck()
  90. {
  91.     RESOURCE    Work = Available;
  92.     bool        Finish[PROCESSES_NUMBER] = {false,false,false,false,false};
  93.     int     i;
  94.     int     j = 0;
  96.     for (i = 0; i < PROCESSES_NUMBER; i++)
  97.     {
  98.         //是否已检查过
  99.         if(Finish[i] == false)
  100.         {
  101.             //是否有足够的资源分配给该进程
  102.             if(Need[i].A <= Work.A && Need[i].B <= Work.B && Need[i].C <= Work.C && Need[i].D <= Work.D)
  103.             {
  104.                 //有则使其执行完成，并将已分配给该进程的资源全部回收
  105.                 Work.A += Allocation[i].A;
  106.                 Work.B += Allocation[i].B;
  107.                 Work.C += Allocation[i].C;
  108.                 Work.D += Allocation[i].D;
  109.                 Finish[i] = true;
  110.                 safe[j++] = i;
  111.                 i = -1;             //重新进行遍历
  112.             }
  113.         }
  114.     }
  116.     //如果所有进程的Finish向量都为true则处于安全状态，否则为不安全状态
  117.     for (i = 0; i < PROCESSES_NUMBER; i++)
  118.     {
  119.         if (Finish[i] == false)
  120.         {
  121.             return false;
  122.         }
  123.     }
  124.     return true;
  125. }
  127. //资源分配请求
  128. bool request(int process,RESOURCE *res)
  129. {
  130.     //request向量需小于Need矩阵中对应的向量
  131.     if(res->A <= Need[process].A && res->B <= Need[process].B && res->C <= Need[process].C&& res->D <= Need[process].D)
  132.     {
  133.         //request向量需小于Available向量
  134.         if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C && res->D <= Available.D)
  135.         {
  136.             //试探分配
  137.             ProbeAlloc(process,res);
  139.             //如果安全检查成立，则请求成功，否则将分配回滚并返回失败
  140.             if(SafeCheck())
  141.             {
  142.                 return true;
  143.             }
  144.             else
  145.             {
  146.                 printf("安全性检查失败。原因：系统将进入不安全状态，有可能引起死锁。\n");
  147.                 printf("正在回滚...\n");
  148.                 RollBack(process,res);
  149.             }
  150.         }
  151.         else
  152.         {
  153.             printf("安全性检查失败。原因：请求向量大于可利用资源向量。\n");
  154.         }
  155.     }
  156.     else
  157.     {
  158.         printf("安全性检查失败。原因：请求向量大于需求向量。\n");
  159.     }
  160.     return false;
  161. }
  163. //输出资源分配表
  164. void PrintTable()
  165. {
  166.     printf("\t\t\t*********资源分配表*********\n");
  167.     printf("Process       Max                  Allocation             Need                Available\n");
  168.     printf("          A    B    C    D     A    B    C    D      A    B    C    D     A    B    C   D\n");
  169.     printf("  P0      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d     %d    %d    %d   %d\n",Max[0].A,Max[0].B,Max[0].C,Max[0].D,Allocation[0].A,Allocation[0].B,Allocation[0].C,Allocation[0].D,Need[0].A,Need[0].B,Need[0].C,Need[0].D,Available.A,Available.B,Available.C,Available.D);
  170.     printf("  P1      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d\n",Max[1].A,Max[1].B,Max[1].C,Max[1].D,Allocation[1].A,Allocation[1].B,Allocation[1].C,Allocation[1].D,Need[1].A,Need[1].B,Need[1].C,Need[1].D);
  171.     printf("  P2      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d\n",Max[2].A,Max[2].B,Max[2].C,Max[2].D,Allocation[2].A,Allocation[2].B,Allocation[2].C,Allocation[2].D,Need[2].A,Need[2].B,Need[2].C,Need[2].D);
  172.     printf("  P3      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d\n",Max[3].A,Max[3].B,Max[3].C,Max[3].D,Allocation[3].A,Allocation[3].B,Allocation[3].C,Allocation[3].D,Need[3].A,Need[3].B,Need[3].C,Need[3].D);
  173.     printf("  P4      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d\n",Max[4].A,Max[4].B,Max[4].C,Max[4].D,Allocation[4].A,Allocation[4].B,Allocation[4].C,Allocation[4].D,Need[4].A,Need[4].B,Need[4].C,Need[4].D);
  174.     printf("\n");
  175. }
  177. int main()
  178. {
  179.     inputMax() ;
  180.     inputAllocation();
  181.     int i;
  183.     for (i = 0; i < PROCESSES_NUMBER; i++)
  184.     {
  186.             Need[i].A = Max[i].A - Allocation[i].A;
  187.             Need[i].B = Max[i].B - Allocation[i].B;
  188.             Need[i].C = Max[i].C - Allocation[i].C;
  189.             Need[i].D = Max[i].D - Allocation[i].D;
  191.     }
  192.     int ch;
  194.     printf("先检查初始状态是否安全。\n");
  195.     if (SafeCheck())
  196.     {
  197.         printf("系统处于安全状态。\n");
  198.         printf("安全序列是{P%d,P%d,P%d,P%d,P%d}。\n",safe[0],safe[1],safe[2],safe[3],safe[4]);
  199.     }
  200.     else
  201.     {
  202.         printf("系统处于不安全状态。程序将退出...\n");
  203.         goto over;
  204.     }
  205.     do
  206.     {
  207.         int     process;
  208.         RESOURCE    res;
  209.         PrintTable();
  210.         printf("请依次输入请求分配的进程和对四类资源的请求数量：");
  211.         scanf("%d%d%d%d%d",&process,&res.A,&res.B,&res.C,&res.D);
  212.         if (request(process,&res))
  213.         {
  214.             printf("分配成功。\n");
  215.             printf("安全序列是{P%d,P%d,P%d,P%d,P%d}。\n",safe[0],safe[1],safe[2],safe[3],safe[4]);
  216.         }
  217.         else
  218.         {
  219.             printf("分配失败。\n");
  220.         }
  221.         printf("是否继续分配？(Y/N):");
  222.         fflush(stdin);              //虽然C标准不支持这种用法，但是VC++支持
  223.         ch = getchar();
  224.     } while (ch == 'Y' || ch == 'y');
  227. over:
  228.     printf("执行完毕。");
  229.     return 0;
  230. }

banker.h
  1. #pragma warning(disable:4996)
  4. typedef int bool;
  5. #define false 0
  6. #define true !false
  10. //系统中所有进程数量
  11. #define PROCESSES_NUMBER    5
  13. typedef struct {
  14.     int A;
  15.     int B;
  16.     int C;
  17.     int D;
  18. }RESOURCE;
  20. //最大需求矩阵  Max
  21. RESOURCE Max[PROCESSES_NUMBER];
  23. //已分配资源数矩阵 Allocation
  24. RESOURCE Allocation[PROCESSES_NUMBER];
  26. //需求矩阵
  27. RESOURCE Need[PROCESSES_NUMBER];
  30. //可用资源向量
  31. RESOURCE Available = {1,0,2,0};
  33. int safe[PROCESSES_NUMBER];

历史上的今天
四月
06日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0