银行家算法：避免死锁的资源分配算法[cpp]

最新推荐文章于 2024-01-07 21:59:02 发布

xl拾一

最新推荐文章于 2024-01-07 21:59:02 发布

阅读量1.1k

点赞数

分类专栏：基础文章标签： c++ 算法

本文链接：https://blog.csdn.net/qq_31854267/article/details/131123342

版权

基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

银行家算法：避免死锁的资源分配算法[cpp]

介绍

在多进程环境中，资源的合理分配和管理对系统的正常运行至关重要。然而，不当的资源分配可能会导致死锁，即进程无法继续执行并永久阻塞。为了避免死锁的发生，银行家算法应运而生。本文将介绍银行家算法的基本原理，并提供一个简单的 C++ 实现示例。

死锁与资源分配问题

在操作系统中，多个进程竞争有限的资源，例如内存、文件、打印机等。当一个进程获取了一部分资源并等待其他进程释放资源时，可能会发生死锁。死锁是指系统中的进程无法继续执行，因为它们所需的资源被其他进程占用，而其他进程也在等待被占用的资源。这种情况下，系统无法进行进一步的资源分配，导致进程无法完成。

银行家算法原理

银行家算法是一种资源分配算法，旨在避免系统进入死锁状态。它通过安全性检查来判断在给定的资源分配下，系统是否处于安全状态。银行家算法基于以下几个关键概念：

可用资源向量：表示系统中每个资源的可用数量。
最大需求矩阵：表示每个进程对各个资源的最大需求量。
已分配矩阵：表示每个进程已经分配到的资源数量。
需求矩阵：表示每个进程尚需的资源数量。

银行家算法实现

下面是一个简单的使用 C++ 实现的银行家算法示例。它接受可用资源向量、最大需求矩阵和已分配矩阵作为输入，并判断系统是否处于安全状态。

#include <iostream>

const int MAX_PROCESSES = 5;
const int MAX_RESOURCES = 3;

bool isSafeState(int available[], int max_demand[][MAX_RESOURCES], int allocated[][MAX_RESOURCES], int safe_sequence[]) {
    int num_processes = MAX_PROCESSES;
    int num_resources = MAX_RESOURCES;

    int need[MAX_PROCESSES][MAX_RESOURCES];
    bool finish[MAX_PROCESSES] = {false};
    int work[MAX_RESOURCES];

    // Calculate the need matrix
    for (int i = 0; i < num_processes; i++) {
        for (int j = 0; j < num_resources; j++) {
            need[i][j] = max_demand[i][j] - allocated[i][j];
        }
    }

    // Initialize work array
    for (int j = 0; j < num_resources; j++) {
        work[j] = available[j];
    }

    // Find a process that can be executed
    int count = 0;
    while (count < num_processes) {
        bool found = false;
        for (int i = 0; i < num_processes; i++) {
            if (!finish[i]) {
                bool canExecute = true;
                for (int j = 0; j < num_resources; j++) {
                    if (need[i][j] > work[j]) {
                        canExecute = false;
                        break;
                    }
                }
                if (canExecute) {
                    // Allocate resources to the process
                    for (int j = 0; j < num_resources; j++) {
                        work[j] += allocated[i][j];
                    }

                    // Mark the process as finished
                    finish[i] = true;
                    found = true;
                    count++;
                    // Add the process to the safe sequence
                    safe_sequence[count - 1] = i;

                    break;
                }
            }
        }
        if (!found) {
            break;
        }
    }

    // Check if all processes are finished
    return count == num_processes;
}

int main() {
    int available_resources[] = {3, 3, 2};
    int maximum_demand[][MAX_RESOURCES] = {{7, 5, 3},
                                           {3, 2, 2},
                                           {9, 0, 2},
                                           {2, 2, 2},
                                           {4, 3, 3}};
    int allocated_resources[][MAX_RESOURCES] = {{0, 1, 0},
                                                {2, 0, 0},
                                                {3, 0, 2},
                                                {2, 1, 1},
                                                {0, 0, 2}};

    int safe_sequence[MAX_PROCESSES];
    bool isSafe = isSafeState(available_resources, maximum_demand, allocated_resources, safe_sequence);
    if (isSafe) {
        std::cout << "System is in a safe state." << std::endl;
        std::cout << "Safe sequence: ";
        for (int i = 0; i < MAX_PROCESSES; i++) {
            std::cout << "P" << safe_sequence[i] << " ";
        }
        std::cout << std::endl;
    } else {
        std::cout << "System is in an unsafe state." << std::endl;
    }

    return 0;
}

示例和演示

为了更好地理解银行家算法的工作原理，让我们通过一个具体的示例来演示它的运行过程。

假设有5个进程（P0-P4）和3种不同的资源（R0-R2）。给定的可用资源向量为{3, 3, 2}，最大需求矩阵和已分配矩阵如下：

最大需求矩阵：

已分配矩阵：

我们将使用上述示例数据来运行银行家算法，并观察系统的安全性。

Resources allocated to P1: 2 0 0 
Resource needs for P1: 1 2 2 
Current available resources: 3 3 2 
Available resources after allocation: 5 3 2 

Resources allocated to P3: 2 1 1 
Resource needs for P3: 0 1 1 
Current available resources: 5 3 2 
Available resources after allocation: 7 4 3 

Resources allocated to P0: 0 1 0 
Resource needs for P0: 7 4 3 
Current available resources: 7 4 3 
Available resources after allocation: 7 5 3 

Resources allocated to P2: 3 0 2 
Resource needs for P2: 6 0 0 
Current available resources: 7 5 3 
Available resources after allocation: 10 5 5 

Resources allocated to P4: 0 0 2 
Resource needs for P4: 4 3 1 
Current available resources: 10 5 5 
Available resources after allocation: 10 5 7 

System is in a safe state.
Safe sequence: P1 P3 P0 P2 P4

随机生成数据

#include <iostream>
#include <cstdlib>
#include <ctime>

const int num_processes = 5;
const int num_resources = 3;

bool isSafeState(int available[], int max_demand[][num_resources], int allocated[][num_resources], int safe_sequence[]) {
    int need[num_processes][num_resources];
    int work[num_resources];
    bool finish[num_processes] = { false };

    // Calculate the need matrix
    for (int i = 0; i < num_processes; i++) {
        for (int j = 0; j < num_resources; j++) {
            need[i][j] = max_demand[i][j] - allocated[i][j];
        }
    }

    // Initialize work array
    for (int j = 0; j < num_resources; j++) {
        work[j] = available[j];
    }

    // Find a process that can be executed
    int count = 0;
    while (count < num_processes) {
        bool found = false;
        for (int i = 0; i < num_processes; i++) {
            if (!finish[i]) {
                bool canExecute = true;
                for (int j = 0; j < num_resources; j++) {
                    if (need[i][j] > work[j]) {
                        canExecute = false;
                        break;
                    }
                }
                if (canExecute) {
                    // Allocate resources to the process
                    for (int j = 0; j < num_resources; j++) {
                        work[j] += allocated[i][j];
                    }
                    finish[i] = true;
                    found = true;
                    count++;
                    safe_sequence[count - 1] = i;
                    break;
                }
            }
        }
        if (!found) {
            break;
        }
    }

    // Check if all processes are finished
    return count == num_processes;
}

int main() {
    // Initialize random seed
    std::srand(static_cast<unsigned int>(std::time(0)));

    int available_resources[num_resources];
    int maximum_demand[num_processes][num_resources];
    int allocated_resources[num_processes][num_resources];

    // Generate random values for available resources
    for (int j = 0; j < num_resources; j++) {
        available_resources[j] = std::rand() % 10 + 1;
    }

    // Generate random values for maximum demand and allocated resources
    for (int i = 0; i < num_processes; i++) {
        for (int j = 0; j < num_resources; j++) {
            maximum_demand[i][j] = std::rand() % available_resources[j] + 1;
            allocated_resources[i][j] = std::rand() % (maximum_demand[i][j] + 1);
        }
    }

    // Print the randomly generated values
    std::cout << "Number of processes: " << num_processes << std::endl;
    std::cout << "Number of resources: " << num_resources << std::endl;
    std::cout << "Available resources: ";
    for (int j = 0; j < num_resources; j++) {
        std::cout << available_resources[j] << " ";
    }
    std::cout << std::endl;

    std::cout << "Maximum demand matrix:" << std::endl;
    for (int i = 0; i < num_processes; i++) {
        for (int j = 0; j < num_resources; j++) {
            std::cout << maximum_demand[i][j] << " ";
        }
        std::cout << std::endl;
    }

    std::cout << "Allocated resources matrix:" << std::endl;
    for (int i = 0; i < num_processes; i++) {
        for (int j = 0; j < num_resources; j++) {
            std::cout << allocated_resources[i][j] << " ";
        }
        std::cout << std::endl;
    }

    int safe_sequence[num_processes];

    // Check if the system is in a safe state
    bool is_safe = isSafeState(available_resources, maximum_demand, allocated_resources, safe_sequence);

    // Print the safe sequence if it exists
    if (is_safe) {
        std::cout << "System is in a safe state. Safe sequence: ";
        for (int i = 0; i < num_processes; i++) {
            std::cout << safe_sequence[i] << " ";
        }
        std::cout << std::endl;
    } else {
        std::cout << "System is not in a safe state." << std::endl;
    }

    return 0;
}

测试结果：1

Number of processes: 5
Number of resources: 3
Available resources: 7 8 6 
Maximum demand matrix:
7 1 2 
4 2 3 
1 4 1 
4 1 5 
6 6 2 
Allocated resources matrix:
2 0 0 
4 1 2 
1 2 1 
0 1 1 
4 2 2 
System is in a safe state. Safe sequence: 0 1 2 3 4

测试结果：2

Number of processes: 5
Number of resources: 3
Available resources: 3 4 3 
Maximum demand matrix:
4 4 5 
3 4 4 
3 4 5 
5 6 4 
3 6 5 
Allocated resources matrix:
3 1 0 
0 3 2 
3 2 0 
0 2 1 
1 0 3 
System is in a safe state. Safe sequence: 1 0 2 3 4

测试结果：3

Number of processes: 5
Number of resources: 3
Available resources: 3 4 3 
Maximum demand matrix:
9 8 8 
10 11 9 
9 9 9 
10 10 9 
8 9 8 
Allocated resources matrix:
4 0 1 
7 2 4 
8 4 2 
7 10 2 
4 9 1 
System is not in a safe state.