银行家算法演示【原创】

Code:
  1. /*  
  2. 名称：银行家算法演示  
  3. 作者：杜琪  
  4. 时间：2010.11.14
  5. 作用：  
  6. 演示银行家算法的作用和操作过程：  
  7. 1、判断此刻系统是否处于安全状态  
  8. 2、输入某一进程的请求资源，然后利用银行家算法判断是否可以  
  9. 找到一个安全序列，如果可以，将该进程申请的资源分配出去，  
  10. 并且输出安全序列。  
  11. */  
  12. #include<stdio.h>   
  13. #define RN  3//资源的数目为3   
  14. #define PN  5//进程数目为5   
  15.   
  16.   
  17. /*各个函数声明*/  
  18. void Init();//初始化界面函数声明   
  19. int Banker(int i,int Requist[]);//银行家函数声明   
  20. bool Security(int s[],int t[][RN],int p[][RN]);//安全性检查函数声明   
  21.   
  22. void main()   
  23. {//主函数，程序入口    
  24.     /*初始化银行家算法中所用到的数据结构和变量*/  
  25.     int Available[RN]={3,3,2};//可利用资源向量   
  26.     int Max[PN][RN]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//最大需求矩阵，它定义了系统中PN个进程   
  27.                                                               //中的每一个进程对RN类资源的最大需求   
  28.     int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的   
  29.                                                             //的每一类资源数目   
  30.     int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目     
  31.     int P1[]={1,0,2};//P1数组存放进程1请求的资源   
  32.     int P4[]={3,3,0};   
  33.     int P0[]={0,1,0};   
  34.     int i=0;//表示哪个进程请求资源   
  35.     bool flag1;   
  36.     /*问题背景初始化*/  
  37.     Init();   
  38.     /*判断当前时刻系统是否处于安全状态*/  
  39.     flag1=Security(Available,Need,Allocation);   
  40.     if(flag1)   
  41.     {   
  42.         printf("/n");   
  43.         printf("当前系统处于安全状态！/n");   
  44.     }   
  45.     else  
  46.     {   
  47.         printf("/n");   
  48.         printf("当前系统处于不安全状态！/n");   
  49.     }   
  50. //  进程P1请求资源，Requist(1,0,2)   
  51.     i=1;   
  52.     Banker(i,P1);   
  53.     printf("/n");   
  54. /*  进程p4请求资源，Requist(3,3,0)  
  55.     i=4;  
  56.     Banker(i,P4);  
  57.     printf("/n");  
  58.     进程p0请求资源，Requist(0,2,0)  
  59.     i=0;  
  60.     Banker(i,P0);  
  61.     进程p0请求资源，Requist(0,1,0) */  
  62. }   
  63.   
  64. /*界面初始化函数的定义*/  
  65. void Init()   
  66. {   
  67.     int i,j;   
  68.     /*初始化银行家算法中所用到的数据结构和变量*/  
  69.     int Available[RN]={3,3,2};//可利用资源向量   
  70.     int Max[PN][RN]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//最大需求矩阵，它定义了系统中PN个进程   
  71.                                                               //中的每一个进程对RN类资源的最大需求   
  72.     int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的   
  73.                                                             //的每一类资源数目   
  74.     int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目   
  75.     printf("T0时刻的资源分配图如下:/n");   
  76.     printf("各个资源最大需求矩阵如下:/n");   
  77.     printf("   A B C/n");   
  78.     for(i=0;i<PN;i++)   
  79.     {   
  80.         printf("p%d:",i);   
  81.         for(j=0;j<RN;j++)   
  82.             printf("%d ",Max[i][j]);   
  83.         printf("/n");   
  84.     }   
  85.     printf("各个资源分配矩阵如下:/n");   
  86.     printf("   A B C/n");   
  87.     for(i=0;i<PN;i++)   
  88.     {   
  89.         printf("p%d:",i);   
  90.         for(j=0;j<RN;j++)   
  91.             printf("%d ",Allocation[i][j]);   
  92.         printf("/n");   
  93.     }   
  94.     printf("各个资源需求矩阵如下:/n");   
  95.     printf("   A B C/n");   
  96.     for(i=0;i<PN;i++)   
  97.     {   
  98.         printf("p%d:",i);   
  99.         for(j=0;j<RN;j++)   
  100.             printf("%d ",Need[i][j]);   
  101.         printf("/n");   
  102.     }   
  103.     printf("可利用资源向量如下:/n");   
  104.     printf("   A B C/n");   
  105.     printf("   ");   
  106.     for(i=0;i<RN;i++)   
  107.     {   
  108.         printf("%d ",Available[i]);   
  109.     }      
  110.     printf("/n");   
  111. }   
  112.   
  113. /*银行家算法函数的定义*/  
  114. int Banker(int i,int p[])   
  115. {   
  116.     int Available[RN]={3,3,2};//可利用资源向量   
  117.     int Allocation[PN][RN]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//分配矩阵，表示当前系统中每一个进程获得的   
  118.                                                             //的每一类资源数目   
  119.     int Need[PN][RN]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//表示一个进程上需要的各类资源的数目     
  120.     int Requist[RN];   
  121.     for(int m=0;m<RN;m++)   
  122.     {   
  123.         Requist[m]=p[m];   
  124.     }   
  125.     int j;   
  126.     bool flag1=1;//   
  127.     bool flag2=1;   
  128.     bool flag3=1;   
  129.     for(j=0;j<RN;j++)   
  130.     {   
  131.         if(Requist[j]>Need[i][j])   
  132.         {   
  133.             flag1=0;   
  134.             printf("进程%d需要的资源已超过它宣布的最大值!",i);   
  135.             break;   
  136.         }   
  137.     }   
  138.     if(flag1)   
  139.     {   
  140.         for(j=0;j<RN;j++)   
  141.         {   
  142.             if(Requist[j]>Available[j])   
  143.             {   
  144.                 flag2=0;   
  145.                 printf("没有足够的资源，进程%d必须等待。",i);   
  146.                 break;   
  147.             }   
  148.         }   
  149.         if(flag2)   
  150.         {   
  151.             for(j=0;j<RN;j++)//系统试探着把资源分配给进程i   
  152.             {   
  153.                 Available[j]=Available[j]-Requist[j];   
  154.                 Allocation[i][j]=Allocation[i][j]+Requist[j];   
  155.                 Need[i][j]=Need[i][j]-Requist[j];   
  156.             }   
  157.             flag3=Security(Available,Need,Allocation);//执行安全性检查，当第i个进程发出请求后，如果分配给它它所要的资源，系统是否处于安全状态   
  158.             if(flag3)//如果系统处于安全状态，banker()返回1,正式将资源分配给进程i   
  159.             {   
  160.                 return 1;   
  161.             }   
  162.             else  
  163.             {   
  164.                 //系统处于不安全状态,先将本次的试探分配作废，恢复到原来的资源分配状态   
  165.                 for(j=0;j<RN;j++)   
  166.                 {   
  167.                     Available[j]=Available[j]+Requist[j];   
  168.                     Allocation[i][j]=Allocation[i][j]-Requist[j];   
  169.                     Need[i][j]=Need[i][j]+Requist[j];      
  170.                 }   
  171.             }   
  172.         }   
  173.     }   
  174.     return 0;   
  175. }    
  176.   
  177. /*安全性检查算法函数的定义*/  
  178. bool Security(int Available[],int Need[][RN],int Allocation[][RN])   
  179. {   
  180.     int bian;   
  181.     bool flag1,flag2;   
  182.     flag1=true;   
  183.     int m,n;   
  184.     int Work[RN];   
  185.     for(m=0;m<RN;m++)   
  186.     {   
  187.         Work[m]=Available[m];   
  188.     }   
  189.     bool Finish[PN]={0,0,0,0,0};   
  190.     while(flag1)   
  191.     {   
  192.         bian=0;   
  193.         for(m=0;m<PN;m++)   
  194.         {   
  195.             flag2=true;   
  196.             if(!Finish[m])   
  197.             {   
  198.                 for(n=0;n<RN;n++)   
  199.                 {   
  200.                     if(Need[m][n]>Work[n])   
  201.                     {   
  202.                         flag2=0;   
  203.                         break;   
  204.                     }   
  205.                 }   
  206.                 if(flag2)   
  207.                 {   
  208.                     bian=1;   
  209.                     for(n=0;n<RN;n++)   
  210.                     {   
  211.                         Work[n]=Work[n]+Allocation[m][n];   
  212.                     }   
  213.                     printf("p%d/t",m);   
  214.                     Finish[m]=true;   
  215.                 }   
  216.             }   
  217.         }   
  218.         if(bian==0)   
  219.         {   
  220.             flag1=0;   
  221.         }   
  222.     }   
  223.     return 1;   
  224. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/javaadu/p/11742813.html