操作系统课程设计-银行家算法-CSDN博客

本文链接：https://blog.csdn.net/m0_56369309/article/details/148129788

1、算法原理分析

银行家算法自然语言描述：
设 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］=Available［j］-Requesti［j］;
Allocation［i,j］=Allocation［i,j］+Requesti［j］;
Need［i,j］=Need［i,j］-Requesti［j］;
(4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式
将资源分配给进程 Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的
资源分配状态，让进程 Pi 等待。

安全性算法自然语言描述：
(1) 设置两个向量：

① 工作向量 Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有 m 个元素，在执行安全算法开始时，Work∶=Available;

② Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做 Finish［i］=false; 当有足够资源分配给进程时，再令 Finish［i］∶=true。
(2) 从进程集合中找到一个能满足下述条件的进程：
① Finish［i］=false;

② Need［i,j］≤Work［j］；若找到，执行步骤(3)，否则，执行
步骤(4)
(3) 当进程 Pi 获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work［j］∶ ［i］+Allocation［i,j］
Finish［i］∶=true
go to step (2);
(4) 如果所有进程的 Finish［i］=true 都满足，则表示系统处于安全状态；否则，系统处于
不安全状态。

2、课设要求

假定系统中有五个进程｛P0, P1, P2, P3, P4｝和三类资源｛A, B, C｝，各种资源的数量分别为 10、5、7，在 T0 时刻的资源分配情况下图所示。

回答如下问题：

(1)判断 T0 时刻是否安全？

(2) P1 请求资源：P1 发出请求向量 Request1(1，0，2)，调用银行家算法检查是否能够分配?

(3) P4 请求资源：P4 发出请求向量 Request4(3，3，0)，系统按银行家算法进行检查

(4) P0 请求资源：P0 发出请求向量 Requst0(0，2，0)，系统按银行家算法进行检查

(5) 若 P0 发出请求向量 Requst0(0，1，0)，系统是否将资源分配给它？

3、实现功能

系统使用银行家算法（Banker's Algorithm）来判断系统的安全性，并通过递归的方式生成安全序列。程序主要由以下几个模块组成：

1、初始化模块：用户输入资源总量、每个进程对资源的最大需求、进程已分配的资源数量。计算每个进程的资源需求矩阵（Need），以及更新可用资源矩阵（Available）。

2、资源请求与分配模块：当某个进程请求资源时，首先检查该进程请求的资源是否满足其最大需求以及当前系统是否有足够的可用资源。如果满足条件，临时分配资源，并通过银行家算法判断系统状态是否安全。如果系统处于安全状态，则正式分配资源；否则，撤销资源分配，保持系统的稳定性。

3、安全性判断模块：利用银行家算法检查当前资源分配状态是否安全。如果安全，则生成一个安全序列，按顺序输出各进程的执行顺序。安全性判断依赖于一个递归函数isfinish，该函数会尝试为每个进程分配资源，并检查系统是否能最终达到一个安全状态。

4、状态输出模块：输出当前的资源分配状态，包括每个进程的最大需求、已分配资源、剩余需求和当前可用资源。输出安全序列，展示系统是否处于安全状态。

4、数据结构设计

1、资源数组：

Resource[M]：存储每种资源的总量（M种资源）。

Available[M]：存储每种资源的当前可用数量。

2、矩阵结构：

Max[N][M]：存储每个进程对每种资源的最大需求量（N个进程，每个进程有M种资源需求）。

Allocation[N][M]：存储每个进程已经分配的资源数量。

Need[N][M]：存储每个进程剩余需求的资源数量（即Need[i][j] = Max[i][j] - Allocation[i][j]）。

3、辅助数组：

Finish[N]：标记每个进程是否已经完成（完成即资源已释放，可以继续进行其他进程）。

Work[M]：存储当前可用的资源数量。

List[N]：存储安全序列（即进程的执行顺序）。

4、递归计数：

rec：用于记录递归的深度，辅助生成安全序列。

5、核心代码

初始化状态

void initial()// 创建初始状态：先输入 Resource 、Max 和 和 Allocation ，再计算出 Need 、Available 。
{
printf("Resourse--输入M种资源数量：\n");
int i,j;
for (i=0;i<3;i++){
scanf("%d",&Resource[i]);
Available[i] = Resource[i];
}
printf("Max--输入N个进程分别对M种资源的最大需求量：\n");
for (i=0;i<N;i++)
for (j=0;j<M;j++)
scanf("%d",&Max[i][j]);
printf("Allocation--输入N个进程获得M种资源的数量：\n");
for (i=0;i<N;i++)
for (j=0;j<M;j++){
scanf("%d",&Allocation[i][j]);
Available[j] = Available[j]-Allocation[i][j];
Need[i][j] = Max[i][j]-Allocation[i][j];
}
    for (i=0;i<5;i++)
        List[i] = 0;
    for (i=0;i<3;i++)
        Work[i] = Available[i];
}

输出安全序列

void printList()
// 输出安全序列表|Process |Work |Need |Allocation |Work+Alloc |Finish |
{
    int i;

    printf("安全序列如下：\n");
    printf("|%-8s     |%-8s                |%-8s                |%-8s              |%-8s              |%-8s\n","Process","Work",
           "Need","Allocation","Work+Alloc","Finish");
    for (i=0;i<5;i++){
        if (i==0)
            printf("|P%-12d|%-8d%-8d%-8d|%-8d%-8d%-8d|%-8d%-8d%-8d|%-8d%-8d%-8d%-8s\n",List[i],Available[0],
                   Available[1],Available[2],Need[List[i]][0],Need[List[i]][1],Need[List[i]][2],Allocation[List[i]][0],Allocation[List[i]][1],
                   Allocation[List[i]][2],wa[List[i]][0],wa[List[i]][1],wa[List[i]][2],"|true");
        else
            printf("|P%-12d|%-8d%-8d%-8d|%-8d%-8d%-8d|%-8d%-8d%-8d|%-8d%-8d%-8d%s\n",List[i],wa[List[i-1]][0],wa[List[i-1]][1],wa[List[i-1]][2],Need[List[i]][0],
                   Need[List[i]][1],Need[List[i]][2],Allocation[List[i]][0],Allocation[List[i]][1],
                   Allocation[List[i]][2],wa[List[i]][0],wa[List[i]][1],wa[List[i]][2],"|true");
    }
}