操作系统-银行家算法-课程设计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;
}

 也没什么好说的，放几个运行截图吧！