c 银行家算法

最新推荐文章于 2023-10-21 10:24:57 发布
最新推荐文章于 2023-10-21 10:24:57 发布
阅读量690 收藏 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++）
qq_63055790的博客
01-14 1401
在多道程序系统中，多个进程的并发执行来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险——死锁。所谓死锁(Deadlock)，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种状态时，若无外力作用，他们都无法在向前推进。要预防死锁，有摒弃“请求和保持”条件，摒弃“不剥夺”条件，摒弃“循环等待”条件等方法。但是，在预防死锁的几种方法之中，都施加了较强的限制条件；而在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。
操作系统实验报告
m0_70350178的博客
06-06 3414
利用C++设计实现银行家算法的基本过程。
银行家算法（C++实现）
热门推荐
m0_58136789的博客
11-23 2万+
操作系统实验内容，银行家算法的实现，基于C++语言
银行家算法
不积跬步，无以至千里
09-29 1万+
银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。长度为m的一维数组Available 表示还有多少可用资源nm矩阵Max 表示各进程对资源的最大需求数nm矩阵Allocation表示已经给各进程分配了多少资源Max-Allocation=Need 矩阵表示各进程最多还需要多少资源。
银行家算法课程设计（附源代码）
振华OPPO的博客世界
03-26 1万+
死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验提供了一个系统动态分配资源的简单模拟程序，用于了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生。 Request i 是进程Pi 的请求向量。Request i（j）=k表示进程Pi请求分配Rj类资源k个。当Pi发出资源请求后，系统按下述步骤进行检查： 1．如果Request i≤Need，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。 2．如果Request i≤Available，则转向步骤3；否则，表示
银行家算法C语言代码.doc
05-18
银行家算法C语言代码 银行家算法是操作系统中的一种资源分配算法，用于避免死锁的产生。该算法通过跟踪每个进程的资源需求和当前可用的资源量来避免死锁的产生。 在本文档中，我们提供了银行家算法的C语言代码实现...
C语言银行家算法
01-08
**银行家算法详解** 银行家算法是操作系统领域中用于预防死锁的一种策略，由艾兹格·迪杰斯特拉在1965年提出。它主要用于管理系统的资源分配，以确保系统不会进入死锁状态。在银行家算法中，系统扮演着银行家的角色...
银行家算法C语言实现
12-07
《银行家算法C语言实现详解》 银行家算法是一种经典的资源分配策略，旨在预防系统中的死锁问题。在多道程序设计系统中，多个进程可能会同时请求多种资源，如果资源分配不当，可能导致进程无法继续执行，形成死锁。...
C语言模拟银行家算法
07-18
本项目以C语言实现银行家算法，旨在帮助开发者深入理解该算法的运作机制。 在银行家算法中，系统维护着一个关于当前资源分配和需求的表格。这些表格包括： 1. **可用资源表（Available）**：记录系统当前可分配的...
操作系统银行家算法，C语言
03-31
C语言实现银行家算法时，通常会用数据结构（如二维数组）来表示进程的资源需求、分配和状态，以及系统的资源分配情况。通过编写函数来模拟请求、安全性检查和资源分配的过程。C语言的控制流程语句（如if、for、while...
银行家算法（c语言代码）
12-29
这是我参考了很多的同类代码后，自己写的一个实现银行家算法以及随机分配算法的c语言代码。这个代码符合操作系统课程设计有关银行家算法的实现。这是我的老师验收之后，并且修改过后的代码。欢迎大家下载。这个代码简单易懂，不复杂，适合大多数人使用。代码内注释较详细，更加方便读懂程序。
一文搞懂操作系统中银行家算法
m0_63006478的博客
05-25 4873
在安全序列中，每个进程按照其所需资源的顺序依次执行，并在执行完毕后释放所占用的资源，这样其他进程才能获取到所需的资源。总结来说，不安全状态指的是系统无法找到一种执行顺序，使得每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，可能导致死锁的发生。总结来说，安全序列是指满足系统安全性要求的进程执行顺序，其中每个进程都能在其所需资源得到满足时执行，并在执行完毕后释放资源，而不会发生死锁。安全序列的存在意味着系统中的资源分配是合理的，并且可以满足所有进程的需求，从而确保系统的可靠性和稳定性。
银行家算法——C语言实现
mili_j的博客
09-23 2068
银行家算法——C语言实现
操作系统 - 《银行家算法》
qq_63976098的博客
10-21 449
银行家算法以及如何使用该算法判断系统是否处于安全状态，从而避免死锁。简要地说，当进程请求资源时，银行家算法会尝试为该进程分配资源。但在正式分配之前，算法会先判断，如果现在为该进程分配资源，系统是否仍然处于一个“安全”的状态。"安全"的状态意味着即使为某个进程分配了资源，也仍有足够的资源满足其他进程的最大需求，这样就不会因为某个进程霸占资源而导致其他进程无法完成。如果所有进程都能够完成，并且按照某种顺序释放它们的资源，这样其他等待的进程就能继续完成，那么系统就被认为是“安全”的。
银行家算法(Banker's Algorithm)
蒟蒻升级中...Orz
12-22 4939
银行家算法是用来避免死锁的一种算法。每当有一个新进程，就需要给出它所需资源的最大数目，如果此数目超过系统拥有资源数，则申请失败。 对于进程的每一组请求，首先检查系统是否有足够的资源分配给它，如果有，则进一步计算，当系统分配资源后，是否处于不安全状态，如果处于不安全状态，则拒绝分配。 //main.cpp #include "Bank.h" in
C语言银行家算法的代码实现
最新发布
12-22
抱歉，我无法提供C语言银行家算法的代码实现。但是，我可以为您介绍一下银行家算法的基本原理和步骤。 银行家算法是一种用于避免死锁的资源分配算法。它通过预先分配资源并根据系统的当前状态来决定是否分配资源，以确保系统的安全性。 银行家算法的基本原理如下： 1. 系统中的每个进程都需要在开始执行之前声明其最大资源需求量、已分配资源量和需要的资源量。 2. 当一个进程请求资源时，系统会检查该请求是否能够满足，如果满足则分配资源，否则进程必须等待。 3. 当一个进程完成任务并释放资源时，系统会重新评估当前状态，并决定是否可以满足其他进程的资源请求。 银行家算法的步骤如下： 1. 初始化系统状态，包括可用资源数量和每个进程的最大资源需求量、已分配资源量和需要的资源量。 2. 当一个进程请求资源时，系统会检查该请求是否能够满足，如果满足则分配资源，并更新系统状态。 3. 如果分配资源后系统仍然处于安全状态，则进程可以继续执行，否则进程必须等待。 4. 当一个进程完成任务并释放资源时，系统会重新评估当前状态，并决定是否可以满足其他进程的资源请求。 请注意，银行家算法的具体实现可能会因编程语言和操作系统而有所不同。您可以根据以上原理和步骤自行编写C语言的银行家算法代码实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值