银行家算法

一.死锁的定义：

所谓死锁： 是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

书上写的是如果一组进程中的每一个进程都在等待仅由该组进程中的其他进程才能引发的事件，那么该组进程是死锁的（Deadlock）

产生死锁的必要条件主要是互斥条件，请求和保持条件，不可抢占条件， 循环等待条件。

解决死锁问题主要通过预防死锁，避免死锁，检测死锁，解除死锁四个方面。

二.算法解析

银行家算法是从避免死锁来解决死锁问题。

available[m]　　　　 //m类资源，每种资源可用数目
max[i][j] 　　　　　　//第i个进程第j种资源最大需求量
allocation[i][j]　　　　//第i个进程第j种资源已经分配的量
need[i][j] 　　　　　　//第i个进程第j种资源还需要的量
由上可以看出 max[i][j] = allocation[i][j] + need[i][j]

设requesti是Pi的请求向量
若request[j]>need[i][j]，程序报错
若request[j]>available[i][j]，系统资源数不够，进程陷入等待
系统尝试着把资源分配给进程i，修改如下数据
available[j] -= request[j]
allocation[i][j] += request[j]
need[i][j] -= request[j]
接下来运行安全性算法

设置工作向量work[m]，表示系统目前的各类资源数，初始work=available
finish[n]，表示该进程是否在安全性队列中，初始finish[i] = false
从进程集合中找出一个满足下列条件的进程：
finish[i] = false&&need[i][j] <= work[j]
若找到，修改下列值：
finish[i] = true
work[i] += allocation[i][j]
继续寻找下一个满足的进程

若所有的finish[i] = true，表示系统处于安全性状态，之前提出的请求可以满足。

时间复杂度  O((n * m) ^ n)
参考文献
C++ 代码

#include <bits/stdc++.h>
using namespace std;
int resource[4] = {17, 5, 20}; // 每类资源的总数量
int available[4] = {2, 3, 3}; // 每类资源的剩余量
int work[4]; //工作向量
int allow[6][4] = {{2, 1, 2}, {4, 0, 2}, {4, 0, 5}, {2, 0, 4}, {3, 1, 4}}; //每类资源已经分配的向量
int need[6][4] = {{3, 4, 7}, {1, 3, 4}, {0, 0, 6}, {2, 2, 1}, {1, 1, 0}};//每类资源还需要的向量
int maxx[6][4] = {{5, 5, 9}, {5, 3, 6}, {4, 0, 11}, {4, 2, 5}, {4, 2, 4}};//每类资源总共需要的向量
int n = 5; // 进程数
int m = 3; //资源种类
bool finish[6];
vector<int>ans;
int sum = 0;
void dfs(int u)
{
    if(u == n)
    {
        printf("安全序列%d:", sum ++);
        for (int i = 0; i < ans.size(); i ++ )
            printf("P%d ", ans[i]);
        puts("");
        return;
    }
    for (int i = 0; i < n; i ++ )
    {
        if (!finish[i])
        {
            bool flag = true;
            for (int j = 0; j < m; j ++ )
                if (need[i][j] > work[j]) flag = false;
            if (flag)
            {
                for (int j = 0; j < m; j ++ ) work[j] += allow[i][j];
                finish[i] = true;
                ans.push_back(i);
                dfs(u + 1);
                ans.pop_back();
                for (int j = 0; j < m; j ++ ) work[j] -= allow[i][j];
                finish[i] = false;
            }
        }
    }
}

void solve(int u, int req[])
{
    // 这里偷个懒 ，不输入数据了hh
    bool flag = true;
    for (int i = 0; i < m; i ++ )
        if (need[u][i] < req[i])
        {
            flag = false;
            break;
        }
    if(!flag)
    {
        printf("请求资源数错误\n");
        return;
    }
    flag = true;
    for (int i = 0; i < m; i ++ )
        if(available[i] < req[i])
        {
            flag = false;
            break;
        }
    if(!flag)
    {
        printf("资源数不足,陷入等待\n");
        return;
    }
    sum = 0;
    for (int i = 0; i < m; i ++ )
    {
        work[i] = available[i] - req[i];
        need[u][i] -= req[i];
        allow[u][i] += req[i];
    }
    memset(finish, false, sizeof(finish));
    dfs(0);
    if(sum)
    {
        printf("分配资源 success\n");
    }
    else
    {
        printf("No");
        for (int i = 0; i < m; i ++ )
        {
            need[u][i] += req[i];
            allow[u][i] -= req[i];
        }   
    }
}
int main()
{
    int t = 1;
    int req[] = {0, 0, 0};
    //scanf("%d", &t);
    while (t -- )solve(2, req);
    return 0;
}

好的， 都看到这了，还能不点赞吗？

呜呜呜~

原文链接：银行家算法实现——找出所有安全序列_启人zhr的博客-优快云博客_银行家算法的安全序列怎么找