动态银行家算法c++代码

动态银行家算法是一种解决进程死锁的常见算法，它主要通过资源的分配和回收来避免死锁的发生。以下是一个简单的C++实现：

#include <iostream>
#include <vector>
using namespace std;

// 定义进程结构体
struct Process {
    int id;
    vector<int> allocation;  // 已分配资源数
    vector<int> need;  // 需求资源数
    bool finished;  // 是否完成
};

// 定义银行家类
class Banker {
public:
    Banker(vector<int> available, vector<Process> processes);
    bool isSafe();  // 判断当前状态是否安全
    bool requestResource(int pid, vector<int> request);  // 进程请求资源
private:
    vector<int> available;  // 可用资源数
    vector<Process> processes;  // 进程列表
};

Banker::Banker(vector<int> available, vector<Process> processes) {
    this->available = available;
    this->processes = processes;
    for (int i = 0; i < processes.size(); i++) {
        for (int j = 0; j < available.size(); j++) {
            processes[i].need.push_back(processes[i].allocation[j]);
        }
    }
}

bool Banker::isSafe() {
    vector<int> work = available;  // 可用资源数
    vector<bool> finish(processes.size(), false);  // 是否完成
    vector<int> sequence;  // 安全序列

    int count = 0;
    while (count < processes.size()) {
        bool found = false;
        for (int i = 0; i < processes.size(); i++) {
            if (!finish[i]) {
                bool enough = true;
                for (int j = 0; j < available.size(); j++) {
                    if (processes[i].need[j] > work[j]) {
                        enough = false;
                        break;
                    }
                }
                if (enough) {
                    for (int j = 0; j < available.size(); j++) {
                        work[j] += processes[i].allocation[j];
                    }
                    finish[i] = true;
                    sequence.push_back(i);
                    found = true;
                    count++;
                }
            }
        }
        if (!found) {
            return false;
        }
    }
    cout << "Safe sequence: ";
    for (int i = 0; i < sequence.size(); i++) {
        cout << "P" << sequence[i] << " ";
    }
    cout << endl;
    return true;
}

bool Banker::requestResource(int pid, vector<int> request) {
    Process& process = processes[pid];
    for (int i = 0; i < request.size(); i++) {
        if (request[i] > process.need[i]) {  // 请求资源数大于需求资源数
            return false;
        }
        if (request[i] > available[i]) {  // 请求资源数大于可用资源数
            return false;
        }
        process.allocation[i] += request[i];
        process.need[i] -= request[i];
        available[i] -= request[i];
    }
    return true;
}

int main() {
    vector<int> available = {3, 3, 2};  // 可用资源数
    vector<Process> processes = {{0, {0, 1, 0}, {}, false},
                                 {1, {2, 0, 0}, {}, false},
                                 {2, {3, 0, 2}, {}, false},
                                 {3, {2, 1, 1}, {}, false},
                                 {4, {0, 0, 2}, {}, false}};
    Banker banker(available, processes);

    banker.isSafe();
    banker.requestResource(1, {1, 0, 2});
    banker.isSafe();
    banker.requestResource(3, {0, 0, 1});
    banker.isSafe();

    return 0;
}

以上代码实现了银行家算法，其中包括进程结构体、银行家类以及主函数。通过调用Banker类的isSafe()函数，可以判断当前状态是否安全；通过调用requestResource()函数，可以模拟进程请求资源并判断是否能够成功分配。在主函数中，首先创建一个Banker对象，然后调用isSafe()函数进行判断，接着分别调用requestResource()函数模拟进程请求资源，并再次调用isSafe()函数进行判断。