精华内容
下载资源
问答
  • 银行家算法 安全性算法 C++ 源代码 操作系统实验
  • 银行家算法安全性检银行家银行家算法安全性检查算法及安全性检查查
  • 内容:编程实现银行家算法安全性算法 基本要求 能够根据给定的资源分配情况,及某进程提出的资源请求,通过算法得出是否能进行分配。如能分配,需得出相应的安全序列。 内含多个实验报告 资源整合
  • 操作系统 银行家算法 安全性检查

    千次阅读 2020-11-22 11:05:47
    文章目录算法描述银行家算法安全性检查数据结构安全性算法银行家算法主函数测试用例 算法描述 银行家算法 设进程I提出请求Request[N],则银行家算法按如下规则进行判断 如果Request[N]<= Need [I, N],则转(2);...

    算法描述

    银行家算法

    设进程I提出请求Request[N],则银行家算法按如下规则进行判断

    1. 如果Request[N]<= Need [I, N],则转(2);否则,出错
    2. 如果Request[N]<= Available,则转(3);否则,出错
    3. 系统试探分配资源,修改相关数据:
    • Available = Available -Request
    • Allocation = Allocation +Request
    • Need= Need - Request
    1. 系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待
    安全性检查
    1. 设置两个工作向量Work= Available;Finish[M]=False
    2. 从进程集合中找到一个满足下述条件的进程
      Finish[i]=False
      Need <=Work

    如找到,执行(3);否则,执行(4)

    1. 设进程获得资源,可顺利执行,直至完成,从而释放资源
      Work=Work+ Allocation
      Finish=True
      Go To 2
    2. 如所有的进程Finish[M]=true,则表示安全;否则系统不安全

    数据结构

    int const RESOURCE_NUM = 20; // 最大资源的数目
    int const PCB_COUNT = 10;    // 进程的数目
    // 输入的进程
    int M; //总进程数
    int N; //资源种类
    // 文件输出
    ofstream fout;
    
    char Name[RESOURCE_NUM];                 // 资源的名字
    int PCBName[PCB_COUNT];                  // 进程的名字
    int All_Resource[RESOURCE_NUM];          // 各种资源的数目总和
    int Max[PCB_COUNT][RESOURCE_NUM];        // M个进程对N类资源最大资源需求量
    int Available[RESOURCE_NUM];             // 系统可用资源数
    int Allocation[PCB_COUNT][RESOURCE_NUM]; // M个进程已经得到N类资源的资源量
    int Need[PCB_COUNT][RESOURCE_NUM];       // M个进程还需要N类资源的资源量
    int Request[RESOURCE_NUM];               // 请求资源个数
    int Work[RESOURCE_NUM] = {0};            // 系统可提供的资源数量
    int Finish[RESOURCE_NUM] = {0};          // 完成的标志
    int Security[PCB_COUNT];                 // 完成序列
    
    //=========函数声明================
    void initData();              // 输入信息
    void showData();              // 展示输入的数据
    bool safeAlgo();              // 安全序列函数
    void allocationTest(int i);   // 对第i个进程分配预分配资源
    void reAllocationTest(int i); // 对第 i 个进程回收预分配的资源
    bool requestAlgo();           // 第 i 个进程请求资源
    
    • 获取系统的时间作为输出文件的名字
    string getFileName(string algoName)
    {
        // 获取时间 time_t是一个64位的整型。记录的是从1970-01-01 00:00:00到现在经过的时间,精度只能到秒
        time_t now = time(NULL);
        tm *t = localtime(&now);
    
        // 将信息输出到字符串流
        stringstream ss; // 引入sstream头文件
        ss << algoName << "LogFile" << t->tm_year + 1900 << "." << t->tm_mon + 1 << "." << t->tm_mday << ".." << t->tm_hour << "." << t->tm_min << "." << t->tm_sec << ".txt";
        cout << "写入的文件为: " << ss.str() << endl;
        return ss.str();
    }
    
    • 输入资源信息、Max矩阵、Allocation矩阵
    void initData()
    {
        // 输入系统资源的种类与名字 名字用char类型
        cout << "输入系统资源的种类: " << endl;
        fout << "输入系统资源的种类: " << endl;
    
        cin >> N; // 资源的种类
        fout << N << endl;
    
        for (int i = 0; i < N; ++i)
        {
            cout << "资源的名字: " << endl;
            fout << "资源的名字: " << endl;
    
            cin >> Name[i];
            fout << Name[i] << endl;
    
            cout << "输入资源 " << Name[i] << " 的总个数 : " << endl;
            fout << "输入资源 " << Name[i] << " 的总个数 : " << endl;
    
            cin >> Available[i];
            fout << Available[i] << endl;
        }
    
        cout << "输入系统进程的数目:" << endl;
        fout << "输入系统进程的数目:" << endl;
    
        cin >> M; // M 进程的数目
        fout << M << endl;
    
        // 循环输入最大需求矩阵
        cout << "输入进程的最大需求矩阵" << endl;
        fout << "输入进程的最大需求矩阵" << endl;
    
        // 循环标志
        bool flag;
    
        // 每次输入是初始化输入为false
        flag = false;
        for (int i = 0; i < M; ++i)
        {
            cout << "第 " << i + 1 << " 个进程的Max矩阵" << endl;
            fout << "第 " << i + 1 << " 个进程的Max矩阵" << endl;
    
            PCBName[i] = i + 1;
            do
            {
                flag = false;
                for (int j = 0; j < N; ++j)
                {
                    cin >> Max[i][j];
                    fout << Max[i][j] << " ";
                    // 输入检测,如果输入不合法,即需求的数目大于可分配的数目,重新输入所有的资源数目
                    if (Max[i][j] > Available[j])
                    {
                        flag = true;
                    }
                }
                fout << endl;
                if (flag){
                    cout << "输入需求的最大资源数不合法!请重新输入" << endl;
                    fout << "输入需求的最大资源数不合法!请重新输入" << endl;
                    cout << "第 " << i + 1 << " 个进程的Max矩阵" << endl;
                    fout << "第 " << i + 1 << " 个进程的Max矩阵" << endl;
                }
                
            } while (flag);
    
        }
    
        // 初始化数据
        flag = false;
        /**
        * 输入分配的资源, 需要的资源为Need[i][j] = Max[i][j] - Allocation[i][j] 
        */
        for (int i = 0; i < M; ++i)
        {
            cout << "第 " << i + 1 << " 个进程的Allocation矩阵" << endl;
            fout << "第 " << i + 1 << " 个进程的Allocation矩阵" << endl;
    
            do
            {
                flag = false;
                for (int j = 0; j < N; ++j)
                {
                    cin >> Allocation[i][j];
                    fout << Allocation[i][j] << " ";
    
                    if (Allocation[i][j] > Max[i][j])
                    {   
                        flag = true;
                    } else {
                        // 修改Need数组,得到还需分配的资源
                        Need[i][j] = Max[i][j] - Allocation[i][j];
                        // 修改Available数组, 得到系统剩余的资源
                         Available[j] -= Allocation[i][j];
                    }
                    
                }
                fout << endl;
                if (flag)
                {
                    cout << "输入的Allocation大于Max!请重新输入" << endl;
                    fout << "输入的Allocation大于Max!请重新输入" << endl;
                    cout << "第 " << i + 1 << " 个进程的Allocation矩阵" << endl;
                    fout << "第 " << i + 1 << " 个进程的Allocation矩阵" << endl;
                }
            } while (flag);
        }
    }
    
    • 展示输入的信息
    void showData()
    {
        cout << "==========================================" << endl
             << endl;
        fout << "==========================================" << endl
             << endl;
    
        cout << "系统可用资源的数目: Avaliable: " << endl;
        fout << "系统可用资源的数目: Avaliable: " << endl;
    
        for (int i = 0; i < N; ++i)
        {
            cout << "   " << Name[i];
            fout << "   " << Name[i];
        }
        cout << endl;
        fout << endl;
    
        for (int i = 0; i < N; ++i)
        {
            cout << "   " << Available[i];
            fout << "   " << Available[i];
        }
        cout << endl;
        fout << endl;
    
        cout << "各个进程得到资源的情况: " << endl
             << "PCBName      Max      Allocation      Need" << endl;
        fout << "各个进程得到资源的情况: " << endl
             << "PCBName      Max      Allocation      Need" << endl;
        cout << "            ";
        fout << "            ";
    
        for (int i = 0; i < 3; ++i)
        {
            for (int j = 0; j < N; ++j)
            {
                cout << Name[j] << " ";
                fout << Name[j] << " ";
            }
            cout << "       ";
            fout << "       ";
        }
        cout << endl;
        fout << endl;
    
        for (int i = 0; i < M; ++i)
        {
            cout << PCBName[i] << "           ";
            fout << PCBName[i] << "           ";
    
            // 输出max
            for (int j = 0; j < N; ++j)
            {
                cout << Max[i][j] << " ";
                fout << Max[i][j] << " ";
            }
            cout << "       ";
            fout << "       ";
    
            // 输出Allocation
            for (int j = 0; j < N; ++j)
            {
                cout << Allocation[i][j] << " ";
                fout << Allocation[i][j] << " ";
            }
            cout << "       ";
            fout << "       ";
    
            // 输出Need
            for (int j = 0; j < N; ++j)
            {
                cout << Need[i][j] << " ";
                fout << Need[i][j] << " ";
            }
            cout << endl;
            fout << endl;
        }
    }
    
    

    安全性算法

    bool safeAlgo()
    {
        /**
         * @brief 
         * 安全性算法执行
         * 首先work赋值为Available, Finish全部赋值为false
         * 假设全部都分配给Need, 分配之后进行检测
         * 1. 每一次检测都从第一个开始,如果每一个Need可以被分配,则进行分配
         * 2. 分配完成之后,从第一个循环开始
         */
        // 初始化 work
        int securityCNT = 0;
        for (int i = 0; i < N; ++i)
        {
            Work[i] = Available[i];
        }
        // 初始化Finish
        for (int i = 0; i < M; ++i)
        {
            Finish[i] = false; // 开始的时候假设都没有完成
        }
        // 安全序列算法
        int resource = 0;
        for (int i = 0; i < M; i++)
        {
            // 每一次检测都初始化为0
            resource = 0;
            // 对资源分配进行检测
            for (int j = 0; j < N; ++j)
            {
                // 如果进程没有完成, 并且可以得到需要
                if (Finish[i] == false && Need[i][j] <= Work[j])
                {
                    resource++;
    
                    // 各种资源都可以得到满足的时候
                    if (resource == N)
                    {
    
                        // work资源改变
                        for (int k = 0; k < N; ++k)
                        {
                            // 占用资源释放,相当于 work[k] += Need[i][k] + Allocation[i][k]; Need未进行计算
                            Work[k] += Allocation[i][k];
                        }
                        // 完成标志
                        Finish[i] = true;
                        // 添加到完成序列
                        Security[securityCNT++] = PCBName[i]; // 进程号
    
                        i = -1; // ++i 后从0开始
                    }
                }
            }
        }
    
        // 检测全部的Finish 如果有一个未false 则为不安全序列
        for (int i = 0; i < M; ++i)
        {
            if (Finish[i] == false)
            {
                cout << "系统处于不安全序列" << endl;
                fout << "系统处于不安全序列" << endl;
                return false;
            }
        }
    
        // 此时存在安全序列
        cout << "此时系统是安全的: ";
        fout << "此时系统是安全的: ";
    
        for (int i = 0; i < M; ++i)
        {
            if (i == M - 1)
            {
                cout << Security[i] << endl;
                fout << Security[i] << endl;
            }
            else
            {
                cout << Security[i] << " -> ";
                fout << Security[i] << " -> ";
            }
        }
        return true;
    }
    
    

    银行家算法

    
    // 预分配
    void allocationTest(int i)
    {
        /**
         * @brief 
         * Available减少
         * allocation增加
         * Need改变
         */
        for (int j = 0; j < N; ++j)
        {
            Available[j] -= Request[j];
            Allocation[i][j] += Request[j]; // 占用资源增加
            Need[i][j] -= Request[j];       // 需要的资源减少
        }
    }
    
    // 预分配失败,返回
    void reAllocationTest(int i)
    {
        for (int j = 0; j < N; ++j)
        {
            Available[j] += Request[j];
            Allocation[i][j] -= Request[j];
            Need[i][j] += Request[j];
        }
    }
    
    bool requestAlgo()
    {
        cout << "输入要分配资源的进程:  " << endl;
        fout << "输入要分配资源的进程:  " << endl;
    
        int P;
        cin >> P;
        fout << P << endl;
        P -= 1; // 转换为下标
        cout << "输入要分配各个资源的数目" << endl;
        fout << "输入要分配各个资源的数目" << endl;
    
        for (int i = 0; i < N; ++i)
        {
            cout << Name[i] << ": ";
            fout << Name[i] << ": ";
    
            cin >> Request[i];
            fout << Request[i];
        }
    
        // 对输入的资源进行检测
        for (int i = 0; i < N; ++i)
        {
            // 检测是否大于还需要的进程
            if (Request[i] > Need[P][i])
            {
                cout << "资源申请大于 Need" << endl;
                fout << "资源申请大于 Need" << endl;
    
                return false;
            }
            else
            {
                // 检测是否有可用的资源
                if (Request[i] > Available[i])
                {
                    cout << "申请资源大于 Avaliable" << endl;
                    fout << "申请资源大于 Avaliable" << endl;
    
                    return false;
                }
            }
        }
    
        // 合法 检测通过
        allocationTest(P); // 预分配资源
        showData();
        if (!safeAlgo())
        {
            // 没有安全序列
            reAllocationTest(P);
            showData();
            return false;
        }
        else
        {
            reAllocationTest(P);
            showData();
            return true;
        }
    }
    
    

    主函数

    int main()
    {
    	// 得到文件名
        string fileName = getFileName("BankAlgo");
        // 打开文件
        fout.open(fileName.c_str());
        initData();
        showData();
        if (!safeAlgo())
        {
            return -1;
        }
        while (1)
        {
            requestAlgo();
            cout << "\t\tCtrl + C 结束进程" << endl
                 << endl;
        }
        return 0;
    }
    
    

    测试用例

    3
    A
    10
    B
    5
    C
    7
    
    5
    7 5 3
    3 2 2
    9 0 2
    2 2 2
    4 3 3
    
    0 1 0
    3 0 2
    3 0 2
    2 1 1
    0 0 2
    
    展开全文
  • 银行家算法 安全性检查 绝对原创 保证可以运行 而且程序思路清晰,是我们操作系统实验,特拿出来共享
  • 银行家算法安全性算法笔记

    万次阅读 多人点赞 2018-07-01 15:57:55
    银行家算法简框图 “`flow st=&amp;amp;gt;start: 开始 e=&amp;amp;gt;end: 结束 cond1=&amp;amp;gt;condition: 资源请求合法检查 op1=&amp;amp;gt;operation: 进行尝试的资源分配 op2=&...

    简介

    首先银行家算法属于避免死锁的一个著名算法,由Dijkstra在1965年为T.H.E系统设计的一种避免死锁产生的算法。这是由于该算法用于银行系统现金贷款的发放而得名。


    基本思想

    允许进程动态地申请资源,在资源分配之前,通过相应的算法确定本次资源分配后系统是否安全(不会产生死锁),若是,则进行分配,否则,让进程处于等待状态


    重要概念

    安全状态

    某时刻,对于并发执行的n个进程,若系统能够按照某种顺序如{p1,p2…pn}来为每个进程分配所需资源,直至最大需求,从而使每个进程都可顺利完成,则认为该时刻系统处于安全状态,这样的序列为安全序列

    安全状态例子
    P1、P2和P3三个进程和12台磁带机,T0时刻可用资源为3:

    进程最大需求已分配尚需
    P11055
    P2422
    P1927

    那么此刻如果以{P2,P1,P3} 的顺序来执行,就可以顺利运行(系统就可以救活)
    执行的过程如下表:

    进程空闲资源
    P25
    P110
    P312

    如果在T0 状态不按安全序列进行分配,可能会导致系统进入一个不安全状态,例如在T0状态下P3中申请1台磁带机。


    银行家算法思想简框图

    Created with Raphaël 2.2.0 开始 资源请求合法性检查 进行尝试性的资源分配 分配安全吗? 结束 撤销本次资源分配 不合法性处理 yes no yes no

    银行家算法的数据结构

    可用资源向量 Available[m]

    m为系统中资源种类数,Available[j]=k表示系统中第j类资源数为k个。

    最大需求矩阵 Max[n,m]

    n为系统中进程数,Max[i,j]=k表示进程i对j类资源的最大需求数为中k。

    分配矩阵 Allocation[n,m]

    它定义了系统中每一类资源当前已分配给每一进程资源数, Allocation[i,j] = k表示进程i已分得j类资源的数目为k个。

    需求矩阵 Need[n,m]

    它表示每个进程尚需的各类资源数,Need[i,j]=k 表示进程i 还需要j类资源k个。Need[i,j]=Max[i,j] - Allocation[i,j]。

    进程Pi的请求向量Requesti

    如果Requesti[j]=K,表示进程Pi需要K个Rj类型的资源。


    银行家算法具体框图

    Created with Raphaël 2.2.0 开始 Requesti ≤ Need[i] Request[i]≤Available Available= Available-Requesti Allocation[i]= Allocation[i]+Requesti Need[i]=Need[i]-Requesti 分配安全吗? Available= Available+Requesti Allocation[i]= Allocation[i]-Requesti Need[i]=Need[i]+Requesti 结束 撤销本次资源分配 请求进程等待 资源请求非法 yes no yes no yes no

    银行家算法具体步骤描述

    当Pi发出资源请求后,系统按下述步骤进行检查:

    • (1) 如果Requesti[j]≤Need[i,j],便转向步骤2;否则认为出错,因为它所需要的资源数已超过它所宣布的最大值。
    • (2) 如果Requesti[j]≤Available[j],便转向步骤(3);否则, 表示尚无足够资源,Pi须等待。
    • (3) 系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值 Available[j]:=Available[j] –Requesti[j];
      Allocation[i, j]:=Allocation[i, j]+Requesti[j];
      Need[i, j]:=Need[i, j]-Requesti[j];
    • (4) 系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,
      将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。

    安全性算法

    由银行家算法改进更通用的安全性算法


    安全性算法原理简框图

    Created with Raphaël 2.2.0 开始 寻找一个非阻塞的进程? 运行完成,释放资源 所有进程节点都可以运行完成吗? 系统安全 系统不安全 yes no yes no

    安全性算法的数据结构

    工作向量Work

    它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素

    Finish

    它表示系统是否有足够的资源分配给进程,使之运行完成。开始时先做Finish[i]:= False; 当有足够资源分配给进程时, 再令Finish[i]:= True。


    安全性算法具体框图

    Created with Raphaël 2.2.0 开始 Work=Available; All Finish=FALSE; Finish[i]=false &&Need[i]≤work? Work=Work+Allocation[i]; Finish[i]=TRUE; All finish==TRUE? Return 安全 Return 不安全 yes no yes no

    安全性算法具体步骤描述

    • (1) 设置两个向量: 在执行安全算法开始时,Work∶=Available; Finish[i]:= False;
    • (2) 从进程集合中找到一个能满足下述条件的进程: ① Finish[i]= False; ② Need[i,j]≤Work[j];
      若找到, 执行步骤(3), 否则,执行步骤(4)。
    • (3) 当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:
      Work[j]∶= Work[i]+ Allocation[i, j];
      Finish[i]∶= true; go to step 2;
    • (4) 如果所有进程的Finish[i]=true都满足, 则表示系统处于安全状态;否则,系统处于不安全状态。

    例子

    假定系统中有五个进程{P0、P1、P2、P3、P4}和三种类型资源{A、B、C},每一种资源的数量分别为10、5、7。如下所示

    进程\资源情况Max
    A B C
    Allocation
    A B C
    Need
    A B C
    Available
    A B C
    P07 5 30 1 07 4 33 2 2
    P13 2 22 0 01 2 2
    P29 0 23 0 26 0 0
    P32 2 22 1 10 1 1
    P44 3 30 0 24 3 1
    1. T0时刻是否安全?
      从表中可找出一个序列(P1 、 P3、 P4 、 P2 、 P0)使各进程顺序地一个个地执行完成
    进程\资源情况Work
    A B C
    Need
    A B C
    Allocation
    A B C
    Work+Allocation
    A B C
    Finish
    P13 2 21 2 22 0 05 3 2ture
    P35 3 20 1 12 1 17 4 3ture
    P47 4 34 3 10 0 27 4 5ture
    P27 4 56 0 03 0 210 4 7ture
    P010 4 77 4 30 1 010 5 7ture
    展开全文
  • 银行家算法

    2011-11-17 13:32:56
    操作系统的银行家算法 安全性算法用java实现 。
  • 银行家算法安全性算法

    万次阅读 2016-10-09 01:15:40
    安全序列是指存在一个进程序列{P1,…,Pn}是安全的,不会死锁(至少两个线程占有某资源A,但是都不满足,剩余的资源A分配给谁仍然无法满足),安全状态如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统...

    1. 安全性算法过程描述

    (1) 设置两个向量:① 工作向量Work:它表示系统可提供给进程继续运行所需的各类资源数量的多少,它含有m个元素,在执行安全算法开始时,Work = Available;② Finish:它表示系统是否有足够的资源分配给进程,使之运行完成。开始时先做Finish[i]= false;当有足够资源分配给进程时, 再令Finish[i]= true。

    (2) 从进程集合中找到一个能满足下述条件的进程:
    ① Finish[i]= false; ② Need[i,j]≤ Work[j];
    如果找到,那么,执行步骤(3);否则,执行步骤(4)。

    (3) 当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:

     Work[j]= Work
    展开全文
  • Python3实现银行家算法安全性算法

    千次阅读 2017-11-20 22:17:35
    Python3实现银行家算法安全性算法学习期间写的,希望大家一起进步。 Available = [] #各可用资源数目 Used ={} #某进程目前占有各资源数 Need = {} #某进程目前需求资源数 zhan = [] #临时存储列表 order = [] #...

    Python3实现银行家算法、安全性算法

    学习期间写的,希望大家一起进步。
    
    Available = []  #各可用资源数目
    Used ={} 		#某进程目前占有各资源数
    Need = {}		#某进程目前需求资源数
    zhan = []   	#临时存储列表
    order = []		#进程安全顺序列表
    pandaun = []
    def compare(a = [],b = []):
    	for x in range(0,item):	#进行列表对应元素的比较
    		if (int(a[x]) < int(b[x])): #一旦出现供不应求的情况即返回False
    			return False
    			break			#且跳出循环
    	return True				#如果符合条件即返回True
    def AddUsed(a = [],b = []):	#可用资源某进程当前占用资源对应位置相加
    	for x in range(0,item):	
    		a[x] = int(a[x]) + int(b[x])
    item = int(input("请输入资源种类数: "))
    SP = int(input("请输入进程数: "))
    jinchengshu = SP			#设置临时变量表示进程数量,在后面的判断中用
    #输入各类资源的可用数目并存储到列表Available中
    for x in range(1,item+1):
    	Available.append(input("请输入第"+str(x)+"种资源的可用数目: "))
    #输入各进程名称,占有资源数及所需,键值对存储
    for x in range(1,SP+1):
    	name = input("请输入第"+str(x)+"个进程名称: ")
    	print("该进程占有的"+str(item)+"类资源数为:")
    	for y in range(1,item+1):
    		zhan.append(int(input()))
    	Used[name] = zhan
    	zhan = []	#清空临时列表
    	print("该进程需要的"+str(item)+"类资源数为:")	
    	for z in range(1,item+1):
    		zhan.append(int(input()))
    	Need[name] = zhan
    	zhan = []	#清空临时列表
    #安全性算法开始
    while Need:						#如果进程表Need不为空
    	for key in Need:			#获取Need中的key
    		zhan = Need[key]		#将对应的value赋值给临时列表zhan
    		if compare(Available,zhan):#调用比较函数比较列表中个元素与Avilable中个元素的大小并返回真值
    			AddUsed(Available,Used[key]) #如果返回True则调用相加函数
    			order.append(key)	#将key值放入order列表中以便显示
    			a = key				#设置a令它等于key,删除字典元素时使用
    			break
    	if compare(Available,zhan):	#如果符合大小条件就删除对应的键值对
    		del Need[a]
    		jinchengshu -= 1
    	if SP == jinchengshu:
    		print("不存在安全序列!!!")
    		break
    if jinchengshu == 0:
    	for x in range(0,len(order)):
    		print(order[x]+'-->',end='')
    	print("END!")
    
    
    
    
    
    展开全文
  • 文章目录一、实验目的二、实验内容2.1 数据结构2.2 银行家算法2.3 安全性算法三、流程图3.1 单道批处理系统的作业调度四、代码实现五、运行结果5.1 初始化5.2 验证初始化状态的安全性5.3 进程1请求资源 1 0 2 并通过...
  • 一句话+一张图说清楚——银行家算法

    万次阅读 多人点赞 2018-05-08 21:10:44
    当一个进程申请使用资源的时候,银行家算法通过先 试探 分配给该进程资源,然后通过安全性算法判断分配后的系统是否处于安全状态,若不安全则试探分配作废,让该进程继续等待。 那么此时会有一个问题,...
  • 用c++实现,代码比较容易懂,是操作系统的一个实验,欢迎大家学习交流
  • 编程实现银行家算法中的安全性检查子算法,要求: (1) 本程序要能描述 n 个并发进程共享 m 类资源,在某一时刻的资源分配状态; n、m 自定,但都不能小于 3; (2) 本程序功能: ① 联机输入:系统拥有的每类资源的...
  • 主要用银行家算法来实现检查系统的安全性,从而判断是否为其分配资源。其中主要有给定了资源的类型和数目。
  • 银行家算法是操作系统中很重要的一部分内容 Q:在银行家算法中,若出现下述资源分配情况(5 个进程,资源 A/B/C 共 3 类) 假设系统有 A类资源5个,B类资源7个,C类资源 12 个,某一时刻有以下分资源分配 Process Max ...
  • 操作系统银行家算法+安全性算法

    千次阅读 2019-05-30 14:22:33
    # todo 实现安全性算法,安全返回true,反之false def _safe(self): count = 0 while count flag = False # 一次循环中找不到安全的状态,直接变为不安全,结束循环 for i in range(self._processes): if not...
  • 银行家算法——安全性检查

    千次阅读 2018-05-25 16:28:17
    //不断的去递归银行家算法 void solve( int index) { if (index == n){ for ( int i = 1 ; i ; i++) printf ( "i = %d " ,xu[i]); printf ( "\n" ); } else { for ( int i = 1 ; i ; i++){ if...
  • 银行家算法安全性检查 一、实验目的 实现银行家算法模拟 理解死锁避免的概念和死锁的解决措施 二、实验软硬件环境 Windows或Linux平台 三、实验内容及要求 实验内容: 假设某银行有可借免息工程资助款项共10亿...
  • 银行家算法安全性检查 操作系统中,进程调度是一个非常重要的问题。每个进程都需要一定的资源才能顺利执行,进程执行过程中使用的资源在进程结束时都会释放。不同的资源分配策略会对系统的运行效率产生很大的影响...
  • 文章目录银行家算法实验原理银行家算法中的数据结构银行家算法安全性算法完整代码测试测试代码测试数据测试结果 银行家算法 银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源...
  • (2)对于给定的一组进程和某时刻系统状态(用资源分配矩阵和可用资源向量刻画),当某进程发出资源分配请求时,判断分配是否安全; (3)要求:若安全,应演示分配(进程推进完成)序列;否则提示无法分配。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,853
精华内容 8,741
关键字:

银行家算法安全性算法