银行家算法(模拟)

        银行家算法是一种避免死锁的有效算法,它借鉴了银行家贷款的策略。在分配资源之前,银行家会检查系统是否有足够的资源满足进程的最大需求,若有,则暂时分配资源,然后继续检查剩余资源是否足够满足其他进程的最大需求。只有当所有进程的需求都能得到满足时,才进行资源分配。

代码实现:

#include<stdio.h>
void menu(){
    printf("--------------------------------------------\n");
    printf("-----            银行家算法            -----\n");
    printf("----- 1.判断当前是否安全,输出安全序列 -----\n");
    printf("----- 2.提出新的请求,并判断是否安全 -------\n");
    printf("----- 0.退出进程调度 -----------------------\n");
    printf("--------------------------------------------\n");
}
//将当前系统分配信息打印
void print(int allocation[5][4],int need[5][4],int available[4]){
    int i,j;
    printf("allocation:\n");
    for(i=0;i<5;i++){
        printf("P%d|",i);
        for(j=0;j<4;j++){
            printf(" %d ",allocation[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    printf("need:\n");
    for(i=0;i<5;i++){
        printf("P%d|",i);
        for(j=0;j<4;j++){
            printf(" %d ",need[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    printf("available:\n");
    for(i=0;i<4;i++){
        printf(" %d",available[i]);
    }
    printf("\n");
}
//安全性检测算法
void safe(int work[4],int allocation[5][4],int need[5][4],int finish[5])
{
    int link[5]={0};//用来存放安全序列
    int i,j,k,m=0,n=5;
    int count;
    while(n--)   //有五个进程,有5次从进程编号0开始找的机会
    {
        for(i=0;i<5;i++)
        {
            if(finish[i]==0)  //未完成进程i
            {
                count=0;
                for(j=0;j<4;j++)  //对进程i提出的资源请求和可用资源进行比较
                {
                    if(need[i][j]<=work[j]&&finish[i]==0)
                    {
                        count++;
                    }
                }
               /*当count==4时,说明当前进程需要的每一项资源都小于等于可用资源,
                可使得该进程完成工作并释放资源*/
                if(count==4)
                {
                    for(k=0;k<4;k++)
                    {
                        work[k]+=allocation[i][k];   //该进程还回之前已分配的资源
                    }
                    link[m++]=i;  //将这个进程加入到安全序列中
                    finish[i]=1; //并将它的完成与否标记为1,代表已经完成
                }
            }
        }
    }
    //如果m==5,说明所有进程号都被存入link数组中,存在一个安全序列
    if(m==5)
    {
        printf("该状态安全,安全序列是:");
        for(i=0;i<m;i++)
        {
            printf("P%d ",link[i]);
        }
        printf("\n");
    }
    else
    {
        printf("该状态不安全!\n");
    }
}
//银行家算法(判断当前是否安全;或某进程提出新的申请后判断是否安全)
void judge_apply(int input){
    int i=0,j=0;
    int count1=0;
    int count2=0;
    //根据题目设置好初始值
    int allocation[5][4]={{0,0,3,2},
                         {1,0,0,0},
                         {1,3,5,4},
                         {0,3,3,2},
                         {0,0,1,4}};
    //进程有5个,资源有4种
    int need[5][4]={{0,0,1,2},
                    {1,7,5,0},
                    {2,3,5,6},
                    {1,6,5,2},
                    {0,6,5,6}};
    //各项资源的可用数量
    int available[4]={1,6,2,2};
    int finish[5]={0}; //是否该进程已完成,0未完成,1已完成
    int request[4]={0};
    //打印当前系统资源分配情况
    print(allocation, need,available);
    //根据用户的选择来执行
    if(input==1){
        //判断当前状态是否安全
        //直接调用安全性算法
        safe(available,allocation,need,finish);
    }
    else{
        //某进程提出请求后是否可以满足
        printf("提出请求的进程是:");
        scanf("%d",&i);
        while(1){
            if(i<0||i>4){
                printf("进程号错误,请重新输入:");
                scanf("%d",&i);
            }
            else
                break;
        }
        printf("请求的资源数分别是:");
        for(j=0;j<4;j++){
            scanf("%d",&request[j]);
        }
        //判断申请的资源数是否大于需要的资源数,大于说明错误
        for(j=0;j<4;j++){
            if(request[j]<=need[i][j]){
                count1++;
            }
        }
        if(count1==4){
            for(j=0;j<4;j++){
                //判断当前可用资源是否大于申请资源
                if(request[j]<=available[j]){
                    count2++;
                }
            }
            if(count2==4){
                //有足够的可用资源,进行预分配,调用安全性检测算法
                for(j=0;j<4;j++){
                    available[j]-=request[j];
                    allocation[i][j]+=request[j];
                    need[i][j]-=request[j];
                }
                safe(available,allocation,need,finish);
            }
            else{
                printf("当前系统可用资源少于申请资源,不能分配,需要等待!!!\n");
            }
        }
        else{
            printf("进程申请资源大于其需要资源,出错了!!!\n");
            return ;
        }
    }
}
void test() {
    int input = 0;
    do {
        menu();
        printf("请选择:->");
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            judge_apply(input);
            break;
        case 2:
            judge_apply(input);
            break;
        case 0:
            printf("已退出银行家算法\n");
            break;
        default:
            printf("输入有误,请重新输入!\n");
            break;
        }
    } while (input);
}
int main(){
    test();
    return 0;
}

资源分布图:

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0

0  0  3  2

0  0  1  2

1  6  2  2

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

银行家算法的安全验证序列 :

验证步骤:

步骤1:P0

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

1  6  5  4

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

步骤2 P3

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

1  9  8  6

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3(finish)

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

步骤3:P4

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

1  9  1  10

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3(finish)

0  3  3  2

1  6  5  2

P4(finish)

0  0  1  4

0  6  5  6

步骤4:P1

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

2  9  1  10

P1(finish)

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3(finish)

0  3  3  2

1  6  5  2

P4(finish)

0  0  1  4

0  6  5  6

步骤5:P2

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

3  12  6  14

P1(finish)

1  0  0  0

1  7  5  0

P2(finish)

1  3  5  4

2  3  5  6

P3(finish)

0  3  3  2

1  6  5  2

P4(finish)

0  0  1  4

0  6  5  6

新的请求(超出目前Need的情况)请求不安全

新的请求(超出目前Available的情况)请求不安全。

提出新的请求(P1 request [1 0 0 0]),请求不安全

资源分配步骤:

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0

0  0  3  2

0  0  1  2

1  6  2  2

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

步骤1:P1请求1 0 0 0,小于need值符合请求

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0

0  0  3  2

0  0  1  2

1  6  2  2

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

步骤2:允许完成,将请求分配给P1

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0

0  0  3  2

0  0  1  2

0  6  2  2

P1

2  0  0  0

0  7  5  0

P2

1  3  5  4

2  3  5  6

P3

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

步骤3:进行匹配,P0符合要求

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0

0  0  3  2

0  0  1  2

0  6  2  2

P1

2  0  0  0

0  7  5  0

P2

1  3  5  4

2  3  5  6

P3

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

步骤4:分配,返还

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

0  6  5  4

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

步骤5:剩下的P1 P2 P3 P4不满足分配条件,原因是availble资源不足

​​​​​​​提出新的请求(P3 request [1 5 1 0]),请求安全:

资源分配图:

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0

0  0  3  2

0  0  1  2

1  6  2  2

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

0  3  3  2

1  6  5  2

P4

0  0  1  4

0  6  5  6

步骤1:对比P3的need参数,判断是否符合分配

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0

0  0  3  2

0  0  1  2

1  6  2  2

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

1  8  4  2

0  1  4  2

P4

0  0  1  4

0  6  5  6

步骤2:满足条件,下发资源

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0

0  0  3  2

0  0  1  2

0  1  1  2

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

1  8  4  2

0  1  4  2

P4

0  0  1  4

0  6  5  6

步骤3:P0请求资源,分配资源,完成运行,返还资源

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

0  1  4  4

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3

1  8  4  2

0  1  4  2

P4

0  0  1  4

0  6  5  6

步骤4:P3请求资源,分配资源,完成运行,返还资源

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

1  9  8  6

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3(finish)

1  8  4  2

0  1  4  2

P4

0  0  1  4

0  6  5  6

步骤5:P4请求资源,分配资源,完成运行,返还资源

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

1  9  9  10

P1

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3(finish)

1  8  4  2

0  1  4  2

P4(finish)

0  0  1  4

0  6  5  6

步骤6:P1请求资源,分配资源,完成运行,返还资源

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

2  9  9  10

P1(finish)

1  0  0  0

1  7  5  0

P2

1  3  5  4

2  3  5  6

P3(finish)

1  8  4  2

0  1  4  2

P4(finish)

0  0  1  4

0  6  5  6

步骤7:P2请求资源,分配资源,完成运行,返还资源。

       资源

进程

Allocation

A  B  C  D

Need

A  B  C  D

Available

A  B  C  D

P0(finish)

0  0  3  2

0  0  1  2

3  12  14  14

P1(finish)

1  0  0  0

1  7  5  0

P2(finish)

1  3  5  4

2  3  5  6

P3(finish)

1  8  4  2

0  1  4  2

P4(finish)

0  0  1  4

0  6  5  6

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/bicheng/60231.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

「QT」几何数据类 之 QSizeF 浮点型尺寸类

✨博客主页何曾参静谧的博客&#x1f4cc;文章专栏「QT」QT5程序设计&#x1f4da;全部专栏「VS」Visual Studio「C/C」C/C程序设计「UG/NX」BlockUI集合「Win」Windows程序设计「DSA」数据结构与算法「UG/NX」NX二次开发「QT」QT5程序设计「File」数据文件格式「PK」Parasolid…

L1-021 重要的话说三遍

一、问题描述 这道超级简单的题目没有任何输入。 你只需要把这句很重要的话 —— “Im gonna WIN!”——连续输出三遍就可以了。 注意每遍占一行&#xff0c;除了每行的回车不能有任何多余字符。 1. 输入样例 无 2. 输出样例 Im gonna WIN! Im gonna WIN! Im gonna WIN! 二…

【动手学电机驱动】STM32-FOC(3)STM32 三路互补 PWM 输出

STM32-FOC&#xff08;1&#xff09;STM32 电机控制的软件开发环境 STM32-FOC&#xff08;2&#xff09;STM32 导入和创建项目 STM32-FOC&#xff08;3&#xff09;STM32 三路互补 PWM 输出 STM32-FOC&#xff08;4&#xff09;IHM03 电机控制套件介绍 STM32-FOC&#xff08;5&…

数据库DQL

DQL 语法 SELECT字段列表 FROM表名列表 WHERE条件列表 GROUP BY分组字段列表 HAVING分组后条件列表 ORDER BY排序字段列表 LIMIT分页参数 基本查询 查询多个字段 SELECT 字段1,字段2,字段3,... FROM 表名; SELECT * FROM 表名; 设置别名 SELECT 字段1 [AS 别名1],字段2 …

Spark中的shuffle

Shuffle的本质基于磁盘划分来解决分布式大数据量的全局分组、全局排序、重新分区【增大】的问题。 1、Spark的Shuffle设计 Spark Shuffle过程也叫作宽依赖过程&#xff0c;Spark不完全依赖于内存计算&#xff0c;面临以上问题时&#xff0c;也需要Shuffle过程。 2、Spark中哪…

ffmpeg 视频滤镜:屏蔽边框杂色- fillborders

滤镜描述 fillborders 官网链接 > FFmpeg Filters Documentation fillborders滤镜有几种方式帮你屏蔽边框的杂色、不好的图案。 滤镜使用 参数 left <int> ..FV.....T. set the left fill border (from 0 to INT_MAX) (default 0)right …

「C/C++」C++标准库 之 #include<iostream> 标准输入输出

✨博客主页何曾参静谧的博客&#x1f4cc;文章专栏「C/C」C/C程序设计&#x1f4da;全部专栏「VS」Visual Studio「C/C」C/C程序设计「UG/NX」BlockUI集合「Win」Windows程序设计「DSA」数据结构与算法「UG/NX」NX二次开发「QT」QT5程序设计「File」数据文件格式「PK」Parasoli…

智能合约在供应链金融中的应用

&#x1f493; 博客主页&#xff1a;瑕疵的CSDN主页 &#x1f4dd; Gitee主页&#xff1a;瑕疵的gitee主页 ⏩ 文章专栏&#xff1a;《热点资讯》 智能合约在供应链金融中的应用 智能合约在供应链金融中的应用 智能合约在供应链金融中的应用 引言 智能合约概述 定义与原理 发展…

前端实现文件下载常用几种方式

项目中前端下载一般分为两种情况&#xff1a; 后端直接提供一个文件地址&#xff0c;通过浏览器打开就可以下载。需要发送请求&#xff0c;后端返回二进制流数据&#xff0c;前端解析流数据&#xff0c;生成URL实现下载。 前端对应的实质是a标签和Blob文件下载&#xff0c;这…

设计模式之责任链模式(Chain Of Responsibility)

一、责任链模式介绍 1、责任链模式介绍 职责链模式(chain of responsibility pattern) 定义: 避免将一个请求的发送者与接收者耦合在 一起&#xff0c;让多个对象都有机会处理请求。将接收请求的对象连接成一条链&#xff0c;并且沿着这条链 传递请求&#xff0c;直到有一个对…

centos docker 安装 rabbitmq

安装docker 1.更新现有的软件包 首先&#xff0c;确保您的系统是最新的&#xff0c;可以通过运行以下命令来实现&#xff1a; sudo yum update -y 2.移除旧版本的Docker 如果您之前安装过Docker&#xff0c;可能需要先卸载旧版本。使用以下命令来卸载旧版本的Docker&#…

设计模式之——观察者模式

一、观察者模式概述 观察者模式是一种对象行为模式&#xff0c;它在软件设计中有着广泛的应用。这种模式定义了一种一对多的依赖关系&#xff0c;其中一个主题对象可被多个观察者对象同时监听。当主题对象的状态发生变化时&#xff0c;它会主动发出通知&#xff0c;使得所有依赖…

CSS 淡入淡出增加元素隐藏

visibility: IsShow? "visible" : "hidden", opacity: IsShow? 1 : 0, transition: "all 0.8s ease" IsShow是一个控制显示和透明度的变量&#xff0c;可以用代码控制 注意:transition只对opacity有效果&#xff0c;但是因为这里增加了visbi…

C语言中的 printf( ) 与 scanf( )

时隔多日&#xff0c;小编我又回来咯小编相信之前的博客能够给大家带来不少的收获。在我们之前的文章中&#xff0c;许多代码块的例子都用到了printf( ) 与 scanf( )这两个函数&#xff0c;大家都知道他们需要声明头文件之后才能使用&#xff0c;那这两个函数是什么呢&#xff…

数字乡村解决方案-1

1. 政策背景与新时代党建 党的十九大报告提出新时代党建总要求&#xff0c;强调乡村治理在国家治理体系中的重要性&#xff0c;并作为实现乡村振兴战略的基石。提出按照产业兴旺、生态宜居、乡风文明、治理有效、生活富裕的总要求&#xff0c;推进乡村治理体系和治理能力现代化…

CentOS 9 Stream 上安装 PostgreSQL 16

CentOS 9 Stream 上安装 PostgreSQL 16 CentOS 9 Stream 上安装 PostgreSQL 16设置密码并且远程连接 CentOS 9 Stream 上安装 PostgreSQL 16 在 CentOS 9 Stream 上安装 PostgreSQL 16 可以通过以下步骤完成&#xff1a; 添加 PostgreSQL 官方仓库&#xff1a; PostgreSQL 提…

栈和队列相关题 , 用队列实现栈, 用栈实现队列 ,设计循环队列 C/C++双版本

文章目录 1.用队列实现栈2.用栈实现队列3. 设计循环队列 1.用队列实现栈 225. 用队列实现栈 思路&#xff1a; 使用两个队列&#xff0c;始终保持一个队列为空。 当我们需要进行压栈操作时&#xff0c;将数据压入不为空的队列中&#xff08;若两个都为空&#xff0c;则随便压…

零基础入门进程间通信:task 1(匿名管道与vscode使用)

目录 引言 VSCODE使用 进程间通信正题 基础背景 进程间通信分类 匿名管道 理解匿名管道 代码实现 匿名管道的特性 管道的四种情况 应用场景 引言 在当今的计算机技术领域&#xff0c;操作系统作为计算机系统的核心组件&#xff0c;承担着资源管理、任务调度和进程管…

#渗透测试#SRC漏洞挖掘#Python自动化脚本的编写04之通过面向对象编程学生管理信息系统01

免责声明 本教程仅为合法的教学目的而准备&#xff0c;严禁用于任何形式的违法犯罪活动及其他商业行为&#xff0c;在使用本教程前&#xff0c;您应确保该行为符合当地的法律法规&#xff0c;继续阅读即表示您需自行承担所有操作的后果&#xff0c;如有异议&#xff0c;请立即停…

c#程序结构

以下是一个简单的 C# 程序结构示例: using System;namespace HelloWorld {class Program{static void Main(string[] args){Console.WriteLine("Hello, World!");}} } 在此示例中,程序包含以下部分: using 指令:用于引入所需的命名空间。在本例中,我们引入了 …