C程序模拟实现银行家算法

　　上周又做操作系统实验，题目是用程序模拟实现银行家算法，写了半天还真有点晕，主要是因为想尽可能符合课本上的描述，所以写出来的程序就比较恶心了，好了，银行家算法就不多说了，不了解的可以先看一下百度百科上的描述，分段上代码吧。完整代码包下载地址：https://files.cnblogs.com/pianoid/Banker.rar

　　首先要定义一些结构体，为了符合课本描述，我只定义了一个结构体：

　　

typedef struct {
    int    A;
    int    B;
    int    C;
}RESOURCE;

　　结构体里面的三个域分别表示三种资源的数量。

　　根据课本例题上的数据初始化三个矩阵和一个向量。

//最大需求矩阵
RESOURCE Max[PROCESSES_NUMBER] = 
{
    {7,5,3},
    {3,2,2},
    {9,0,2},
    {2,2,2},
    {4,3,3}
};

//已分配资源数矩阵
RESOURCE Allocation[PROCESSES_NUMBER] = 
{
    {0,1,0},
    {2,0,0},
    {3,0,2},
    {2,1,1},
    {0,0,2}
};

//需求矩阵
RESOURCE Need[PROCESSES_NUMBER] = 
{
    {7,4,3},
    {1,2,2},
    {6,0,0},
    {0,1,1},
    {4,3,1}
};

//可用资源向量
RESOURCE Available = {3,3,2};

　　为了能够输出安全状态时的安全序列，还可以添加一个记录安全序列的数组int SafeSequence[PROCESSED_NUMBER]。

　　因为银行家算法使用的是试探分配的策略，如果进程请求分配的资源既不大于自己尚需的资源，又不大于系统现存的资源，那就可以先试探着将资源分配给该进程，然后测试分配后是不是有可能造成死锁，如果不会引起死锁（即安全状态）就可以完成分配，否则（即不安全状态）就将试探分配的资源回收回来让其等待。那么根据上面定义的数据就可以很容易的写出试探分配和回收资源的函数。

//试探分配
void ProbeAlloc(int process,RESOURCE *res)
{
    Available.A -= res->A;
    Available.B -= res->B;
    Available.C -= res->C;

    Allocation[process].A += res->A;
    Allocation[process].B += res->B;
    Allocation[process].C += res->C;

    Need[process].A -= res->A;
    Need[process].B -= res->B;
    Need[process].C -= res->C;
}

//若试探分配后进入不安全状态，将分配回滚
void RollBack(int process,RESOURCE *res)
{
    Available.A += res->A;
    Available.B += res->B;
    Available.C += res->C;

    Allocation[process].A -= res->A;
    Allocation[process].B -= res->B;
    Allocation[process].C -= res->C;

    Need[process].A += res->A;
    Need[process].B += res->B;
    Need[process].C += res->C;
}

　　接下来就是安全性检查函数了，在这个函数中还需要设置一个Work向量和一个Finish向量，函数实现主要就是通过一个for循环检查试探分配后系统的可用资源数是否能满足所有进程的需求，若能满足某一个进程的需求，则假设分配其所需资源使之完成运行，然后就可以将资源回收以分配给其它进程，如果依照这种方法所有的进程都可以成功执行，那么现在的状态就是安全状态，否则即为不安全状态，有可能引起死锁。

bool SafeCheck()
{
    RESOURCE    Work = Available;
    bool        Finish[PROCESSES_NUMBER] = {false,false,false,false,false};
    int        i;
    int        j = 0;

    for (i = 0; i < PROCESSES_NUMBER; i++)
    {
        //该进程是否已执行完毕
        if(Finish[i] == false)
        {
            //是否有足够的资源分配给该进程
            if(Need[i].A <= Work.A && Need[i].B <= Work.B && Need[i].C <= Work.C)
            {
                //有则使其执行完成，并将已分配给该进程的资源全部回收
                Work.A += Allocation[i].A;
                Work.B += Allocation[i].B;
                Work.C += Allocation[i].C;
                Finish[i] = true;
                safeSeq[j++] = i;   //顺便记录下来安全序列
                i = -1;                //需要从开始重新进行遍历
            }
        }
    }

    //如果所有进程的Finish向量都为true则处于安全状态，否则为不安全状态
    for (i = 0; i < PROCESSES_NUMBER; i++)
    {
        if (Finish[i] == false)
        {
            return false;
        }
    }
    return true;
}

有了以上三个函数就可以写出请求分配资源的函数了。

//资源分配请求
bool request(int process,RESOURCE *res)
{
    //request向量需小于Need矩阵中对应的向量
    if(res->A <= Need[process].A && res->B <= Need[process].B && res->C <= Need[process].C)
    {
        //request向量需小于Available向量
        if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C)
        {
            //试探分配
            ProbeAlloc(process,res);

            //如果安全检查成立，则请求成功，否则将分配回滚并返回失败
            if(SafeCheck())
            {
                return true;
            }
            else
            {
                printf("安全性检查失败。原因：系统将进入不安全状态，有可能引起死锁。\n");
                printf("正在回滚...\n");
                RollBack(process,res);
            }
        }
        else
        {
            printf("安全性检查失败。原因：请求向量大于可利用资源向量。\n");
        }
    }
    else
    {
        printf("安全性检查失败。原因：请求向量大于需求向量。\n");
    }
    return false;
}

　　好了，基本上所有必须的函数都已经写完了，为了输出更直观的信息，也可以再加一个PrintTable函数将当前资源非配表显示出来，我就不贴了，如果你想看的话请下载完整代码吧。

　　给出一个运行截图。

　　上面啰嗦了一大堆，大概你也已经烦了，呵呵，代码实在写的丑，都不大好意思放了，不过有交流才有进步，如果有哪儿说不不正确，欢迎指正。

　　完整代码下载地址：https://files.cnblogs.com/pianoid/Banker.rar