操作系统实验2 银行家算法

最新推荐文章于 2023-04-03 08:00:00 发布

肯定睡着不困

最新推荐文章于 2023-04-03 08:00:00 发布

阅读量3.1k

点赞数 4

分类专栏：操作系统文章标签：算法操作系统

本文链接：https://blog.csdn.net/HYK_DJ5201314/article/details/116806843

版权

操作系统专栏收录该内容

3 篇文章 2 订阅

订阅专栏

操作系统实验2 银行家算法

1．目的和要求
银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。
2．实验内容
①数据结构：

可利用资源向量Availabl。是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available[j]=K，则表示系统中现有Rj类资源K个。
2）最大需求矩阵Max。这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K，则表示进程i需要Rj类资源的最大数目为K。
3）分配矩阵Allocation。这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K，则表示进程i当前已分得Rj类资源的数目为K。
4）需求矩阵Need。这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。Need[i,j]=Max[i,j]-Allocation[i,j]。

②银行家算法。
在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。
银行家算法的基本思想是分配资源之前，判断系统是否是安全的；若是，才分配。它是最具有代表性的避免死锁的算法。
设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。
(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转（2)；否则，出错。
(2)如果REQUEST [cusneed] [i]<= AVAILABLE[i]，则转（3)；否则，等待。
(3)系统试探分配资源，修改相关数据：
AVAILABLE[i]-=REQUEST[cusneed][i];
ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];
NEED[cusneed][i]-=REQUEST[cusneed][i];
(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

③ 安全检查算法。
1)设置两个工作向量Work=AVAILABLE;FINISH
(2)从进程集合中找到一个满足下述条件的进程，
FINISH==false;
NEED<=Work;
如找到，执行（3)；否则，执行（4)
(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
Work=Work+ALLOCATION;
Finish=true;
GOTO 2
(4)如所有的进程Finish= true，则表示安全；否则系统不安全。
3．实验环境
①PC兼容机
②Windows、DOS系统、Turbo c 2.0
③C语言
4．实验程序
流程图
在这里插入图片描述

#include <iostream>
using namespace std;
#define MAXPROCESS 50                        //最大进程数
#define MAXRESOURCE 100                      //最大资源数
int AVAILABLE[MAXRESOURCE];                  //可用资源数组
int MAX[MAXPROCESS][MAXRESOURCE];            //最大需求矩阵
int ALLOCATION[MAXPROCESS][MAXRESOURCE];     //分配矩阵
int NEED[MAXPROCESS][MAXRESOURCE];           //需求矩阵
int REQUEST[MAXPROCESS][MAXRESOURCE];        //进程需要资源数
bool FINISH[MAXPROCESS];                     //系统是否有足够的资源分配
int p[MAXPROCESS];                           //记录序列
int m,n;                                     //m个进程,n个资源
void Init();    //初始化变量
bool Safe();    //安全检测
void Bank();    //银行家算法
void showdata(int,int);    //显示输出系统信息
int main()
{
    Init();
    Safe();
    Bank();
}


/*初始化变量*/
void Init()                
{
    int i,j;//输入进程 
    cout << "请输入进程的数目:";
    cin >> m;//m为进程数目 
    cout << "请输入资源的种类:";
    cin >> n;//有n中资源 
    cout << "请输入每个进程最多所需的各资源数,按照" << m << "x" << n << "矩阵输入" << endl;
    for(i=0;i<m;i++)//通过循环，输入了每个进程的各类资源最大需求量MAX 
        for(j=0;j<n;j++)
            cin >> MAX[i][j];
    cout << "请输入每个进程已分配的各资源数,也按照" << m << "x" << n << "矩阵输入" << endl;
    for(i = 0; i < m; i++)//输入每个进程的各类资源已分配量 
        for(j = 0; j < n; j++)
        {
            cin >> ALLOCATION[i][j];
            NEED[i][j] = MAX[i][j] - ALLOCATION[i][j];//还需要的各类资源数目=最大需求-已经获得的 
            if(NEED[i][j] < 0)//若已经获得的>最大需求量，则需要重新输入，Allocation 
            {
                cout << "您输入的第" << i+1 << "个进程所拥有的第" << j+1 << "个资源数错误,请重新输入:" << endl;
                j--;
                continue;
            }
        }
        cout << "请输入各个资源现有的数目:" << endl; 
        for(i = 0; i < n; i++)//现有的各类资源数目 
            cin >> AVAILABLE[i];
}


/*银行家算法*/
void Bank()               
{
    int i,cusneed,flag = 0;    //cousneed资源进程号
    char again;    //键盘录入一个字符用于判断是否继续请求资源
    while(1)
    {
        showdata(n,m);//得到n和m 
        cout << endl;
        /*请求资源*/
        while(true)
        {
            cout << "请输入要申请资源的进程号(注:第1个进程号为0,依次类推)" << endl;
            cin >> cusneed;//输入哪个进程需要请求资源 
            if (cusneed > m)//如果编程号>现有的进程数 ,则是输入的进程编号错误 
            {
                cout << "没有该进程，请重新输入" << endl;
                continue;
            }
            cout << "请输入进程所请求的各资源的数量" << endl;
            for(i = 0; i < n; i++)//输入请求的各类资源数 
                cin >> REQUEST[cusneed][i];
            for(i = 0; i < n; i++)
            {
                if(REQUEST[cusneed][i] > NEED[cusneed][i])    //如果用户选择的线程的第i个资源请求数＞该线程该资源所需的数量
                {
                    cout << "您输入的请求数超过进程的需求量!请重新输入!" << endl;
                    continue;
                }
                if(REQUEST[cusneed][i] > AVAILABLE[i])    //如果用户选择的线程的第i个资源请求数＞系统现有的第i个资源的数量
                {
                    cout << "您输入的请求数超过系统有的资源数!请重新输入!" << endl;
                    continue;
                }
            }
            break;
        }
        /*如果请求合理，那么开始银行家算法计算*/
        /*先将申请的资源进行分配*/
        for(i = 0; i < n; i++)
        {
            AVAILABLE[i] -= REQUEST[cusneed][i];            //系统可用资源减去申请了的
            ALLOCATION[cusneed][i] += REQUEST[cusneed][i];    //线程被分配的资源加上已申请了的
            NEED[cusneed][i] -= REQUEST[cusneed][i];        //线程还需要的资源减去已申请得到的
        }
        /*判断分配申请资源后的系统是否安全；如果不安全则将分配的申请资源还回系统*/
        if(Safe())    //AVAILABLE  ALLOCATION  NEED变动之后，是否会导致不安全
            cout << "同意分配请求!" << endl;
        else
        {
            cout << "您的请求被拒绝!" << endl;
            /*资源还回系统*/
            for(i = 0; i < n; i++)//拒绝后，已获得资源，需求和现有各类资源情况变化 
            {
                AVAILABLE[i] += REQUEST[cusneed][i];
                ALLOCATION[cusneed][i] -= REQUEST[cusneed][i];
                NEED[cusneed][i] += REQUEST[cusneed][i];
            }
        }
        /*对进程的需求资源进行判断；是否还需要资源；即NEED数组是否为0*/
        for (i = 0; i < n; i++)//计算已经不需要资源的进程有多少个 
            if (NEED[cusneed][i] <= 0)
                flag++;
        if (flag == n)    //如果该进程各资源都已满足条件，则释放资源
        {
            for (i = 0; i < n; i++)//释放资源 
            {
                AVAILABLE[i] += ALLOCATION[cusneed][i];
                ALLOCATION[cusneed][i] = 0;
                NEED[cusneed][i] = 0;
            }
            cout << "线程" << cusneed << " 占有的资源被释放！" << endl;
            flag = 0;
        }
        for(i = 0; i < m; i++)    //分配好了以后将进程的标识FINISH改成false
            FINISH[i] = false;
        /*判断是否继续申请*/
        cout << "您还想再次请求分配吗?是请按y/Y,否请按其它键" << endl;
        cin >> again;
        if(again == 'y' || again == 'Y')
            continue;
        break;
    }
}


/*安全性算法*/
//要找到一个安全序列 
bool Safe() 
{
    int i, j, k, l = 0;
    int Work[MAXRESOURCE];    //工作数组
    /*工作数组赋值，与AVAILABLE数组相同*/
    for (i = 0; i < n; i++)//将Available的值赋给work 
        Work[i] = AVAILABLE[i];
    /*FINISH数组赋值，初始为全部false*/
    for (i = 0; i < m; i++)
        FINISH[i] = false;    //FINISH记录每个进程是否安全
    while (l < m)    //正常的话，共执行m次
    {
        int init_index = l;
        for (i = 0; i < m; i++)
        {
            if (FINISH[i] == true)    //如果这个进程安全则继续下一个循环
                continue;
            for (j = 0; j < n; j++)
                if (NEED[i][j] > Work[j])//若需求>work，则现在不能是这个进程 
                    break;
            if (j == n)
            {
                FINISH[i] = true;
                for (k = 0; k < n; k++)
                    Work[k] += ALLOCATION[i][k];
                p[l++] = i;//记录进程号    
            }
            else    //如果超过继续循环下一个进程
                continue;
        }
        if (l==init_index)
        {
            cout << "系统是不安全的" << endl;
            return false;
        }
    }
    cout << "系统是安全的" << endl;
    cout << "安全序列:" << endl;
    for (i = 0; i < l; i++)
    {
        cout << p[i];
        if (i != l - 1)
            cout << "-->";
    }
    cout << endl;
    return true;
}


/*显示*/
void showdata(int n,int m)
{
    int i,j;
    cout << endl << "-------------------------------------------------------------" << endl;  
    cout << "系统可用的资源数为:    ";
    for (j = 0; j < n; j++)
        cout << "    " << AVAILABLE[j];         
    cout << endl << "各进程还需要的资源量:" << endl; 
    for(i = 0; i < m; i++)   
    {
        cout << "    进程" << i << ":";   
        for(j = 0; j < n; j++)
            cout << "     " << NEED[i][j];   
        cout << endl;   
    }   
    cout << endl << "各进程已经得到的资源量:    " << endl << endl;
    for (i = 0; i < m; i++)   
    {
        cout << "    进程" << i << ":";   
        for (j = 0; j < n; j++)
            cout << "     " << ALLOCATION[i][j];
        cout << endl;   
    }  
    cout << endl; 
}

4.2实践一
在银行家算法中，若出现下述资源分配情况，试问：
在这里插入图片描述
1）该状态是否安全？
2）若进程P2提出请求Request（1,2,2,2）后，系统能否将资源分配？
4.2.1数学运算过程
解：
1）
资源分配情况：
进行安全检查：

经过安全检查，存在一个安全系列{P0,P3,P1,P2,P4}，所以系统是安全的。
2）
P2提出请求Request（1,2,2,2）后，资源变化情况如下所示
Request(1,2,2,2)<Available(1,6,2,2);
Request(1,2,2,2)<Need(2,3,5,6)
所以先假定分配这个P2请求的资源，资源变化情况如下所示
Available=Available-Request=(0,4,0,0)
Need=Need-Request=(1,1,3,4)
Allocation=Allocation+Request=(2,5,7,6）
在这里插入图片描述
此时不存在一个安全序列，所以不能将P2请求的资源分配给它，让P2等待。
4.2.2代码运行结果截图

肯定睡着不困

关注

4
点赞
踩
44

收藏

觉得还不错? 一键收藏
2
评论
操作系统实验2 银行家算法

操作系统实验2 银行家算法1．目的和要求银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。2．实验内容①数据结构：可利用资源向量Availabl。是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available[j]=K，则表示系统中现有Rj类资源K个。2）最大需求矩阵Max。这是一个n
复制链接

扫一扫