银行家算法

最新推荐文章于 2022-12-06 17:57:35 发布
最新推荐文章于 2022-12-06 17:57:35 发布
阅读量259 收藏
点赞数
分类专栏： OS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pwnpanda/article/details/84931876
版权

目的：解决死锁问题

环境：Windows10 + codeblocks

直接上代码，打印表的部分用于自我验证，可以设置为手动输入数据，也可以设置为读取文件数据

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
#include "banker.h"

//输入最大需求矩阵
void inputMax()
{
    int i;
    printf("请输入最大需求矩阵\n");
    for (i = 0; i < PROCESSES_NUMBER; i++)
    {
        scanf("%d%d%d%d", &Max[i].A, &Max[i].B, &Max[i].C, &Max[i].D);
    }
}

//输入已经分配资源矩阵
void inputAllocation()
{
    int i;
    printf("请输入已经分配资源数矩阵\n");
    for (i = 0; i < PROCESSES_NUMBER; i++)
    {
        scanf("%d%d%d%d", &Allocation[i].A, &Allocation[i].B, &Allocation[i].C, &Allocation[i].D);
    }
}

void input()
{
    int i, j;
    FILE *fp = fopen("data.txt", "r");

    if (fp == NULL)
    {
        printf("无文件");
        return -1;
    }
    for (i = 0; i < 5; i++)
    {
        fscanf(fp, "%d%d%d%d", &Max[i].A, &Max[i].B, &Max[i].C, &Max[i].D);
    }

    for (i = 0; i < 5; i++)
    {
        fscanf(fp, "%d%d%d%d", &Allocation[i].A, &Allocation[i].B, &Allocation[i].C, &Allocation[i].D);
    }

    fclose(fp);
}

//试探分配
void ProbeAlloc(int process, RESOURCE *res)
{
    Available.A -= res->A;
    Available.B -= res->B;
    Available.C -= res->C;
    Available.D -= res->D;

    Allocation[process].A += res->A;
    Allocation[process].B += res->B;
    Allocation[process].C += res->C;
    Allocation[process].D += res->D;

    Need[process].A -= res->A;
    Need[process].B -= res->B;
    Need[process].C -= res->C;
    Need[process].D -= res->D;
}

//试探分配后进入不安全状态，将分配回滚
void RollBack(int process, RESOURCE *res)
{
    Available.A += res->A;
    Available.B += res->B;
    Available.C += res->C;
    Available.D += res->D;

    Allocation[process].A -= res->A;
    Allocation[process].B -= res->B;
    Allocation[process].C -= res->C;
    Allocation[process].D -= res->D;

    Need[process].A += res->A;
    Need[process].B += res->B;
    Need[process].C += res->C;
    Need[process].D += res->D;
}

//安全性检查
bool SafeCheck()
{
    RESOURCE Work = Available;
    bool Finsh[PROCESSES_NUMBER] = { false, false, false, false, false };

    int i;
    int j = 0;
    for (i = 0; i < PROCESSES_NUMBER; i++)
    {
        //判断是否已经检查过
        if (Finsh[i] == false)
        {
            if (Need[i].A <= Work.A && Need[i].B <= Work.B
                    && Need[i].C <= Work.C && Need[i].D <= Work.D)
            {
                Work.A += Allocation[i].A;
                Work.B += Allocation[i].B;
                Work.C += Allocation[i].C;
                Work.D += Allocation[i].D;

                Finsh[i] = true;
                safe[j++] = i;
                i = -1; //重新遍历
            }
        }
    }

    //如果所有进程的Finsh向量均为true，则处于安全状态，否则是不安全状态
    for (i = 0; i < PROCESSES_NUMBER; i++)
    {
        if (Finsh[i] == false)
        {
            return false;
        }
    }
    return true;
}

//资源分配请求
bool request(int process, RESOURCE *res)
{
    //request向量小于Need矩阵中对应的向量
    if (res->A <= Need[process].A && res->B <= Need[process].B
            && res->C <= Need[process].C && res->D <= Need[process].D)
    {
        //request向量小于Available向量
        if (res->A <= Need[process].A && res->B <= Need[process].B
                && res->C <= Need[process].C && res->D <= Need[process].D)
        {
            //试探分配
            ProbeAlloc(process, res);

            //如果安全检查成立，则请求成功
            if (SafeCheck())
            {
                Available.A += Allocation[process].A;
                Available.B += Allocation[process].B;
                Available.C += Allocation[process].C;
                Available.D += Allocation[process].D;

                return true;
            }
            else
            {
                printf("安全性检查失败");
                printf("正在回滚...\n");
                RollBack(process, res);
            }
        }
        else
        {
            printf("安全性检查失败，失败原因：请求量大于可利用资源量\n");
        }
    }
    else
    {
        printf("安全性检查失败，失败原因：请求量大于需求量\n");
    }
    return false;
}

//打印资源表
void PrintTable();

int main()
{
//    inputMax();
//    inputAllocation();

    FILE *fp1 = fopen("data1.txt","w");

    input();

    int i;
    for (i = 0; i < PROCESSES_NUMBER; i++)
    {
        Need[i].A = Max[i].A - Allocation[i].A;
        Need[i].B = Max[i].B - Allocation[i].B;
        Need[i].C = Max[i].C - Allocation[i].C;
        Need[i].D = Max[i].D - Allocation[i].D;

    }
    int ch;
    printf("先检查初始状态是否安全。\n");
    if (SafeCheck())
    {
        printf("系统处于安全状态\n");
        printf("安全序列是{P%d,P%d,P%d,P%d,P%d}。\n", safe[0], safe[1], safe[2],
               safe[3], safe[4]);
    }
    else
    {
        printf("系统处于不安全状态，程序将退出...\n");
    }

    PrintTable();

    do
    {
        int process;
        RESOURCE res;

        printf("请依次输入请求分配的进程和对四类资源的请求数量：");
        scanf("%d%d%d%d%d", &process, &res.A, &res.B, &res.C, &res.D);
        if (request(process, &res))
        {
            printf("分配成功 \n");
            printf("安全序列是{P%d,P%d,P%d,P%d,P%d}。\n", safe[0], safe[1], safe[2],
                   safe[3], safe[4]);

            PrintTable();
        }
        else
        {
            printf("分配失败 \n");
        }
        printf("是否继续分配?(Y/N):");
        fflush(stdin);
        ch = getchar();

    }
    while (ch == 'Y' || ch == 'y');

over:
    printf("执行完毕");
    return 0;
}

void PrintTable()
{
    printf("\t\t\t*********资源分配表*********\n");
    printf(
        "Process       Max                  Allocation             Need                Available\n");
    printf(
        "          A    B    C    D     A    B    C    D      A    B    C    D     A    B    C   D\n");
    printf(
        "  P0      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d     %d    %d    %d   %d\n",
        Max[0].A, Max[0].B, Max[0].C, Max[0].D, Allocation[0].A,
        Allocation[0].B, Allocation[0].C, Allocation[0].D, Need[0].A,
        Need[0].B, Need[0].C, Need[0].D, Available.A, Available.B,
        Available.C, Available.D);
    printf(
        "  P1      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d\n",
        Max[1].A, Max[1].B, Max[1].C, Max[1].D, Allocation[1].A,
        Allocation[1].B, Allocation[1].C, Allocation[1].D, Need[1].A,
        Need[1].B, Need[1].C, Need[1].D);
    printf(
        "  P2      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d\n",
        Max[2].A, Max[2].B, Max[2].C, Max[2].D, Allocation[2].A,
        Allocation[2].B, Allocation[2].C, Allocation[2].D, Need[2].A,
        Need[2].B, Need[2].C, Need[2].D);
    printf(
        "  P3      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d\n",
        Max[3].A, Max[3].B, Max[3].C, Max[3].D, Allocation[3].A,
        Allocation[3].B, Allocation[3].C, Allocation[3].D, Need[3].A,
        Need[3].B, Need[3].C, Need[3].D);
    printf(
        "  P4      %d    %d    %d    %d     %d    %d    %d    %d      %d    %d    %d    %d\n",
        Max[4].A, Max[4].B, Max[4].C, Max[4].D, Allocation[4].A,
        Allocation[4].B, Allocation[4].C, Allocation[4].D, Need[4].A,
        Need[4].B, Need[4].C, Need[4].D);
    printf("\n");
}


typedef int bool;
#define false 0
#define true !false

//系统中所有的进程数量
#define PROCESSES_NUMBER 5

typedef struct
{
	int A;
	int B;
	int C;
	int D;
}RESOURCE;

//最大需求矩阵 Max
RESOURCE Max[PROCESSES_NUMBER];

//已经分配资源数矩阵 Allocation
RESOURCE Allocation[PROCESSES_NUMBER];

//需求矩阵 Need
RESOURCE Need[PROCESSES_NUMBER];

//可用资源向量
RESOURCE Available = {1,0,2,0};

int safe[PROCESSES_NUMBER];

测试数据：

max      
4 1 1 1 0 2 1 2 4 2 1 0 1 1 1 1 2 1 1 0
allocation 
3 0 1 1 0 1 0 0 1 1 1 0 1 1 0 1 0 0 0 0

结果：

先检查初始状态是否安全。
系统处于安全状态
安全序列是{P3,P0,P1,P2,P4}。
                        *********资源分配表*********
Process       Max                  Allocation             Need                Available
          A    B    C    D     A    B    C    D      A    B    C    D     A    B    C   D
  P0      4    1    1    1     3    0    1    1      1    1    0    0     1    0    2   0
  P1      0    2    1    2     0    1    0    0      0    1    1    2
  P2      4    2    1    0     1    1    1    0      3    1    0    0
  P3      1    1    1    1     1    1    0    1      0    0    1    0
  P4      2    1    1    0     0    0    0    0      2    1    1    0

请依次输入请求分配的进程和对四类资源的请求数量：

参考链接：https://liuyanzhao.com/2932.html

Pwnpanda
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统课设-银行家算法
weixin_44535721的博客
07-04 2024
成 绩： 南华大学计算机学院 课 程 设 计 课 程 操作系统Ⅰ 题 目 银行家算法 学 院 计算机学院 专 业 软件工程 班 级 姓 名 学 号 指导教师 曹军 2019 年 6 月 16 日 目 录 1.设计目的与要求 1.1设计目的 1.2设计要求 2.设计思想及系统平台 2.1设计思想 2.2系统平台及使用语言 3.详...
c语言实现银行家算法
最新发布
leekos的博客，分享web安全相关知识~
04-17 1565
3. 对本次尝试性分配进行确认：分别对所有未结束的进程进行判断，若能找到一个安全执行序列，则本次尝试性分配进行确认，否则执行回滚操作并恢复尝试性分配前的状态。1. 当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。，若剩余可用量大于本次申请量则按当前的申请量尝试性分配资源，否则也要推迟分配。2. 当进程在执行中继续申请资源时，若超过则拒绝分配资源，若能满足则。程序预期运行结果截图。
银行家算法的模拟
一个追逐梦想的码农
12-06 1698
本文是操作系统资源并发申请管理的模拟，主要加深对死锁预防算法的认识。代码在centos上测试通过。银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。如果某一客户的交易认为对银行的后续业务产生不安全风险，那么就延迟或不进行这笔交易。算法的重点对于安全和不安全状态的定义。如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，
银行家算法 C++描述
qq_44486439的博客
04-30 410
银行家算法 C++描述 实现代码 main.cpp #include "BankerAlgorithm.h" int main() { int n, m; scanf("%d%d", &n, &m); vector<vector<int> > max(n, vector<int>(m)); vector<vector<int> > allocation(n, vector<int>(m)
操作系统课程设计(银行家算法)附报告
07-24
用c语言实现了操作系统的银行家算法，功能比较全面，注释很丰富。有多种判错机制，几乎没有崩溃的情况。内附课设报告流程图 编辑软件为codeblocks.
使用java实现银行家算法
08-25
"使用Java实现银行家算法" 银行家算法是操作系统中的一种资源分配算法，用于避免死锁和饥饿现象。该算法的主要思想是，系统中有多个资源和进程，进程需要请求资源来执行任务，系统需要确保资源的分配是安全的，即...
银行家算法模拟_银行家算法_
09-29
《银行家算法模拟详解及其C语言实现》 在操作系统领域，银行家算法是一种经典的资源分配策略，用于预防死锁的发生。这一算法源自1965年E.F.科德（Edsger Dijkstra）提出的一个类比，它将操作系统中的进程与银行的...
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该...
java实现银行家算法
08-25
Java 实现银行家算法详解 Java 实现银行家算法是操作系统中的一种资源分配算法，用于避免死锁和饥饿的出现。银行家算法的主要思想是，系统中存在一种有限的资源，多个进程竞争这些资源，需要避免死锁和饥饿的出现...
操作系统银行家算法 实验报告+源代码
11-24
大三上学期的操作系统课程的实验作业，要求模拟实现银行家算法。代码格式良好，注释得当，可供有需要的人参考学习。
C++ 银行家算法实现（手动矩阵输入）
11-24
主函数调用三个函数void init(输入)、bool safe(安全性算法)、void bank（银行家算法）.. 没有释放资源代码段 所以不能实现银行家算法的全部过程 定义如下 #include <iostream> using namespace std; #define MAXPROCESS 50 /*最大进程数*/ #define MAXRESOURCE 100 /*最大资源数*/ int AVAILABLE[MAXRESOURCE]; /*可用资源数组*/ int MAX[MAXPROCESS][MAXRESOURCE]; /*最大需求矩阵*/ int ALLOCATION[MAXPROCESS][MAXRESOURCE]; /*分配矩阵*/ int NEED[MAXPROCESS][MAXRESOURCE]; /*需求矩阵*/ int REQUEST[MAXPROCESS][MAXRESOURCE]; /*进程需要资源数*/ bool FINISH[MAXPROCESS]; /*系统是否有足够的资源分配*/ int p[MAXPROCESS]; /*记录序列*/ int m,n; /*m个进程,n个资源*/ void Init(); bool Safe(); void Bank();
银行家算法模拟实验
04-21
银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的...
操作系统实验二——银行家算法
08-29
银行家算法就是为了防止这种情况而提出的一种策略，尤其在多任务并发环境下，资源的有效分配显得尤为重要。该算法的精髓在于预先分配资源，以确保系统始终能处于安全状态，即无论进程如何请求资源，系统总能找到一种...
银行家算法python实现
03-26
保证能跑
银行家算法java语言,操作系统--银行家算法c语言代码
weixin_42511255的博客
03-10 310
#include#include#include"banker.h"/*@authorWellsLiu@urlliuyanzhao.com测试数据max41110212421011112110allocation30110100111011010000request测试eg1:1...
银行家算法C++实现
热门推荐
lingpy的博客
04-12 3万+
网上有很多银行家算法的源代码，下面是本人自己写的，基本算法模型参考教材。 介绍 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉（Edsger Wybe Dijkstra）在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 背景简介 在银行中...
java实现简单银行家算法
08-25
Java 实现简单银行家算法 一、标题解释 本文主要介绍了 Java 实现简单银行家算法的相关知识点，通过实例代码，详细介绍了银行家算法的实现过程。 二、描述解释 银行家算法是一种避免死锁的方法，它可以判断是否...
银行家算法实现与资源优化
"银行家算法是一种用于预防操作系统中死锁的经典策略，由Edsger Dijkstra于1965年提出。它通过模拟银行家如何管理资金来分配系统资源，确保系统不会进入无法解决的死锁状态。此文档是一份针对本科生的课程设计报告，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值