C语言银行家算法

最新推荐文章于 2024-03-14 12:39:18 发布
最新推荐文章于 2024-03-14 12:39:18 发布
阅读量6.4w 收藏 521
点赞数 61
分类专栏： C语言 操作系统 徐奕的专栏 文章标签： C语言 操作系统
© 2023 • OmegaXYZ.com-版权所有，转载请注明出处-原创代码采用 Apache 2.0 授权，原创文章采用 BY-NC-SA 4.0 授权
本文链接：https://blog.csdn.net/xyisv/article/details/80466946
版权

算法简介
银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。

算法目的
为了了解系统的资源分配情况，假定系统的任何一种资源在任意时刻只能被一个进程使用，任何进程已经占用的资源只能由进程自己释放，而不能由其他进程抢占，当进程申请的资源不能满足时，必须等待。因此只要资源分配算法能保证进程的资源请求，且不出现循环等待，则系统不会出现死锁。

算法原理
在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。

银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是，才分配。它是最具有代表性的避免死锁的算法。

设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。

(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转（2)；否则，出错。
(2)如果REQUEST [cusneed] [i]<= AVAILABLE[i]，则转（3)；否则，等待。
(3)系统试探分配资源，修改相关数据：
AVAILABLE[i]-=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

NEED[cusneed][i]-=REQUEST[cusneed][i];

(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
安全性检查算法

（1）设置两个工作向量Work=AVAILABLE;FINISH
（2）从进程集合中找到一个满足下述条件的进程，
FINISH==false;

NEED<=Work;

如找到，执行（3)；否则，执行（4)

(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
Work=Work+ALLOCATION;

Finish=true;

GOTO 2
这里写图片描述
原始代码：

#include<stdio.h>
#define true 1
#define false 0
#define processNum 5
#define resourceNum 3
#define MAXINT 9999
typedef int bool;

int available[resourceNum]={3,3,2};
int maxRequest[processNum][resourceNum]={7,5,3,3,2,2,9,0,2,2,2,2,4,3,3};
int allocation[processNum][resourceNum]={0,1,0,2,0,0,3,0,2,2,1,1,0,0,2};
int need[processNum][resourceNum]={7,4,3,1,2,2,6,0,0,0,1,1,4,3,1};
bool Finish[processNum];
int safeSeries[processNum]={MAXINT, MAXINT , MAXINT , MAXINT , MAXINT};
int request[resourceNum];

void Init()
{
    int i, j;
    printf("输入进程数量、资源数量\n");
    //scanf("%d %d",&processNum,&resourceNum);
    printf("输入当前资源可用数目\n");
    for(i = 0; i < resourceNum; i++){
        scanf("%d",&available[i]);
    }
    printf("输入最大需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&maxRequest[i][j]);
        }
    }
    printf("输入分配矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&allocation[i][j]);
        }
    }
    printf("输入当前需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&need[i][j]);
        }
    }
}

void showInfo()
{
    int i,j;
    printf("当前资源剩余：");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",available[j]);
    }
    printf("\n");
    printf(" PID\t Max\t\tAllocation\tNeed\n");
    for(i = 0; i < processNum; i++){
        printf(" P%d\t",i);
        for(j = 0; j < resourceNum; j++){
            printf("%d ",maxRequest[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",allocation[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",need[i][j]);
        }
        printf("\n");
    }
}

bool isSafe()
{
    int i,j,k;
    int trueFinished = 0;
    int work[resourceNum];
    for(i = 0; i < resourceNum; i++){
        work[i]=available[i];
    }

    for(i = 0; i < processNum; i++){
        Finish[i]=false;
    }
    i = 0;
    int temp = 0;
    while(trueFinished != processNum){
        int j =0;
        if(Finish[i]!= true){
            for(j = 0; j < resourceNum; j++){
                if(need[i][j] > work[j]){break;}
            }
        }
        if(j == resourceNum){
            Finish[i]=true;
            SafeInfo(work,i);
            for(k = 0; k < resourceNum; k++){
                work[k]+=allocation[i][k];
            }
            int k2;
            safeSeries[trueFinished++] = i;
        }
        i++;
        if(i >= processNum)
        {
            i = i % processNum;
            if(temp == trueFinished)
                break;
        }
        temp = trueFinished;
    }

    if(trueFinished == processNum){
        printf("\n系统安全！\n\n安全序列为：");
        for(i = 0; i < processNum; i++){
            printf("%d ",safeSeries[i]);
        }
        return true;
    }
    printf("******系统不安全！******\n");
    return false;
}

void SafeInfo(int *work, int i)
{
    int j;
    printf(" P%d\t",i);
    for(j = 0; j < resourceNum; j++){
        printf("%d ",work[j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",need[i][j]);
    }
    printf("\t ");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]+work[j]);
    }
    printf("\n");
}


int main()
{
    int i,j,curProcess;
    int wheInit = 0;
    printf("是否使用内置数据？0是，1否：");
    scanf("%d",&wheInit);
    if(wheInit)
        Init();  //可以不使用，选用内置的数据进行测试
    printf("---------------------------------------------------------\n");
    showInfo();
    printf("\n系统安全情况分析\n");
    printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
    isSafe();
    while(true){
        printf("\n---------------------------------------------------------\n");
        printf("\n输入要分配的进程：");
        scanf("%d",&curProcess);
        printf("\n输入要分配给进程P%d的资源：",curProcess);
        for(j = 0; j < resourceNum; j++){
            scanf("%d", &request[j]);
        }
        for(j = 0; j < resourceNum; j++){
            if(request[j] <= need[curProcess][j])continue;
            else{printf("ERROR！\n");break;}
        }
        if(j == resourceNum){
            for(j = 0; j < resourceNum; j++){
                if(request[j] <= need[curProcess][j])continue;
                else{printf("资源不足，等待中！\n");break;}
            }
            if(j == resourceNum){
                for(j = 0; j < resourceNum; j++){
                    available[j] -= request[j];
                    allocation[curProcess][j] += request[j];
                    need[curProcess][j] -= request[j];
                }
                printf("\n系统安全情况分析\n");
                printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
                if(isSafe()){
                    printf("分配成功！\n");
                    showInfo();
                }else{
                    for(j = 0; j < resourceNum; j++){
                        available[j] += request[j];
                        allocation[curProcess][j] -= request[j];
                        need[curProcess][j] += request[j];
                    }
                    printf("分配失败！\n");
                    showInfo();
                }
            }
        }
    }
}

这里写图片描述
修正后的代码：参考评论Sean0977

#include<stdio.h>
#define true 1
#define false 0
#define processNum 5
#define resourceNum 3
#define MAXINT 9999
typedef int bool;

int available[resourceNum]={3,3,2};
int maxRequest[processNum][resourceNum]={7,5,3,3,2,2,9,0,2,2,2,2,4,3,3};
int allocation[processNum][resourceNum]={0,1,0,2,0,0,3,0,2,2,1,1,0,0,2};
int need[processNum][resourceNum]={7,4,3,1,2,2,6,0,0,0,1,1,4,3,1};
bool Finish[processNum];
int safeSeries[processNum]={MAXINT, MAXINT , MAXINT , MAXINT , MAXINT};
int request[resourceNum];

void Init()
{
    int i, j;
    printf("输入进程数量、资源数量\n");
    //scanf("%d %d",&processNum,&resourceNum);
    printf("输入当前资源可用数目\n");
    for(i = 0; i < resourceNum; i++){
        scanf("%d",&available[i]);
    }
    printf("输入最大需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&maxRequest[i][j]);
        }
    }
    printf("输入分配矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&allocation[i][j]);
        }
    }
    printf("输入当前需求矩阵\n");
    for(i = 0; i < processNum; i++){
        for(j = 0; j < resourceNum; j++){
            scanf("%d",&need[i][j]);
        }
    }
}

void showInfo()
{
    int i,j;
    printf("当前资源剩余：");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",available[j]);
    }
    printf("\n");
    printf(" PID\t Max\t\tAllocation\tNeed\n");
    for(i = 0; i < processNum; i++){
        printf(" P%d\t",i);
        for(j = 0; j < resourceNum; j++){
            printf("%d ",maxRequest[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",allocation[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++){
            printf("%d ",need[i][j]);
        }
        printf("\n");
    }
}

bool isSafe()
{
    int i,j,k;
    int trueFinished = 0;
    int work[resourceNum];
    for(i = 0; i < resourceNum; i++){
        work[i]=available[i];
    }

    for(i = 0; i < processNum; i++){
        Finish[i]=false;
    }
    i = 0;
    int temp = 0;
    while(trueFinished != processNum){
        int j =0;
        if(Finish[i]!= true){
            for(j = 0; j < resourceNum; j++){
                if(need[i][j] > work[j]){break;}
            }
        }
        if(j == resourceNum){
            Finish[i]=true;
            SafeInfo(work,i);
            for(k = 0; k < resourceNum; k++){
                work[k]+=allocation[i][k];
            }
            int k2;
            safeSeries[trueFinished++] = i;
        }
        i++;
        if(i >= processNum)
        {
        	if(flag==0)
        	{
        		temp=trueFinished;
        		temp0=trueFinished;        		
			}
            i = i % processNum;         
            if(flag==1){
            temp=trueFinished;
            if(temp == temp0)
                break;
            else
            	temp0=temp;
            }        
            flag=1;
        }
        temp = trueFinished;
    }

    if(trueFinished == processNum){
        printf("\n系统安全！\n\n安全序列为：");
        for(i = 0; i < processNum; i++){
            printf("%d ",safeSeries[i]);
        }
        return true;
    }
    printf("******系统不安全！******\n");
    return false;
}

void SafeInfo(int *work, int i)
{
    int j;
    printf(" P%d\t",i);
    for(j = 0; j < resourceNum; j++){
        printf("%d ",work[j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",need[i][j]);
    }
    printf("\t ");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++){
        printf("%d ",allocation[i][j]+work[j]);
    }
    printf("\n");
}


int main()
{
    int i,j,curProcess;
    int wheInit = 0;
    printf("是否使用内置数据？0是，1否：");
    scanf("%d",&wheInit);
    if(wheInit)
        Init();  //可以不使用，选用内置的数据进行测试
    printf("---------------------------------------------------------\n");
    showInfo();
    printf("\n系统安全情况分析\n");
    printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
    isSafe();
    while(true){
        printf("\n---------------------------------------------------------\n");
        printf("\n输入要分配的进程：");
        scanf("%d",&curProcess);
        printf("\n输入要分配给进程P%d的资源：",curProcess);
        for(j = 0; j < resourceNum; j++){
            scanf("%d", &request[j]);
        }
        for(j = 0; j < resourceNum; j++){
            if(request[j] <= need[curProcess][j])continue;
            else{printf("ERROR！\n");break;}
        }
        if(j == resourceNum){
            for(j = 0; j < resourceNum; j++){
                if(request[j] <= need[curProcess][j])continue;
                else{printf("资源不足，等待中！\n");break;}
            }
            if(j == resourceNum){
                for(j = 0; j < resourceNum; j++){
                    available[j] -= request[j];
                    allocation[curProcess][j] += request[j];
                    need[curProcess][j] -= request[j];
                }
                printf("\n系统安全情况分析\n");
                printf(" PID\t Work\t\tNeed\tAllocation\tWork+Allocation\n");
                if(isSafe()){
                    printf("分配成功！\n");
                    showInfo();
                }else{
                    for(j = 0; j < resourceNum; j++){
                        available[j] += request[j];
                        allocation[curProcess][j] -= request[j];
                        need[curProcess][j] += request[j];
                    }
                    printf("分配失败！\n");
                    showInfo();
                }
            }
        }
    }
}

更多内容访问omegaxyz.com
网站所有代码采用Apache 2.0授权
网站文章采用知识共享许可协议BY-NC-SA4.0授权
© 2018 • OmegaXYZ-版权所有 转载请注明出处

Reacubeth
关注
  • 61
    点赞
  • 踩
  • 521
    收藏
    觉得还不错? 一键收藏
  • 21
    评论
专栏目录
银行家算法（c语言代码）
12-29
这是我参考了很多的同类代码后，自己写的一个实现银行家算法以及随机分配算法的c语言代码。这个代码符合操作系统课程设计有关银行家算法的实现。这是我的老师验收之后，并且修改过后的代码。欢迎大家下载。这个代码简单易懂，不复杂，适合大多数人使用。代码内注释较详细，更加方便读懂程序。
C语言实现的操作系统银行家算法
流楚丶格念的博客
12-19 1万+
文章目录一、银行家算法二、方案分析三、开发环境四、设计思想及实验步骤4.1 设计思想4.2 银行家算法中的数据结构4.3 银行家算法bank()4.4 安全性算法safe()五、程序的基本结构框图和流程图5.1 程序结构功能图5.2 流程图六、源代码 一、银行家算法 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 　　在
银行家算法的实现
最新发布
m0_68447809的博客
03-14 662
本次实验是操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。
用C语言描述银行家算法，安全性算法的过程
qq_37431083的博客
07-05 1590
算法简介 银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为了实现银行家算法，在系统中必须设置这样四个数据结构，分别用来描述系统中可利用的资源、所有进程对资源的最大需求、系统中的资源分配，以及所有进程还需要多少资源的情况。 1.数据结构 (1) 可利用资源向量 Available。这是一个含有 m 个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系
操作系统实验四 银行家算法
热门推荐
cyang's blog
11-30 8万+
操作系统实验四 银行家算法一、实验目的 1、 理解银行家算法。 2、 掌握进程安全性检查的方法与资源分配的方法。 二、实验内容与基本要求编制模拟银行家算法的程序，并以下面给出的例子验证所编写的程序的正确性。 进程 已占资源 最大需求数 资源种类 A B C D A B C D P0 0 0 1 2 0 0 1 2 P1 1 0 0 0 1 7
操作系统------银行家算法（C语言）
weixin_33716941的博客
12-13 2347
（1）基本概念 死锁：多个进程在执行过程中，因为竞争资源会造成相互等待的局面。如果没有外力作用，这些进程将永远无法向前推进。此时称系统处于死锁状态或者系统产生了死锁。 安全序列：系统按某种顺序并发进程，并使它们都能达到获得最大资源而顺序完成的序列为安全序列。 安全状态：能找到安全序列的状态称为安全状态，安全状态不会导致死锁。 ...
C语言实现银行家算法
喂兔子的菜
04-25 7332
//银行家算法/*** 作者：老谢* 最后修改日期：2006，4，21* Email：[email protected]* 功能：银行家算法实现**/#include #include #include #define M 5 /*进程数*/#define N 3 /*资源数*//*** TC中用到#define true 1#define false 0typedef int bool*
银行家算法C语言实现
12-07
银行家算法C语言实现，避免死锁的经典算法的C语言实现
银行家算法（c语言）
01-18
操作系统课的实验（银行家算法）#include "malloc.h" 　　#include "stdio.h" 　　#include "stdlib.h" 　　#define alloclen sizeof(struct allocation) 　　#define maxlen sizeof(struct max) 　　#define avalen sizeof(struct available) 　　#define needlen sizeof(struct need) 　　#define finilen sizeof(struct finish) 　　#define pathlen sizeof(struct path) 　　struct allocation 　　{ 　　int value; 　　struct allocation *next; 　　}; 　　struct max 　　{ 　　int value; 　　struct max *next; 　　}; 　　struct available /*可用资源数*/ 　　{ 　　int value; 　　struct available *next; 　　}; 　　struct need /*需求资源数*/ 　　{ 　　int value; 　　struct need *next; 　　}; 　　struct path 　　{ 　　int value; 　　struct path *next; 　　}; 　　struct finish 　　{ 　　int stat; 　　struct finish *next; 　　}; 　　int main() 　　{ 　　int row,colum,status=0,i,j,t,temp,processtest; 　　struct allocation *allochead,*alloc1,*alloc2,*alloctemp; 　　struct max *maxhead,*maxium1,*maxium2,*maxtemp; 　　struct available *avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1; 　　struct need *needhead,*need1,*need2,*needtemp; 　　struct finish *finihead,*finish1,*finish2,*finishtemp; 　　struct path *pathhead,*path1,*path2; 　　printf("\n请输入系统资源的种类数:"); 　　scanf("%d",&colum); 　　printf("请输入现时内存中的进程数:"); 　　scanf("%d",&row); 　　printf("请输入已分配资源矩阵:\n"); 　　for(i=0;i<row;i++) 　　{ 　　for (j=0;jnext=alloc2->next=NULL; 　　scanf("%d",&allochead->value); 　　status++; 　　} 　　else 　　{ 　　alloc2=(struct allocation *)malloc(alloclen); 　　scanf("%d,%d",&alloc2->value); 　　if(status==1) 　　{ 　　allochead->next=alloc2; 　　status++; 　　} 　　alloc1->next=alloc2; 　　alloc1=alloc2; 　　} 　　} 　　} 　　alloc2->next=NULL; 　　status=0; 　　printf("请输入最大需求矩阵:\n"); 　　for(i=0;i<row;i++) 　　{ 　　for (j=0;jnext=maxium2->next=NULL; 　　scanf("%d",&maxium1->value); 　　status++; 　　} 　　else 　　{ 　　maxium2=(struct max *)malloc(maxlen); 　　scanf("%d,%d",&maxium2->value); 　　if(status==1) 　　{ 　　maxhead->next=maxium2; 　　status++; 　　} 　　maxium1->next=maxium2; 　　maxium1=maxium2; 　　} 　　} 　　} 　　maxium2->next=NULL; 　　status=0; 　　printf("请输入现时系统剩余的资源矩阵:\n"); 　　for (j=0;jnext=available2->next=NULL; 　　work1->next=work2->next=NULL; 　　scanf("%d",&available1->value); 　　work1->value=available1->value; 　　status++; 　　} 　　else 　　{ 　　available2=(struct available*)malloc(avalen); 　　work2=(struct available*)malloc(avalen); 　　scanf("%d,%d",&available2->value); 　　work2->value=available2->value; 　　if(status==1) 　　{ 　　avahead->next=available2; 　　workhead->next=work2; 　　status++; 　　} 　　available1->next=available2; 　　available1=available2; 　　work1->next=work2; 　　work1=work2; 　　} 　　} 　　available2->next=NULL; 　　work2->next=NULL; 　　status=0; 　　alloctemp=allochead; 　　maxtemp=maxhead; 　　for(i=0;i<row;i++) 　　for (j=0;jnext=need2->next=NULL; 　　need1->value=maxtemp->value-alloctemp->value; 　　status++; 　　} 　　else 　　{ 　　need2=(struct need *)malloc(needlen); 　　need2->value=(maxtemp->value)-(alloctemp->value); 　　if(status==1) 　　{ 　　needhead->next=need2; 　　status++; 　　} 　　need1->next=need2; 　　need1=need2; 　　} 　　maxtemp=maxtemp->next; 　　alloctemp=alloctemp->next; 　　} 　　need2->next=NULL; 　　status=0; 　　for(i=0;inext=finish2->next=NULL; 　　finish1->stat=0; 　　status++; 　　} 　　else 　　{ 　　finish2=(struct finish*)malloc(finilen); 　　finish2->stat=0; 　　if(status==1) 　　{ 　　finihead->next=finish2; 　　status++; 　　} 　　finish1->next=finish2; 　　finish1=finish2; 　　} 　　} 　　finish2->next=NULL; /*Initialization compleated*/ 　　status=0; 　　processtest=0; 　　for(temp=0;temp<row;temp++) 　　{ 　　alloctemp=allochead; 　　needtemp=needhead; 　　finishtemp=finihead; 　　worktemp=workhead; 　　for(i=0;istat==0) 　　{ 　　for(j=0;jnext,worktemp=worktemp->next) 　　if(needtemp->valuevalue) 　　processtest++; 　　if(processtest==colum) 　　{ 　　for(j=0;jvalue+=alloctemp->value; 　　worktemp1=worktemp1->next; 　　alloctemp=alloctemp->next; 　　} 　　if(status==0) 　　{ 　　pathhead=path1=path2=(struct path*)malloc(pathlen); 　　path1->next=path2->next=NULL; 　　path1->value=i; 　　status++; 　　} 　　else 　　{ 　　path2=(struct path*)malloc(pathlen); 　　path2->value=i; 　　if(status==1) 　　{ 　　pathhead->next=path2; 　　status++; 　　} 　　path1->next=path2; 　　path1=path2; 　　} 　　finishtemp->stat=1; 　　} 　　else 　　{ 　　for(t=0;tnext; 　　finishtemp->stat=0; 　　} 　　} 　　else 　　for(t=0;tnext; 　　alloctemp=alloctemp->next; 　　} 　　processtest=0; 　　worktemp=workhead; 　　finishtemp=finishtemp->next; 　　} 　　} 　　path2->next=NULL; 　　finishtemp=finihead; 　　for(temp=0;tempstat==0) 　　{ 　　printf("\n系统处于非安全状态!\n"); 　　exit(0); 　　} 　　finishtemp=finishtemp->next; 　　} 　　printf("\n系统处于安全状态.\n"); 　　printf("\n安全序列为: \n"); 　　do 　　{ 　　printf("p%d ",pathhead->value); 　　} 　　while(pathhead=pathhead->next); 　　printf("\n"); 　　return 0; 　　} #include "string.h" #include #include #define M 5 #define N 3 #define FALSE 0 #define TRUE 1 /*M个进程对N类资源最大资源需求量*/ int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; /*系统可用资源数*/ int AVAILABLE[N]={10,5,7}; /*M个进程对N类资源最大资源需求量*/ int ALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}}; /*M个进程已经得到N类资源的资源量 */ int NEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; /*M个进程还需要N类资源的资源量*/ int Request[N]={0,0,0}; void main() { int i=0,j=0; char flag='Y'; void showdata(); void changdata(int); void rstordata(int); int chkerr(int); showdata(); while(flag=='Y'||flag=='y') { i=-1; while(i=M) { printf("请输入需申请资源的进程号（从0到"); printf("%d",M-1); printf("，否则重输入!）:"); scanf("%d",&i); if(i=M)printf("输入的进程号不存在，重新输入!\n"); } printf("请输入进程"); printf("%d",i); printf("申请的资源数\n"); for (j=0;jNEED[i][j]) { printf("进程"); printf("%d",i); printf("申请的资源数大于进程"); printf("%d",i); printf("还需要"); printf("%d",j); printf("类资源的资源量!申请不合理，出错!请重新选择!\n"); /*printf("申请不合理，出错!请重新选择!\n");*/ flag='N'; break; } else { if(Request[j]>AVAILABLE[j]) { printf("进程"); printf("%d",i); printf("申请的资源数大于系统可用"); printf("%d",j); printf("类资源的资源量!申请不合理，出错!请重新选择!\n"); /*printf("申请不合理，出错!请重新选择!\n");*/ flag='N'; break; } } } if(flag=='Y'||flag=='y') { changdata(i); if(chkerr(i)) { rstordata(i); showdata(); } else showdata(); } else showdata(); printf("\n"); printf("是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: "); scanf("%c",&flag); } } void showdata() { int i,j; printf("系统可用的资源数为:\n"); printf(" "); for (j=0;j<N;j++){ printf(" 资源"); printf("%d",j); printf(":"); printf("%d",AVAILABLE[j]); /*printf("\n");*/ /* cout<<endl; // cout<<"各进程资源的最大需求量:"<<endl<<endl; // for (i=0;i<M;i++) // { // cout<<"进程"<<i<<":"; // for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<MAX[i][j]; // cout<<endl; */ } printf("\n"); printf("各进程还需要的资源量:\n"); for (i=0;i<M;i++) { printf(" 进程"); printf("%d",i); printf(":"); for (j=0;j<N;j++){ printf("资源"); printf("%d",j); printf(":"); printf("%d",NEED[i][j]); /*printf("\n");*/ } printf("\n"); } printf("各进程已经得到的资源量: \n"); for (i=0;i<M;i++) { printf(" 进程"); printf("%d",i); /*printf(":\n");*/ for (j=0;j<N;j++){ printf("资源"); printf("%d",j); printf(":"); printf("%d",ALLOCATION[i][j]); /*printf("\n");*/ } printf("\n"); } } void changdata(int k) { int j; for (j=0;j<N;j++) { AVAILABLE[j]=AVAILABLE[j]-Request[j]; ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j]; NEED[k][j]=NEED[k][j]-Request[j]; } }; void rstordata(int k) { int j; for (j=0;j<N;j++) { AVAILABLE[j]=AVAILABLE[j]+Request[j]; ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j]; NEED[k][j]=NEED[k][j]+Request[j]; } }; int chkerr(int s) { int WORK,FINISH[M],temp[M]; int i,j,k=0; for(i=0;i<M;i++)FINISH[i]=FALSE; for(j=0;j<N;j++) { WORK=AVAILABLE[j]; i=s; while(i<M) { if (FINISH[i]==FALSE&&NEED[i][j]<=WORK) { WORK=WORK+ALLOCATION[i][j]; FINISH[i]=TRUE; temp[k]=i; k++; i=0; } else { i++; } } for(i=0;i<M;i++) if(FINISH[i]==FALSE) { printf("\n"); printf("系统不安全!!! 本次资源申请不成功!!!\n"); printf("\n"); return 1; } } printf("\n"); printf("经安全性检查，系统安全，本次分配成功。\n"); printf("\n"); printf(" 本次安全序列："); for(i=0;i"); } printf("\n"); return 0; }
银行家算法-C语言实现
m0_56655241的博客
05-13 4512
算法简介 银行家算法（Banker’sAlgorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 —百度百科 当一个进程申请使用资源的时候，银行家算法通过先试探分配给该进程资源，然后通过安全性算法判断分配后的系统是否处于安全状态，若不安全则试探分配作废，让该进程继续等待。 安全性算法是判断分配后的系统是否会进入不安全状态，若不存在安全序列，则判定系统已经进入
银行家算法——C语言（11计科1班-孙鹏启——修正）
张同光 (Tongguang Zhang)：Hello everyone !
02-01 878
#define M 50 #include "stdio.h" int max[M][M], allocation[M][M], need[M][M], available[M];    /*定义全局变量 */ int i, j, n, m, r, t; void main() {     void check();     void print();     int p, q;
银行家算法C语言代码
06-20
银行家算法C语言代码银行家算法C语言代码银行家算法C语言代码银行家算法C语言代码
c语言银行家算法编程
04-14
(1) 进程 已分配资源数下列状态是否安全？(三个进程共享12个同类资源) 最大需求数 1 1 4 (状态a) 2 4 4 3 5 8 1 1 4 2 4 6 (状态b) 3 6 8 (2) 考虑下列系统状态 分配矩阵 最大需求矩阵 可用资源矩阵 0 0 1 2 0 0 1 2 1 5 2 0 1 0 0 0 1 7 5 0 1 3 5 4 2 3 5 6 0 6 3 2 0 6 5 2 0 0 1 4 0 6 5 6 问系统是否安全？若安全就给出所有的安全序列。若进程2请求(0420)，可否立即分配？ 编程实现解决上述问题。
银行家算法C语言代码.doc
05-18
银行家算法C语言代码.doc
c语言银行家算法
01-01
c编写的银行家算法，c语言编写的银行家算法比较简单，看看指出不足之处。
C语言 银行家算法
12-11
亲自编写的C语言 操作系统 银行家算法，有各种容错性！
银行家算法详解（C语言）
sparky的博客
05-16 2万+
概述 银行家算法是荷兰学者Dijkstra为银行系统设计的，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况。后来该算法被用在操作系统中，用于避免死锁 核心思想：在进程提出资源申请时，先预判此分配是否会导致系统进入不安全状态。如果会进入不安全状态，就暂时不答应这次请求，让该进程先阻塞等待。 过程演示图解 假定有五个进程{P0,P1,P2,P3,P4}和三类资源{A，B，C}，各种资源的数量分别为10、5、7。在T0时刻的资源分配情况如下 T0时刻的安全性 P1发出请求向量Request1（1,
c语言银行家算法代码
05-31
下面是一个简单的C语言银行家算法代码示例： ```c #include int main() { int i, j, process_count, resource_count; printf("Enter number of processes: "); scanf("%d", &process_count); printf("Enter...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值