操作系统-银行家算法

一、实验目的

理解银行家算法的原理和应用；
掌握死锁检测和资源分配的方法。

二、实验环境

系统：Windows 11
开发工具：Eclipse IDE
编程语言：Java

三、实验步骤

（1）从命令行输入进程数量、系统资源数量、以及每个进程对每种资源的需求和已经分配的资源数量。

（2）根据输入的数据初始化系统资源和进程信息。

（3）执行安全检查，获取到需要分配资源的进程。

（4）将资源分配给进程，并更新系统资源状态。

（5）回收进程使用的资源，并更新系统资源状态。

（6）重复3-5步骤，直到所有进程都已经结束。

import java.util.Scanner;
 
public class BankerAlgorithm {
    public static void main (String[] args) {
        
        Scanner scan = new Scanner(System.in);
        int n; // 进程数量
        int m; // 资源数量
 
        System.out.println("请输入进程的数量：");
        n = scan.nextInt();
        System.out.println("请输入资源的数量：");
        m = scan.nextInt();
 
        int[][] max = new int[n][m]; // 最大需求矩阵
        int[][] allocation = new int[n][m]; // 已分配矩阵
        int[][] need = new int[n][m]; // 还需要矩阵
        int[] available = new int[m]; // 可用资源向量
 
        // 读入最大需求矩阵
        System.out.println("请输入最大需求矩阵：");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                max[i][j] = scan.nextInt();
            }
        }
 
        // 读入已分配矩阵
        System.out.println("请输入已分配矩阵：");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                allocation[i][j] = scan.nextInt();
                need[i][j] = max[i][j] - allocation[i][j];
                System.out.print( need[i][j] );
            }
            
            System.out.println("\n");
            System.out.println(" 上述是执行进程"+i+"还需要的资源数量");
       
        }
        // 读入可用资源向量
        System.out.println("请输入总共可用的资源向量：");
        for (int i = 0; i < m; i++) {
            available[i] = scan.nextInt();
        }
 
        // 执行银行家算法
        int[] work = available.clone(); // 工作向量
        boolean[] finish = new boolean[n]; // 是否可以完成向量
        int[] safeSeq = new int[n]; // 安全序列
 
        int count = 0; // 统计已完成进程数
 
        while (count < n) {
            boolean find = false;
            for (int i = 0; i < n; i++) {
                if (!finish[i]) {
                    boolean canFinish = true;
                    for (int j = 0; j < m; j++) {
                        if (need[i][j] > work[j]) {
                            canFinish = false;
                            break;
                        }
                    }
                    if (canFinish) {
                        for (int j = 0; j < m; j++) {
                            work[j] += allocation[i][j];
                        }
                        finish[i] = true;
                        safeSeq[count] = i;
                        count++;
                        find = true;
                    }
                }
            }
            if (!find) {
                System.out.println("系统不安全");
                break;
            }
        }
        
        if (count == n) {
            System.out.print("系统安全，安全序列为：");
            for (int i = 0; i < n; i++) {
                System.out.print("P" + safeSeq[i]);
                if (i != n-1) {
                    System.out.print(" --> ");
                }
            }
        }
    }
}

四、实验结论

银行家算法是一种用于管理和分配计算机系统资源的算法。它主要用于避免死锁、确定可用资源并确保安全地将资源分配给进程。
银行家算法基于如下假设：每个进程在开始执行之前必须向系统声明其需要的最大资源数量，以及在任何时候已经分配给它们的资源数量。系统必须知道关于每种资源的总量，并能够判断当所有进程都请求其最大资源数量时，系统是否处于安全状态。

为了实现这些，银行家算法采用了一个数据结构，即资源分配表。该表包括三个部分：
1、已分配资源矩阵（Allocation）：将进程和它们所需的资源相对应
2、最大需求矩阵（Max）：定义每个进程需要的最大资源
3、可利用资源向量（Available）：系统中尚未分配给任何进程的资源 银行家算法的主要目标是分配资源以满足所有进程的需求并避免死锁。

银行家算法需要完成以下步骤：
1、计算进程当前需要的资源数（Need）：Need[i][j] = Max[i][j] -
Allocation[i][j]
2、检查当前状态是否安全并有无可利用的资源进行分配。
3、若不安全，则暂时拒绝进程的请求并等待资源可用。
4、若安全，则为进程分配它需要的资源，并将其从Available中减去。

银行家算法可以防止死锁。当在系统中向某个进程分配资源会导致系统状态不安全时，进程会被阻塞，直到其他进程释放资源以使系统状态变得安全。
银行家算法应用于各种计算机系统，包括操作系统、服务器、数据库管理系统、Web应用程序，以确保它们的可用性和稳定性。除此之外，在嵌入式系统和网络通信中也经常使用银行家算法来优化效率和避免死锁。

银行家算法中的死锁检测是通过安全性算法来实现的。该算法可以检测系统在当前状态下是否存在死锁，并根据检测结果决定是否能够为请求资源的进程分配资源。

安全性算法的基本思想是尝试对当前各个进程进行资源分配，以判断系统是否能够在不发

生死锁的情况下满足所有进程的资源需求。具体分为以下几个步骤：

1、对于未完成的进程，生成它们所需要的全部资源向量以及已经分配给它们的资源向量。
2、找到一个未完成的进程，需要数量小于等于当前可用资源数，且其所需资源向量与当前可用资源向量之和也小于等于系统总资源数的进程。
3、将这个进程所需资源分配给它，并根据这个进程释放掉的资源更新当前可用资源数。
4、重复执行第二步和第三步，直到所有未完成进程都被处理完成。
5、如果所有进程都能够得到所需资源，则当前状态是安全的；否则，当前状态是不安全的。
安全性算法的核心是对未完成进程的遍历和资源判断，可以有效地检测出系统发生死锁的情况，并做出正确的处理。

需要注意的是，安全性算法只是检测当前状态下是否存在死锁，但不能保证系统一定不会在未来的某个时刻发生死锁。因此，在实际应用中，需要针对具体情况设计合适的死锁预防策略，以确保系统稳定可靠地运行。

银行家算法是一种资源管理算法，其资源分配方法如下：

1. 初始化系统状态：在系统启动时，需要记录每种资源的总数、每个进程已经占用的资源情况以及每个进程还需要的资源数量。
2. 进程请求资源：当一个进程请求更多的资源时，银行家算法首先检查此次请求是否合法。如果此次请求的资源量超过了系统中未使用的资源总和，那么该请求将被拒绝；否则向下执行第三步。
3. 执行安全性检查：为了确保系统不会陷入死锁，银行家算法会根据现有的资源配置和还需的资源量计算出系统是否处于安全状态。若发现当前状态不安全，则无法为申请资源的进程分配资源；否则，可以向下执行第四步。
4. 分配资源：将请求的资源分配给相应的进程，同时更新系统中资源的数量和每个进程的资源占用信息。
5. 检查进程是否完成：在分配完资源后，必须检查进程是否已经完成任务，如果是，则需要回收已分配给进程的资源，并释放进程所占用的所有系统资源。
6. 重复执行上述过程：循环执行以上过程，直到所有进程都已经成功完成任务或者某些进程因为请求资源无法满足而终止。
   通过对系统状态的动态更新和安全性检查，银行家算法可以有效控制资源分配，避免死锁问题的发生。

Need=总资源-已经分配的资源
可用的=总资源-max Work=可用的
进程完成后，finsh标为1