操作系统-进程调度(HRRN和RR)

最新推荐文章于 2023-02-19 12:47:32 发布
最新推荐文章于 2023-02-19 12:47:32 发布
阅读量1.5k 收藏 13
点赞数 2
分类专栏： 操作系统 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45742603/article/details/125714771
版权

文章目录

进程调度(HRRN和RR)

问题描述

设计程序模拟进程的高响应比HRRN和时间片轮转RR调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。如果选择RR算法，还需要指定时间片大小q。分别采用高响应比HRRN和时间片RR进程调度算法进行调度，计算每个进程的完成时间，周转时间、带权周转时间和等待时间，并且统计n个进程的平均周转时间、平均带权周转时间和平均等待时间。最后，对两个算法做出比较评价。

要求采用高响应比HRRN和时间片RR分别调度进程运行，计算每个进程的周转时间，带权周转时间和等待时间，并且计算所有进程的平均周转时间，带权平均周转时间和平均等待时间。

实验环境

  • Windows 11
  • Visual Studio Code
  • gcc version 8.1.0

输入

进程数n，进程编号，以及每个进程的到达时间T1, … ,Tn和服务时间S1, … ,Sn。在屏幕上要以表的形式显示输入的信息。

根据显示信息：“1-HRRN，2-RR”，选择1或者2进入对应的算法过程。如果选择2，则需要输入时间片大小q。

输出

  • 要求模拟整个调度过程，输出每个时刻的进程运行状态
  • 要求输出计算出来的每个进程的周转时间，带权周转时间和等待时间
  • 要求输出所有进程的平均周转时间，带权平均周转时间和平均等待时间

测试数据

Process Num.12345
Arrival Time01234
CPU Burst62598

实验设计

数据结构

#define MaxNum 100                                   // 最大进程数
double CurrentTime = 0.0;                            // 当前时间
double AverageWT_HRRN = 0.0, AverageWT_RR = 0.0;     // 平均等待时间
double AverageTAT_HRRN = 0.0, AverageTAT_RR = 0.0;   // 平均周转时间
double AverageWTAT_HRRN = 0.0, AverageWTAT_RR = 0.0; // 平均带权周转时间
int ProNum = 0;                                      // 进程数量
int DisplayNum = 0;                                  // 输出进程信息数量
int ProIndex = 0;                                    // 已完成的进程数量
int TimeSlice = 0;                                   // 时间片

// 进程结构体
typedef struct PROCESS
{
    int index;                    // 进程序号
    int RunedTime;                // RR算法已服务的时间
    int Signal;                   // 第一次运行标志位 0表示该进程第一次运行 否则为1
    int ProStatus;                // 进程状态 0表示等待 1表示运行 2表示完成
    double ServiceTime;           // 服务时间
    double ArrivalTime;           // 到达时间
    double StartTime;             // 开始时间
    double FinishTime;            // 结束时间
    double TurnArroundTime;       // 周转时间
    double WaitTime;              // 等待时间
    double ResponseRatio;         // 响应比
    double WeightTurnArroundTime; // 带权周转时间
} PRO[MaxNum];

函数的功能、参数和输出

// 输出各进程的到达时间和服务时间
void display_base(PRO PC, int n)

// 输出每个时刻的进程运行状态
void display_status(PRO PC, int n)

// 输出各进程的周转时间、带权周转时间和等待时间
void display_time(PRO PC, int n)

// 输出所有进程的的平均周转时间、带权平均周转时间和平均等待时间
void display_average()
    
// 按到达时间排序
void SortArrival(PRO &PC, int n)

// 计算各项时间
void CountTime(PRO &PC, int n)

// HRRN算法
void HRRN(PRO &PC, int n)

// RR输出函数
void PrintRR(PRO PC)

// 改变就绪队列的顺序 将当前进程移动到队尾
void MovePro(PRO &PC, int index)

// 删除已完成的进程
void RemovePro(PRO &PC, int index)
    
// 判断一个进程是否完成并计算时间
int IfProEnd(PRO &PC, int index)
    
// 指定时间片进程运行
int RunProcess(PRO &PC, int index)
    
// RR算法
void RR(PRO &PC, int n)

// 关于以上函数的参数，PC均为进程的结构体数组，n均为进程的数量，index为执行进程的索引

主要函数算法设计

// 按到达时间排序
void SortArrival(PRO &PC, int n)
{
    PROCESS temp;
    for (int i = 0; i < n; i++)
    {
        int min = i;
        for (int j = i + 1; j < n; j++)
            if (PC[j].ArrivalTime < PC[min].ArrivalTime)
                min = j;
        temp = PC[i];
        PC[i] = PC[min];
        PC[min] = temp;
    }
}

// HRRN算法
void HRRN(PRO &PC, int n)
{
    SortArrival(PC, n); // 先按到达时间排序
    // 类比选择排序的思想 从第二个到达的进程开始 遍历当前进程后面的进程 如果有响应比比当前最短响应比更高的 则交换位置
    int End = PC[0].ArrivalTime + PC[0].ServiceTime; // 之前服务的结束时间
    int rmax = 1;                                    // 当前最高响应比的索引
    PROCESS temp;
    for (int x = 1; x < n; x++)
    {
        for (int r = x; r < n; r++)
        {
            if (PC[r].ArrivalTime <= End)
                PC[r].ResponseRatio = (End - PC[r].ArrivalTime + PC[r].ServiceTime) / PC[r].ServiceTime;
        }
        for (int y = x + 1; y < n; y++)
        {
            if (PC[y].ArrivalTime <= End && PC[y].ResponseRatio >= PC[rmax].ResponseRatio)
                rmax = y;
        }
        // 将当前进程与等待队列中响应比最大的进程进行交换
        temp = PC[x];
        PC[x] = PC[rmax];
        PC[rmax] = temp;
        End += PC[x].ServiceTime;
        rmax = x + 1; // 重置rmax为当前等待队列中的首位
    }
    CountTime(PC, n);      // 计算各项时间
    display_status(PC, n); // 模拟整个调度过程，输出每个时刻的进程运行状态
    display_time(PC, n);   // 输出各进程的周转时间、带权周转时间和等待时间
}

// 改变就绪队列的顺序 将当前进程移动到队尾
void MovePro(PRO &PC, int index)
{
    int Num = 0;
    for(int s = 0;s<ProNum;s++) // 更新等待队列的进程数量
        if(PC[s].ArrivalTime<=CurrentTime)
            Num++;
    PROCESS temp = PC[index];
    for (int i = index; i < Num - 1; i++)
    {
        PC[i] = PC[i + 1];
    }
    PC[Num - 1] = temp;
}

// 删除已完成的进程
void RemovePro(PRO &PC, int index)
{
    MovePro(PC, index);
    PC[ProNum - 1].ProStatus = 2;
    if (ProNum == 1) // 服务全部结束
    {
        cout << endl
             << "Finally Result : " << endl;
        PrintRR(PC);
    }
    ProIndex++;
    ProNum--;
}

// 指定时间片进程运行
int RunProcess(PRO &PC, int index)
{
    for (int i = 0; i < TimeSlice; i++) // 每个单位时间循环一次
    {
        CurrentTime++;
        if (PC[index].Signal == 0)
        {
            PC[index].StartTime = CurrentTime - 1;
            PC[index].Signal = 1;
        }
        PC[index].ProStatus = 1;
        PC[index].RunedTime++;
        PrintRR(PC); // 每个单位时间输出一次结果
        if (IfProEnd(PC, index) == 1)
            return 0;
    }
    MovePro(PC, index);
    PC[ProNum - 1].ProStatus = 0;
    return 0;
}

// RR算法
void RR(PRO &PC, int n)
{
    // 对全局变量进行初始化以便实现循环多次使用
    CurrentTime = 0;
    ProNum = n;
    ProIndex = 0;
    TimeSlice = 0;
    for (int s = 0; s < n; s++) // 标志位初始化为0
    {
        PC[s].Signal = 0;
        PC[s].ProStatus = 0;
        PC[s].RunedTime = 0;
    }
    cout << "TimeSlice = ";
    cin >> TimeSlice;
    SortArrival(PC, n); // 先按到达时间排序
    cout << endl;
    while (1)
    {
        if (CurrentTime >= PC[0].ArrivalTime)
        {
            RunProcess(PC, 0);
        }
        else
        {
            MovePro(PC, 0);
            PC[ProNum - 1].ProStatus = 0;
        }
        if (ProIndex == n)
            break; // 已完成的进程数量等于总数量 则退出循环
    }
    SortArrival(PC, n); // 按到达时间排序 使输出的结果更方便观看
    for (int i = 0; i < n; i++)
    {
        PC[i].FinishTime = PC[i].ArrivalTime + PC[i].TurnArroundTime;
        PC[i].WaitTime = PC[i].TurnArroundTime - PC[i].ServiceTime;
    }
    cout << endl
         << "Process Num\t"
         << "Start Time\t"
         << "End Time"
         << endl;
    for (int j = 0; j < n; j++)
    {
        cout << PC[j].index << "\t\t" << PC[j].StartTime << "\t\t" << PC[j].FinishTime << endl;
    }
    display_time(PC, DisplayNum); // 输出各进程的周转时间、带权周转时间和等待时间
    // 计算平均时间
    double sumWT = PC[0].WaitTime, sumTAT = PC[0].TurnArroundTime, sumWTAT = PC[0].WeightTurnArroundTime;
    for (int m = 1; m < n; m++)
    {
        sumWT += PC[m].WaitTime;
        sumTAT += PC[m].TurnArroundTime;
        sumWTAT += PC[m].WeightTurnArroundTime;
    }
    AverageWT_RR = sumWT / n;
    AverageTAT_RR = sumTAT / n;
    AverageWTAT_RR = sumWTAT / n;
}

详细设计

  • 变量初始化

  • 接收用户输入n，T1, … ,Tn，S1, … ,Sn

  • 循环等待用户选择算法：1-HRRN，2-RR

  • 按照选择算法进行进程调度

  • 计算进程的开始时间、完成时间、周转时间、带权周转时间和等待时间

  • 计算所有进程的平均周转时间、平均带权周转时间和平均等待时间

  • 按格式输出调度结果

流程图

image-20220402222255918

实验结果与分析

结果展示与描述

image-20220402224733605

image-20220402222609127

中间部分省略…

image-20220402222711888

  • 输入进程数量和各进程的基本信息：到达时间和服务时间
  • 选择算法 注：在选择0之前需要将1和2都选择过
  • 选择1 按HRRN算法输出各进程的执行顺序、开始和完成时间、等待队列、周转时间、带权周转时间和等待时间
  • 选择2 按RR算法输出各时刻的进程队列、开始和完成时间、周转时间、带权周转时间和等待时间
  • 选择0 输出本实验数据使用两种算法得到的不同平均周转时间、平均带权周转时间和平均等待时间
  • 实验结束

结果分析

  • HRRN算法通过按响应比排序的方式得到服务顺序，计算时还需要考虑当前进程结束时下一个进程是否已经到达，进行条件判断后代入不同结果计算，最终验证与手动计算结果相同
  • RR算法需要对每个单位时间都进行计算，与先来先服务的方法相似，每个时间片后更新等待队列，如果当前进程已完成则将其移出等待队列，最终验证与手动计算结果相同

总结

  • 本次实验将较长的的代码都打包成函数，在主函数中直接进行调用，并使用函数嵌套，使代码简洁、清晰。
  • 在数据结构方面，因为对队列的使用还不是很熟悉，所以我在实现算法的过程中，使用了结构体数组，考虑到计算过程会出现整数与小数的混合运算，我将除进程序号外的所有数据都设为double型，便不会在结果中出现小数部分被舍弃的问题。
  • 对于HRRN算法的排序，我直接对等待队列进行排序，避免使用复杂的算法，使用变量End判定进程是否处在等待队列，将所有进程都排好序之后直接调用CountTime函数进行计算，使算法更简单明了，便于学习和理解。
  • 对于RR算法，每个单位时间都会进行循环，在时间片结束后对各进程的状态以及等待队列的进程数量进行更新，确保进程的执行顺序不出错，因为此算法较为复杂，部分结果的输出便没有另写函数，而是直接在算法函数中实现，避免代码过于复杂，且不易出错。
  • 在主函数中，使用while循环，实现算法选择的功能，若选择0则输出所有进程的平均周转时间，带权平均周转时间和平均等待时间并且退出循环。

源代码

#include <iostream>

#define MaxNum 100                                   // 最大进程数
double CurrentTime = 0.0;                            // 当前时间
double AverageWT_HRRN = 0.0, AverageWT_RR = 0.0;     // 平均等待时间
double AverageTAT_HRRN = 0.0, AverageTAT_RR = 0.0;   // 平均周转时间
double AverageWTAT_HRRN = 0.0, AverageWTAT_RR = 0.0; // 平均带权周转时间
int ProNum = 0;                                      // 进程数量
int DisplayNum = 0;                                  // 输出进程信息数量
int ProIndex = 0;                                    // 已完成的进程数量
int TimeSlice = 0;                                   // 时间片
using namespace std;

// 进程结构体
typedef struct PROCESS
{
    int index;                    // 进程序号
    int RunedTime;                // RR算法已服务的时间
    int Signal;                   // 第一次运行标志位 0表示该进程第一次运行 否则为1
    int ProStatus;                // 进程状态 0表示等待 1表示运行 2表示完成
    double ServiceTime;           // 服务时间
    double ArrivalTime;           // 到达时间
    double StartTime;             // 开始时间
    double FinishTime;            // 结束时间
    double TurnArroundTime;       // 周转时间
    double WaitTime;              // 等待时间
    double ResponseRatio;         // 响应比
    double WeightTurnArroundTime; // 带权周转时间
} PRO[MaxNum];

// 输出各进程的到达时间和服务时间
void display_base(PRO PC, int n)
{
    cout << endl;
    cout << "Process Num\t"
         << "Arrival Time\t"
         << "CPU Burst" << endl;
    for (int t = 0; t < n; t++)
        cout << PC[t].index << "\t\t" << PC[t].ArrivalTime << "\t\t" << PC[t].ServiceTime << endl;
}

// 模拟整个调度过程 输出每个时刻的进程运行状态
void display_status(PRO PC, int n)
{
    cout << endl;
    cout << "Process Num\t"
         << "Start Time\t"
         << "End Time\t"
         << "Ready Queue" << endl;
    for (int t = 0; t < n; t++) // 循环输出每个进程的服务时间内 处在等待队列的进程 即到达时间在当前进程开始和结束时间之间的进程
    {
        cout << PC[t].index << "\t\t" << PC[t].StartTime << "\t\t" << PC[t].FinishTime << "\t\t";
        for (int q = t + 1; q < n; q++)
        {
            if (PC[q].ArrivalTime <= PC[t].FinishTime)
                cout << PC[q].index << " ";
        }
        cout << endl;
    }
}

// 输出各进程的周转时间、带权周转时间和等待时间
void display_time(PRO PC, int n)
{
    cout << endl;
    cout << "Process Num\t"
         << "Turnaround Time\t"
         << "Weighted Turnaround Time\t"
         << "Waiting Time" << endl;
    for (int t = 0; t < n; t++)
        cout << PC[t].index << "\t\t" << PC[t].TurnArroundTime << "\t\t" << PC[t].WeightTurnArroundTime << "\t\t\t\t" << PC[t].WaitTime << endl;
}

// 输出所有进程的的平均周转时间、带权平均周转时间和平均等待时间
void display_average()
{
    cout << endl;
    cout << "Algorithm\t"
         << "Average TAT\t"
         << "Average WTAT\t"
         << "Average WT" << endl;
    cout << "HRRN\t\t" << AverageTAT_HRRN << "\t\t" << AverageWTAT_HRRN << "\t\t" << AverageWT_HRRN << endl;
    cout << "RR\t\t" << AverageTAT_RR << "\t\t" << AverageWTAT_RR << "\t\t" << AverageWT_RR << endl;
}

// 按到达时间排序
void SortArrival(PRO &PC, int n)
{
    PROCESS temp;
    for (int i = 0; i < n; i++)
    {
        int min = i;
        for (int j = i + 1; j < n; j++)
            if (PC[j].ArrivalTime < PC[min].ArrivalTime)
                min = j;
        temp = PC[i];
        PC[i] = PC[min];
        PC[min] = temp;
    }
}

// 计算各项时间
void CountTime(PRO &PC, int n)
{
    PC[0].StartTime = PC[0].ArrivalTime;
    PC[0].FinishTime = PC[0].ArrivalTime + PC[0].ServiceTime;
    PC[0].TurnArroundTime = PC[0].FinishTime - PC[0].ArrivalTime;
    PC[0].WaitTime = 0;
    PC[0].WeightTurnArroundTime = PC[0].TurnArroundTime / PC[0].ServiceTime;
    double sumWT = PC[0].WaitTime, sumTAT = PC[0].TurnArroundTime, sumWTAT = PC[0].WeightTurnArroundTime;
    for (int m = 1; m < n; m++)
    {
        if (PC[m].ArrivalTime >= PC[m - 1].FinishTime)
        {
            PC[m].StartTime = PC[m].ArrivalTime;
            PC[m].WaitTime = 0;
        }
        else
        {
            PC[m].StartTime = PC[m - 1].FinishTime;
            PC[m].WaitTime = PC[m - 1].FinishTime - PC[m].ArrivalTime;
        }
        PC[m].FinishTime = PC[m].StartTime + PC[m].ServiceTime;
        PC[m].TurnArroundTime = PC[m].FinishTime - PC[m].ArrivalTime;
        PC[m].WeightTurnArroundTime = PC[m].TurnArroundTime / PC[m].ServiceTime;
        sumWT += PC[m].WaitTime;
        sumTAT += PC[m].TurnArroundTime;
        sumWTAT += PC[m].WeightTurnArroundTime;
    }
    AverageWT_HRRN = sumWT / n;
    AverageTAT_HRRN = sumTAT / n;
    AverageWTAT_HRRN = sumWTAT / n;
}

// HRRN算法
void HRRN(PRO &PC, int n)
{
    SortArrival(PC, n); // 先按到达时间排序
    // 类比选择排序的思想 从第二个到达的进程开始 遍历当前进程后面的进程 如果有响应比比当前最短响应比更高的 则交换位置
    int End = PC[0].ArrivalTime + PC[0].ServiceTime; // 之前服务的结束时间
    int rmax = 1;                                    // 当前最高响应比的索引
    PROCESS temp;
    for (int x = 1; x < n; x++)
    {
        for (int r = x; r < n; r++)
        {
            if (PC[r].ArrivalTime <= End)
                PC[r].ResponseRatio = (End - PC[r].ArrivalTime + PC[r].ServiceTime) / PC[r].ServiceTime;
        }
        for (int y = x + 1; y < n; y++)
        {
            if (PC[y].ArrivalTime <= End && PC[y].ResponseRatio >= PC[rmax].ResponseRatio)
                rmax = y;
        }
        // 将当前进程与等待队列中响应比最大的进程进行交换
        temp = PC[x];
        PC[x] = PC[rmax];
        PC[rmax] = temp;
        End += PC[x].ServiceTime;
        rmax = x + 1; // 重置rmax为当前等待队列中的首位
    }
    CountTime(PC, n);      // 计算各项时间
    display_status(PC, n); // 模拟整个调度过程，输出每个时刻的进程运行状态
    display_time(PC, n);   // 输出各进程的周转时间、带权周转时间和等待时间
}

// RR输出函数
void PrintRR(PRO PC)
{
    cout << endl
         << "Current Time : " << CurrentTime << endl;
    cout << "Process Num\t"
         << "Start Time\t"
         << "Runed Time\t"
         << "Process Status" << endl;
    for (int t = 0; t < DisplayNum; t++) // 循环输出每个进程的服务时间内 处在等待队列的进程 即到达时间在当前进程开始和结束时间之间的进程
        cout << PC[t].index << "\t\t" << PC[t].StartTime << "\t\t" << PC[t].RunedTime << "\t\t" << PC[t].ProStatus << endl;
}

// 改变就绪队列的顺序 将当前进程移动到队尾
void MovePro(PRO &PC, int index)
{
    int Num = 0;
    for(int s = 0;s<ProNum;s++) // 更新等待队列的进程数量
        if(PC[s].ArrivalTime<=CurrentTime)
            Num++;
    PROCESS temp = PC[index];
    for (int i = index; i < Num - 1; i++)
    {
        PC[i] = PC[i + 1];
    }
    PC[Num - 1] = temp;
}

// 删除已完成的进程
void RemovePro(PRO &PC, int index)
{
    MovePro(PC, index);
    PC[ProNum - 1].ProStatus = 2;
    if (ProNum == 1) // 服务全部结束
    {
        cout << endl
             << "Finally Result : " << endl;
        PrintRR(PC);
    }
    ProIndex++;
    ProNum--;
}

// 判断一个进程是否完成并计算时间
int IfProEnd(PRO &PC, int index)
{
    if (PC[index].ServiceTime == PC[index].RunedTime)
    {
        PC[index].FinishTime = CurrentTime;
        PC[index].TurnArroundTime = PC[index].FinishTime - PC[index].ArrivalTime;
        PC[index].WeightTurnArroundTime = PC[index].TurnArroundTime / PC[index].ServiceTime;
        RemovePro(PC, index);
        return 1;
    }
    return -1;
}

// 指定时间片进程运行
int RunProcess(PRO &PC, int index)
{
    for (int i = 0; i < TimeSlice; i++) // 每个单位时间循环一次
    {
        CurrentTime++;
        if (PC[index].Signal == 0)
        {
            PC[index].StartTime = CurrentTime - 1;
            PC[index].Signal = 1;
        }
        PC[index].ProStatus = 1;
        PC[index].RunedTime++;
        PrintRR(PC); // 每个单位时间输出一次结果
        if (IfProEnd(PC, index) == 1)
            return 0;
    }
    MovePro(PC, index);
    PC[ProNum - 1].ProStatus = 0;
    return 0;
}

// RR算法
void RR(PRO &PC, int n)
{
    // 对全局变量进行初始化以便实现循环多次使用
    CurrentTime = 0;
    ProNum = n;
    ProIndex = 0;
    TimeSlice = 0;
    for (int s = 0; s < n; s++) // 标志位初始化为0
    {
        PC[s].Signal = 0;
        PC[s].ProStatus = 0;
        PC[s].RunedTime = 0;
    }
    cout << "TimeSlice = ";
    cin >> TimeSlice;
    SortArrival(PC, n); // 先按到达时间排序
    cout << endl;
    while (1)
    {
        if (CurrentTime >= PC[0].ArrivalTime)
        {
            RunProcess(PC, 0);
        }
        else
        {
            MovePro(PC, 0);
            PC[ProNum - 1].ProStatus = 0;
        }
        if (ProIndex == n)
            break; // 已完成的进程数量等于总数量 则退出循环
    }
    SortArrival(PC, n); // 按到达时间排序 使输出的结果更方便观看
    for (int i = 0; i < n; i++)
    {
        PC[i].FinishTime = PC[i].ArrivalTime + PC[i].TurnArroundTime;
        PC[i].WaitTime = PC[i].TurnArroundTime - PC[i].ServiceTime;
    }
    cout << endl
         << "Process Num\t"
         << "Start Time\t"
         << "End Time"
         << endl;
    for (int j = 0; j < n; j++)
    {
        cout << PC[j].index << "\t\t" << PC[j].StartTime << "\t\t" << PC[j].FinishTime << endl;
    }
    display_time(PC, DisplayNum); // 输出各进程的周转时间、带权周转时间和等待时间
    // 计算平均时间
    double sumWT = PC[0].WaitTime, sumTAT = PC[0].TurnArroundTime, sumWTAT = PC[0].WeightTurnArroundTime;
    for (int m = 1; m < n; m++)
    {
        sumWT += PC[m].WaitTime;
        sumTAT += PC[m].TurnArroundTime;
        sumWTAT += PC[m].WeightTurnArroundTime;
    }
    AverageWT_RR = sumWT / n;
    AverageTAT_RR = sumTAT / n;
    AverageWTAT_RR = sumWTAT / n;
}

int main()
{
    PRO pc;
    int n;
    cout << "请输入进程的数量：";
    cin >> n;
    DisplayNum = n;
    ProNum = n;
    cout << "请输入每个进程的到达时间和服务时间：" << endl;
    for (int i = 0; i < n; i++)
    {
        pc[i].index = i + 1;
        cin >> pc[i].ArrivalTime >> pc[i].ServiceTime;
    }
    display_base(pc, n);
    int choice;
    cout << endl
         << "输入0-输出平均时间并退出程序  输入1-HRRN  输入2-RR" << endl
         << "请选择要执行的操作：";
    cin >> choice;
    while (choice != 0)
    {
        if (choice == 1)
            HRRN(pc, n);
        if (choice == 2)
            RR(pc, n);
        cout << endl
             << "请输入接下来要执行的操作：";
        cin >> choice;
    }
    display_average();
    cout << endl;
    system("pause");
    return 0;
}
Stories Untold.
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java操作系统进程调度算法——时间片轮转(RR)算法
吉祥宝典
04-22 6760
Java操作系统进程调度算法——时间片轮转(RR)算法 文章目录Java操作系统进程调度算法——时间片轮转(RR)算法前言一、算法思想二、数据结构1.定义PCB进程控制块2.实现思路三、流程图四、完整代码五、实验结果1、输入示例2、运行截图 前言 一、算法思想 按进程到达顺序将进程依次加入就绪队列当中，然后将 CPU 分配给位于队首的进程，确定一个时间片，让该进程执行一个时间片。当该进程执行时间到时，该进程可能已经执行完毕（可能在时间片未到时就以及执行完毕），或者未执行完毕，如果是前者只需将进程弹出队列
调度算法，FCFS、RR（q=1）、SPN、SRT、HRRN进行调度各进程的完成时间、周转时间、响应比的值。
10-28
随机给出一个进程调度实例，如： 进程 到达时间 服务时间 A 0 3 B 2 6 C 4 4 D 6 5 E 8 2 模拟进程调度，给出按照算法先来先服务FCFS、轮转RR（q=1）、最短进程优先SPN、最短剩余时间SRT、最高响应比优先HRRN进行调度各进程的完成时间、周转时间、响应比的值。
操作系统—进程调度—HRRN，RR 高响应比和时间片轮转算法
engineer_z的博客
05-10 2728
1.问题描述及需求分析 设计程序模拟进程的高响应比HRRN和时间片轮转RR调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。如果选择RR算法，还需要指定时间片大小q。分别采用高响应比HRRN和时间片RR进程调度算法进行调度，计算每个进程的完成时间，周转时间、带权周转时间和等待时间，并且统计n个进程的平均周转时间、平均带权周转时间和平均等待时间。最后，对两个算法做出比较评价。 2.实验设计 HRRN（hignest response ratio next
操作系统之HRRN - 最高响应比调度
不知道你是通过何种途径访问到这里，总之欢迎来到red velet的博客
02-19 2321
操作系统之HRRN - 最高响应比调度；最高响应比优先调度算法是一种对CPU[中央控制器](https://baike.baidu.com/item/中央控制器/4851471?响应比的分配的一种算法。HRRN是介于FCFS（[先来先服
操作系统 进程调度之轮换调度（RR调度）
海向的博客
11-24 1037
【具体代码】RR_Math.javapackage RR;import java.text.DecimalFormat; import java.util.LinkedList; import java.util.Scanner;public class RR_Math { private LinkedList<Progress> l; //调度队列 private Progress
操作系统-进程调度实验.docx
11-17
操作系统-进程调度实验.docx
操作系统-进程调度算法.zip
12-25
操作系统进程调度算法 先进先出FIFO、最高优先级HPF（非抢占式）、时间片轮转算法RR 输入：进程序列文件，其中存储的是一系列要执行的进程， 每个进程包括 四个数据项： 进程id 号、 进程状态(1 就绪 2 等待 3 运行)...
操作系统实验四------进程调度
05-09
操作系统进程调度中的HRRN高响应比算法和RR时间片轮转算法
操作系统实验四---进程调度算法
08-04
编写先来先服务算法，短进程优先调度算法，时间片轮转算法。 给出程序中使用的数据结构及符号说明 给出程序流程图和源程序，源程序中要附有详细的注释 输入：时间片，五个进程的进程名、到达时间、服务时间 输出：...
操作系统实验-进程调度和内存管理-java语言版本.docx
11-19
操作系统实验-进程调度和内存管理-java语言版本.docx
高响应比优先调度算法(HRRN)
04-30
java平台运行高响应比优先调度算法，如果响应比相同则短作业优先。输出进程工作顺序、调度时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。压缩带有测试案例
操作系统RR算法的实现
06-09
该算法采用队列的方法 支持动态输入进程数 RR算法的实现 可以看到优先顺序
操作系统作业调度HRN算法
03-11
就是这样的、。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
单处理器进程调度算法实现FCFS,RR,SPN,SRT,HRRN
11-14
单处理器进程调度算法实现FCFS,RR,SPN,SRT,HRRN,使用C++实现
操作系统-实验三  模拟处理机HRRN调度算法（Java实现）
好吗好的~的技术博客
12-11 3146
                                                             实验三  模拟处理机HRRN调度算法   一、实验目的：用c,c++,java设计HRRN调度算法程序。 二、实验内容：本实验随机输入的进程个数、进程名称、进程提交到系统的时间、进程运行所需时间。通过模拟程序。显示以下信息： 1）处理机对进程的调度过程。 2）计算这N...
【操作系统】RR算法
热门推荐
PPDY93的博客
11-01 1万+
文章目录一、调度算法 一、调度算法 时间片 q=1 和 时间片 q=2 和 时间片q=4的平均周转时间和平均带权周转时间 q=1 进程名 A B C D E 平均 到达时间 0 2 4 6 8 服务时间 3 6 4 5 2 完成时间 4 18 17 20 15 周转时间 4 16 13 14 8 10.8 带权周转时间 1.33 2.67 3.25 2.8 服务时间算法 ...
【操作系统】进程调度（3）：RR（轮转） 算法 原理与实践
X
10-14 7619
0 前言 接上一篇文章：进程调度（2b）：STCF（最短完成时间优先） 算法 原理与实践 1 前提铺垫 除了与上一篇相同的，这里介绍新的基础知识。 1.1 三种类型的程序 计算密集型（CPU导向） 输入输出密集型（I/O导向） 中间型 所谓计算密集型程序，就是大量时间都在占用CPU做运算，例如科学计算。而输入输出密集型程序，则大量时间都在进行输入输出，你很熟悉它，例如人机交互，我们每时每刻都在用计算机干这个事情。中间型就是二者都有，占比差不多。 那么介绍这个有什么用？ 当我们的目标不同的时候，性能指标的
用java编写hrrn算法_硬核操作系统讲解 - sowhat1412的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_28846179的博客
03-01 173
阻塞一般是当系统执行IO操作时，此时进程进入阻塞状态，等待某个事件的返回。挂起是指进程没有占有物理内存，被写到磁盘上了。这时进程状态是挂起状态。阻塞挂起：进程被写入硬盘并等待某个事件的出现。就绪挂起：进程被写入硬盘，进入内存可直接进入就绪状态。3.2 PCB为了描述跟控制进程的运行，系统为每个进程定义了一个数据结构——进程控制块 Process Control Block，它是进程实体的一部分，是...
进程调度算法FCFS和RR
hnu_Cheng的博客
11-16 6269
一、 实验题目 本次试验要求编写的是进程调度中的FCFS算法和RR算法（轮转法）。 FCFS算法：最简单的CPU调度算法，采取先到先服务的规则，不存在进程优先级之说，也不管进程服务时间的长短，只有前面的进程完成或者阻塞后面的进程才会开始处理。这种算法不利于短进程，因为短进程要等待很久，而CPU繁忙进程则比较适合这种调度算法。 RR算法：这是一种轮询算法，每次将时间片给队首的进程去使用，如果该进程在...
操作系统实验 1-进程调度
最新发布
05-10
进程调度是操作系统的一个重要组成部分，负责管理进程的运行与切换。在操作系统中，进程是指正在运行的程序实例，它们需要通过进程调度器来分配 CPU 时间片，并在不同进程之间切换，以保证系统的高效运行。 操作系统实验1中，我们需要实现一个简单的进程调度器，具体步骤如下： 1. 创建进程结构体 定义一个进程结构体，包含进程 ID、进程状态、进程优先级等信息。 2. 创建进程队列 创建至少两个进程队列，一个用于存储处于就绪状态的进程，另一个用于存储处于阻塞状态的进程。 3. 实现进程创建和销毁 实现进程的创建和销毁函数，用于将新创建的进程加入就绪队列，或将已完成的进程从就绪队列中删除。 4. 实现进程调度 实现进程调度函数，用于从就绪队列中选取一个进程运行，或将当前正在运行的进程挂起并放回就绪队列中。 5. 实现进程阻塞和唤醒 实现进程阻塞和唤醒函数，用于将当前正在运行的进程阻塞，并将其放入阻塞队列中，或将阻塞队列中的进程唤醒并放回就绪队列中。 6. 测试 编写测试程序，测试进程的创建、销毁、调度、阻塞和唤醒等功能是否正常。 以上是操作系统实验1-进程调度的基本步骤，通过实践操作，可以更深入地理解操作系统的进程调度机制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值