操作系统linux:银行家算法(C语言实现)

一、实验内容和要求
1、在Linux环境下编译运行程序;
2、按照教材的算法编写;
3、输入数据从文本文件中读出,不从键盘录入,数据文件格式见以下说明;
4、主要数据结构的变量名和教材中的一致,包括Available、Max、Allocation、Need、Request、Work、Finish。
5、程序可支持不同个数的进程和不同个数的资源;
6、验证教材中的“银行家算法示例”中的例子(包括可成功分配、不可分配)。

二、实验原理
1.资源分配算法
令Request i表示进程p i的申请向量。Request i[j]=k,表示进程p i需要申请k个r j类资源。当进程p i申请资源时,执行下列动作:
①若Request i>Need i,表示出错,因为进程对资源申请量大于它说明的最大值。
②如果Request i>Available,则p i等待。
③假设系统把申请的资源分给进程p i,则应对有关数据结构进行修改:
Available:=Available-Request i
Allocation i:=Allocation i+Rquest i
Need i:=Need i-Request i
④系统执行安全性算法,查看此时系统状态是否安全。如果时安全的,就实际分配资源,满足进程p i的此次申请;否则,若新状态是不安全的,则p i等待,对申请的资源暂不予分配,并且把资源分配状态恢复成③之前的情况。
2.安全性算法
为了确定一个系统是否在安全状态,可采用下述算法:
①令Work和Finish分别表示长度为m和n的向量,最初,置Work:=Available,Finish[i]:=flase,i=1,2…,n。
②搜索满足下列条件的i值:Finish[i]=false,且Need i<=Work。若没有找到,则转向④。
③修改数据值:Work:=Work+Allocation i(p i释放所占的全部资源),Finish[i]:=true。转向②。
④若Finish[i]=true对所有i都成立(任一进程都可能是p i),则系统处于安全状态;否则,系统处于不安全状态。

三、验证数据:建立在程序目录下建立data文件,文件内容是:
5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
1 1 0 2
4 3 3 0
0 0 2 0
第一行:5个进程,3种资源。
第二行:每种资源系统拥有的最大数量。
3-7行:第一列是进程号(按顺序排),2-4列是Allocation(已有资源)向量,5-7列是Max(最大资源需求量)向量。
8-10行:第一列是进程号,2-4列是Request(资源请求)向量。
运行程序,通过命令行参数指定文件,如: ./banker ./data运行。

四、实现代码(banker.c文件):

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int  n ,m,t,w,flag1=1,flag2=1,flag4=1,flag5=1;
    int*Available,*Request,*Finish;
    int **Allocation,**Max,**Need,**Work;
    FILE*fp;
    fp=fopen("/home/student/data.txt","r");                   //打开.txt文件
    fscanf(fp,"%d",&n),fscanf(fp,"%d",&m);                 //赋值.txt文件的数值,n*m二维数组
    Available = (int*)malloc(sizeof(int)*m);                                  //开动态一维数组
    for(int i=0;i<m;i++)                                                         //给一维数组赋值
        fscanf(fp,"%d",&Available[i]);
    Allocation= (int**)malloc(sizeof(int*)*n);               //开动态二维数组
    Max= (int**)malloc(sizeof(int*)*n); 
    Need= (int**)malloc(sizeof(int*)*n); 
    for (int i = 0; i < n; i++)
         {
            Allocation[i] = (int*)malloc(sizeof(int)*m);
            Max[i] = (int*)malloc(sizeof(int)*m);
            Need[i] = (int*)malloc(sizeof(int)*m);
         }
    for(int i=0;i<n;i++)                       //给二维数组赋值
        {
            fscanf(fp,"%d",&t);               //t为进程编号
            for(int j=0;j<m;j++)
                fscanf(fp,"%d",&Allocation[t][j]);
            for(int  j=0;j<m;j++)
                fscanf(fp,"%d",&Max[t][j]);
            for(int j=0;j<m;j++)
                Need[i][j]=Max[i][j]-Allocation[i][j];
        }
     for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
                Available[i]-=Allocation[j][i];
    fscanf(fp,"%d",&w);             //w为发出请求的进程的编号
    Request = (int*)malloc(sizeof(int)*m);
    for(int i=0;i<m;i++)
            fscanf(fp,"%d",&Request[i]);
    for(int i=0;i<m;i++)
        if(Request[i]>Need[w][i])
            flag1=0; 
    if(!flag1)                       //flag1用来判断Request是否小于等于Need
        printf("Flase");
    else {
        for(int i=0;i<m;i++)
            if(Request[i]>Available[i])
                flag2=0; 
        if(!flag2)                          //flag2用来判断Request是否小于等于Available
            printf("p %d 等待",w);
        else {
            for(int i=0;i<m;i++)             //假设系统把申请的资源分给进程
                {
                    Available[i]-=Request[i];
                    Allocation[w][i]+=Request[i];
                    Need[w][i]-=Request[i];
                }
            Work= (int**)malloc(sizeof(int*)*n);
            for (int i = 0; i < n; i++)
                Work[i] = (int*)malloc(sizeof(int)*m);
            Finish = (int*)malloc(sizeof(int)*n);
            for(int i=0;i<n;i++)
                Finish[i]=0;                     //fnish[i]=0代表fnish[i]=flase,fnish[i]=1代表fnish[i]=true
            for(int i=0;i<n;i++)
                for(int j=0;j<m;j++)
                        Work[i][j]=Available[j];
            while(flag5)               //安全性算法,flag5用来判断系统是否已经完成安全性判断
                {
                    for(int i=0;i<n;i++)                //每次从0号进程开始搜索是否有满足条件的进程
                        {
                            int flag3=1;                             //flag3用来判断Need是否小于等于Work
                            for(int j=0;j<m;j++)
                                   if(Need[i][j]>Work[i][j])
                                        flag3=0;
                            if(!Finish[i]&&flag3)            //找到满足Finish[i]=false且Need小于等于Work
                            {
                                Finish[i]=1;                            //置Finish[i]=true
                                for(int j=0;j<n;j++)                   //释放进程所占全部资源
                                    for(int k=0;k<m;k++)
                                        if(j!=i&&!Finish[j])
                                               Work[j][k]=Work[i][k]+Allocation[i][k];
                                break;
                            }
                            else if(i==n-1)                        //没有找到满足条件的并且是最后一个进程
                            {
                                    for(int j=0;j<n;j++)
                                        if(!Finish[j])
                                            flag4=0; 
                                    if(flag4)                       //flag4用来判断是否所有进程都是Finish[i]=true
                                    {
                                        printf("系统处于安全状态\n");
                                        printf("Work:\n");
                                        for(int j=0;j<n;j++)              //输出安全状态下,系统把申请的资源分配给进程资源的情况
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Work[j][k]);
                                                printf("\n");
                                            }
                                        printf("Alllcation:\n");
                                        for(int j=0;j<n;j++)
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Allocation[j][k]);
                                                printf("\n");
                                            }
                                        printf("Need:\n");
                                        for(int j=0;j<n;j++)
                                            {
                                                for(int k=0;k<m;k++)
                                                printf("%4d",Need[j][k]);
                                                printf("\n");
                                            }
                                        printf("Available:\n");
                                        for(int j=0;j<m;j++)
                                            printf("%4d",Work[n-1][j]+Allocation[n-1][j]);
                                        flag5=0;
                                    }
                                    else{
                                        printf("系统处于不安全状态\n");
                                        for(int j=0;j<m;j++)             //系统不安全,还原资源分配给进程前的情况
                                            {
                                                Available[j]+=Request[j];
                                                Allocation[w][j]-=Request[j];
                                                Need[w][j]+=Request[j];
                                            }
                                        flag5=0;
                                    }
                            }
                        }
                }
        }
    }
}

五、结果验证
1.验证第一个资源请求
//data.txt.文件
5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
1 1 0 2

输出结果:
在这里插入图片描述
2.验证第二个资源请求
/data.txt文件/
5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
4 3 3 0

输出结果:
在这里插入图片描述
3.验证第三个资源请求
/data.txt文件/

5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
0 0 2 0

输出结果:
在这里插入图片描述
4.验证资源请求出错(即Request i>Need i)
/data.txt文件/
5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
3 0 2 1

输出结果:
在这里插入图片描述
5.验证进程资源请求等待(即Request i>Available)
/data.txt文件/
5 3
10 5 7
0 0 1 0 7 5 3
1 2 0 0 3 2 2
2 3 0 2 9 0 2
3 2 1 1 2 2 2
4 0 0 2 4 3 3
0 4 4 3

输出结果:
在这里插入图片描述

  • 14
    点赞
  • 122
    收藏
    觉得还不错? 一键收藏
  • 7
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值