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

最近在做操作系统的上机实验，顺便给大家分享一下自己实验的过程和成果。
以下是实验步骤∶
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);
}