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);
}

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

FCFS,SJF以及PSA进程调度算法效率的比较
实现下面是用 Java 程序比较 FCFS,SJF 和 PSA 算法效率的示例代码: FCFS 思路对于 FCFS 算法,我们可以定义一个 Process 类来表示一个进程,其中包含进程名称.到达 ...
FCFS,SJF以及PSA进程调度算法的比较
实现下面是用 Java 程序比较 FCFS,SJF 和 PSA 算法效率的示例代码: FCFS 思路对于 FCFS 算法,我们可以定义一个 Process 类来表示一个进程,其中包含进程名称.到达 ...
Java模拟操作系统实验一：四种进程调度算法实现（FCFS,SJF,RR,HRN）
前言刚学完操作系统,模拟实现了其中一些经典的算法,内容比较多,打算写一个系列的总结,将自己的源码都分享出来,既方便自己以后复习,也希望能帮助到一些刚入坑的小伙伴.我的所有代码的运行环境都是基于Ecl ...
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
说明: 1.假设有只两种状态,就绪状态和结束状态.进程的初始状态都为就绪状态. 2.每次运行所设计的处理器调度程序调度进程之前,为每个进程随机生成它的要求运行时间. 3.模拟处理器调度,被选中的进程并 ...
进程调度算法Java代码
第一步:创建一个found类 import java.util.ArrayList;class Found {ArrayList<PCB> sequnce;//创建就绪队列PCB pcb[ ...
进程调度算法——C++实现 [ FCFS,SJF,HPR,HRN + 开源代码 + 详细解析 ]
✅ (原创,库存,第100篇博客,纪念一下) 文章目录零.动态演示图一.实现原理二.实现内容: 三.算法流程图: 3.1 先来先服务算法(FCFS)的流程图: 3.2 最短作业优先算法(SJF) ...
进程调度c语言 fcfs,计算机进程调度算法FCFS、RR、SJF的实现
调度算法,在Linux环境下用C语言编写程序,模拟FCFS.RR.SJF等进程调度算法,以及利用信号量等方法解决哲学家就餐问题. 在主进程中,创建 20 个子线程,分别模拟进程调度算法FCFS.RR. ...
【操作系统 - 1】先来先服务FCFS和短作业优先SJF进程调度算法
操作系统系列学习至此,发现很多学了但很久没用的知识,久而久之,慢慢遗忘.等哪天还需要的话,却发现已经忘得差不多了,即使整理了文档(word等),还是得从头再学一遍.读研第一学期,发现很多东西都可以从 ...
操作系统实验二——进程调度算法（FCFS、RR）
目录进程调度算法 FCFS算法代码 RR算法代码进程调度算法 FCFS算法代码 #include <stdio.h> #include <string.h> #includ ...

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

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

最新文章

热门文章