银行家算法实现

最新推荐文章于 2024-05-14 00:53:41 发布
最新推荐文章于 2024-05-14 00:53:41 发布
阅读量1.1w 收藏 25
点赞数 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w326159487/article/details/78882223
版权

算法流程：

预设 系统 预处理 资源种数 && 每种资源总数 进程数量 进程对资源的最大需求量 Max 进程已分配到的资源量 All 计算剩余可用资源量 Ava 计算各进程还需的资源量 Need 预设 系统 预处理
Created with Raphaël 2.2.0 开始 预设 安全性检测 进程请求分配资源 请求大于所需(资源) 请求大于可用(资源) 模拟分配资源给进程 安全性检测 系统安全，将资源分配给进程 系统不安全，不分配资源 结束 yes no yes no yes no yes no

整个算法的核心就是安全性检测

Created with Raphaël 2.2.0 安全性检测 设置所有进程Finish状态为false 设置Work向量为Available向量 所有进程Finish状态均为true 系统安全 遍历进程 i++,i<=进程数 Finish[i]==false 遍历资源 j++,j<=资源数 Need[i][j]<=Available[j] 更新Work/Finish Work[i] += All[i]; Finish[i] = true 数据无更新 系统不安全 yes no yes no yes no yes no yes no yes no

表格不固定版本（横排输出）

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;
const int N = 1e3 + 10;

/ 变量
int pro_num;            // 进程数
int res_num;            // 资源种数
int Available[N];       // 可利用资源向量

int Allocation[N][N];   // 分配矩阵
int Max[N][N];          // 最大需求矩阵
int Need[N][N];         // 需求矩阵
                        // Need[i][j] = Max[i][j] - Allocation[i][j];

int Work[N];            // 工作向量  表示系统可提供给进程继续运行所需的各类资源数目
bool Finish[N];         // 标记系统是否有足够资源分配给进程并使之运行完成

int re_pro_num;         // 请求进程对应编号
int requset_res[N];     // 请求资源数量

/ 函数
void get_res();         // 获取资源相关信息
void get_pro();         // 获取进程相关信息
void request();         // 请求资源
bool safe_check();      // 安全性检测

void menu();            // 菜单栏

void display();         // 展示资源分配状况

int main()
{
    while(true){
        printf("--------------------银行家算法--------------------\n\n");
        get_res();                  // 获取资源相关信息
        get_pro();                  // 获取进程相关信息
        display();
        printf("\n\n--------------------检查T0时刻的系统安全性--------------------\n\n");
        bool safe = safe_check();   // 检查T0时刻的系统安全性
        bool over = false;          //结束标记
        while(!over){
            menu();
            int ope;                // 选择操作
            printf("请输入要执行的操作：");
            scanf("%d",&ope);
            if(!safe) printf("\n系统处于不安全状态！\n");
            switch(ope){
                case 1:
                    request();      // 请求资源
                    break;
                case 2:
                    over = true;    // 结束本次算法
                    break;
                case 3:
                    display();      // 展示当前资源分配状况
                    break;
                default:
                    printf("\n***操作无效***\n");
                    break;
            }
//            display();              // 展示资源分配状况
        }
        printf("--------------------本次算法结束------------------\n\n\n");
    }
    return 0;
}

void get_res(){
    printf("\n请输入资源的种数： ");
    scanf("%d",&res_num);
    for(int i=1;i<=res_num;i++){
        printf("\n请输入第%3d 种资源的总数： ",i);
        scanf("%d",&Available[i]);
    }
    printf("------------------------------------------------\n\n");
}

void get_pro(){
    printf("\n\n请输入进程的个数： ");
    scanf("%d",&pro_num);
    for(int i=1;i<=pro_num;i++){
        for(int j=1;j<=res_num;j++){
            printf("\n请输入第%3d 个进程需要第%3d 种资源的个数： ",i,j);
            scanf("%d",&Max[i][j]);
        }
        for(int j=1;j<=res_num;j++){
            printf("\n请输入第%3d 个进程已经分配第%3d 种资源的个数： ",i,j);
            scanf("%d",&Allocation[i][j]);
            Need[i][j] = Max[i][j] - Allocation[i][j];
            Available[j] -= Allocation[i][j];
        }
        printf("\n");
    }
    
    printf("------------------------------------------------\n\n");
}

void request(){
    printf("\n\n请输入请求资源的进程（第一个进程为P<0>）：");
    scanf("%d",&re_pro_num);
    printf("\n请输入 进程%3d 对%3d 种资源的请求（两种资源之间用空格或换行符隔开）:  ",re_pro_num,res_num);
    
    bool flag1 = false;     // 标记请求的资源数量是否超过了所需要的资源数量
    bool flag2 = false;     // 标记请求的资源数量是否超过了当前所能利用的资源数量
    
    for(int i=1;i<=res_num;i++){
        scanf("%d",&requset_res[i]);
        if(requset_res[i]>Need[re_pro_num][i]){
            flag1 = true;
        }
        if(requset_res[i]>Available[i]){
            flag2 = true;
        }
    }
    if(flag1||flag2){
        if(flag1&&flag2){
            printf("\n请求的资源数量超过了所需要的资源数量和当前所能利用的资源数量!\n\n");
        }else if(flag1){
            printf("\n请求的资源数量超过了所需要的资源数量!\n\n");
        }else{
            printf("\n请求的资源数量超过了当前所能利用的资源数量!    等待\n\n");
        }
    }else{
        
        for(int i=1;i<=res_num;i++){
                            //将资源分配出去
            Available[i] -= requset_res[i];
                            //更新进程资源分配状况 即更新 All 和 Need
            Allocation[re_pro_num][i] += requset_res[i];
            Need[re_pro_num][i] -= requset_res[i];
        }
        
        display();          //展示当前资源分配状况
        
                            //检查系统安全性
        if(safe_check()){
                            //系统安全，分配资源给进程
//            display();      //展示分配状况
        }else{
                            //系统不安全，恢复分配资源前可利用资源分配状态
            
            printf("\n系统不安全，不将资源分配给进程 P<%d> ，令其等待\n",re_pro_num-1);
            for(int i=1;i<=res_num;i++){
                            //复原操作
                Available[i] += requset_res[i];
                Allocation[re_pro_num][i] -= requset_res[i];
                Need[re_pro_num][i] += requset_res[i];
            }
        }
    }
    printf("------------------------------------------------\n\n");
}

//安全性检测函数
bool safe_check(){
    
    // 效率 O(n^2)
    int safe_list[N];
    printf("\n--------------------安全性检测--------------------\n\n");
    memset(Finish, false, sizeof Finish);
    for(int i=1;i<=res_num;i++){
        Work[i] = Available[i];
    }
    printf("\t\t\t|\t\t\tWork\t\t|\t\t\tNeed\t\t|\t\t\tAllocation\t\t|\t\t\tWork+All\t\t|\t\tFinish\n");
    printf("资源情况  ");
    for(int i=0;i<4;i++){
        for(int j=1;j<=res_num;j++){
            printf("\t资源%d",j);
        }
        printf(" |");
    }
    printf("\n进程\n");
    for(int i=1;i<=pro_num;i++){
        bool flag = false;              // 标记是否还存在 Finish[i] = false && Need[i][j]<=Work[j]
        for(int j=1;j<=pro_num;j++){
            if(Finish[j]) continue;
            bool flag2 = true;          // 标记该进程是否满足 Finish[i] = false && Need[i][j]<=Work[j]
            for(int k=1;k<=res_num;k++){
                if(Need[j][k] > Work[k]) flag2 = false;
            }
            if(flag2){
                                        //若该进程满足条件，则将其加入安全序列，并更新Work向量
                flag = Finish[j] = true;
                safe_list[i] = j-1;
                printf("P<%d>",j-1);
                for(int k=1;k<=res_num;k++){
                    printf("\t\t%d ",Work[k]);
                }
                for(int k=1;k<=res_num;k++){
                    printf("\t\t%d ",Need[j][k]);
                }
                for(int k=1;k<=res_num;k++){
                    printf("\t\t%d ",Allocation[j][k]);
                }
                for(int k=1;k<=res_num;k++){
                    Work[k] += Allocation[j][k];
                    printf("\t\t%d ",Work[k]);
                }
                printf("\t\ttrue\n\n");
                break;
            }
        }
        if(flag == false && i <= pro_num){
            printf("\n--------------------系统不安全--------------------\n\n");
            return false;
        }
    }
    printf("\n--------------------系统安全--------------------\n\n");
    printf("存在安全序列：{");
    for(int i=1;i<=pro_num;i++){
        printf("P<%d>%c",safe_list[i],i==pro_num?'}':',');
    }
    printf("\n");
    return true;
}

void menu(){
    printf("\n    1:请求资源   2:结束本次银行家算法   3:显示当前资源分配状况\n\n");
}

void display(){
    printf("\n-------------------------资源分配情况-----------------------\n\n");
    printf("\t\t\t|\t\t\tMax\t\t|\t\t\tAllocation\t\t|\t\t\tNeed\t\t|\t\t\tAvailable\t\t|\n");
    printf("资源情况  ");
    for(int i=0;i<4;i++){
        for(int j=1;j<=res_num;j++){
            printf("\t资源%d ",j);
        }
        printf("|");
    }
    printf("\n进程\n");
    for(int i=1;i<=pro_num;i++){
        printf("P<%d>",i-1);
        for(int j=1;j<=res_num;j++){
            printf("\t\t%d ",Max[i][j]);
        }
        for(int j=1;j<=res_num;j++){
            printf("\t\t%d ",Allocation[i][j]);
        }
        for(int j=1;j<=res_num;j++){
            printf("\t\t%d ",Need[i][j]);
        }
        if(i==1){
            for(int j=1;j<=res_num;j++){
                printf("\t\t%d ",Available[j]);
            }
        }
        printf("\n\n");
    }
}

由于美观度的原因所以有了以下的版本！

表格固定版本（竖排输出）

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <iomanip>

using namespace std;
const int N = 1e3 + 10;

/ 变量
int pro_num;            // 进程数
int res_num;            // 资源种数
int Available[N];       // 可利用资源向量

int Allocation[N][N];   // 分配矩阵
int Max[N][N];          // 最大需求矩阵
int Need[N][N];         // 需求矩阵
                        // Need[i][j] = Max[i][j] - Allocation[i][j];

int Work[N][N];         // 工作向量  表示系统可提供给进程继续运行所需的各类资源数目
                        // 为了存储整个过程的 Work 变化所以开了二维的

int Work_add_All[N][N]; // 用来存储安全性检查过程中的Work+Allocation数据

int safe_list[N];       // 安全队列

int safe_count;         // 安全数列中元素个数

bool Finish[N];         // 标记系统是否有足够资源分配给进程并使之运行完成

int re_pro_num;         // 请求进程对应编号
int requset_res[N];     // 请求资源数量

/ 函数
void get_res();         // 获取资源相关信息
void get_pro();         // 获取进程相关信息
void request();         // 请求资源
bool safe_check();      // 安全性检测
void menu();            // 菜单栏
void display();         // 展示资源分配状况

int main()
{
    while(true){
        printf("--------------------银行家算法--------------------\n\n");
        get_res();                  // 获取资源相关信息
        get_pro();                  // 获取进程相关信息
        display();
        printf("\n\n--------------------检查T0时刻的系统安全性--------------------\n\n");
        bool safe = safe_check();   // 检查T0时刻的系统安全性
        bool over = false;          //结束标记
        while(!over){
            menu();
            int ope;                // 选择操作
            printf("请输入要执行的操作：");
            scanf("%d",&ope);
            if(!safe) printf("\n系统处于不安全状态！\n");
            switch(ope){
                case 1:
                    request();      // 请求资源
                    break;
                case 2:
                    display();      // 结束本次算法
                    break;
                case 3:
                    over = true;    // 展示当前资源分配状况
                    break;
                default:
                    printf("\n***操作无效***\n");
                    break;
            }
        }
        printf("--------------------本次算法结束------------------\n\n\n");
    }
    return 0;
}

void get_res(){
    printf("\n请输入资源的种数： ");
    scanf("%d",&res_num);
    for(int i=1;i<=res_num;i++){
        printf("\n请输入第%3d 种资源的总数： ",i);
        scanf("%d",&Available[i]);
    }
    printf("------------------------------------------------\n\n");
}

void get_pro(){
    printf("\n\n请输入进程的个数： ");
    scanf("%d",&pro_num);
    for(int i=1;i<=pro_num;i++){
        for(int j=1;j<=res_num;j++){
            printf("\n请输入第%3d 个进程需要第%3d 种资源的个数： ",i,j);
            scanf("%d",&Max[i][j]);
        }
        for(int j=1;j<=res_num;j++){
            printf("\n请输入第%3d 个进程已经分配第%3d 种资源的个数： ",i,j);
            scanf("%d",&Allocation[i][j]);
            Need[i][j] = Max[i][j] - Allocation[i][j];
            Available[j] -= Allocation[i][j];
        }
        printf("\n");
    }
    
    printf("------------------------------------------------\n\n");
}

void request(){
    printf("\n\n请输入请求资源的进程（第一个进程为P<0>）：");
    scanf("%d",&re_pro_num);
    printf("\n请输入 进程%3d 对%3d 种资源的请求（两种资源之间用空格或换行符隔开）:  ",re_pro_num,res_num);
    
    bool flag1 = false;     // 标记请求的资源数量是否超过了所需要的资源数量
    bool flag2 = false;     // 标记请求的资源数量是否超过了当前所能利用的资源数量
    
    for(int i=1;i<=res_num;i++){
        scanf("%d",&requset_res[i]);
        if(requset_res[i]>Need[re_pro_num][i]){
            flag1 = true;
        }
        if(requset_res[i]>Available[i]){
            flag2 = true;
        }
    }
    if(flag1||flag2){
        if(flag1&&flag2){
            printf("\n请求的资源数量超过了所需要的资源数量和当前所能利用的资源数量!\n\n");
        }else if(flag1){
            printf("\n请求的资源数量超过了所需要的资源数量!\n\n");
        }else{
            printf("\n请求的资源数量超过了当前所能利用的资源数量!    等待\n\n");
        }
    }else{
        
        for(int i=1;i<=res_num;i++){
                            //将资源分配出去
            Available[i] -= requset_res[i];
                            //更新进程资源分配状况 即更新 All 和 Need
            Allocation[re_pro_num][i] += requset_res[i];
            Need[re_pro_num][i] -= requset_res[i];
        }
        
        display();          //展示当前资源分配状况
        
                            //检查系统安全性
        if(safe_check()){
                            //系统安全，分配资源给进程
//            display();      //展示分配状况
        }else{
                            //系统不安全，恢复分配资源前可利用资源分配状态
            
            printf("\n系统不安全，不将资源分配给进程 P<%d> ，令其等待\n",re_pro_num-1);
            for(int i=1;i<=res_num;i++){
                            //复原操作
                Available[i] += requset_res[i];
                Allocation[re_pro_num][i] -= requset_res[i];
                Need[re_pro_num][i] += requset_res[i];
            }
        }
    }
    printf("------------------------------------------------\n\n");
}

void show(){
    string str[15] = {"Work|","Need|","All|","Work+All|","Finish|","R","P<>","Pro|","Res","","|"};
    cout<<setw(10)<<str[7]<<setw(5)<<str[9];
    for(int i=1;i<safe_count;i++) cout<<setw(7)<<"P<"+to_string(safe_list[i])+">";
    cout<<endl<<setw(10)<<str[10]<<setw(5)<<str[8]<<endl;
    
    for(int i=0;i<5;i++){
        printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n\n");
        if(i==4){
            cout<<setw(10)<<str[i]<<setw(5)<<str[9];
            for(int j=1;j<safe_count;j++) {
                int now = safe_list[j]+1;
                cout<<setw(6)<<((Finish[now]==true)?"T":"F")<<" ";
            }
            cout<<endl;
            break;
        }
        for(int j=1;j<=res_num;j++){
            cout<<setw(10)<<((j==1)?str[i]:str[10])<<setw(5)<<str[5]+to_string(j);
            if(i==0) for(int k=1;k<safe_count;k++) printf("%6d ",Work[k][j]);
            else if(i==1) for(int k=1;k<safe_count;k++) printf("%6d ",Need[safe_list[k]+1][j]);
            else if(i==2) for(int k=1;k<safe_count;k++) printf("%6d ",Allocation[safe_list[k]+1][j]);
            else for(int k=1;k<safe_count;k++) printf("%6d ",Work_add_All[k][j]);
            printf("\n");
        }
    }
}

//安全性检测函数
bool safe_check(){
    
    // 效率 O(n^2)
    safe_count = 1;
    printf("\n--------------------安全性检测--------------------\n\n");
    memset(Finish, false, sizeof Finish);
    
    for(int i=1;i<=res_num;i++){
        Work[1][i] = Available[i];
    }
    
    for(int i=1;i<=pro_num;i++){
        bool flag = false;              // 标记是否还存在 Finish[i] = false && Need[i][j]<=Work[j]
        for(int j=1;j<=pro_num;j++){
            if(Finish[j]) continue;
            bool flag2 = true;          // 标记该进程是否满足 Finish[i] = false && Need[i][j]<=Work[j]
            for(int k=1;k<=res_num;k++){
                if(Need[j][k] > Work[safe_count][k])
                    flag2 = false;
            }
            if(flag2){
                                        //若该进程满足条件，则将其加入安全序列，并更新Work向量
                flag = Finish[j] = true;
                safe_list[i] = j-1;
                for(int k=1;k<=res_num;k++){
                    Work[safe_count+1][k] = Work[safe_count][k] + Allocation[j][k];
                    Work_add_All[safe_count][k] = Work[safe_count+1][k];
                }
                safe_count++;
                break;
            }
        }
        if(flag == false && i <= pro_num){
            
            show();
            printf("\n--------------------系统不安全--------------------\n\n");
            return false;
        }
    }
    show();
    printf("\n--------------------系统安全--------------------\n\n");
    printf("存在安全序列：{");
    for(int i=1;i<=pro_num;i++){
        printf("P<%d>%c",safe_list[i],i==pro_num?'}':',');
    }
    printf("\n");
    return true;
}

void menu(){
    printf("\n    1:请求资源   2:显示当前资源分配状况   3:结束本次银行家算法\n\n");
}


void display(){
    printf("\n-------------------------资源分配情况-----------------------\n\n");
    string str[15] = {"Max|","All|","Need|","Avl|","R","P<>","Pro|","Res","","|"};
    cout<<setw(5)<<str[6]<<setw(5)<<str[8];
    for(int i=0;i<pro_num;i++) cout<<setw(6)<<"P<"+to_string(i)+">";
    cout<<endl<<setw(5)<<str[9]<<setw(5)<<str[7]<<endl;
    
    for(int i=0;i<4;i++){
        printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n\n");
        for(int j=1;j<=res_num;j++){
            cout<<setw(5)<<((j==1)?str[i]:str[10])<<setw(5)<<str[4]+to_string(j);
            if(i==0) for(int k=1;k<=pro_num;k++) printf("%5d ",Max[k][j]);
            else if(i==1) for(int k=1;k<=pro_num;k++) printf("%5d ",Allocation[k][j]);
            else if(i==2) for(int k=1;k<=pro_num;k++) printf("%5d ",Need[k][j]);
            else printf("%5d ",Available[j]);
            printf("\n");
        }
    }
}
/*
测试样例 3资源 5进程
 3 10 5 7 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
 */
wang_hoho
关注
  • 5
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
408 操作系统 知识点总结
waaaa1999的博客
07-05 2万+
我在准备21年408考研的过程中，根据王道考研书的内容、linjiafengyang的总结和其它相关资料，将操作系统的知识点总结如下。大家复制后可以根据自身需求增删知识点、打印成册以方便学习。其中一些公式和特殊符号无法显示，可以点击此处下载docx文件查看。 文章目录第1章 计算机系统概述第2章 进程管理第3章 内存管理第4章 文件管理第5章 输入/输出（ I/O）管理 第1章 计算机系统概述 1.1 操作系统的基本概念 操作系统： 操作系统是指控制和管理整个计算机系统的硬件和软件资源，并合理地组织调度计
周转时间，带权周转时间简单的相关计算公式
qq_45872719的博客
12-13 1万+
周转时间=作业完成时刻—作业到达时刻； 带权周转时间=周转时间/服务时间； 平均周转时间=作业周转时间之和/作业个数； 平均带权周转时间=带权周转时间之和/作业个数； 注：服务时间即作业的运行时间 ...
2024年最全银行家算法——C语言实现_银行家算法c语言实现(1)，2024最新C C++笔经
最新发布
2401_84978503的博客
05-14 1028
/尝试将资源分配给请求进程的时候，发生改变的数组有，allocation，stillNeeds，available,work;j++) //j表示列。printf(“进程%d所申请的资源已经超过了其一开始定义的最大值，不予分配\n”);//第一步检查进程所申请的资源数目是否超过其一开始声明的最大值。printf(“请输入系统中各种资源的数量：\n”);printf(“当前系统的资源分配情况如下:\n”);printf(“资源名称\t”);//初始化系统中各个资源的数量。
【周转时间、平均周转时、带权周转时间和平均带权周转时间的计算】
weixin_63521821的博客
06-23 1万+
有5个作业，分别为A、B、C、D、E，它们依次到达后备队列的时刻为0、2、3、4、5(注意：没有1哈)。一个作业到达后就是一个作业的提交时间，从提交时间起到开始执行之间的时间为等待时间。带权周转时间 = (执行时间+等待时间) / 执行时间 = 1+（等待时间)/执行时间。[3]作业A、B、C、D、E的带权周转时间依次为3、3、3.33、3.33、2.75。[1]作业A、B、C、D、E的完成时间依次为12、8、13、14、16。[2]作业A、B、C、D、E的周转时间依次为12、6、10、10、11。
周转时间和带权周转时间的计算
fzzjoy的专栏
04-09 9万+
周转时间=作业完成时刻—作业到达时刻； 带权周转时间=周转时间/服务时间； 平均周转时间=作业周转总时间/作业个数； 平均带权周转时间=带权周转总时间/作业个数； 例： 有4个进程A,B,C,D,设它们依次进入就绪队列，因相差时间很短可视为同时到达。4个进程按轮转法分别运行11,7,2,和4个时间单位，设时间片为1。四个进程的平均周转时间为 ？ 解析：由于是视为同时到达，则
调度算法的评价指标
xzy的博客
06-19 991
文章目录调度算法的评价指标知识总览图CPU利用率系统吞吐量周转时间等待时间响应时间 调度算法的评价指标 知识总览图 CPU利用率 系统吞吐量 周转时间 一个有味道的例子:排队上厕所。有的人A上厕所需要1分钟，有的人B上厕所需要10分钟，如果你要让那个需要1分钟的人，等在那个需要10分钟的人后面，这样的安排给用户的体验会很差；如果你要让那个需要10分钟的人，等在那个需要1分钟的人后面，这样的安排给用户的体验会很好。下面的带权周转时间就是按照上面的思想设计的。所以带权周转时间其实你可以理解成是，如何给
ese.rar_银行家算法实现
09-21
总的来说，"ese.rar_银行家算法实现"是一个用于教学或研究的实用程序，它演示了如何在实际环境中应用银行家算法，帮助理解如何避免死锁，并为有限资源的安全分配提供解决方案。通过运行和分析这个程序，我们可以更...
周转时间, 平均周转时间, 带权周转时间
lishuangzhi的博客
06-22 1万+
周转时间(作业周转时间)指的是从作业被提交给系统开始, 到作业完成为止的这段时间 周转时间包括四部分: 作业在外存后备队列上等待作业调度的时间 进程在就绪队列上等待进程调度的时间 进程在cpu上执行的时间 进程等待I/O操作完成的时间 ...
关于【完成时间、周转时间、平均周转时间、带权周转时间和平均带权周转时间】的公式和计算
三桥君
07-02 2万+
本文介绍了计算“完成时间、周转时间、平均周转时间、带权周转时间和平均带权周转时间”的公式，并且用先来先服务（FCFS）、短作业优先（SJF）两种调度算法来分析一个例题。
平均周转时间和平均带权周转时间怎么算？
qq_44444107的博客
06-03 6万+
周转时间=作业完成时刻-作业到达时刻 带权周转时间=周转时间/服务时间 平均周转时间=作业周转总时间/作业个数 平均带权周转时间=带权周转总时间/作业个数 例题: 假定要在一台处理器上执行下表所示作业，且假定这些作业在时刻0以1、2、3、4、5的顺序到达。说明分别使用FCFS、RR（时间片=1）、SJF、非剥夺式优先级调度算法以及多级队列反馈算法（第i级队列的时间片=2i-1）时，这些作业的执行情况（优先级的高低顺序依次为1到5），针对以上每种调度算法，给出平均周转时间和平均带权周转时间。 ...
一句话+一张图说清楚——银行家算法
热门推荐
土豆洋芋山药蛋的博客
05-08 15万+
本文试图用一句话+一张图说清楚操作系统中的银行家算法。我相信用一句话可以讲清楚一个算法的核心思想，一张图可以描述整个算法的操作步骤。但本人能力有限，错误之处望大家指出，多谢。 一句话： 当一个进程申请使用资源的时候，银行家算法通过先 试探 分配给该进程资源，然后通过安全性算法判断分配后的系统是否处于安全状态，若不安全则试探分配作废，让该进程继续等待。 那么此时会有一个问题，...
【银行家算法】超清晰代码
7TribeZ的博客
12-25 8177
一、实验目的 理解死锁的概念，了解导致死锁的原因。 掌握死锁的避免方法，理解安全状态和不安全状态的概念。 理解银行家算法，并应用银行家算法避免死锁。 二、实验原理 银行家算法的基本思想：分配资源之前，判断系统是否处于安全状态，若处于安全状态则分配资源，否则不进行分配。该算法是典型的避免死锁算法。 银行家算法的基本结构如下： 假设Requesti是进程 Pi 的资源请求向量， 如果Requesti [j] = k，表示进程 Pi 需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查
银行家算法——C++实现 [ 开源代码 + 详细解析 ]
Wang_Dou_Dou_的博客
12-31 1万+
关键词：运行结果图、银行家算法简介(Dijkstra在1965年提出)、安全状态、算法实质与思想、算法所需的相关数据结构、算法的设计思想、算法样例、完整代码 —— C++版本
安全性算法
KeepSilent的博客
05-24 5567
题目背景作答思路解释关键结构与函数struct Reourcestruct Situationvoid show(void ini(void request(int respond(void update(int NoEnd(main()关键运行结果① 初始化后②P1 Request-> 1 2 2③P0 Request-> 2 4 3④运行到最后总结①②附录：代码 题目背景 作答 思路解释 ①每次随机选取一个进程，生成一个request ②对这个request，进行判断，看.
操作系统：避免死锁的银行家算法及安全性算法/C++
qq_64960904的博客
12-30 2012
利用C++实现避免死锁中的银行家算法以及安全性算法，实现某进程每次请求资源是否安全的判断。
操作系统 | 银行家算法及代码实现
偶然i的博客
05-05 955
技术交流qq：1032492413 技术交流VX:Chamfion
计算机操作系统——银行家算法详解（C语言版）
钢铁大侠的博客
04-24 9万+
计算机操作系统——银行家算法详解（C语言版）
银行家算法实现资源分配
10-31
银行家算法实现资源分配的过程如下： 1. 当一个进程请求资源时，系统首先检查该请求是否合法，即该进程请求的资源数是否小于等于系统当前可用的资源数。 2. 如果该请求合法，则系统试图为该进程分配资源，并更新系统...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值