先来先服务FCFS和短作业优先SJF进程调度算法(C++)

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

程序要求：

1）进程个数n；每个进程的到达时间T1, … ,Tn和服务时间S1, … ,Sn；选择算法1-FCFS，2-SJF。

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

3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；

4）输出：要求输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

完整代码

#include <iostream>
#include <bits/stdc++.h>
#include <iomanip>
#include <stdlib.h>
using namespace std;
 
#define MaxNum 100
 
class Process{
	private:
		int n=0;//进程个数
		string Name[MaxNum];//进程名
		int ArrivalTime[MaxNum];//到达时间
		int ServiceTime[MaxNum];//服务时间
		int FinishTime[MaxNum];//完成时间
		int WholeTime[MaxNum];//周转时间
		double WeightWholeTime[MaxNum];//带权周转时间
		double AverageWT_FCFS,AverageWT_SJF;//FCFS、SJF平均周转时间
		double AverageWWT_FCFS,AverageWWT_SJF;//FCFS、SJF平均带权周转时间 
		bool isFinished_FCFS[MaxNum];//记录FCFS服务是否完成 
		bool isFinished_SJF[MaxNum];
		
	public:
		Process();//构造函数 
		~Process();	//析构函数 
		
		void Input();
		void Output();
		int GetFirst();//获取FCFS第一个调度的作业
		int GetFirst_SJF();//获取SJF第一个调度的作业 
		void FCFS();
		void SJF(); 
		void menu();
};
Process::Process(){
	cout<<"请输入进程个数：";
	cin>>n;
	for(int i=0;i<n;i++){//初始化 
		ArrivalTime[i]=0;
		ServiceTime[i]=0; 
		FinishTime[i]=0;
		WholeTime[i]=0;
		WeightWholeTime[i]=0;
		AverageWT_FCFS=0;
		AverageWT_SJF=0;
		AverageWWT_FCFS=0;
		AverageWWT_SJF=0;
		isFinished_FCFS[i]=false;
		isFinished_SJF[i]=false;
	}
}
Process::~Process(){
}
void Process::Input(){
	cout<<"请输入"<<n<<"个进程的进程名字（空格隔开）：";
	for(int k=0;k<n;k++){
		cin>>Name[k];
	}
	
	cout<<"请输入"<<n<<"个进程的到达时间（空格隔开）：";
	for(int i=0;i<n;i++){
		cin>>ArrivalTime[i];
	}
	
	cout<<"请输入"<<n<<"个进程的服务时间（空格隔开）：";
	for(int j=0;j<n;j++){
		cin>>ServiceTime[j];
	}
}
void Process::Output(){
	cout<<"进程信息如下："<<endl;
	cout<<"------------------------------------------------------------------------"<<endl;
	cout<<left<<setw(12)<<"进程名"<<setw(12)<<"到达时间"<<setw(12)<<"服务时间"<<setw(12)<<"完成时间"<<setw(12)<<"周转时间"<<setw(12)<<"带权周转时间"<<endl;
	cout<<"------------------------------------------------------------------------"<<endl;
	for(int i=0;i<n;i++){
		cout<<left<<setw(12)<<Name[i];
		cout<<setw(12)<<ArrivalTime[i];
		cout<<setw(12)<<ServiceTime[i];
		cout<<setw(12)<<FinishTime[i];
		cout<<setw(12)<<WholeTime[i];
		cout<<setw(12)<<WeightWholeTime[i]<<endl;
	}
	cout<<"------------------------------------------------------------------------"<<endl;
	cout<<endl;
	for(int j=0;j<n;j++){
		cout<<"时刻"<<FinishTime[j-1]<<"：进程"<<Name[j]<<"开始运行"<<endl; 
	}
	cout<<endl;
}

int Process::GetFirst(){
	//获取FCFS将要调度的第一个作业 按照到达时间最早的开始即可 
	int first=MaxNum;
	for(int i=0;i<n;i++){
		if(ArrivalTime[i]<=ArrivalTime[first]){
			first=i;
		}
	}
	return first;
}

void Process::FCFS(){
	//调用 GetFirst_FCFS()找到要调度的作业
	int first=GetFirst();
	
	int nowTime=0;//当前时间 
	//cout<<"时刻"<<nowTime<<"：进程"<<Name[first]<<"开始运行"<<endl;
	FinishTime[first]=ArrivalTime[first]+ServiceTime[first];
	WholeTime[first]=FinishTime[first]-ArrivalTime[first];//周转时间=完成时间-到达时间
	WeightWholeTime[first]=WholeTime[first]/ServiceTime[first];//带权周转时间=周转时间/服务时间
	isFinished_FCFS[first]=true;
	nowTime+=ServiceTime[first] ;//当前时间=目前所有作业的服务时间之和 
	
	int nextPro=n;
	for(int i=0;i<n;i++){
		nextPro=n;
		for(int j=0;j<n;j++){
			if(!isFinished_FCFS[j]){//j没有执行 
				if(ArrivalTime[j]<=nowTime){//进程j已经就绪 
					if(nextPro==n){//已经执行到了最后一个进程 
						nextPro=j; 
					}
					else{
						if(ArrivalTime[nextPro]>ArrivalTime[j]){
							nextPro=j;//j比nextPro先到，所以j作为下一个执行的进程 
						}
					}
				}
			}
		} 
		isFinished_FCFS[nextPro]=true;
		FinishTime[nextPro]=nowTime+ServiceTime[nextPro];
		//cout<<"时刻"<<nowTime<<"：进程"<<Name[nextPro]<<"开始运行"<<endl;
		nowTime+=ServiceTime[nextPro];
		
		WholeTime[nextPro]=FinishTime[nextPro]-ArrivalTime[nextPro];
		WeightWholeTime[nextPro]=(double)WholeTime[nextPro]/ServiceTime[nextPro]; 
	}
	double SumWT=0;//周转时间之和 
	double SumWWT=0;//带权周转时间之和 
	for(int i=0;i<n;i++){
		SumWT+=WholeTime[i];
		SumWWT+=WeightWholeTime[i];
	}
	AverageWT_FCFS=SumWT/n;
	AverageWWT_FCFS=SumWWT/n;
	cout<<endl; 
	Output();
	cout<<"FCFS算法的平均周转时间："<<AverageWT_FCFS<<endl;
	cout<<"FCFS算法的平均带权周转时间："<<AverageWWT_FCFS<<endl;
} 
void Process::SJF(){
	//调用 GetFirst_SJF()找到要调度的作业
	int first=GetFirst();//只能从最先到达的作业开始 
	
	int nowTime=0;//当前时间 
	
	FinishTime[first]=ArrivalTime[first]+ServiceTime[first];
	WholeTime[first]=FinishTime[first]-ArrivalTime[first];//周转时间=完成时间-到达时间
	WeightWholeTime[first]=WholeTime[first]/ServiceTime[first];//带权周转时间=周转时间/服务时间
	isFinished_SJF[first]=true;
	nowTime+=ServiceTime[first] ;//当前时间=目前所有作业的服务时间之和 
	
	int nextPro=n;
	for(int i=0;i<n;i++){
		nextPro=n;
		for(int j=0;j<n;j++){
			if(!isFinished_SJF[j]){//j没有执行 
				if(ArrivalTime[j]<=nowTime){//进程j已经就绪 
					if(nextPro==n){//已经执行到了最后一个进程 
						nextPro=j; 
					}
					else{
						if(ServiceTime[nextPro]>ServiceTime[j]){
							nextPro=j;//j比nextPro服务时间短，所以j作为下一个执行的进程 
						}
					}
				}
			}
		} 
		isFinished_SJF[nextPro]=true;
		FinishTime[nextPro]=nowTime+ServiceTime[nextPro];
		nowTime+=ServiceTime[nextPro];
		WholeTime[nextPro]=FinishTime[nextPro]-ArrivalTime[nextPro];
		WeightWholeTime[nextPro]=(double)WholeTime[nextPro]/ServiceTime[nextPro]; 
	}
	double SumWT=0;//周转时间之和 
	double SumWWT=0;//带权周转时间之和 
	for(int i=0;i<n;i++){
		SumWT+=WholeTime[i];
		SumWWT+=WeightWholeTime[i];
	}
	AverageWT_SJF=SumWT/n;
	AverageWWT_SJF=SumWWT/n;
	
	Output();
	cout<<"SJF算法的平均周转时间："<<AverageWT_SJF<<endl;
	cout<<"SJF算法的平均带权周转时间："<<AverageWWT_SJF<<endl;
}
void Process::menu(){
	cout<<endl;
	cout<<"算法清单"<<endl;
	cout<<"1.先来先服务算法（FCFS）"<<endl;
	cout<<"2.短作业优先算法（SJF）"<<endl;
	cout<<"3.退出程序（EXIT）"<<endl;
	cout<<endl;
}

int main(){
	Process Myprocess;
	Myprocess.Input();
	int choice;
	do{
		Myprocess.menu();
		cout<<"请选择要进行的操作：";
		cin>>choice;
		cout<<endl;
		switch(choice){
			case 1:
				cout<<"使用先来先服务算法"<<endl;
				Myprocess.FCFS();
				break;
			case 2:
				cout<<"使用短作业优先算法"<<endl;
				Myprocess.SJF();
				break;
			case 3:
				cout<<"程序终止！"<<endl;
				return 0;
		}
		cout<<endl;
		system("pause");
	}while(choice);
	return 0;
}

运行结果1（FCFS）

运行结果2（SJF）