c 银行家算法

最新推荐文章于 2024-07-25 15:50:18 发布
最新推荐文章于 2024-07-25 15:50:18 发布
阅读量693 收藏 2
点赞数
分类专栏： 操作系统实验 文章标签： 读文件 linux 算法 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengzheng_hit/article/details/17384933
版权

环境:

configure_bank.txt内容：

3 3 2


7 5 3
3 2 2
9 0 2
2 2 2
4 3 3

0 1 0
2 0 0
3 0 2
2 1 1

0 0 2


#include <stdlib.h>
#include <stdio.h>
//数据结构
int allocation[5][3];
int max[5][3];
int available[3];
int request[3];
int work[3];
int need[5][3];
int safeSequence[5];
int finish[5];
int i;//全局变量：：
int m,n;
int count = 0;
int flag = 0;
int k = 0;
int s = 0;
//读取文件
int read()
{
    //  int m,n;
    FILE* fp = fopen("configure_bank.txt","r");
    if(fp == NULL)
    {
        printf("无法读取配置文件");
        return -1;
    }

    for(m=0; m<3; m++)
    {
        fscanf(fp,"%d",&available[m]);
    }
    fscanf(fp,"\n");

    for(m = 0; m<5; m++)
    {
        for(n=0; n<3; n++)
        {
            fscanf(fp,"%d",&max[m][n]);
        }
        fscanf(fp,"\n");
    }

    fscanf(fp,"\n");
    for(m = 0; m<5; m++)
    {
        for(n=0; n<3; n++)
        {
            fscanf(fp,"%d",&allocation[m][n]);
        }
        fscanf(fp,"\n");
    }
    return 1;
}
int safe()
{
    int i = ::i;
    while(1)
    {
        if(finish[i]==1)
        {
            i=(i+1)%5;
        }
        else
        {
            for(n=0; n<3; n++)
            {
                flag = work[n]-need[i][n];
                //   printf("flag:%d\n",flag);
                if(flag<0)
                {
                    break;
                }
            }
            //回收资源
            if(flag>=0)
            {
                for(k =0; k<3; k++)
                {
                    work[k]=work[k]+allocation[i][k];
                }
                finish[i]=1;
                //printf("有进程可以分配%d\n",i );

                safeSequence[s] = i;
                // printf("safeSequence:::%d\n",safeSequence[s] );
                s++;
            }
            flag = 1;
            for(n = 0; n<5; n++)
            {
                if(finish[n]==0)
                {
                    //  printf("%d\n",finish[i]);
                    flag=0;
                    break;
                }
            }
            // printf("%d\n",flag);
            if(count<120&&flag==1)
            {
                printf("find the 安全序列:\n");
                /*
                for (m = 0; m <5 ; m++)
                {
                printf("%d\t\n",finish[m]);

                }
                */
                for (m = 0; m <5 ; m++)
                {
                    printf("%d\t",safeSequence[m]);
                }
                printf("\n");
                /*
                 for(m =0;m<5;m++)
                 {
                     finish[m]=0;
                     safeSequence[m]=0;
                 }
                 */
                break;
            }
            else if(count>=120)
            {
                break;
                return 0;

            }
            count++;
            i=(i+1)%5;
        }

    }

}

int main()
{
    if(read()==-1)
    {
        printf("read error!");
        return 0;
    }

    //已经分配的

    printf("分配的资源的allocation矩阵（5*3）\n");
    for(m=0; m<5; m++)
    {
        for(n=0; n<3; n++)
        {
            printf("%d\t",allocation[m][n]);
            if(n ==2)
            {
                printf("\n");
            }
        }
    }

    printf("资源总数（1*3）：\n");
    int s;

    for(s=0; s<3; s++)
    {
        printf("%d\t",available[s]);
    }
    //实际需要的
    printf("\n4个进程每个进程对应的nmax矩阵（5*3）\n");
    for(m=0; m<5; m++)
    {
        for(n=0; n<3; n++)
        {
            printf("%d\t",max[m][n]);
            if(n ==2)
            {
                printf("\n");
            }
        }
    }

    //   首先先找出它的Need，Need即Max(最多需要多少资源)减去Allocation(原本已经分配出去的资源)
    for(m=0; m<5; m++)
    {
        for(n=0; n<3; n++)
        {
            need[m][n]=max[m][n]-allocation[m][n];
        }
    }
    printf("4个进程每个进程对应的need矩阵（5*3）\n");
    for(m=0; m<5; m++)
    {
        for(n=0; n<3; n++)
        {
            printf("%d\t",need[m][n]);
            if(n == 2)
            {
                printf("\n");
            }
        }
    }
    printf("\n");
    printf("\n");

    for(m=0; m<5; m++)
    {
        finish[m]=0;
    }

    printf("请输入进程申请的资源的进程号\n");
    scanf("%d",&::i);
    printf("请输入%d 号进程需要的资源情况\n",::i);

    for(m = 0; m<3; m++)
    {
        scanf("%d",&request[m]);
    }
    int sign =1;
//i =1;
    for(m =0; m<3; m++)
    {
        if(request[m]>need[::i][m]||request[m]>available[m])
        {
            sign = 0;
            printf("%d号资源不够分配\n",m);
        }

    }
    if(sign)
    {
        printf("可以分配\n");
        for(m=0; m<3; m++)
        {
            available[m]= available[m]-request[m];
            allocation[::i][m] = allocation[::i][m]+request[m];
            need[::i][m]= need[i][m]-request[m];
        }
        for(m=0; m<3; m++)
        {
            work[m] = available[m];
        }
        safe();
    }
    else
    {
        printf("不可以分配\n");
        return 0;
    }

    return 0;
}
/*

    printf("第一个资源的请求\n");
    for(s=0;s<4;s++)
    {
    scanf("%d",&(available[0][s]));
    }


    printf("第2个资源的请求\n");
    for(s=0;s<4;s++)
    {
    scanf("%d",&(available[1][s]));
    }


    printf("第3个资源的请求\n");
    for(s=0;s<4;s++)
    {
    scanf("%d",&(available[2][s]);
    }



    printf("第4个资源的请求\n");
    for(s=0;s<4;s++)
    {
    scanf("%d",&(available[3][s]);
    }


*/
/*
for(m=0;m<5;m++)
{
for(n=0;n<3;n++)
{
scanf("%d",&allocation[m][n]);
if(n ==2)
{
printf("\n");
}
}
}
5*3

    /*
    allocation[0][0] = 0;
    allocation[0][1] = 1;
    allocation[0][2] = 0;

    allocation[1][0] = 2;
    allocation[1][1] = 0;
    allocation[1][2] = 0;

    allocation[2][0] = 3;
    allocation[2][1] = 0;
    allocation[2][2] = 2;

    allocation[3][0] = 2;
    allocation[3][1] = 1;
    allocation[3][2] = 1;

    allocation[4][0] = 0;
    allocation[4][1] = 0;
    allocation[4][2] = 2;

    */
/* for(m=0;m<5;m++)
{
for(n=0;n<3;n++)
{
scanf("%d",&(max[m][n]));
if(n ==2)
{
printf("\n");
}
}
}
*/
/*
max[0][0] = 7;
max[0][1] = 5;
max[0][2] = 3;

max[1][0] = 3;
max[1][1] = 2;
max[1][2] = 2;

max[2][0] = 9;
max[2][1] = 0;
max[2][2] = 2;

max[3][0] = 2;
max[3][1] = 2;
max[3][2] = 2;

max[4][0] = 4;
max[4][1] = 3;
max[4][2] = 3;


*/
/*  for(s=0;s<3;s++)
{
scanf("%d",&(available[s]));
}
*/
/*
available[0] = 3;
available[1] = 3;
available[2] = 2;
    /*
    request[0]=1;
    request[1]=0;
    request[2]=2;
    */
/* for(m=0;m<5;m++)
{
printf("%d\t",finish[m]);
}*/
/*
::i表示使用全局的i
* *
for(m=0; m<5; m++)
{
    for(n=0; n<3; n++)
    {
        printf("%d\t",need[m][n]);
        if(n == 2)
        {
            printf("\n");
        }
    }
}
printf("\n");
printf("\n");

for(m=0; m<5; m++)
{
    finish[m]=0;
}

printf("请输入进程申请的资源的进程号\n");
scanf("%d",&::i);
printf("请输入%d 号进程需要的资源情况\n",::i);

for(m = 0; m<3; m++)
{
    scanf("%d",&request[m]);
}
int sign =1;
//i =1;
for(m =0; m<3; m++)
{
    if(request[m]>need[::i][m]||request[m]>available[m])
    {
        sign = 0;
        printf("%d号资源不够分配\n",m);
    }

}
if(sign)
{
    printf("可以分配\n");
    for(m=0; m<3; m++)
    {
        available[m]= available[m]-request[m];
        allocation[::i][m] = allocation[::i][m]+request[m];
        need[::i][m]= need[i][m]-request[m];
    }
    for(m=0; m<3; m++)
    {
        work[m] = available[m];
    }
    safe();
}
else
{
    printf("不可以分配\n");
    return 0;
}

return 0;
}
/*

printf("第一个资源的请求\n");
for(s=0;s<4;s++)
{
scanf("%d",&(available[0][s]));
}


printf("第2个资源的请求\n");
for(s=0;s<4;s++)
{
scanf("%d",&(available[1][s]));
}


printf("第3个资源的请求\n");
for(s=0;s<4;s++)
{
scanf("%d",&(available[2][s]);
}



printf("第4个资源的请求\n");
for(s=0;s<4;s++)
{
scanf("%d",&(available[3][s]);
}


*/
/*
for(m=0;m<5;m++)
{
for(n=0;n<3;n++)
{
scanf("%d",&allocation[m][n]);
if(n ==2)
{
printf("\n");
}
}
}
5*3

    /*
    allocation[0][0] = 0;
    allocation[0][1] = 1;
    allocation[0][2] = 0;

    allocation[1][0] = 2;
    allocation[1][1] = 0;
    allocation[1][2] = 0;

    allocation[2][0] = 3;
    allocation[2][1] = 0;
    allocation[2][2] = 2;

    allocation[3][0] = 2;
    allocation[3][1] = 1;
    allocation[3][2] = 1;

    allocation[4][0] = 0;
    allocation[4][1] = 0;
    allocation[4][2] = 2;

    */
/* for(m=0;m<5;m++)
{
for(n=0;n<3;n++)
{
scanf("%d",&(max[m][n]));
if(n ==2)
{
printf("\n");
}
}
}
*/
/*
max[0][0] = 7;
max[0][1] = 5;
max[0][2] = 3;

max[1][0] = 3;
max[1][1] = 2;
max[1][2] = 2;

max[2][0] = 9;
max[2][1] = 0;
max[2][2] = 2;

max[3][0] = 2;
max[3][1] = 2;
max[3][2] = 2;

max[4][0] = 4;
max[4][1] = 3;
max[4][2] = 3;


*/
/*  for(s=0;s<3;s++)
{
scanf("%d",&(available[s]));
}
*/
/*
available[0] = 3;
available[1] = 3;
available[2] = 2;
    /*
    request[0]=1;
    request[1]=0;
    request[2]=2;
    */
/* for(m=0;m<5;m++)
{
printf("%d\t",finish[m]);
}*/
/*
::i表示使用全局的i
* */


我想我可以更强
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
银行家算法 c语言
mdjsmg的博客
04-16 3057
操作系统学习之银行家算法，c语言代码实现
C语言银行家算法
徐奕的专栏
05-27 6万+
算法简介 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 算法目的 为了了解系统的资源分配情况，假定系统的任何一种资源在任意时刻只能被一个进程使用，任何进程已经占用的资源只能由进程自己释放，而不能由其他进...
银行家算法
clllllz_的博客
05-19 176
银行家算法
C语言实现银行家算法
qq_53250579的博客
12-10 1181
C语言实现银行家算法
计算机操作系统——银行家算法详解（C语言版）
热门推荐
钢铁大侠的博客
04-24 9万+
计算机操作系统——银行家算法详解（C语言版）
银行家算法——C语言实现
mili_j的博客
09-23 2089
银行家算法——C语言实现
银行家算法详解（C语言）
sparky的博客
05-16 2万+
概述 银行家算法是荷兰学者Dijkstra为银行系统设计的，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况。后来该算法被用在操作系统中，用于避免死锁 核心思想：在进程提出资源申请时，先预判此分配是否会导致系统进入不安全状态。如果会进入不安全状态，就暂时不答应这次请求，让该进程先阻塞等待。 过程演示图解 假定有五个进程{P0,P1,P2,P3,P4}和三类资源{A，B，C}，各种资源的数量分别为10、5、7。在T0时刻的资源分配情况如下 T0时刻的安全性 P1发出请求向量Request1（1,
用c语言编写银行家算法,C语言实现银行家算法
weixin_35014204的博客
05-19 1720
《C语言实现银行家算法》由会员分享，可在线阅读，更多相关《C语言实现银行家算法(8页珍藏版)》请在人人文库网上搜索。1、C语言实现银行家算法(源码、运行结果)一、 源码/* 银行家算法 10-22*/#include/函数声明void init(int * pcount,int * scount,int Allocation1010,int Need1010,int Available10);vo...
c语言 银行家算法,C语言实现银行家算法
weixin_36368404的博客
05-20 218
#include #include #include #include // bool 类型int N = 0; // 进程数目int M = 0; // 资源数目int* Available; // 可利用资源向量 Mint** Max; // 最大需求矩阵 M * Nint** Allocation; // 分配矩阵 M * Nint*...
c语言银行家算法实验报告,银行家算法-实验报告.doc
weixin_36125588的博客
05-21 1454
.课内实验报告课 程 名： 操作系统任课教师：专 业： 信息管理与信息系统学 号：姓 名：二○一六至二○一七 年度 第 一 学期南京邮电大学 经济与管理学院《 操作系统 》课程实验第 一 次实验报告实验内容及基本要求：实验项目名称：调度系统的设计与实现实验类型：设计每组人数： 1实验内容及要求：实验内容:本次实验的主要内容是模拟调度系统的实现，包括高级、中级和...
c语言实现银行家算法
帝一松鼠的博客
01-01 2120
【代码】c语言实现银行家算法。
银行家算法C语言代码.doc
05-18
银行家算法C语言代码 银行家算法是操作系统中的一种资源分配算法，用于避免死锁的产生。该算法通过跟踪每个进程的资源需求和当前可用的资源量来避免死锁的产生。 在本文档中，我们提供了银行家算法的C语言代码实现...
银行家算法C语言实现
12-07
《银行家算法C语言实现详解》 银行家算法是一种经典的资源分配策略，旨在预防系统中的死锁问题。在多道程序设计系统中，多个进程可能会同时请求多种资源，如果资源分配不当，可能导致进程无法继续执行，形成死锁。...
C语言模拟银行家算法
07-18
本项目以C语言实现银行家算法，旨在帮助开发者深入理解该算法的运作机制。 在银行家算法中，系统维护着一个关于当前资源分配和需求的表格。这些表格包括： 1. **可用资源表（Available）**：记录系统当前可分配的...
Linux初学基本命令
最新发布
yuan20010401的博客
07-25 575
1、rm 文件名称 删除多个文件多个目录需要用空格 删除根目录（rm -rf /*）1、touch 文件名字 用于linux创建文件 创建多个目录需要用空格隔开。2、mkdir 目录名称 用于创建文件夹 创建多个嵌套文件夹需要用/隔开。1、cp 当前文件 其他目录名称 拷贝文件夹需要在最后 -r。退出不保存时按Esc+:q!1、ls 查看当前目录下面的文件或者文件夹。2、more 文件名称 查看文件更多内容。1、mv 原文件路径 目标文件路径。退出保存时按Esc + :wq。
【linux】Shell脚本三剑客之awk命令的详细用法攻略
景天科技苑
07-24 4961
在Linux和Unix系统中，awk是一种强大的文本处理工具，广泛应用于数据提取、分析和报告生成。它基于模式匹配和条件执行，能够逐行读取输入文本文件，并对每行数据执行指定的操作。本教程将详细介绍`awk`在shell脚本中的用法，包括其基本语法、常用选项、内置变量、高级特性以及结合shell脚本的实际案例。
60个常见的 Linux 指令
yatingliu的博客
07-25 1298
是 “substitute user” 或 “switch user” 的缩写，它可以让你切换到另一个用户账户，包括 root 用户。是 “manual” 的缩写，通过它你可以访问系统的手册页（manual pages），这些手册页提供了详细的使用说明和参考信息。在一些 Linux 发行版中，adduser 是 useradd 的一个友好封装，功能上类似但提供了更多的默认设置和提示。-f, --force：强制删除，不提示错误信息，即使文件不存在也不会报错。：设置密码过期时间，单位为天。
【C语言】Linux 飞翔的小鸟
Minuhy
07-22 810
在Linux下运行的，用C语言编写的飞翔的小鸟，一款挺无聊的小游戏，分享给大家~
C语言银行家算法的代码实现
12-22
抱歉，我无法提供C语言银行家算法的代码实现。但是，我可以为您介绍一下银行家算法的基本原理和步骤。 银行家算法是一种用于避免死锁的资源分配算法。它通过预先分配资源并根据系统的当前状态来决定是否分配资源，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值