银行家算法 C++实现

操作系统中预防死锁的银行家算法，测试用例来自《计算机操作系统（第四版）》113页例题。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#define Process_Max 100                                         //进程数量最大值
#define Resource_Max 100                                        //资源种类最大值
using namespace std;
int Available[Resource_Max];                                    //系统当前每种资源可分配数
int Max[Process_Max][Resource_Max];                             //每个进程对每种资源最大需求
int Allocation[Process_Max][Resource_Max];                      //每个进程已分配资源
int Need[Process_Max][Resource_Max];                            //每个进程当前需求资源
int Work[Resource_Max];                                         //工作向量
int Finish[Process_Max];
int List[Process_Max];
int instruct=0;
int Process_Num=0,Resource_Num=0;
int List_Num=0;
void Input_OS()
{
    cout << "OS" << endl;
    instruct=0;
    while(Resource_Num<1){
        cout << "输入资源种类 Enter Resource_Num:" << endl;
        cin >> Resource_Num;
    }
    cout << "输入系统当前可利用资源数 Enter Available:" << endl;
    for(int i=0;i<Resource_Num;i++)
    {
        cout << "R" << i << ":";
        cin >> Available[i];
    }
}
void Input_P()
{
    instruct=0;
    int a;
    cout << "Process" << endl;
    while(Process_Num<1){
        cout << "输入进程数 Enter Process_Num:" << endl;
        cin >> Process_Num;
    }
    for(int i=0;i<Process_Num;i++)
    {
        cout << "输入进程 P" << i << "的最大资源需求 Max:" << endl;
        for(int j=0;j<Resource_Num;j++)
        {
            cout << "R" << j << ":" ;
            cin >> Max[i][j];
        }
        cout << endl;
        cout << "输入进程 P" << i << "的已分配资源 Allocation:" << endl;
        cout << "输入 -1 设置该进程剩余已分配资源为 0 :" << endl;
        for(int j=0;j<Resource_Num;j++)
        {
            cout << "R" << j << ":" ;
            cin >> a;
            if(a<0){
                for(;j<Resource_Num;j++)Allocation[i][j]=0;
                break;
            }
            Allocation[i][j]=a;
        }
        cout << endl;
        for(int j=0;j<Resource_Num;j++)
            Need[i][j]=Max[i][j]-Allocation[i][j];
    }
}
void Reset_Finish()
{
    memset(Finish,0,sizeof(Finish));
    memset(Work,0,sizeof(Work));
    List_Num=0;
}

int Safe()                                                     //安全性算法
{
    int flag=0,Count=0;
    cout << "Safe" << endl;
    Reset_Finish();
    cout << "     Work      Need      Allocation      Work+Allocation      Finish"<<endl;
    for(int i=0;i<Resource_Num;i++)Work[i]=Available[i];
    while(List_Num<Process_Num)
    {
        for(int i=0;i<Process_Num;i++)
        {
            if(!Finish[i])
            {
                flag = 0;
                for(int j=0;j<Resource_Num;j++)
                {
                    if(Need[i][j]>Work[j])
                    {
                        flag=1;
                        break;
                    }
                }
                if(!flag)
                {
                    List[List_Num++]=i;
                    cout << "P" << i <<"|";
                    for(int j=0;j<Resource_Num;j++)
                    {
                        printf("%3d",Work[j]);
                        Work[j]+=Allocation[i][j];
                    }
                    cout << "|   ";
                    for(int j=0;j<Resource_Num;j++)printf("%3d",Need[i][j]);cout << "|   ";
                    for(int j=0;j<Resource_Num;j++)printf("%3d",Allocation[i][j]);cout << "|   ";
                    for(int j=0;j<Resource_Num;j++)printf("%3d",Work[j]);cout << "|   ";
                    Finish[i]=1;
                    printf("true\n");
                }
            }
        }
        Count++;
        if(Count>=Process_Num)break;
    }
    if(List_Num<Process_Num)
    {
        cout << "No safe List" << endl;
        return 0;
    }
    else {
        cout << "Safe list exist" << endl;
        return 1;
    }
}
void Request()                                                  //银行家算法
{
    int pro,Request_Num[Resource_Max],inst=0;
    int flag=0;
    while(!inst)
    {
        cout << "输入发出请求的进程 Enter Process_Num:" << endl;
        cin>> pro;
        cout << "输入请求向量 Enter Request_Num:" <<endl;
        for(int i=0;i<Resource_Num;i++)
        {
            cout << "R" << i << ":";
            cin>> Request_Num[i];
        }
        flag=0;
        for(int i=0;i<Resource_Num;i++)
        {
            if(Request_Num[i]>Need[pro][i])
            {
                cout << "Error:Out of range" << endl;
                return;
            }
        }
        for(int i=0;i<Resource_Num;i++)
        {
            if(Request_Num[i]>Available[i])
            {
                flag=1;
                cout <<"没有足够资源 等待..." << endl;
                cout << "No enough resource wait..." << endl;
            }
        }
        if(!flag)
        {
            for(int i=0;i<Resource_Num;i++)
            {
                Available[i]-=Request_Num[i];
                Allocation[pro][i]+=Request_Num[i];
                Need[pro][i]-=Request_Num[i];
            }
            if(!Safe())
            {
                for(int i=0;i<Resource_Num;i++)
                {
                    Available[i]+=Request_Num[i];
                    Allocation[pro][i]-=Request_Num[i];
                    Need[pro][i]+=Request_Num[i];
                }
            }
        }
        cout << "------------------------------" << endl;
        cout << "请输入指令:" << endl;
        cout << "1.继续输入请求 Request" << endl;
        cout << "2.退出到主界面 Return" << endl;
        cin >> inst;
        if(inst!=1)return;
        else inst=0;
    }
}

void Banker()                                                   //计算T0时刻安全序列
{
    instruct=0;
    int flag=0,Count=0,inst=0;
    cout << "Banker" << endl;
    cout << "     Work      Need      Allocation      Work+Allocation      Finish"<<endl;
    for(int i=0;i<Resource_Num;i++)Work[i]=Available[i];
    while(List_Num<Process_Num)                                 //银行家算法及安全性算法
    {

        for(int i=0;i<Process_Num;i++)
        {
            if(!Finish[i])
            {
                flag = 0;
                for(int j=0;j<Resource_Num;j++)
                {
                    if(Need[i][j]>Work[j])
                    {
                        flag=1;
                        break;
                    }
                }
                if(!flag)
                {
                    List[List_Num++]=i;
                    cout << "P" << i <<"|";
                    for(int j=0;j<Resource_Num;j++)
                    {
                        printf("%3d",Work[j]);
                        Work[j]+=Allocation[i][j];
                    }
                    cout << "|   ";
                    for(int j=0;j<Resource_Num;j++)printf("%3d",Need[i][j]);cout << "|   ";
                    for(int j=0;j<Resource_Num;j++)printf("%3d",Allocation[i][j]);cout << "|   ";
                    for(int j=0;j<Resource_Num;j++)printf("%3d",Work[j]);cout << "|   ";
                    Finish[i]=1;
                    printf("true\n");
                }
            }
        }
        Count++;
        if(Count>=Process_Num)break;
    }
    if(List_Num<Process_Num)
    {
        cout << "No safe List" << endl;
        return;
    }
    else cout << "T0 safe list" << endl;
    Reset_Finish();
    cout << "------------------------------" << endl;
    cout << "请输入指令:" << endl;
    cout << "1.输入请求向量 Request" << endl;
    cout << "2.退出到主页面 Return" << endl;
    cout << "------------------------------" << endl;
    cin >> inst;
    if(inst==1)Request();
    else inst=0;
}

void Shout()                                                    //输出系统与进程信息
{
    instruct=0;
    cout << "Shout" << endl;
    cout << "系统信息 OS:" << endl;
    cout << "资源种类 Resource_Num:" << Resource_Num << endl;
    cout << "当前可利用资源 Available:" << endl;
    for(int i=0;i<Resource_Num;i++)
    {
        cout << "R" << i << ":" << Available[i] << " ";
    }
    cout << endl;
    cout << "进程信息 Process:" << endl;
    cout << "最大需求 Max:" <<endl;
    for(int i=0;i<Process_Num;i++)
    {
        cout << "P" << i <<endl;
        for(int j=0;j<Resource_Num;j++)
        {
            cout << "R" << j << ":" << Max[i][j] << " ";
        }
        cout <<endl;
    }
    cout << "已分配资源 Allocation:" << endl;
    for (int i=0;i<Process_Num;i++)
    {
        cout << "p" << i <<endl;
        for(int j=0;j<Resource_Num;j++)
        {
            cout << "R" << j << ":" << Allocation[i][j] << " ";
        }
        cout <<endl;
    }
    cout << "需求矩阵 Need:" << endl;
    for (int i=0;i<Process_Num;i++)
    {
        cout << "p" << i <<endl;
        for(int j=0;j<Resource_Num;j++)
        {
            cout << "R" << j << ":" << Need[i][j] << " ";
        }
        cout <<endl;
    }
    /*cout << "工作向量 Work:" << endl;
    for (int i=0;i<Process_Num;i++)
    {
        cout << "p" << i <<endl;
        for(int j=0;j<Resource_Num;j++)
        {
            cout << "R" << j << ":" << Work[j] << " ";
        }
        cout <<endl;
    }*/
    cout <<endl;
}
void Reset()                                                    //重置所有数据
{
    cout << "Reset" << endl;
    instruct=0;
    Process_Num=0;
    List_Num=0;
    Resource_Num=0;
    memset(Allocation,0,sizeof(Allocation));
    memset(Available,0,sizeof(Available));
    memset(Max,0,sizeof(Max));
    memset(Need,0,sizeof(Need));
    memset(Work,0,sizeof(Work));
    Reset_Finish();
}
int main()
{

    Reset();
    do{
    if(instruct==1)Input_OS();
    else if(instruct==2)Input_P();
    else if(instruct==3)Banker();
    else if(instruct==4)Shout();
    else if(instruct==5)Reset();
    else if(!instruct);
    else cout << "Error" << endl;
    cout << "------------------------------" << endl;
    cout << "请输入指令:" << endl;
    cout << "1.输入系统信息 Input OS information" << endl;
    cout << "2.输入进程信息 Input Process information" << endl;
    cout << "3.执行银行家算法 Run Banker‘s" << endl;
    cout << "4.查看系统与进程信息 Print all information" << endl;
    cout << "5.重置所有信息 Reset" << endl;
    cout << "-1.退出 exit" << endl;
    cout << "------------------------------" << endl;
    }while(scanf("%d",&instruct)!=EOF&&instruct!=-1);
    return 0;
}

/*
测试用例：
1
3
3 3 2
2
5
7 5 3
0 1 0
3 2 2
2 0 0
9 0 2
3 0 2
2 2 2
2 1 1
4 3 3
0 0 2
3
1
1
1 0 2
1
4
3 3 0
1
0
0 2 0
1
0
0 1 0

*/

运行结果：

Reset
------------------------------
请输入指令:
1.输入系统信息 Input OS information
2.输入进程信息 Input Process information
3.执行银行家算法 Run Banker‘s
4.查看系统与进程信息 Print all information
5.重置所有信息 Reset
-1.退出 exit
------------------------------
1
OS
输入资源种类 Enter Resource_Num:
3
输入系统当前可利用资源数 Enter Available:
R0:3 3 2
R1:R2:------------------------------
请输入指令:
1.输入系统信息 Input OS information
2.输入进程信息 Input Process information
3.执行银行家算法 Run Banker‘s
4.查看系统与进程信息 Print all information
5.重置所有信息 Reset
-1.退出 exit
------------------------------
2
Process
输入进程数 Enter Process_Num:
5
输入进程 P0的最大资源需求 Max:
R0:7 5 3
R1:R2:
输入进程 P0的已分配资源 Allocation:
输入 -1 设置该进程剩余已分配资源为 0 :
R0:0 1 0
R1:R2:
输入进程 P1的最大资源需求 Max:
R0:3 2 2
R1:R2:
输入进程 P1的已分配资源 Allocation:
输入 -1 设置该进程剩余已分配资源为 0 :
R0:2 0 0
R1:R2:
输入进程 P2的最大资源需求 Max:
R0:9 0 2
R1:R2:
输入进程 P2的已分配资源 Allocation:
输入 -1 设置该进程剩余已分配资源为 0 :
R0:3 0 2
R1:R2:
输入进程 P3的最大资源需求 Max:
R0:2 2 2
R1:R2:
输入进程 P3的已分配资源 Allocation:
输入 -1 设置该进程剩余已分配资源为 0 :
R0:2 1 1
R1:R2:
输入进程 P4的最大资源需求 Max:
R0:4 3 3
R1:R2:
输入进程 P4的已分配资源 Allocation:
输入 -1 设置该进程剩余已分配资源为 0 :
R0:0 0 2
R1:R2:
------------------------------
请输入指令:
1.输入系统信息 Input OS information
2.输入进程信息 Input Process information
3.执行银行家算法 Run Banker‘s
4.查看系统与进程信息 Print all information
5.重置所有信息 Reset
-1.退出 exit
------------------------------
3
Banker
     Work      Need      Allocation      Work+Allocation      Finish
P1|  3  3  2|     1  2  2|     2  0  0|     5  3  2|   true
P3|  5  3  2|     0  1  1|     2  1  1|     7  4  3|   true
P4|  7  4  3|     4  3  1|     0  0  2|     7  4  5|   true
P0|  7  4  5|     7  4  3|     0  1  0|     7  5  5|   true
P2|  7  5  5|     6  0  0|     3  0  2|    10  5  7|   true
T0 safe list
------------------------------
请输入指令:
1.输入请求向量 Request
2.退出到主页面 Return
------------------------------
1
输入发出请求的进程 Enter Process_Num:
1
输入请求向量 Enter Request_Num:
R0:1 0 2
R1:R2:Safe
     Work      Need      Allocation      Work+Allocation      Finish
P1|  2  3  0|     0  2  0|     3  0  2|     5  3  2|   true
P3|  5  3  2|     0  1  1|     2  1  1|     7  4  3|   true
P4|  7  4  3|     4  3  1|     0  0  2|     7  4  5|   true
P0|  7  4  5|     7  4  3|     0  1  0|     7  5  5|   true
P2|  7  5  5|     6  0  0|     3  0  2|    10  5  7|   true
Safe list exist
------------------------------
请输入指令:
1.继续输入请求 Request
2.退出到主界面 Return
1
输入发出请求的进程 Enter Process_Num:
4
输入请求向量 Enter Request_Num:
R0:3 3 0
R1:R2:没有足够资源 等待...
No enough resource wait...
------------------------------
请输入指令:
1.继续输入请求 Request
2.退出到主界面 Return
1
输入发出请求的进程 Enter Process_Num:
0
输入请求向量 Enter Request_Num:
R0:0 2 0
R1:R2:Safe
     Work      Need      Allocation      Work+Allocation      Finish
No safe List
------------------------------
请输入指令:
1.继续输入请求 Request
2.退出到主界面 Return
1
输入发出请求的进程 Enter Process_Num:
0
输入请求向量 Enter Request_Num:
R0:0 1 0
R1:R2:Safe
     Work      Need      Allocation      Work+Allocation      Finish
P1|  2  2  0|     0  2  0|     3  0  2|     5  2  2|   true
P3|  5  2  2|     0  1  1|     2  1  1|     7  3  3|   true
P4|  7  3  3|     4  3  1|     0  0  2|     7  3  5|   true
P0|  7  3  5|     7  3  3|     0  2  0|     7  5  5|   true
P2|  7  5  5|     6  0  0|     3  0  2|    10  5  7|   true
Safe list exist
------------------------------

时间： 2024-12-20 04:15:38

银行家算法 C++实现的相关文章

操作系统—银行家算法

参考http://blog.csdn.net/yaopeng_2005/article/details/6935235 对小鹏_加油的代码进行了部分修改,并加入了自己的文档注释 定义全局变量,以及主函数main 1 #include <iostream> 2 using namespace std; 3 #define MAXPROCESS 50 //最大进程数 4 #define MAXRESOURCE 100 //最大资源数 5 int AVAILABLE[MAXRESOURCE]; //

银行家算法

我们可以把操作系统作为一个银行家.操作系统管理的资金相当于银行家的资源.过程向操作系统请求分配相当于用户资源,银行贷款. 为了保证资金的安全性,银行规定: (1) 当资金客户最大需求不超过可用资金的银行家可以接受客户; (2) 贷款,但贷款的总数不能超过最大需求量; (3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款; (4) 当顾客得到所需的所有资金后,一定能在有限的时间里归还所有的资金. 银行家算法数据结构 1)可利用资源向量A

C语言实现 操作系统 银行家算法

嘿嘿,今晚心血来潮,在宿舍把银行家算法实现了. /************************************************** 银行家算法: 主要的思想是 舍大取小,先满足小的,最后才满足大的. author: lyb date: 2014/10/15 ***************************************************/ #include <stdio.h> #include <stdlib.h> #include <

操作系统之银行家算法

一.需求分析 1.进程的状态有:就绪,等待和完成.当系统不能满足进程的资源请求时,进程出于等待状态.资源需求总量表示进程运行过程中对资源的总的需求量.已占资源量表示进程目前已经得到但还为归还的资源量.因此,进程在以后还需要的剩余资源量等于资源需要总量减去已占资源量.陷入每个进程的资源需求总量不应超过系统拥有的资源总量. 2.银行家算法分配资源的原则是:当某个进程提出资源请求时,假定先分配资源给它,然后查找各进程的剩余请求,检查系统的剩余资源量是否由于进程的分配而导致系统死锁.若能,则让进程等待,

避免死锁的银行家算法C++程序实现

 本篇博文为追忆曾经写过的算法系列第二篇(20081021) 温故知新 目的:具有代表性的死锁避免算法是Dijskstra给出的银行家算法.本实验是基于银行家算法的思想通过编写C++程序实现银行家算法的计算机程序化,使其更实用.同时也加深了有关自愿申请.避免死锁等概念,体会避免死锁的实际实现过程与方法. 要求: 1.设定进程p对各类资源r合理的最大需求max及初值确定:2.设定系统提供资源初始状况allocation:3.设定每次某个进程对各类资源的申请表示need:4.编制C++程序,基于

银行家算法java实现

关于银行家算法的理论知识,课本或者百度上有好多资料,我就不再多说了,这里把我最近写的银行家算法的实现带码贴出来. 由于这是我们的一个实验,对系统资源数和进程数都指定了,所以这里也将其指定了,其中系统资源数为3,进程数为5. import java.util.Scanner; import javax.swing.plaf.basic.BasicInternalFrameTitlePane.MaximizeAction; import javax.swing.text.StyledEditorKi

[OS] 死锁相关知识点以及银行家算法详解

因此我们先来介绍一下死锁: 死锁特征 当出现死锁时,进程永远不能完成,并且系统资源被阻碍使用,阻止了其他作业开始执行.在讨论处理死锁问题的各种方法之前,先深入讨论一下死锁的特征. ·必要条件 (1)互斥:至少有一个资源必须处于非共享模式,即一次只有一个进程使用.如果另一进程申请该资源,那么申请进程必须等到该资源被释放为止. (2)占有并等待:一个进程必须占有至少一个资源,并等待另一资源,而该资源为其他进程所占有. (3)非抢占:资源不能被抢占,即资源只能在进程完成任务后自动释放. (4)循环等待

银行家算法——软考探究（四）

著名的银行家算法,最早是由Dijkstra提出来的.它是一种最有代表性的避免死锁的算法.在避免死锁方法中允许进程动态地申请资源,但系资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待. 银行家算法最重要的就是判断是可用资源和仍需资源之间的关系,如果可用资源数大于人需资源数,那么我们认为这个进程就是可以执行的,也是安全的,反之,便是不安全的.所以重中之重的是找到各种资源数. 对进程的判断遵循以下步骤: 1.计算系统开始时所有的资源数,即开始的可用资源数;

死锁的避免——银行家算法

银行家把一定数量的资金供多个用户周转使用.当顾客对资金的最大申请量不超过银行家现金时,就可接纳一个新顾客:顾客可以分期借款:但借款总数不能超过最大申请量:银行家对顾客的借款可以推迟支付,但一定是顾客总能在有限的时间里得到借款:当顾客得到全部资金后,他一定能在有限时间里面归还所有资金. 采用银行家算法分配资源时候,测试进程对资源的最大需求量,如果系统现存的资源可以满足他的最大需求量时,就满足进程当前的申请,否则就推迟分配.这样做,能保证至少有一个进程可得到需要的全部资源而执行到结束,然后归还资源供