【操作系统】基于c语言的银行家算法模拟实现

设置系统资源数目为3，并发进程最大数量为10；程序开始即表示并发进程同时运行，用户可指定相应的进程申请一定数量的资源，直到所有进程完成或用户主动退出。并发进程的数量以及资源最大需求，已分配资源数量均需用户自己定义，且每次申请之后会将结果返回，成功则将安全性检查表与安全序列一并输出。
源码如下：

#include
#include
#include

#define source_num 3   // 每个进程所需的资源的种类数量
#define Thread_max 10      //可容纳的最多的进程数量

int Max_Need[Thread_max][source_num];    //所有进程所需要的资源的最大数目
int Allocation[Thread_max][source_num];      //所有进程已经分配到的资源的数目
int tmp_Available[source_num];//剩余资源数目备份
int current_Allocation[Thread_max][source_num];// 已分配的资源数量备份
int Need[Thread_max][source_num];        //所有进程还需要的设备的数目
int current_Need[Thread_max][source_num];//需要资源数量备份
int current_Available[Thread_max][source_num];    //记录分配完之后，此时系统的可用资源数目
int Work[Thread_max][source_num];          //记录运行完成之后，系统中各个资源的数目
int Available[source_num];           //系统中剩余的资源数量
int finish[Thread_max];                   //存放所有进程的状态。
int que[Thread_max];                     //用于存放安全队列。 
int Thread_num;           
int RQ[source_num];

//初始化函数，对Max，Need，Available，Allocation进行初始化。
void init() {
    printf("请输入系统中各类资源的数目总和：n");
    for (int i = 0; i < source_num; i++)
        scanf("%d", &Available[i]);
    printf("n");
    do {
        printf("请输入进程的数量：n");
        scanf("%d", &Thread_num);
    } while (Thread_num > 10);
    printf("n");
    printf("请输入各个进程运行对各个程序的最大需求：n");
    for (int i = 0; i < Thread_num; i++) {
        for (int j = 0; j < source_num; j++)
        {
            scanf("%d", &Max_Need[i][j]);
        }
    }
    printf("n");
    printf("请输入各个进程已经分配到的资源数目：n");
    for (int i = 0; i < Thread_num; i++) {
        for (int j = 0; j < source_num; j++)
        {
            scanf("%d", &Allocation[i][j]);
            Available[j] = Available[j] - Allocation[i][j];    //计算系统中剩余设备的数目
            Need[i][j] = Max_Need[i][j] - Allocation[i][j];   //计算各个进程依然所需要的各个设备的数目 
        }
    }
    printf("n");
    for (int i = 0; i < Thread_num; i++)
    {
        finish[i] = 0;
        que[i] = -1;
    }
}
//对安全检查表进行输出
void print() {
    printf("进程IDt|tMaxt|tAllocatet|tNeedt|tAvailablet|tWorkt|tfinishn");
    for (int i = 0; i < Thread_num; i++)
    {
        int tmp;
        tmp = que[i];
        printf("%dt|t%d,%d%,%dt|t    %d,%d%,%d    t|t%d,%d%,%dt|      t%d,%d%,%dt       |t%d,%d,%dt|t%dn",tmp, Max_Need[tmp][0], Max_Need[tmp][1], Max_Need[tmp][2], Allocation[tmp][0], Allocation[tmp][1], Allocation[tmp][2], Need[tmp][0], Need[tmp][1], Need[tmp][2], current_Available[tmp][0], current_Available[tmp][1], current_Available[tmp][2], Work[tmp][0], Work[tmp][1], Work[tmp][2], finish[tmp]);
    }
}

//实现安全性检查和资源分配；通过index实现线程循环遍历。Order为安全队列的线程顺序
void allocate() {
    int result = 1;              //判断死锁。就是遍历一遍之后没有进程可以运行。
    int index = 0;                  //判断是哪一个进程
    int order = 0;              //用于记录安全队列的下标
    int times = 0;              //因为有num个变量， 所以假如有安全队列，最多就是寻找num的平方次
    for(int i=0;iAvailable[j] ) {
                t = 0;
            }
        }
        if (t == 1 && finish[index] == 0) {
            result = 0;
            finish[index] = 1;              //表示该进程获得资源后运行完毕
            for (int i = 0; i < source_num; i++)        
            {
                current_Available[index][i] = Available[i];
                Available[i] -= Need[index][i];             
                   //记录分配完之后，此时系统的可用资源数目（因为假如会产生安全队列，那么有多少个进程就会产生多少次这样的当前分配后的可用资源数目）
            }
            for (int i = 0; i < source_num; i++)
            {
                 Available[i] = Available[i] + *(Max_Need[index] + i);
                 Work[index][i] = Available[i];
            }
            que[order] = index;
            order++;
            if (order == Thread_num) {

                printf("资源已分配n");
                for (int k=0; k < source_num; k++)
                    Available[k] = tmp_Available[k];
                print();
                    printf("存在安全路径");
                    for (int i = 0; i < Thread_num; i++)
                    {
                        printf("%d  ", que[i]);
                    }
                    printf("n");
                break;
            }
        }
        if (result == Thread_num) {
            printf("无安全队列n");
            for (int k = 0; k < source_num; k++)
            {
                //归还拟申请的资源
                for (int j = 0; j < Thread_num; j++) {
                    Need[j][k] = current_Need[j][k];
                    Allocation[j][k] = current_Allocation[j][k];
                }
                Available[k]=tmp_Available[k]+Need[que[0]][k];   
            }
            break;
        }
        if (index == Thread_num - 1) {
            index = 0;
            continue;
        }
        result++;
        index++;
    }
}
//资源申请函数，指定申请资源的进程与申请各类资源的数目。
void request() {
    int index=0;
    //统计拟使用的资源
    while (true) {
    printf("请输入拟申请资源的进程号：n");
    scanf("%d", &index);
    if (index > Thread_num)
        break;
    printf("请输入申请的各资源的数量：n");
    for (int i = 0; i < source_num; i++) {
        scanf("%d", &RQ[i]);
    }
    for (int j = 0; j < source_num; j++) {
        for (int i = 0; i < Thread_num; i++){
            current_Allocation[i][j] = Allocation[i][j];
        current_Need[i][j] = Need[i][j];
    }
        Allocation[index][j] += *(RQ + j);
        Need[index][j] = Max_Need[index][j] - Allocation[index][j];
        Available[j] -= *(RQ + j);
    }

    allocate();
    } 
}

int main(void) {
    init();
    request();
}        Need[index][j] = Max_Need[index][j] - Allocation[index][j];
        Available[j] -= *(RQ + j);
    }

    allocate();
    } 
}

int main(void) {
    init();
    request();
}