银行家算法

问题描述

Write the general program of banker algorithm. Avoiding deadlock in resource allocation process.
Requests: There should be at least 4 kinds of resources and 6 processes. The program can decide whether allocate resources to the process according to banker algorithm. The process requests should be input by user manually.
编写了银行家算法的通用程序。避免资源分配过程中的死锁。
要求：至少有4种资源和6个进程。程序可以根据银行家算法来决定是否为进程分配资源。流程请求应由用户手动输入。

实现过程

First, we need to create a structure to record the need,allocation and max values of each process.

Before writing the main program, we need to write a function to check the security algorithm, and each time after we enter the data, we will focus on judging whether there is a security sequence to determine whether to carry out the following resource allocation test.


In the main function, we first need to enter the total amount of four resources, and then enter the allocation and max values for each process. Calculate the threshold value of each of our processes through the allocation and max values, and then pass in the security detection function to judge.
After passing the safe sequence function, we will give a safe sequence.

After judging the first few sequences, we will make a request for process resources and determine whether resources can be allocated.

首先，我们需要创建一个结构来记录每个进程的需求、分配和最大值。
在写主程序之前，我们需要编写一个函数来检查安全算法，每次输入数据后，我们都会重点判断是否有安全序列，以确定是否进行下面的资源分配测试。
在主函数中，我们首先需要输入四个资源的总量，然后再输入每个进程的分配值和最大值。通过分配和最大值计算我们每个进程的阈值，然后传入安全检测函数进行判断。
在通过安全序列函数后，我们将给出一个安全序列。
在判断前几个序列后，我们将请求进程资源，并确定是否可以分配资源。

代码 code

#include <stdio.h>
#include <stdlib.h>

struct process
{
    int a,b,c,d;  //max值
    int x,y,z,v;  //allocation值
    int need1,need2,need3,need4;  //need值
    int finish;
}p[6];

int n=6,i,t;
int resource[5]={0};
int sum[5]={0};
int avai[4]={0};
int work[4]={0};
int request[4]={0};

void Security_Algorithm()
{ 
    int i;
    printf("系统的available值为:%d %d %d %d\n",avai[0],avai[1],avai[2],avai[3]);

    int flag=1;
    int t=0;
    int f[6]={0};

    int time;
while(1)  //
    {
        for(i=0;i<n;i++)
        {
            if( (p[i].finish==0) && (p[i].need1<=work[0]&&p[i].need2<=work[1]&&p[i].need3<=work[2]&&p[i].need4<=work[3]) )  //判断此进程是否可以通过当前的available值来运行 
            {
            work[0]+=p[i].x;
            work[1]+=p[i].y;
            work[2]+=p[i].z;
            work[3]+=p[i].v;
            p[i].finish=1;
            flag++;
            f[t++]=i;  //记录安全序列数
            }
        }
        if(flag>=6) break;   //当所有
    }

    for(i=0;i<n;i++)  //不是安全队列的情况
    {
        if(p[i].finish!=1)    //如果有一个不能进入序列，即为不安全序列
        {
            printf("系统状态不安全\n");
            break;
        }

    }

    if(i==n)   //是安全队列的情况
    {
        printf("系统状态安全\n");
        printf("安全序列为：  ");
        for(i=0;i<t;i++)     //循环打印出安全序列
        {
            printf("Process %d ",f[i]);
        }
        printf("\n");
    }

}

int main()
{
    struct process;

    printf("注: 本算法代码分析有6个进程、4类资源的问题\n");

    printf("请输入四类资源的总数量为：\n");
    for(i=0;i<4;i++)         //四类资源的总数量all a,b,c,d  
    {
        scanf("%d",&resource[i]);
    }

    printf("请按次序输入6个进程(p0-p4)的max值:\n");
    for(i=0;i<n;i++)     //每个进程所需要来运行的总值，即allocation + need 
    {
        scanf("%d %d %d %d",&p[i].a,&p[i].b,&p[i].c,&p[i].d);
        p[i].finish=0;
    }

    printf("请按次序输入6个进程(p0-p4)的allocation值:\n"); //已经有的值
    for(i=0;i<n;i++){
        scanf("%d %d %d %d",&p[i].x,&p[i].y,&p[i].z,&p[i].v);
    }

    for(i=0; i<n; i++) //计算出当前已经分配出去的值 之后用总量减去即可得到 avaliable
    {
        sum[0]+=p[i].x;
        sum[1]+=p[i].y;
        sum[2]+=p[i].z;
        sum[3]+=p[i].v;
    }

    for(i=0;i<n;i++) //计算每个程序所需要的值 即 need 
    {
        p[i].need1=p[i].a-p[i].x;
        p[i].need2=p[i].b-p[i].y;
        p[i].need3=p[i].c-p[i].z;
        p[i].need4=p[i].d-p[i].v;
    }


    //先调用安全算法
    for(i=0;i<4;i++){
        avai[i]=resource[i]-sum[i];   //得到四个资源在初始时的available值 
        work[i]=avai[i];   //得到work值
    }
    Security_Algorithm();


    //将finish置零
    for(i=0;i<n;i++)
    {
        p[i].finish=0;
    }

    
    printf("请输入你想让哪个进程发出请求(0-5):");
    scanf("%d",&t);
    printf("请输入进程发出的请求序列：");

    for(i=0;i<4;i++)
    {
        scanf("%d",&request[i]);
    }



    if(request[0]<=p[t].need1&&request[1]<=p[t].need2&&request[2]<=p[t].need3&&request[3]<=p[t].need4)
    {
        if(request[0]<=avai[0]&&request[1]<=avai[1]&&request[2]<=avai[2]&&request[3]<=avai[3])
        {
        //修改allocation值
            p[t].x+=request[0];
            p[t].y+=request[1];
            p[t].z+=request[2];
            p[t].v+=request[3];
            printf("假分配后allocation值:%d %d %d %d\n",p[t].x,p[t].y,p[t].z,p[t].v);
        //修改need值
            p[t].need1-=request[0];
            p[t].need2-=request[1];
            p[t].need3-=request[2];
            p[t].need4-=request[3];
            printf("假分配后need值:%d %d %d %d\n",p[t].need1,p[t].need2,p[t].need3,p[t].need4);
        //修改available值
            avai[0]-=request[0];
            avai[1]-=request[1];
            avai[2]-=request[2];
            avai[3]-=request[3];

            for(i=0;i<4;i++){
            work[i]=avai[i];
        }
            Security_Algorithm();
            printf("系统可以分配资源\n");
            
        }
        else printf("不满足available值,无法分配\n");
    }

    else printf("不满足条件任何一个进程的need值,无法分配\n");

    return 0;
}

运行结果

本文作者： 王某某
发布时间： 2022-05-05
最后更新： 2024-06-13
本文标题： 银行家算法
本文链接： https://www.lifeandcode.top/2022/05/05/银行家算法/
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！