操作系统 银行家算法（C++实现）

时间:2020-05-28
本文章向大家介绍操作系统 银行家算法（C++实现），主要包括操作系统 银行家算法（C++实现）使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

1. 系统安全状态

　　系统在进行资源分配之前，应先计算此次资源分配的安全性，即判断系统当前拥有的资源数，是否满足该进程目前所需要的资源数，若满足则将该进程运行完毕，并将在此之前分配给该进程的资源释放，然后继续推进，该推进顺序为安全序列；若无法满足，则称当前系统处于不安全状态。

2. 银行家算法中的数据结构

  • 可用资源向量Available。其中含有 m 个元素（m 即为资源种类），Available[ j ] 的值表示，当前资源 j 所拥有的个数。
  • 最大需求矩阵Max。这是一个n * m的矩阵（n 即为进程个数），Max[ i ][ j ] 的值表示，进程 i 对于 资源 j 的最大需求值。
  • 分配矩阵Allocation。这是一个n * m的矩阵，Allocation[ i ][ j ] 的值表示，当前系统对于进程 i 已分配资源 j 的个数。
  • 需求矩阵Need。这是一个n * m的矩阵，Need[ i ][ j ] 的值表示，当前进程 i 对于 资源 j 的需求个数。

上述三个矩阵满足如下关系：

　　　　　　　　Need[ i ][ j ] = Max[ i ][ j ] - Allocation[ i ][ j ]

3. 银行家算法

　　设 Requesti 是进程 Pi 的请求向量，如果 Requesti[ j ] = K, 表示进程 Pi 需要K个 Rj 类的资源。当 Pi 发出资源请求后，系统按下述步骤进行检查：

  1. 如果 Requesti[ j ]  <= Need[ i ][ j ] ,便转向步骤（2）；否则认为出错，因为它所需要的资源超过所宣布的最大值。
  2. 如果 Requesti[ j ]  <= Available[ j ]，便转向步骤（3）；否则，表示尚无足够资源，Pi需等待。
  3. 系统尝试着把资源分配给进程Pi，并修改下面数据结构中的数值：

　　　　　　Available[ j ] -= Requesti[ j ];

　　　　　　Allocation[ i ][ j ] += Requesti[ j ];

　　　　　　Need[ i ][ j ] -= Requesti[ j ];

　　 4. 系统执行安全性算法，检查此次资源分配后是否安全。若安全才正式将资源分配给进程 Pi，以完成本次分配；否则将此次请求视为作废，恢复原来分配状态，让 Pi 等待。

4. 代码实现

　　4.1 银行家算法之例

　

 　　4.2 安全性检验函数

 1 //安全性检验及输出安全序列
 2 vector<int> CountSafeOrder( vector<int> Ava, vector<vector<int> > Max, 
 3                 vector<vector<int> > All, vector<vector<int> > Need){
 4     int pro_number = Max.size();
 5     int res_number = Ava.size();
 6     vector<bool> Finish(pro_number,false);
 7     vector<int> SafeOrder;
 8     vector<int> temp;
 9     vector<vector<int> >work(pro_number,temp);
10     
11     queue<int> q;
12     int count = 0; //用来记录循环是否超过次数；
13     for(int i = 0; i < pro_number; i ++)
14         q.push(i);
15     while( !q.empty() ){
16         int num = q.front();
17         bool arg = true; 
18         q.pop(); count ++;
19         //判断当前可用资源是否大于需求
20         for(int j = 0; j < res_number ; j ++){
21             if(Ava[j] < Need[num][j] ){
22                 q.push(num); arg = false; break; 
23             }
24         }
25         //将当前可用资源增加，并记录工作向量
26         if( arg ){
27             for(int j = 0; j < res_number && arg; j ++){
28                 work[num].push_back(Ava[j]);
29                 Ava[j] += All[num][j];
30             }
31             SafeOrder.push_back(num);
32             count = 0;
33         }
34         //如果循环次数超时，则跳出循环
35         if( count > q.size())
36             break;
37     }
38     return SafeOrder;           
39 }

　　4.3 资源请求函数

 1 void RequestRes(vector<int> &Ava, vector<vector<int> > &All, 
 2                         vector<vector<int> > &Need, vector<vector<int> >Request, int num){
 3     int res_number = Ava.size();
 4     bool arg = true;
 5     // 判断请求的资源是否满足条件
 6     for(int i = 0; i < res_number; i ++ ){
 7         if(Request[num][i] > Need[num][i] || Request[num][i] > Ava[i] ){
 8             cout << "需求过大，无法满足请等待！\n"; arg = false; break;
 9         }    
10     }
11     // 若满足条件，则修改向量值
12     if( arg ){
13         for(int i = 0; i < res_number; i ++){
14             Ava[i] -= Request[num][i];
15             Need[num][i] -= Request[num][i];
16             All[num][i] += Request[num][i];
17         }
18     }
19 }

原文地址：https://www.cnblogs.com/john1015/p/12980235.html

随机文章
本站知识点必读
最近更新