FCFS、SJF、RR、SRT进程调度算法的代码实现

最新推荐文章于 2024-05-30 06:45:00 发布
最新推荐文章于 2024-05-30 06:45:00 发布
阅读量2.8k 收藏 29
点赞数 12
分类专栏： 笔记 文章标签： 操作系统 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52744273/article/details/121217503
版权

最近在做操作系统的上机实验，顺便给大家分享一下自己实验的过程和成果。
以下是实验步骤∶
1、用一个结构体来存储进程的信息，结构体中包含以下变量。
int id;
int arriving_time;//到达时间
int leaving_time;//结束时间
int service_time;//服务时间
int remaining_time;//剩余时间
int cycling_time;//周转时间
vector<pair<int,int>> start_end;//进程运行的时间段，可能有多段
2、模拟FCFS算法
FCFS算法模拟比较简单，只要按照到达时间从前到后对所有进程排个序，排完后的顺序就是进程被执行的顺序
3、模拟SJF算法
模拟的核心操作：如果cpu空闲或者刚执行完一个进程，那么就从已到达的进程中，找到一个服务时间最短的进程，并执行它。
重复上述操作，直至所有的进程执行完毕。
4、模拟RR算法
①设立一个时间片，时间片的大小由用户输入。
②将第一个进程的到达时间作为第一个时间片的起始时间。
③每当时间片耗尽，如果有进程正在执行，则终止当前进程，并将该进程压入就绪队列末端，然后从就绪队列中寻找可执行的进程开始执行。
④每当进程执行完毕，将该进程从就绪队列中移除，然后从就绪队列中寻找可执行的进程开始执行。
⑤如果所有的进程都已完成执行，即就绪队列为空，则结束循环，RR算法运行结束。
5、模拟SRT算法
①设立一个cnt变量记录已执行完毕进程的数量，初始值为0。
②SRT算法的核心操作：从所有已到达且未运行完毕的进程中选择一个剩余时间最短的进程，然后运行这个进程。
③每当有进程到达时，进行②中的操作。
④每当有进程执行完毕时，cnt++，并且执行②中的操作。
⑤直到所有进程执行完毕，即cnt等于进程总数量时，退出循环，SRT算法运行结束。
运行结果截图：在这里插入图片描述
代码如下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
int n;
const int INF=0x3f3f3f3f;
struct Progress
{
    int id;
    int arriving_time;//到达时间
    int leaving_time;//结束时间
    int service_time;//服务时间
    int remaining_time;//剩余时间
    int cycling_time;//周转时间
    vector<pair<int,int>> start_end;//进程占用cpu运行的时间段，可能有多段
    void showInfo( )
    {
        printf( "progress:%d, arriving time:%d, leaving time:%d, service time:%d, cycling time:%d, start&ends:[ ",id,arriving_time,leaving_time,service_time,cycling_time);
        for( int i=0;i<start_end.size( );i++)
        {
            if(i!=0) 
            {
                printf(",");
            }
            printf( "(%d,%d)",start_end[i].first, start_end[i].second);
        }
        printf( " ]\n");
    }
    void showInfos( Progress p[])
    {
        for( int i=0;i<n;i++)
        {
            p[i].showInfo();
        }
    }
};

Progress p[1010];
Progress p_fcfs[1010];
Progress p_sjf[1010];
Progress p_srt[1010];
Progress p_rr[1010];

bool cmp1( Progress p1,Progress p2)
{
    return p1.arriving_time<p2.arriving_time;
}
bool cmp2( Progress p1,Progress p2)
{
    return p1.service_time<p2.service_time;
}
bool cmp3( Progress p1,Progress p2)
{
    return p1.start_end[0].first<p2.start_end[0].first;
}
bool cmp4( Progress p1,Progress p2)
{
    return p1.id<p2.id;
}
void caculate(Progress p[])
{
    for(int i=0;i<n;i++)
    {
        p[i].leaving_time=p[i].start_end[p[i].start_end.size()-1].second;
        p[i].cycling_time=p[i].leaving_time-p[i].arriving_time;
    }
}
void FCFS( Progress p[])
{
    sort( p,p+n,cmp1);//fcfs简单依照到达时间从小到大对进程进行排序即可
    int t=p[0].arriving_time;//t为当前的时间，初始化为进程的最早到达时间
    for( int i=0;i<n;i++)
    {
        p[i].start_end.push_back(  make_pair(  t,t+p[i].service_time) );
        t+=p[i].service_time;
        p[i].cycling_time=t-p[i].arriving_time;
    }
    sort(p,p+n,cmp4);
    caculate(p);
}

void SJF( Progress p[])
{

    sort( p,p+n,cmp1);//先按到达时间排个序
    int t=p[0].arriving_time;//t为当前的时间，初始化为进程的最早到达时间
    bool isOver[1010];//记录进程是否已运行结束
    for( int i=0;i<n;i++)
        isOver[i]=false;
    for( int i=0;i<n;i++)
    {
        int x;
        int min=INF;
        bool flag=false;
        for( int j=0;j<n;j++)//该循环找出到达时间小于t并且服务时间最短的那个进程，用x记录其下标。
        {
            if(!isOver[j] && p[j].arriving_time<=t && min>p[j].service_time)
            {
                x=j;
                min=p[j].service_time;
            }            
        }
        if( min!=INF)//min不再是初始值INF，这证明我们找到了符合条件的进程，根据SJF的原则，该进程就是在t时刻开始运行的进程。
        {
            p[x].start_end.push_back( make_pair( t,t+p[x].service_time));
            t+=p[x].service_time;
            isOver[x]=true;
        }
        else //我们没有找到符合条件的进程，说明t太小了，没有合适进程的到达时间早于t
        {
            t=INF;//将t赋值为正无穷（实际上是一个大于1e9的int类型整数）
            for( int j=0;j<n;j++)
            {
                if( !isOver[j])
                {
                    t=( t<p[j].arriving_time)? t:p[j].arriving_time;//找到剩余进程的最早到达时间，并将值赋给t
                }
            }
            i--;
        }
    }
    sort(p,p+n,cmp4);
    caculate(p);
}

void SRT( Progress p[])
{
    sort( p,p+n,cmp1);
    for( int i=0;i<n;i++)
        p[i].remaining_time=p[i].service_time;
    int t=p[0].arriving_time;//t为当前的时间，初始化为进程的最早到达时间
    int cnt=0;
    //cnt为已运行结束进程的数量
    while ( cnt<n)
    {
        
        int minr=INF;
        int x;
        for( int i=0;i<n;i++)//该循环找到到达时间小于等于t且剩余时间最短的进程，将其下标赋给为x
        {
            if( p[i].arriving_time<=t && p[i].remaining_time>0 && p[i].remaining_time<minr)
            { 
                minr=p[i].remaining_time;
                x=i;
            }
        }
        if( minr==INF)
        {//没有找到符合条件的进程，处理方法跟SJF里面类似（SJF函数里面不小心将一个变量命名为min，所以不能直接使用min函数 w(ﾟДﾟ)w）

            t=INF;
            for( int i=0;i<n;i++)
            {
                if( p[i].remaining_time>0)
                {
                    t=min( t,p[i].arriving_time);
                }
            }
        }
        else//找到了符合条件的进程
        {
            int nextArriving=INF;//nextArriving为在t之后第一个新到达的进程的到达时间，初始化为正无穷
            for( int i=x+1;i<n;i++)//该循环作用是找到这个到达时间，并赋给nextArriving
            {
                if(p[i].remaining_time==p[i].service_time&&p[i].arriving_time>t)
                {
                    nextArriving=p[i].arriving_time;
                    break;
                }
            }

            if( nextArriving-t>=p[x].remaining_time)
            {//如果下一个进程的到达时间减去当前的时间>=现在这个进程的剩余时间，那么现在这个进程可以直接运行至结束。
                
                if( p[x].start_end.size()==0 || p[x].start_end[ p[x].start_end.size()-1].second!=t)
                {
                    p[x].start_end.push_back(make_pair(t,t+p[x].remaining_time));
                }
                    
                else 
                {
                    p[x].start_end[ p[x].start_end.size()-1].second=t+p[x].remaining_time;
                }
                t+=p[x].remaining_time;
                p[x].remaining_time=0;
                cnt++;
            }
            else//否则，现在这个进程只能运行到下一个进程到达，然后进入下一次循环，根据所有已到达进程的剩余时长，重新判断要执行哪一个进程。
            {
                if( p[x].start_end.size()==0 || p[x].start_end[ p[x].start_end.size()-1].second!=t)
                {
                    p[x].start_end.push_back(make_pair(t,nextArriving));
                }
                else
                {
                    p[x].start_end[ p[x].start_end.size()-1].second=nextArriving;
                } 
                   

                p[x].remaining_time-=nextArriving-t;
                t=nextArriving;
            }
        }
    }
    sort(p,p+n,cmp4);
    caculate(p);
}

void RR(Progress p[],int timeslice)
{
    sort( p,p+n,cmp1);
    for( int i=0;i<n;i++)
        p[i].remaining_time=p[i].service_time;
    queue <Progress> q;//q为就绪队列
    for( int i=0;i<n;i++)
        q.push(p[i]);
    int t=p[0].arriving_time;//t为当前的时间，初始化为进程的最早到达时间
    int t0=t;
    int cnt=0;
    while (!q.empty())//队列为空，即所有进程运行完毕
    {
        queue <Progress> tem=q;
        bool flag=true;
        while(!tem.empty())
        {
            if(tem.front().arriving_time<=t)
            {
                flag=false;
                break;
            }
            tem.pop();
        }
        if(flag) t=((t-t0)/timeslice+1)*timeslice+t0;
        int time=((t-t0)/timeslice+1)*timeslice-(t-t0);//time为当前时间片剩余时间
        if(q.front().remaining_time<=time&&q.front().arriving_time<=t)//如果剩余时间大于该进程剩余时间，则该进程运行结束，
        {                                                             //更新t值，并将该进程从队列中移出
            if( q.front().start_end.size()==0 || q.front().start_end[ q.front().start_end.size()-1].second!=t)
            {
                q.front().start_end.push_back( make_pair(t,t+q.front().remaining_time));
            } 
            else
            {
                q.front().start_end[ q.front().start_end.size()-1].second=t+q.front().remaining_time;
            }        
            t+=q.front().remaining_time;
            q.front().remaining_time=0;
            p[cnt++]=q.front();
            q.pop();

        }
        else if(q.front().arriving_time<=t)//如果剩余时间大于该进程剩余时间，则该进程运行结束，
        {                                  //更新t值，更新进程剩余运行时间，然后进行下一次循环
            if( q.front().start_end.size()==0 || q.front().start_end[ q.front().start_end.size()-1].second!=t)
            {
                q.front().start_end.push_back( make_pair(t,t+time));
            }
            else
            {
                q.front().start_end[ q.front().start_end.size()-1].second=t+time;
            }           
            q.front().remaining_time-=time;
            q.push(q.front());
            q.pop();
            t+=time;
        }
        else
        {
            q.push(q.front());
            q.pop();
        }
    }
    sort(p,p+n,cmp4);
    caculate(p);
}

int main( )
{
    cout<<"please input count of progresses:"<<endl;
    cin>>n;
    
    for( int i=0;i<n;i++)
    {
        p[i].id=i;
        cout<<"progress"<<i<<",please input arriving time and service time: "<<endl;
        cin>>p[i].arriving_time>>p[i].service_time;
    }

    for( int i=0;i<n;i++)
       p_rr[i]=p_sjf[i]=p_srt[i]=p_fcfs[i]=p[i];
    
    FCFS( p_fcfs);
    cout<<"FCFS:"<<endl;
    p_fcfs[0].showInfos( p_fcfs);

    SJF( p_sjf);
    cout<<"SJF:"<<endl;
    p_sjf[0].showInfos( p_sjf);

    SRT(p_srt);
    cout<<"SRT:"<<endl;
    p_srt[0].showInfos(p_srt);

    cout<<"please input timeslice:"<<endl;
    int timeslice;
    cin>>timeslice;
    RR(p_rr,timeslice);
    cout<<"RR:"<<endl;
    p_rr[0].showInfos(p_rr);
}
开longlong了吗？
关注
  • 12
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
进程调度算法实现代码（操作系统）
07-30
进程调度算法实现代码（操作系统）
操作系统进程调度算法实现
rj2017211811的博客
04-24 429
bug好多 #include<unistd.h> #include<stdio.h> #include<stdlib.h> //enum STATE{Ready,Running,Blocked}; #define MAX_SIZE 100 typedef struct process_pcb { //进程ID int ID;//process...
【调度】操作系统中调度算法（FCFS、RR、SPN（SJF）、SRT、HRRN）
bandaoyu的note
07-03 5567
决策模式 决策模式说明选择函数在执行的瞬间的处理方式，通常分为以下两类： 非抢占：一旦进入运行状态，就不会终止直到运行结束。 抢占：当前正在运行的进程可以被打断，并转移到就绪态。 一个调度算法是否能抢占，对进程的顺序有着极大的影响。 先来先服务FCFS 先来先服务是最简单的策略，也成为先进先出FIFO。首先它是一个非抢占的。如字面的意思，它根据进程到达时间决定先运行哪一个进程。 这里给出一个实际的例子。以表格的形式表现出在FIFO策略下各进程的情况。 简单说就是依次执行完成，从...
操作系统之CPU调度算法——FCFS、SJF和SRTF
最新发布
PleaSure乐事的博客
05-30 1358
对CPU调度算法中FCFS、SJF和SRTF的一些解释
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
Johana_C的博客
04-06 1万+
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
进程调度算法——C++实现 [ FCFS,SJF,HPR,HRN + 开源代码 + 详细解析 ]
热门推荐
Wang_Dou_Dou_的博客
04-18 1万+
关键词：运行结果图、进程调度算法、算法的设计思想、算法样例、完整代码 —— C++版本、先来先服务算法(FCFS)的流程图、最短作业优先算法(SJF)的流程图、最高优先级优先(HPR)的流程图、最高响应比优先算法(HRN)的流程图。
【HDL系列】除法器(3)——基2 SRT算法
纸上谈芯的专栏
11-01 6841
目录 一、除法表示 二、数字递归算法基础公式 三、QDS（Quotient Digit Selection）函数 四、基2 SRT算法 一、除法表示 除法被定义如下： 其中，x是被除数，d是除数，q是商，rem是余数。 商的精度由ulp（unit of last position）来决定: 如果ulp=1, 商q则是整数； 如果ulp=r^(-n)，n是商数个数，r是所有输入操作数的基，此时商为小数。 二、数字递归算法基础公式 在使用数字递归算法（Digit Re...
操作系统进程调度实验（内含可成功运行C++代码）
m0_48117581的博客
05-23 9859
操作系统实验 进程调度 C++/C
操作系统调度算法FCFS、SJF、RR、多级反馈算法
05-06
本文将深入探讨四种常见的CPU调度算法：先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）以及多级反馈队列（Multi-Level Feedback Queue, MLFQ）。 1. **先来先服务（FCFS）**： FCFS是最简单的调度算法...
c语言 进程调度FCFS SJF HRRN RR
05-11
在代码中，SJF算法的实现并未完整给出，但从描述和部分代码可以看出，它需要跟踪每个进程的预计运行时间，并根据这个信息做出调度决策。 ### 最高响应比优先（HRRN） HRRN算法是一种动态优先级调度算法，其中进程...
CpuSchedullingCalc:FCFS-SJF-SRT-RR算法计算器
04-29
本项目"CPU调度计算"（CpuSchedullingCalc）聚焦于四种基本的调度算法：先来先服务（FCFS）、最短作业优先（SJF）、最短剩余时间（SRT）和时间片轮转（RR）。这些都是计算机科学中基础且重要的概念，对理解操作系统...
操作系统进程调度算法C语言代码
12-08
操作系统进程调度算法C语言代码 本算法包含四种调度:先到先服务，短作业优先，时间片轮转，优先级优先！
进程调度算法实现
11-11
对于初学进程的同学来说，可以直观的看出进程的调度方法。程序可直接使用。
C++实现SRT、FCFS、SJF、RR、HRRN和银行家算法.zip
12-15
自己学习C++的时候写的项目： C++实现SRT、FCFS、SJF、RR、HRRN和银行家算法
处理器调度算法实现（c++）先来先服务（FCFS） 短作业优先（SJF）时间轮转（RR）优先数算法
10-02
c++语言实现处理器低级调度，主要包括先来先服务，短作业优先，时间轮转算法，优先数算法（优先数越高级别越高） 有什么疑问请访问我的邮箱（ntufangang@yahoo.cn）
C语言简单模拟CPU调度算法（FCFS,SJF,HRRF,RR）
一只懒猫的博客
11-08 7153
文章目录一、处理器调度算法简介1、概念解释2、产生原因3、算法优劣性的指标资源利用率：吞吐率：公平性：作业周转时间：二、代码总体思路二、先来先服务（First Come First Serve，FCFS）算法思想：具体代码三、短作业优先（Short Job First，SJF）算法思想代码实现四、高响应比优先（High Response Ratio First，HRRF）算法思想具体实现五、时间片轮转算法（Round-Robin scheduling，RR）算法思想具体实现六、完整项目链接 在学OS的时候，
操作系统4种进程调度算法（c语言）
weixin_74337975的博客
11-14 3267
抢占性的 HPF 允许正在执行的进程被更高优先级的进程中断，以便立即执行更高优先级的任务。需要注意的是，SJF 算法的一个问题是它对于长服务时间的进程可能会导致其他进程长时间等待，可能会出现饥饿（Starvation）的情况。这是一种非抢占式的调度算法，即一旦进程开始执行，就一直执行到完成，除非有更短的作业进入就绪队列。在这种算法中，进程按照它们到达就绪队列的顺序依次执行，即先到达的进程先执行，后到达的进程排队等待。如果新进程的服务时间比当前正在执行的进程更短，那么系统会中断当前进程，转而执行新的进程。
操作系统进程调度算法 C++
qq_31605553的博客
12-01 1949
操作系统 进程调度
模拟操作系统中处理机调度算法（Python）
Binary_huang的简介
08-13 3009
我在学习操作系统的进程调度部分后，产生了一个有趣的想法：通过编写代码来模拟进程调度算法，以加深对这一知识点的理解。我投入了一整天的时间，实践了这个突发奇想。 在操作系统中，进程调度是一个重要的概念，它决定了如何合理地分配处理器时间，以便多个进程能够高效地并发运行。我决定通过编写代码来模拟一些经典的调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（Round Robin）、优先级调度以及最高响应比（HRRN）算法。
FCFS SJF STN RR四种进程调度的算法
05-24
RR（Round Robin）算法是指按照时间片轮流调度进程。每个进程被分配一个时间片，在该时间片内运行，时间片结束后，进程被放到就绪队列末尾，等待下一次调度。该算法能够保证所有进程都能得到一定的CPU时间，但是在...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值