操作系统-银行家算法-课程设计C语言版本

博主终于从各种课程设计中解脱了,虽然还有其他事情要做,大学虽然靠躺,但是我还是认为在某些事情上认真投入自己的心血还是有必要的。比如课程设计,你投入了不仅老师会给你高分,你自己的能力也会见长。

想必银行家算法也不要多说什么了,学过操作系统的都知道。下面是我粘贴的别人的描述的一段话:

实验基本知识及原理

(1)基本概念
    死锁:多个进程在执行过程中,因为竞争资源会造成相互等待的局面。如果没有外力作用,这些进程将永远无法向前推进。此时称系统处于死锁状态或者系统产生了死锁。
    安全序列:系统按某种顺序并发进程,并使它们都能达到获得最大资源而顺序完成的序列为安全序列。
    安全状态:能找到安全序列的状态称为安全状态,安全状态不会导致死锁。
    不安全状态:在当前状态下不存在安全序列,则系统处于不安全状态。
(2)银行家算法
    银行家算法顾名思义是来源于银行的借贷业务,一定数量的本金要满足多个客户的借贷周转,为了防止银行家资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。

在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其它进程使用资源。如果资源分配不当,就会发生进程循环等待资源,则进程都无法继续执行下去的死锁现象。
    当一进程提出资源申请时,银行家算法执行下列步骤以决定是否向其分配资源:
    (1)检查该进程所需要的资源是否已超过它所宣布的最大值。
    (2)检查系统当前是否有足够资源满足该进程的请求。
    (3)系统试探着将资源分配给该进程,得到一个新状态。
    (4)执行安全性算法,若该新状态是安全的,则分配完成;若新状态是不安全的,则恢复原状态,阻塞该进程。
 

我还是喜欢直接贴代码,本次代码可以实现动态资源量,动态的进程数,可以实现自由输入。

#include <stdio.h>

#define SIZE 100

typedef int bool;
#define false 0
#define true !false

int Available[SIZE];
int Max[SIZE][SIZE];
int Allocation[SIZE][SIZE];
int Need[SIZE][SIZE];
int safe[SIZE];
int Finish[SIZE];

int Ava,Pnum;
char ch,A;


//试探分配
void ProbeAlloc(int process,int *res){
    int i;
    
    for (i=0; i<Ava; i++) {
        Available[i] -= res[i];
    }
    
    for (i=0; i<Ava; i++) {
        Allocation[process][i] += res[i];
    }
    
    for (i=0; i<Ava; i++) {
        Need[process][i] -= res[i];
    }
    
}

//若试探分配后进入不安全状态,将分配回滚
void RollBack(int process,int *res){
    int i;
    
    for (i=0; i<Ava; i++) {
        Available[i] += res[i];
    }
    
    for (i=0; i<Ava; i++) {
        Allocation[process][i] -= res[i];
    }
    
    for (i=0; i<Ava; i++) {
        Need[process][i] += res[i];
    }
}


void init()
{
    int i=0,j=0;
    //初始化Available数组数值为-1
    for(i = 0; i <SIZE; i++)
        Available[i] = -1;
    
    //初始化Max数组
    for(i=0;i<SIZE;i++){
        for(j=0;j<SIZE;j++){
            Max[i][j] = -1;
        }
    }
    //初始化Allocation数组
    for(i=0;i<SIZE;i++){
        for(j=0;j<SIZE;j++){
            Allocation[i][j] = -1;
        }
    }//初始化Need数组
    for(i=0;i<SIZE;i++){
        for(j=0;j<SIZE;j++){
            Need[i][j] = -1;
        }
    }
}
void input()
{
    
    
    A='A';
    
    
    int i,j;
    
    printf("请输入资源数量:");
    scanf("%d",&Ava);
    ch=getchar();
    printf("\n");
    for(i=0;i<Ava;i++)
    {
        int data;
        printf("请输入资源%c的数量:",A+i);
        
        scanf("%d",&data);
        ch=getchar();
        
        printf("\n");
        Available[i]=data;
    }
    printf("\n资源输入完毕\n");
    
    //Max段
    printf("请输入进程的数量:");
    scanf("%d",&Pnum);
    ch=getchar();
    printf("\n开始输入进程Max值\n");
    for(i=0;i<Pnum;i++)
    {
        A='A';
        for(j=0;j<Ava;j++)
        {
            int data;
            printf("请输入进程 p%d 资源 %c Max的值:",i,A+j);
            
            scanf("%d",&data);
            ch=getchar();
            
            Max[i][j]=data;
            
        }
        printf("\n");
    }
    printf("Max输入完毕\n");
    
    //Allocation段
    printf("\n开始输入进程Allocation(已经获得的资源)值\n");
    for(i=0;i<Pnum;i++)
    {
        A='A';
        for(j=0;j<Ava;j++)
        {
            int data;
            printf("请输入进程 p%d 资源 %c Allocation的值:",i,A+j);
            
            scanf("%d",&data);
            ch=getchar();
            
            Allocation[i][j]=data;
            
        }
        printf("\n");
    }
    printf("Allocation输入完毕\n");
    
    //计算Need段
    for(i=0;i<Pnum;i++)
    {
        for(j=0;j<Ava;j++)
        {
            Need[i][j]=Max[i][j]-Allocation[i][j];
        }
    }
    printf("Need计算完成!!!\n");
    
}



void output()
{
    
    int i,j;
    printf("\n*********************************资源分配表*********************************\n");
    printf("Process       Max          Allocation          Need         \n");
    
    printf("\t\t\t");
    
    A='A';//Max
    for(i=0;i<Ava;i++){
        printf("%c  ",A+i);
    }printf("\t\t");
    A='A';//Allocation
    for(i=0;i<Ava;i++){
        printf("%c  ",A+i);
    }printf("\t\t  ");
    A='A';//Need
    for(i=0;i<Ava;i++){
        printf("%c  ",A+i);
    }printf("\n");
    
    
    
    for (i=0; i<Pnum; i++) {
        printf("p%d\t\t\t",i);
        //Max
        for(j=0;j<Ava;j++){
            printf("%d  ",Max[i][j]);
        }printf("\t\t");
        //Allocation
        for(j=0;j<Ava;j++){
            printf("%d  ",Allocation[i][j]);
        }printf("\t\t  ");
        //Need
        for(j=0;j<Ava;j++){
            printf("%d  ",Need[i][j]);
        }
        printf("\n");
    }
    
    printf("\nAvailable\n");
    A='A';
    for(i=0;i<Ava;i++){
        printf("%c  ",A+i);
    }printf("\n");
    for(i=0;i<Ava;i++){
        printf("%d  ",Available[i]);
    }printf("\n\n");
    
}


//安全性检查
bool SafeCheck(){
    int Work[SIZE];
    int i,j,x=0,t;
    
    
    //复制Available数组
    for (i=0; i<SIZE; i++) {
        Work[i]=Available[i];
    }
    
    
    
    //初始化Finish
    for(i = 0; i <SIZE; i++)
        Finish[i] = false;
    
    for(i=0;i<Pnum;i++)
    {
        
        //是否已检查过
        if(Finish[i] == false){
            //是否有足够的资源分配给该进程 重点修改 j<Ava
            for(j=0;j<Ava;j++)
            {
                if (Need[i][j] <= Work[j]) {
                    continue;
                }else{
                    break;
                }
            }
            
            if(j==Ava){
                for(t=0;t<Ava;t++){
                    Work[t]+=Allocation[i][t];
                }
                Finish[i] = true;
                safe[x++]=i;
                i=-1;
            }
            
            
        }
    }
    //如果所有进程的Finish向量都为true则处于安全状态,否则为不安全状态
    for (i = 0; i < Pnum; i++){
        if (Finish[i] == false){
            return false;
        }
    }
    return true;
}


//资源分配请求
bool request(int process,int *res){
    int i,j;
    int x,t;
    
    //request向量需小于Need矩阵中对应的向量
    for(i=0;i<Ava;i++){
        if(res[i]<=Need[process][i])
        {
            continue;
        }else{
            break;
        }
    }
    if(i==Ava){
        for (x=0; x<Ava; x++) {
            if(res[x]<=Available[x]){
                continue;
            }else{
                break;
            }
        }
        if(x==Ava){
            //试探分配
            ProbeAlloc(process,res);
            
            if(SafeCheck()){
                return true;
            }
            else{
                printf("安全性检查失败。原因:系统将进入不安全状态,有可能引起死锁。\n");
                printf("正在回滚...\n");
                RollBack(process,res);
            }
            
        }else{
            printf("安全性检查失败。原因:请求向量大于可利用资源向量。\n");
        }
    }else{
        printf("安全性检查失败。原因:请求向量大于需求向量。\n");
    }
    
    
    
    
    return false;
}




int main()
{
    char run;
    init();
    printf("*****************************************************************************\n");
    printf("**********************欢迎来到银行家算法—作者:xxxx ***********************\n");
    printf("*****************************************************************************\n");
    input();
    output();
    printf("首先检查系统初始状态是否安全。\n");
    if (SafeCheck()){
        printf("系统处于安全状态。\n");
        printf("安全序列是:");
        for(int t;t<Pnum;t++){
            printf("  p%d  ",safe[t]);
        }
        
    }
    else{
        printf("当前系统处于不安全状态。程序将退出...\n");
        goto over;
    }
    
    do{
        int process;
        int res[SIZE];
        for(int i = 0; i <SIZE; i++)
            res[i] = -1;
        printf("\n请输入请求分配的进程序号:");
        scanf("%d",&process);
        while(process>Pnum){
            printf("请输入比现有进程号“小”的数字!!!");
            printf("\n请输入请求分配的进程序号:");
            scanf("%d",&process);
            ch=getchar();
        }printf("\n");
        A='A';//f请求资源输入
        for(int i=0;i<Ava;i++){
            printf("请输入请求分配的进程对资源 %c 的请求数量:",A+i);
            int data;
            scanf("%d",&data);
            res[i]=data;
            ch=getchar();
        }printf("\n");
        
        if (request(process,&res)){
            printf("资源分配成功。\n");
            printf("安全序列是:");
            for(int t;t<Pnum;t++){
                printf("  p%d  ",safe[t]);
            }
        }
        else{
            printf("资源分配失败。\n");
        }
        printf("是否选择继续分配资源?(Y/N):");
        fflush(stdin);
        run = getchar();
    }while(run == 'Y' || run == 'y');
    
over:
    printf("\n执行完毕\n");
    return 0;
}

 也没什么好说的,放几个运行截图吧!

 

  • 1
    点赞
  • 57
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
设计一个n个并发进程共享m个系统资源的程序以实现银行家算法。要求: 1) 简单的选择界面; 2) 能显示当前系统资源的占用和剩余情况。 3) 为进程分配资源,如果进程要求的资源大于系统剩余的资源,不与分配并且提示分配不成功; 4) 撤销作业,释放资源。 编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁的发生。 银行家算法分配资源的原则是:系统掌握每个进程对资源的最大需求量,当进程要求申请资源时,系统就测试该进程尚需资源的最大量,如果系统中现存的资源数大于或等于该进程尚需求资源最大量时,就满足进程的当前申请。这样就可以保证至少有一个进程可能得到全部资源而执行到结束,然后归还它所占有的全部资源供其它进程使用。 银行家算法中的数据结构 (1)可利用资源向量Available(一维数组) 是一个含有m个元素,其中的每一个元素代表一类可利用的资源数目,其初值是系统中所配置的该类全部可用资源数目。如果Available[j]=k, 表示系统中现有Rj类资源k个。 (2)最大需求矩阵Max(二维数组) m的矩阵,它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max(i,j)=k, 表示进程i需要Rj类资源的最大数目为k。 (3)分配矩阵Allocation(二维数组) m的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation(i,j)=k, 表示进程i当前已分得Rj类资源k个。 (4)需求矩阵Need (二维数组) 是一个含有n*m的矩阵,用以表示每一个进程尚需的各类资源数。如果Need(i,j)=k, 表示进程i还需要Rj类资源k个,方能完成其任务。 Need(i,j)= Max(i,j)-Allocation(i,j)
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值