操作系统-进程调度(FCFS和SJF)

最新推荐文章于 2024-07-19 13:59:11 发布
最新推荐文章于 2024-07-19 13:59:11 发布
阅读量1.8k 收藏 26
点赞数 7
分类专栏： 操作系统 文章标签： 进程调度 FCFS SJF 周转时间 等待时间
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45742603/article/details/125714742
版权

文章目录

进程调度(FCFS和SJF)

问题描述

设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间，周转时间、带权周转时间和等待时间，并且统计n个进程的平均周转时间、平均带权周转时间和平均等待时间。最后，对两个算法做出比较评价。

要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间和等待时间，并且计算所有进程的平均周转时间，带权平均周转时间和平均等待时间。

实验环境

  • Windows 11
  • Visual Studio Code
  • gcc version 8.1.0

输入

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

根据显示信息：“1-FCFS，2-SJF”，选择1或者2进入对应的算法过程。

输出

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

测试数据

Process Num.12345
Arrival Time01346
CPU Burst57382

实验设计

数据结构

#define MaxNum 100                                // 最大进程数
double AverageWT_FCFS = 0, AverageWT_SJF = 0;     // 平均等待时间
double AverageTAT_FCFS = 0, AverageTAT_SJF = 0;   // 平均周转时间
double AverageWTAT_FCFS = 0, AverageWTAT_SJF = 0; // 平均带权周转时间
using namespace std;

// 进程结构体
typedef struct PROCESS
{
    int index;                    // 进程序号
    double ServiceTime;           // 服务时间
    double ArrivalTime;           // 到达时间
    double StartTime;             // 开始时间
    double FinishTime;            // 结束时间
    double TurnArroundTime;       // 周转时间
    double WaitTime;              // 等待时间
    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)

// 计算各项时间 z为记号变量 用于区别FCFS和SJF
void CountTime(PRO &PC, int n, int z)

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

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

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

主要函数算法设计

// 模拟整个调度过程，输出每个时刻的进程运行状态
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 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;
    }
}

// 计算各项时间 z为记号变量 用于区别FCFS和SJF
void CountTime(PRO &PC, int n, int z)
{
    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;
    }
    if(z == 1) // 计算FCFS
    {
        AverageWT_FCFS = sumWT / n;
        AverageTAT_FCFS = sumTAT / n;
        AverageWTAT_FCFS = sumWTAT / n;
    }
    if(z == 2) // 计算SJF
    {
        AverageWT_SJF = sumWT / n;
        AverageTAT_SJF = sumTAT / n;
        AverageWTAT_SJF = sumWTAT / n;
    }
}

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

    SortArrival(PC, n);    // 按到达时间进行排序
    CountTime(PC, n, 1);   // 计算各项时间
    display_status(PC, n); // 模拟整个调度过程，输出每个时刻的进程运行状态
    display_time(PC, n);   // 输出各进程的周转时间、带权周转时间和等待时间
}

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

详细设计

  • 变量初始化

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

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

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

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

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

  • 按格式输出调度结果

流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ftLBFZYW-1657501806383)(E:\work\操作系统\实验2\code\flow.png)]

实验结果与分析

结果展示与描述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AGXUoPej-1657501806385)(E:\work\操作系统\实验2\code\result.png)]

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

结果分析

  • FCFS算法通过按到达时间排序的方式得到服务顺序，计算时还需要考虑当前进程结束时下一个进程是否已经到达，进行条件判断后代入不同结果计算，最终验证与手动计算结果相同
  • SJF算法先按到达时间排序，再将每个进程服务时间段内的等待队列按服务时间由短至长排序，从而得到服务顺序，之后的计算方式与FCFS相同，最终验证与手动计算结果相同

总结

  • 本次实验将所有需要重复使用的代码都打包成函数，在主函数中直接进行调用，使代码简洁、清晰。

  • 在数据结构方面，因为对队列的使用还不是很熟悉，所以我在实现算法的过程中，使用了结构体数组，考虑到计算过程会出现整数与小数的混合运算，我将除进程序号外的所有数据都设为double型，便不会在结果中出现小数部分被舍弃的问题。

  • 对于SJF算法的排序，我直接对等待队列进行排序，避免使用复杂的算法，使用变量End判定进程是否处在等待队列，将所有进程都排好序之后直接调用CountTime函数进行计算，不仅使算法更简单，还体现出了FCFS和SJF两种算法的区别，便于学习和理解。

  • 在主函数中，使用while循环，重复选择算法，若选择0则输出所有进程的平均周转时间，带权平均周转时间和平均等待时间并且退出循环，以实现循环选择算法的功能。

源代码

#include <iostream>

#define MaxNum 100                                // 最大进程数
double AverageWT_FCFS = 0, AverageWT_SJF = 0;     // 平均等待时间
double AverageTAT_FCFS = 0, AverageTAT_SJF = 0;   // 平均周转时间
double AverageWTAT_FCFS = 0, AverageWTAT_SJF = 0; // 平均带权周转时间
using namespace std;

// 进程结构体
typedef struct PROCESS
{
    int index;                    // 进程序号
    double ServiceTime;           // 服务时间
    double ArrivalTime;           // 到达时间
    double StartTime;             // 开始时间
    double FinishTime;            // 结束时间
    double TurnArroundTime;       // 周转时间
    double WaitTime;              // 等待时间
    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 << "FCFS\t\t" << AverageTAT_FCFS << "\t\t" << AverageWTAT_FCFS << "\t\t" << AverageWT_FCFS << endl;
    cout << "SJF\t\t" << AverageTAT_SJF << "\t\t" << AverageWTAT_SJF << "\t\t" << AverageWT_SJF << 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;
    }
}

// 计算各项时间 z为记号变量 用于区别FCFS和SJF
void CountTime(PRO &PC, int n, int z)
{
    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;
    }
    if (z == 1) // 计算FCFS
    {
        AverageWT_FCFS = sumWT / n;
        AverageTAT_FCFS = sumTAT / n;
        AverageWTAT_FCFS = sumWTAT / n;
    }
    if (z == 2) // 计算SJF
    {
        AverageWT_SJF = sumWT / n;
        AverageTAT_SJF = sumTAT / n;
        AverageWTAT_SJF = sumWTAT / n;
    }
}

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

    SortArrival(PC, n);    // 按到达时间进行排序
    CountTime(PC, n, 1);   // 计算各项时间
    display_status(PC, n); // 模拟整个调度过程，输出每个时刻的进程运行状态
    display_time(PC, n);   // 输出各进程的周转时间、带权周转时间和等待时间
}

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

int main()
{
    PRO pc;
    int n;
    cout << "请输入进程的数量：";
    cin >> 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-FCFS  输入2-SJF" << endl
         << "请选择要执行的操作：";
    cin >> choice;
    while (choice != 0)
    {
        if (choice == 1)
            FCFS(pc, n);
        if (choice == 2)
            SJF(pc, n);
        cout << endl
             << "请输入接下来要执行的操作：";
        cin >> choice;
    }
    display_average();
    cout << endl;
    system("pause");
    return 0;
}
Stories Untold.
关注
  • 7
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《操作系统》实验一：先来先服务FCFS和短作业优先SJF进程调度算法
weixin_46531010的博客
11-02 2105
先来先服务FCFS和短作业优先SJF进程调度算法
计算机操作系统--FCFS和SJF代码实现
HWQlet的博客
04-25 848
FCFS实现较简单： 1.按照时间先后到达顺序，进行进程对列的构造 2.有的时候一个进程处理结束但是后一个进程还未到，则后一个进程的完成时间=进程到达时间+进程服务时间 SJF实现有许多细节要注意：终于有用到for...else结构了 1.第一个是最早到达的进程，而不管他是否服务时间最短 2.后面的进程选取服务时间最短的 2.1：有可能进程处理完成后，后面服务时间最短的进程还未到...
先来先服务FCFS和短作业优先SJF进程调度算法
04-11 3166
【实验题目】：先来先服务FCFS和短作业优先SJF进程调度算法 【实验目的】 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。【实验内容】问题描述：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先S...
操作系统实验一 先来先服务FCFS和短作业优先SJF进程调度算法
02-02
操作系统实验一 先来先服务FCFS和短作业优先SJF进程调度算法（内含源代码和详细实验报告），详细介绍：http://blog.csdn.net/xunciy/article/details/79239096
先来先服务FCFS和短作业优先SJF进程调度（C语言代码）
sparky的博客
05-02 6201
文章目录1.先来先服务FCFS1.1内容概括1.2实验及代码2.短作业优先SJF2.1内容概括2.2实验及代码 1.先来先服务FCFS 1.1内容概括 1.2实验及代码 代码实现 #include<stdio.h> #include<stdlib.h> struct fcfs //ID { char name[20]; float startime; float...
操作系统—进城调度（先来先服务FCFS和短进程优先SJF）算法
engineer_z的博客
05-10 763
问题描述及需求分析 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间，周转时间、带权周转时间和等待时间，并且统计n个进程的平均周转时间、平均带权周转时间和平均等待时间。最后，对两个算法做出比较评价。 实验设计 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在.
实验一 先来先服务FCFS和短作业优先SJF进程调度算法
qq_65892509的博客
12-06 1457
设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,...
操作系统-进程调度实验.docx
11-17
操作系统的进程调度是操作系统中一个非常重要的概念，它是指操作系统如何将可用的 CPU 时间分配给多个进程，以提高系统的性能和效率。在这个实验中，我们将通过模拟进程调度算法来了解进程调度的原理和实现。 进程...
Scheduling_algo：操作系统调度算法，FCFS和SJF
02-04
操作系统调度算法 先来先服务（FCFS）和最短作业优先（SJF）调度 此代码是非抢占式的 这些算法是非抢占式或抢占式的。 非抢占式算法的设计使进程一旦进入运行状态，就无法抢占它，直到它完成其分配的时间为止，而...
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
01-01
在计算机科学领域，操作系统是管理计算机硬件与软件资源的核心程序，而进程调度...通过FCFS、SJF、RR和HRN这四种算法的实现，我们可以更好地理解和掌握进程调度的基本原理，为设计和优化更复杂的调度策略打下坚实基础。
FCFS和SJF进程调度算法实验报告
07-19
FCFS（First-Come, First-Served，先来先服务）和SJF（Shortest Job First，最短作业优先）是两种常见的进程调度算法，在操作系统中用于决定如何为多个进程分配处理器时间。这两种算法在处理多任务环境时具有不同的...
操作系统实验之先来先服务和短作业优先算法
qq_41696136的博客
01-14 1049
一、实验内容 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,Sn。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。 二、C++代码 个人觉得代码里边的还是有问题 // test...
操作系统（五）：FCFS/SJF/非抢占优先级/RR
weixin_43531643的博客
09-22 1万+
操作系统（五）：FCFS/SJF/非抢占优先级/RR 一、题目1（书上170页5.7） 5.4 5.4 Consider the following set of processes, with the length of the CPU burst time given in milliseconds: The processes are assumed to have arrived in ...
【操作系统 - 1】先来先服务FCFS和短作业优先SJF进程调度算法
热门推荐
Houchaoqun_XMU的博客
03-17 6万+
【操作系统系列】学习至此，发现很多学了但很久没用的知识，久而久之，慢慢遗忘。等哪天还需要的话，却发现已经忘得差不多了，即使整理了文档（word等），还是得从头再学一遍。读研第一学期，发现很多东西都可以从博客上学习到，也有不少博主呕心沥血整理了挺多有用的博文。于是，本人借此契机，也慢慢开始整理一些博文，不断改进完善中。整理博文（IT）有如下目的。1. 首要目的：记录“求学生涯”的所学所悟，不断修改，不断更新！（有读者的互动）2. 其次目的：在这“开源”的时代，整理并分享所学所悟是一种互利的行为。
最短作业优先调度算法（SJF算法）的C++实现
EbowTang的练习场
08-29 1万+
题目要求： 在作业调度中，该算法每次从后备作业队列中挑选估计服务时间最短的一个或几个作业，将他们调入内存，分配必要的资源，创建进程并放入就绪队列。与在进程调度中的原理类似。假设有n项作业位于就绪队列中，这些作业的提交时间用数组requestTimes按照提交时间的先后顺序存储，对应的作业服务时间（持续时间）用数组durations存储。采用SJF算法，计算n项作业的平均等待时间。当存在多个相同长
操作系统之FCFS - 先来先服务算法
不知道你是通过何种途径访问到这里，总之欢迎来到red velet的博客
12-30 5323
先来先服务调度算法是最简单的调度方法，计算开始时间、完成时间、周转时间、带权周转时间、平均周转时间、平均带权周转时间
有关FCFS与SJF的作业算法的理解（操作系统原理）
wanglei539的博客
04-25 2102
操作系统原理FCFS 和 SJF 理解
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 383
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值