操作系统实验（三）——银行家算法

一个班（20信安）的同学搜到这篇别直接copy我的，代码仅供参考

一、银行家算法

代码

#include <cstdlib>
#include <windows.h>
#include <tchar.h>
#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
const int n = 5;//进程数
const int m = 3;//资源数
int resources[m] = {10, 5, 7};// 存储系统中资源数 
int request[m]; // 请求向量
int request_num; // 请求进程号
struct pro{
    int max[n][m]={{7, 5, 3},// n个进程最大需要资源总数
                   {3, 2, 2},
                   {9, 0, 2},
                   {2, 2, 2},
                   {4, 3, 3}}; 
    int alloc[n][m]={{0, 1, 0}, // n个进程t0时刻（初始化）下已分配资源总数
                     {2, 0, 0},
                     {3, 0, 2},
                     {2, 1, 1},
                     {0, 0, 2}}; // n个进程t0时刻（初始化）下还需要分配资源总数
    int need[n][m]={{7, 4, 3},
                    {1, 2, 2},
                    {6, 0, 0},
                    {0, 1, 1},
                    {4, 3, 1}};

    int available[m] = {2, 3, 0};
};  

// 生成进程空间bank
pro bank;

// 获得进程请求向量
void request_input(){
    // 获取request
    cout << "请输入请求资源的进程号:";
    cin >> request_num;
    cout << "输入进程" << request_num << "需要请求的资源:";
    for(int i = 0; i < m; i++){
        cin >> request[i];
    }
    
    // 计算available
    for(int i=0; i<m; i++)
    {   
        int sumi = 0;
        // 第i种资源已分配量 sumi 计算
        for(int j=0; j<n; j++)
        {
            sumi += bank.alloc[j][i];
        }
        bank.available[i] = resources[i] - sumi;
    }

    // // 计算need
    // for(int i = 0; i < n; i++){
    //     for(int j = 0; j < m; j++){
    //         bank.need[i][j] = bank.max[i][j] - bank.alloc[i][j];
    //     }
    // }
}

// 银行家检查算法
bool test_bank()
{
    cout << "进行银行家算法检查" << endl;
    for(int j=0; j<m; j++)
    {
        if(request[j] > bank.need[request_num][j])
        {
            cout << "request超出进程的need,银行家检查失败" << endl;
            return false;
        } 
        if(request[j] > bank.available[j])
        {
            cout << "request超出系统的available,银行家检查失败" << endl;
            return false;
        }  
    }
    cout << "请求通过银行家算法" << endl;
    return true;
}

// 安全性检查
bool test_safe(){
    // 先进行银行家算法
    if(!test_bank()) return false;

    // 再进行安全性检查算法
    cout << "进行安全性检查算法" << endl;
    int Work[m];

    // 取t0时刻的available
    for(int i = 0; i < m; i++)
        Work[i] = bank.available[i];
    
    vector<int> flags;
    while(true)
    {
        int temp = flags.size();
        for(int i = 0; i < n; i++)
        {
            if(count(flags.begin(), flags.end(), i) > 0)
            {
                continue;
            }
            // 判断是否满足进程i的need向量
            bool flag = true;
            for(int j = 0; j < m; j++)
            {
                if(bank.need[i][j] <= Work[j]){
                    continue;
                }
                else{
                    flag = false;
                    break;
                }
            }
            // 
            if(flag){
                //该进程满足条件
                flags.push_back(i); // 将进程加入到安全序列
                cout << "释放:" << i << endl; 
                for(int j = 0; j < m; j++){
                    //进程运行完后释放资源
                   Work[j] += bank.alloc[i][j];
                }
            }
        }
        // 所有进程检测完need后，检测flags长度是否更改
        if(flags.size() == temp) {
            // 长度不改，说明不是死锁就是安全序列找到了
            if(flags.size() == n){
                // 安全序列找到了
                cout << "经过安全性检查，安全序列为:";
                for(int i=0; i<flags.size(); i++)
                {
                    cout << flags[i] << "->";
                }
                cout << "over" << endl;

                // 更改进程的need，alloc和系统的available
                for(int k=0; k<m; k++)
                {
                    bank.alloc[request_num][k] += request[k];
                    bank.need[request_num][k] = max(0, bank.need[request_num][k] - request[k]);
                    bank.available[k] -= request[k];
                }
                return true;
            }
            else{
                // 死锁了
                cout << "未经过安全性检查，死锁" << endl;
                return false;
            }
            break;
        }
    }
}

int main(){
    request_input();
    // test_bank();
    test_safe();
    request_input();
    test_safe();
    request_input();
    test_safe();
}

运行截图

二、小结

1、每一次进程的资源请求，都需要经历一次银行家算法和安全性检查算法，否则系统不会分配给进程所要的request资源
2、除主函数外，定义了3个函数，分别是请求输入函数request_input，银行家算法test_bank以及安全性检查算法test_safe。
3、安全性算法执行前提是进程的请求经过了银行家算法的考验，因此安全性检查算法内调用了银行家算法作为执行前提
4、代码的初始化就是t0时刻的系统分配，因为要实现三个请求，因此调用了3次请求输入函数和三次安全性检查算法（这里安全性检查算法内调用了银行家算法作为执行前提）