操作系统实验：银行家算法C语言实现

大家好，又见面了，我是你们的朋友全栈君。

银行家算法C语言实现

#include<stdio.h>
#include<stdlib.h>
#define ok 1
#define true 1
#define error 0
#define false 0

int claim[100][100] = { 
   0}; // 各个进程需要的最大资源数量
int alloc[100][100] = { 
   0}; // 各个进程已分配的资源数量
int need[100][100] = { 
   0};  // 各个进程还需要的资源数量
int resource[100] = { 
   0};   // 各个资源的总数
char name[100] = { 
   0};      // 各个资源的名字
int available[100] = { 
   0};  // 可分配的资源数
int work[100] = { 
   0};       // 用于存放alloc+available两个数组和的值
int finish[100] = { 
   0};     // 判断是否分配完成
int ss[100] = { 
   0};         // 安全序列
int request[100] = { 
   0};    // 请求单独分配的资源数量
int n, m; // n:进程的数量 m:资源的种数

int init()
{ 
   
    int i, j;
    //char Name;

    printf("请输入进程所需资源的种数:");
    scanf("%d", &m);
    for(i = 0; i < m; i++)
    { 
   
        printf("请输入资源%d的名字:", i);
        fflush(stdin);// 用于刷新缓冲区，VScode这里一定要这么做
        scanf("%c", &name[i]);
        //name[i] = Name;
        printf("请输入资源%c的资源总数:", name[i]);
        scanf("%d", &resource[i]);
    }
    printf("==============================\n");
    printf("请输入各个资源可分配的资源数:\n");
    for(i = 0; i < m; i++)
    { 
   
        printf("%c:", name[i]);
        scanf("%d", &available[i]);
    }
    printf("==============================\n");
    printf("请输入进程的数量:");
    scanf("%d", &n);
    printf("请输入各个进程需要的最大资源数量:\n");
    for(i = 0; i < n; i++)
    { 
   
        for(j = 0; j < m; j++)
            scanf("%d", &claim[i][j]);
    }
    printf("==============================\n");
    printf("请输入各个进程已分配的资源数量:\n");
    for(i = 0; i < n; i++)
    { 
   
        for(j = 0; j < m; j++)
            scanf("%d", &alloc[i][j]);
    }
    return ok;
}

int safe()
{ 
   
    int i, j, k, s = 0;
    int flag;
    int t;

    //初始化work数组,在available数组改变时用于替换available数组进行加法的运算。
    for(j = 0; j < m; j++)
        work[j] = available[j];
    //初始化finish数组，用于在分配完之后跳过这个进程。
    for(i = 0; i < n; i++)
        finish[i] = false;
    //算出各个进程还需要的各种资源的数量。
    for(i = 0; i < n; i++)
    { 
   
        for(j = 0; j < m; j++)
        { 
   
            need[i][j] = claim[i][j] - alloc[i][j];
        }
    }
    printf("==============================\n");
    printf("各个进程还需要的资源数量:\n");
    for(i = 0; i < n; i++)
        printf("%c ", name[i]);
        printf("\n");
    for(i = 0; i < n; i++)
    { 
   
        for(j = 0; j < m; j++)
        { 
   
            printf("%d ", need[i][j]);
        }
        printf("\n");
    }
    printf("==============================\n");
    printf("判断是否安全:");
    for(i = 0; i < n; i++)
    { 
   
        t = 0;
        for(j = 0; j < m; j++)
        { 
   
            if(work[j] >= need[i][j] && finish[i] == false)
            { 
   
                t++;
                if(t == m)
                { 
   
                    for(k = 0; k < m; k++)
                    work[k] = work[k] + alloc[i][k];
                    finish[i] = true;
                    ss[s++] = i;
                    i = -1;//保证每次都从第一行开始找起
                }
            }    
        }
    }
    for(i = 0; i < n; i++)
    { 
   
        if(finish[i] == false)
        { 
      
            printf("不安全!");
            return error;
        }
    }
    printf("安全，存在一个安全序列:");
    for(i = 0; i < n; i++)
    { 
   
        printf("P%d", ss[i]);
        if(i < n-1)
         printf("->");
    }
    printf("\n");
    return ok;
}

int  banker()
{ 
   
    int p, i, j;
    int flag = true;

    printf("==============================\n");
    printf("请输入第几个进程请求分配的资源(0~%d):", n-1);
    scanf("%d", &p);
    printf("请分别输入请求分配的资源数量:\n");
    for(i = 0; i < m; i++)
    { 
   
        printf("%c:", name[i]);
        scanf("%d", &request[i]);
    }

    for(j = 0; j < m; j++)
    { 
   
        if((request[j] + alloc[p][j]) > claim[p][j])
        { 
   
            printf("不合理\n");
            flag = false;
            break;
        }
        else
        { 
   
            if(request[j] > available[j])
            { 
   
                printf("不可能\n");
                flag = false;
                break;
            }
        }
    }

    if(flag)
    { 
   
        test(p);  // 尝试将请求的资源数量分配到请求的进程
        safe();
        reset(p); // 重置可分配的数组和已分配的数组
    }
    return ok;
}

int test(int i)
{ 
   
    int j;
    for(j = 0; j < m; j++)
    { 
   
        available[j] = available[j] - request[j];
        alloc[i][j] = alloc[i][j] + request[j];
    }
}

int reset(int i)
{ 
   
    int j;
    for(j = 0; j < m; j++)
    { 
   
        available[j] = available[j] + request[j];
        alloc[i][j] = alloc[i][j] - request[j];
    }
}

int main()
{ 
   
    int t = 0;

    while(t != 4){ 
   
    printf("------------------------------\n");
    printf(" 银行家算法模拟 \n");
    printf("------------------------------\n");
    printf("1: 初始化 2:判断是否安全\n");
    printf("3:请求分配 4:退出 \n");
    printf ("请选择(1~4):");
    scanf("%d", &t);
    switch(t)
        { 
   
            case 1 :
                    init();
                break;
            case 2:
                    safe();
                break;
            case 3:
                    banker();
                break;
            case 4 :
                    printf("银行家算法模拟结束Bye!");
                exit(0);
        }
    }
    return 0;
}