银行家算法的模拟实现（C++）

// OS_Lab4.cpp : 定义控制台应用程序的入口点。
//

//#include "stdafx.h"
#include <stdio.h>
#define N_max 5               //定义进程数目N_max
#define M_max 3               //定义进程所需资源数目M_max
int Available[M_max];         //当前系统可调用的各类资源数目
int Max[N_max][M_max];        //各进程所需要的各类资源的最大数目
int Allocation[N_max][M_max]; //各进程已经被分配的各类资源数目
int Need[N_max][M_max];       //各进程仍需要的各类资源的数目
int finish[N_max] = {0};      //初始化各进程的完成状态
int Work[M_max];              //系统可提供给各进程的各类资源的数目
int safe_order[N_max] = {-1}; //安全序列获取
int N, M;

void Data_Initialization(int N, int M); //用户数据初始化
void Data_Show(int N, int M);           //资源使用情况展示
int Finish(int cus_num, int M);         //死锁产生判断
int Safe_Jundge(int N, int M);          //系统安全性判断
int request_resources(int cus_num);     //进程请求系统各类资源
void release_resources(int cus_num);    //进程完成后释放所有各类资源

int main()
{

    //数据初始化
    Data_Initialization(N, M);
    //资源分配情况展示
    Data_Show(N, M);
    while (!Safe_Jundge(N, M))
    {
        printf("系统处于不安全状态，请重新进行初始化！");
        Data_Initialization(N, M);
        //资源分配情况展示
        Data_Show(N, M);
    }

    int cus_num, count = 0;
    while ((count < N))
    {
        //用户选择执行的进程
        scanf("%d", &cus_num);
        //判断系统是否有足够的资源支持进程完成
        if (Finish(cus_num, M))
        {
            printf("当前系统无法支持该进程完成，请重新选择进程！");
            continue;
        }

        //请求资源
        request_resources(cus_num);
        //资源展示
        Data_Show(N, M);
        //资源释放
        release_resources(cus_num);
        //资源展示
        Data_Show(N, M);
        count++;
    }

    return 0;
}

void Data_Initilization(int N, int M)
{
    int jundge = 0;

    //初始化用户数N
    printf("请输入用户数N：\n");
    scanf("%d", N);

    //合法性判断，N需大于0且小于等于N_max
    if (N > 0 && N <= N_max)
    {
        jundge = 1;
    }

    while (!jundge)
    {
        printf("输入的用户数不合法，请重新输入：\n");
        scanf("%d", &N);

        if (N > 0 && N <= N_max)
        {
            jundge = 1;
        }
    }

    jundge = 0;

    //初始化资源的种类数目M
    printf("请输入资源种类数目M：\n");
    scanf("%d", &M);

    //合法性判断，M需大于0且小于等于M_max
    if (M > 0 && M <= M_max)
    {
        jundge = 1;
    }

    while (!jundge)
    {
        printf("输入的资源的种类数目不合法，请重新输入：\n");
        scanf("%d", &M);

        if (M > 0 && M <= M_max)
        {
            jundge = 1;
        }
    }

    //初始化 当前系统可调用的各类资源数目
    for (int i = 0; i < M; i++)
    {
        printf("请输入可调用的第%d类资源的数目：\n", i + 1);
        scanf("%d", &Available[i]);
    }
    //合法性判断，可调用资源数一开始必须大于0

    //初始化各进程所需要的各类资源的最大数目
    for (int i = 0; i < N; i++)
    {
        printf("请输入第%d个进程所需的各类资源的最大数目：", i + 1);
        for (int j = 0; j < M; j++)
        {
            scanf("%d", &Max[i][j]);
        }
    }
    //合法性判断，每个进程对各类资源需求需大于等于0，且不可均为0

    //初始化各进程已经被分配的各类资源数目
    for (int i = 0; i < N; i++)
    {
        printf("请输入第%d个进程已经别分配到的各类资源的数目：", i + 1);
        for (int j = 0; j < M; j++)
        {
            scanf("%d", &Allocation[i][j]);
        }
    }
    //合法性判断，已经分配的各类资源数目需大于等于0，且需小于等于所需的最大数目

    //初始化各进程仍需要的各类资源的数目
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            Need[i][j] = Max[i][j] - Allocation[i][j];
        }
    }

    //初始化Work
    for (int i = 0; i < M; i++)
    {
        Work[i] = Available[i];
    }
}

void Data_Show(int N, int M)
{
    printf("PID \t MAX \t Allocation \t Need \t Available\n");

    for (int i = 0; i < N; i++)
    {
        //输入PID
        printf("P%d \t ", safe_order[i]);

        //输入Max
        for (int j = 0; j < M; j++)
        {
            printf("%d ", Max[safe_order[i]][j]);
            if (j == M - 1)
            {
                printf("\t ");
            }
        }

        //输入Allocation
        for (int j = 0; j < M; j++)
        {
            printf("%d ", Allocation[safe_order[i]][j]);
            if (j == M - 1)
            {
                printf("\t ");
            }
        }

        //输入Need
        for (int j = 0; j < M; j++)
        {
            printf("%d ", Need[safe_order[i]][j]);
            if (i == 0)
            {
                if (j == M - 1)
                {
                    printf("\t ");
                }
            }
            else
            {
                if (j == M - 1)
                {
                    printf("\n");
                }
            }
        }

        //输入Available
        if (i == 0)
        {
            for (int j = 0; j < M; j++)
            {
                printf("%d ", Available[j]);
                if (j == M - 1)
                {
                    printf("\n");
                }
            }
        }
    }
}

int Finish(int cus_num, int M)
{
    for (int i = 0; i < M; i++)
    {
        if (Work[i] - Need[cus_num][i] < 0)
        {
            return 0;
        }
    }
    return 1;
}

int Safe_Jundge(int N, int M)
{
    int count = 0, cir = 0;
    while (cir < N)
    {
        for (int i = 0; i < N; i++)
        {
            //判断进程i是否在完成序列里
            if (safe_order[i] == -1)
            {
                //若存在，则立即跳出本次循环，执行下次循环
                continue;
            }

            //判断i是否能完成
            if (Finish(i, M))
            {
                //若能，则释放其占有的已分配资源到Work中，并将i放入已完成进程序列中
                safe_order[count] = i;
                for (int j = 0; j < M; j++)
                {
                    Work[j] += Allocation[i][j];
                }

                count++;
            }
        }
        if (safe_order[cir] == -1)
        {
            printf("不存在安全序列，系统处于不安全状态！");
            return 0;
        }

        cir++;
    }

    printf("存在安全序列:");
    for (int i = 0; i < N; i++)
    {
        printf("%d ", safe_order[i]);
    }
    printf(",系统处于安全状态。");

    return 1;
}

int request_resources(int cus_num)
{
    for (int i = 0; i < M; i++)
    {
        Allocation[cus_num][i] = Max[cus_num][i];
        Available[i] -= Need[cus_num][i];
    }
    //执行成功返回0
    return 0;
    //不成功返回-1
}

void release_resources(int cus_num)
{
    for (int i = 0; i < M; i++)
    {
        Available[i] += Allocation[cus_num][i];
    }
}