非抢占的高响应比优先调度算法

最新推荐文章于 2024-10-16 11:11:16 发布
最新推荐文章于 2024-10-16 11:11:16 发布
阅读量8.3k 收藏 27
点赞数 4
文章标签： 操作系统 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24489717/article/details/70991719
版权

模拟操作系统进程调度

算法流程图

这里写图片描述

测试数据

进程名： A B C D E
需要运行时间： 3 6 4 5 2

5
ProcA 8 3
ProcB 10 6
ProcC 7 4
ProcD 12 5
ProcE 6 2

代码实现

#include<iostream>
#include<cstdio>
#include<string>
#include<algorithm>
#include<queue>
#include<functional>
using namespace std;
/**
 *  非抢占的高响应比优先调度算法
 */

double avg1 = 0, avg2 = 0;

enum State  // 进程状态
{
    ready, // 就绪
    run, // 运行
    finish // 完成
};

class PCB
{
public:
    string name; // 进程名
    State state; // 进程状态
    double priority; // 优先数
    int needTime; // 需要运行时间
    int runTime; // 已运行时间
    int turnOverTime; //周转时间
    PCB(){}

    PCB(string _name, State _state, double _priority, int _needTime, int _runTime)
    {
        name = _name;
        state = _state;
        priority = _priority;
        needTime = _needTime;
        runTime = _runTime;
    }
    void PCB::show()
    {
        cout << "进程名：" << name << ", "
            << "优先数：" << priority << ", "
            << "已运行时间：" << runTime << ", "
            << "还需要时间：" << needTime - runTime << endl;
    }

    void PCB::runShow()
    {
        cout << "正在运行：进程名：" << name << ", "
            << "优先数：" << priority << ", "
            << "已运行时间：" << runTime << ", "
            << "还需要时间：" << needTime - runTime << endl;
    }

    void PCB::end()
    {
        cout << "\n\n-----------进程：" << name << "运行结束------------------\n\n" << endl;
    }


    void PCB::ShowServiceTime()
    {
        cout << "进程名：" << name << ", "
            << "周转时间：" << turnOverTime << ", "
            << "带权周转时间：" << turnOverTime*1.0/needTime << ", "
            << "平均周转时间：" << avg1/5 << ", "
            << "平均带权周转时间：" << avg2/5 << endl;
    }

    bool operator<(const PCB &pcb)const
    {
        return pcb.priority > this->priority;
    }
};

priority_queue<PCB>PCBqueue;

queue<PCB>finishQueue;

void readFile(){
    ios::sync_with_stdio(false);
    freopen("i.txt", "r", stdin);
    //freopen("o.txt", "w", stdout);
    int n,priority,needTime;
    string PCBname;
    cin >> n;
    for (int i =0 ;i<n;i++)
    {
        cin >> PCBname >> priority >> needTime;
        PCBqueue.push(PCB(PCBname,ready,1.0,needTime,0));
    }
}

void startService()
{

    vector<PCB>temp;
    int waitTime = 0, runTime = 0;
    PCB top;


    while (PCBqueue.size()>0)
    {
        PCB pcb = PCBqueue.top();
        PCBqueue.pop();
        runTime = 0;
        for(int i = 0;i< pcb.needTime;i++)
        {
            pcb.runTime++;
            pcb.runShow();
            waitTime++;
            temp.clear();
            while (PCBqueue.size() > 0) 
            {
                top = PCBqueue.top();
                PCBqueue.pop();
                top.show();
                top.priority = (top.needTime + waitTime) / (top.needTime*1.0);
                temp.push_back(top);
            }
            for (int i = 0; i < temp.size(); i++) 
            {
                PCBqueue.push(temp[i]);
            }
            puts("=====================================================================");
        }
        pcb.turnOverTime = waitTime;
        pcb.end();
        finishQueue.push(pcb);
        avg1 += pcb.turnOverTime;
        avg2 += (pcb.turnOverTime*1.0 / pcb.needTime);
    }

    puts("\n\n--------------------------所有进程已完成-------------------------\n\n");


    while (finishQueue.size() > 0) 
    {
        finishQueue.front().ShowServiceTime();
        finishQueue.pop();
    }
}

int main()
{
    readFile();
    startService();
    return 0;
}

结果输出

正在运行：进程名：ProcA, 优先数：1, 已运行时间：1, 还需要时间：2
进程名：ProcC, 优先数：1, 已运行时间：0, 还需要时间：4
进程名：ProcE, 优先数：1, 已运行时间：0, 还需要时间：2
进程名：ProcB, 优先数：1, 已运行时间：0, 还需要时间：6
进程名：ProcD, 优先数：1, 已运行时间：0, 还需要时间：5
=====================================================================
正在运行：进程名：ProcA, 优先数：1, 已运行时间：2, 还需要时间：1
进程名：ProcE, 优先数：1.5, 已运行时间：0, 还需要时间：2
进程名：ProcC, 优先数：1.25, 已运行时间：0, 还需要时间：4
进程名：ProcD, 优先数：1.2, 已运行时间：0, 还需要时间：5
进程名：ProcB, 优先数：1.16667, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcA, 优先数：1, 已运行时间：3, 还需要时间：0
进程名：ProcE, 优先数：2, 已运行时间：0, 还需要时间：2
进程名：ProcC, 优先数：1.5, 已运行时间：0, 还需要时间：4
进程名：ProcD, 优先数：1.4, 已运行时间：0, 还需要时间：5
进程名：ProcB, 优先数：1.33333, 已运行时间：0, 还需要时间：6
=====================================================================


-----------进程：ProcA运行结束------------------


正在运行：进程名：ProcE, 优先数：2.5, 已运行时间：1, 还需要时间：1
进程名：ProcC, 优先数：1.75, 已运行时间：0, 还需要时间：4
进程名：ProcD, 优先数：1.6, 已运行时间：0, 还需要时间：5
进程名：ProcB, 优先数：1.5, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcE, 优先数：2.5, 已运行时间：2, 还需要时间：0
进程名：ProcC, 优先数：2, 已运行时间：0, 还需要时间：4
进程名：ProcD, 优先数：1.8, 已运行时间：0, 还需要时间：5
进程名：ProcB, 优先数：1.66667, 已运行时间：0, 还需要时间：6
=====================================================================


-----------进程：ProcE运行结束------------------


正在运行：进程名：ProcC, 优先数：2.25, 已运行时间：1, 还需要时间：3
进程名：ProcD, 优先数：2, 已运行时间：0, 还需要时间：5
进程名：ProcB, 优先数：1.83333, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcC, 优先数：2.25, 已运行时间：2, 还需要时间：2
进程名：ProcD, 优先数：2.2, 已运行时间：0, 还需要时间：5
进程名：ProcB, 优先数：2, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcC, 优先数：2.25, 已运行时间：3, 还需要时间：1
进程名：ProcD, 优先数：2.4, 已运行时间：0, 还需要时间：5
进程名：ProcB, 优先数：2.16667, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcC, 优先数：2.25, 已运行时间：4, 还需要时间：0
进程名：ProcD, 优先数：2.6, 已运行时间：0, 还需要时间：5
进程名：ProcB, 优先数：2.33333, 已运行时间：0, 还需要时间：6
=====================================================================


-----------进程：ProcC运行结束------------------


正在运行：进程名：ProcD, 优先数：2.8, 已运行时间：1, 还需要时间：4
进程名：ProcB, 优先数：2.5, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcD, 优先数：2.8, 已运行时间：2, 还需要时间：3
进程名：ProcB, 优先数：2.66667, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcD, 优先数：2.8, 已运行时间：3, 还需要时间：2
进程名：ProcB, 优先数：2.83333, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcD, 优先数：2.8, 已运行时间：4, 还需要时间：1
进程名：ProcB, 优先数：3, 已运行时间：0, 还需要时间：6
=====================================================================
正在运行：进程名：ProcD, 优先数：2.8, 已运行时间：5, 还需要时间：0
进程名：ProcB, 优先数：3.16667, 已运行时间：0, 还需要时间：6
=====================================================================


-----------进程：ProcD运行结束------------------


正在运行：进程名：ProcB, 优先数：3.33333, 已运行时间：1, 还需要时间：5
=====================================================================
正在运行：进程名：ProcB, 优先数：3.33333, 已运行时间：2, 还需要时间：4
=====================================================================
正在运行：进程名：ProcB, 优先数：3.33333, 已运行时间：3, 还需要时间：3
=====================================================================
正在运行：进程名：ProcB, 优先数：3.33333, 已运行时间：4, 还需要时间：2
=====================================================================
正在运行：进程名：ProcB, 优先数：3.33333, 已运行时间：5, 还需要时间：1
=====================================================================
正在运行：进程名：ProcB, 优先数：3.33333, 已运行时间：6, 还需要时间：0
=====================================================================


-----------进程：ProcB运行结束------------------




--------------------------所有进程已完成-------------------------


进程名：ProcA, 周转时间：3, 带权周转时间：1, 平均周转时间：10.2, 平均带权周转时间：2.37667
进程名：ProcE, 周转时间：5, 带权周转时间：2.5, 平均周转时间：10.2, 平均带权周转时间：2.37667
进程名：ProcC, 周转时间：9, 带权周转时间：2.25, 平均周转时间：10.2, 平均带权周转时间：2.37667
进程名：ProcD, 周转时间：14, 带权周转时间：2.8, 平均周转时间：10.2, 平均带权周转时间：2.37667
进程名：ProcB, 周转时间：20, 带权周转时间：3.33333, 平均周转时间：10.2, 平均带权周转时间：2.37667
ACLewis
关注
Python实现高响应比优先调度算法及完整源码
BUG？不存在的！
05-08 334
在实现代码中，首先我们定义了一个hrn函数用于实现高响应比优先调度算法，其中processes参数表示各个进程的服务时间。接着，我们使用waiting_time、turnaround_time和response_ratio三个列表来分别存储等待时间、周转时间和响应比。高响应比优先调度算法是一种通过综合考虑作业服务时间与等待时间的调度算法。总的来说，高响应比优先调度算法是一种高效的调度算法。通过综合考虑作业服务时间与等待时间，可以充分利用CPU资源，提高系统的吞吐量和响应速度，适用于多道批处理系统中。
非抢占式的响应比高者进程调度优先算法java
04-07
非抢占式的响应比高者进程调度优先算法java
（HRRN）高相应比优先调度算法（非抢占式）
Zjyzzy123456789的博客
12-03 908
（HRRN）高相应比优先调度算法（非抢占式）
调度算法-高响应比优先调度算法
最新发布
ACM
10-16 1309
高响应比优先（HRN）是一种改进型的调度算法，它综合考虑了进程的等待时间和执行时间，通过计算每个进程的响应比来决定下一个要执行的进程。HRN算法的主要目标是避免长进程因短进程不断插入而长期等待的情况，从而兼顾系统的公平性和效率。响应比等待时间：进程已经在就绪队列中等待的时间。执行时间：进程所需的CPU时间。通过该公式可以看出，随着等待时间的增加，响应比也会相应提高，这意味着等待时间较长的进程会逐渐得到更高的优先级，解决了短作业优先调度算法中长任务容易饥饿的问题。
高响应比优先调度算法
05-24
C语言编写的高响应优先调度算法，非抢占，需要从txt文件中读取作业
非抢占式高响应比进程调度算法
05-31
操作系统实验，模拟实现非抢占式高响应比进程调度算法。用VC++编写的可视化应用程序。
非抢占式优先级调度算法
12-23
1、实验目的 通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解 2、实验内容 （1）用C语言来实现对N个进程采用动态优先权优先算法的进程调度 （2）每个用来标示进程的PCB用结构来描述，包括字段如下： 进程标示数ID. 进程优先级Priority 进程已占用的CPU时间 CPUTIME 进程还需占用的CPU时间 ALLTIME。进程运行完毕时，ALLTIME变为0。 进程的阻塞时间StartBlock,表示当进程再运行StartBlock个时间片后， 进程将入阻塞状态。 进程被阻塞时间BlockTime,表示已经阻塞的进程再等待BlockTime个时 间片后，将转换为就绪状态。 进程状态State (3)进程优先级改变原则 进程在就绪队列中呆一个时间片，优先级加1 进程运行一个时间片，优先级减3 （4）为了清楚的观察各进程的调度过程，程序应将每个时间片的进程的情况显示。出来
进程调度模拟设计（非强占式短进程优先算法、最高响应比优先调度算法）.zip
03-25
本课程设计关注了三种常见的调度算法：非强占式的短进程优先（Non-preemptive Shortest Process Next, NSPN）、最高响应比优先（Highest Response Ratio Next, HRRN）以及先来先服务（First-Come First-Served, FCFS...
操作系统实验 进程调度 高响应比优先法 动态优先级法 时间片轮转法
11-09
本实验是针对操作系统课程设计的一次实践，主要探讨了三种不同的进程调度算法：高响应比优先法、动态优先级法和时间片轮转法。 首先，高响应比优先法是一种兼顾等待时间和周转时间的调度策略。响应比是进程等待时间...
进程调度算法包括先来先服务调度算法、最短作业时间优先（抢占式和非抢占式）、最高响应比调度算法4种
04-11
进程调度算法包括先来先服务调度算法、最短作业时间优先（抢占式和非抢占式）、最高响应比调度算法4种。(每个人必须做FCFS，然后在后面的三种中任选一种，即每个人必须做2种调度算法的模拟。) [2]. 衡量算法性能的...
高响应比优先调度算法的模拟（非抢占式C++）
falldeep的算法世界
05-14 3070
设置参数 设置了四个作业进行实验，可以在init（）函数中动态修改 根据计算，根据高响应比优先调度算法，得出作业的调度流程图 运行程序，得出程序运行结果 通过对比可以发现，程序运行正确，并且程序还可以输出，每一秒运行的状态，参数包括正在运行的进程名，开始运行时间，及当前就绪队列中的进程名以及它的响应时间 流程图 源程序 #include<iostream> using namespace std; const int N = 20; int h[N], .
非抢占式高优先级调度算法.doc
01-19
算法思想：在按进程达到时间由小到大的顺序输入进程信息后，先对其优先数进行排列，将最先到达的进程的到达时间设为开始时间，计算结束时间，然后对后面到达的时间与该进程的结束时间进行比较，如若小于该进程的结束时间，记录进程的个数，再对其优先数逐个进行比较，将优先数最大的提到前面，每次进程结束都要进行比较，得到执行序列，在依次输出结果
高响应比优先调度算法(HRRN)
04-30
java平台运行高响应比优先调度算法，如果响应比相同则短作业优先。输出进程工作顺序、调度时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。压缩带有测试案例
非抢占按优先数调度算法源代码
11-27
非抢占按优先数调度算法源代码 #include <stdio.h> #include <stdlib.h> #define MAX 5 //进程数 /*非抢占式优先数算法*/ struct pro1 { int num; //进程名 int arriveTime; //到达时间 int burst; //运行时间; int weight; //优先数 struct pro1 *next; }; //函数声明 struct pro1* creatList(); void insert(struct pro1 *head,struct pro1 *s); struct pro1* searchByAT(struct pro1 *head,int AT); void run(struct pro1 *head); void del(struct pro1* p); int getCount(struct pro1 *head,int time); struct pro1* creatList() //创建链表，按照进程的到达时间排列 { struct pro1* head=(struct pro1*)malloc(sizeof(struct pro1)); head->next=NULL; struct pro1 *s; int i; for(i=0;i<MAX;i++) { s=(struct pro1*)malloc(sizeof(struct pro1)); printf("请输入进程名:\n"); scanf("%d",&(s->num)); printf("请输入到达时间:\n"); scanf("%d",&(s->arriveTime)); printf("请输入运行时间:\n"); scanf("%d",&(s->burst)); printf("请输入优先数:\n"); scanf("%d",&(s->weight)); s->next=NULL; insert(head,s); } return head; } void insert(struct pro1 *head,struct pro1 *s) //插入节点 { struct pro1 *p=searchByAT(head,s->arriveTime); s->next=p->next; p->next=s; return; } struct pro1* searchByAT(struct pro1 *head,int AT) //查找第一个到达时间大于等于AT的节点，返回其前一个指针
进程调度算法 —— 非抢占式优先级调度算法
chenhuangbi8480的博客
11-03 6230
/*非抢占式优先级调度算法*/ #include <iostream> using namespace std; struct Num { int priority; //优先级 int dt; //到达时间 int st; //运行时间 }su...
PSA 优先级调度算法 （非抢占式）（java）
JimmyYang的博客
12-18 4067
处理机调度算法：Priority scheduling algorithm 优先级调度算法 运行结果 流程图 ---------------------java代码------------------------ package operate; import java.util.*; /** * 优先级调度算法 * 非抢占式 （完成） * 根据短作业优先算法 改编，只要...
最高响应比优先法
牛牛码特的博客
05-27 1479
最高响应比优先法(HRN，Highest Response_ratio Next)是对FCFS方式和SJF方式的一种综合平衡。FCFS方式只考虑每个作业的等待时间而未考虑执行时间的长短，而SJF方式只考虑执行时间而未考虑等待时间的长短。因此，这两种调度算法在某些极端情况下会带来某些不便。HRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。 ...
7-3 作业调度算法--高响应比优先 (40 分)（思路+详解+vector容器做法）Come Baby!!!!!
qq_48508278的博客
10-12 1967
一：题目 输入N(N>0)个作业，输入每个作业的名字，到达时间，服务时间，按照高响应比优先算法，计算每个作业的完成时间，周转时间，带权周转时间（保留2位小数）。 输入格式: 第一行输入作业数目，第二行输入作业的名字，第三行输入到达时间，第四行输入服务时间。 输出格式: 按照到达时间从小到大排序，第一行输出作业的名字，第二行输出到达时间，第三行输出服务时间，第四行输出完成时间，第五行输出完成时间，第六行输出带权周转时间。 输入样例: 在这里给出一组输入。例如： 5 A B C D E 0 1 2 3
抢占式高响应比优先调度算法(HRRF)
04-26
抢占式高响应比优先调度算法（HRRF）是一种用于进程调度的算法，它考虑了进程的响应时间和等待时间，以决定下一个要执行的进程。它将每个进程的响应比定义为（等待时间+服务时间）/服务时间，然后优先选择响应比最高...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值