进程调度算法实现【先来先服务FCFS】【短进程优先SJF】
作者：互联网
#include <cstdio>
#include <cstdlib>
#include <iostream>
#define MAX_DURANCE 1e6
using namespace std;
/*
* codeBy: slience_me
* time: 2022-5-10 14:00
*/
/**
* 全局参数
*/
int processCounts; //进程数
int *comingTimes; //达到时间
int *serveTimes; //服务时间
int *finishedTimes; //完成时间
int *turnoverTimes; //周转时间
int *waitingTimes; //等待时间
float *turnoverTimesWeight; //带权周转时间
int methodChoosen; //所选调度算法
/**
* 函数声明
*/
void InitProcessCount(); //输入进程个数
void InitComingTime(); //输入进程到达时间
void InitServeTime(); //输入进程服务时间
void PrintInformation(); //打印输入信息
void ChooseMethod(); //选择调度算法
void Initialize(); //数组初始化
void SJF(); //短作业优先
void FCFS(); //先来先服务
void PrintSchedule(); //打印调度信息
/**
* 主方法
* @return
*/
int main() {
// 1. 输入进程个数
InitProcessCount();
// 2. 输入进程到达时间
InitComingTime();
// 3. 输入进程服务时间
InitServeTime();
// 4. 打印输入信息
PrintInformation();
// 5. 数组初始化
Initialize();
// 6. 选择调度算法
ChooseMethod();
switch (methodChoosen) {
case 1:
FCFS();
break;
default:
SJF();
break;
}
PrintSchedule();
system("pause");
return 0;
}
/**
* 初始化进程数量
*/
void InitProcessCount() {
cout << "==>请输入进程个数:";
cin >> processCounts;
}
/**
* 初始化到来时间
*/
void InitComingTime() {
comingTimes = new int[processCounts];
cout << "==>请输入各个进程的到达时间:";
for (int i = 0; i < processCounts; i++) {
cin >> comingTimes[i];
}
}
/**
* 初始化服务时间
*/
void InitServeTime() {
serveTimes = new int[processCounts];
cout << "==>请输入各个进程的要求服务时间:";
for (int i = 0; i < processCounts; i++) {
cin >> serveTimes[i];
}
}
/**
* 打印信息
*/
void PrintInformation() {
cout << "==>被进程输入的进程数量: [ " << processCounts << " ] " << endl;
cout << "==>进程到来的时间展示: ";
for (int i = 0; i < processCounts; i++) {
cout << comingTimes[i] << " ";
}
cout << endl;
cout << "==>进程服务的时间展示: ";
for (int i = 0; i < processCounts; i++) {
cout << serveTimes[i] << " ";
}
cout << endl;
}
/**
* 选择算法类型
*/
void ChooseMethod() {
cout << "请选择一种调度方式[ 1-FCFS, 2-SJF]: ";
cin >> methodChoosen;
}
/**
* 先来先服务算法
*/
void FCFS() {
// 1. 设置初始时间0
int current = 0;
// 2. 复制一份到达时间的副本copy_comingTimes[]
int copy_comingTimes[processCounts];
for (int i = 0; i < processCounts; i++) {
copy_comingTimes[i] = comingTimes[i];
}
// 3. 遍历查找最早到达的进程
for (int j = 0; j < processCounts; j++) {
// 先设置默认最早到达的进程earliest是0，默认第1个进程到来时间最早
int earliestProcess = 0, min = copy_comingTimes[0];
//先找到当前最先到达的进程，需要使用到达时间的副本来找
//设min为所有进程中到来最早的时间
for (int i = 1; i < processCounts; i++) {
if (copy_comingTimes[i] < min) {
//遍历找到到来最早的时间与进程
min = copy_comingTimes[i];
earliestProcess = i;
}
}
//找到后，设置进程对应的时间禁用
copy_comingTimes[earliestProcess] = MAX_DURANCE;
//上一个进程执行完时有可能下个进程还没到达
if (comingTimes[earliestProcess] > current) {
current = comingTimes[earliestProcess];
}
//更新其完成时间 = 到来时间+服务时间
finishedTimes[earliestProcess] = current + serveTimes[earliestProcess];
//等待时间 等待时间 = 当前时间 - 到来时间
waitingTimes[earliestProcess] = current - comingTimes[earliestProcess];
//更新当前时间 当前时间 = 当前时间 + 服务时间
current += serveTimes[earliestProcess];
//更新周转时间 周转时间 = 服务时间 + 等待时间
turnoverTimes[earliestProcess] = serveTimes[earliestProcess] + waitingTimes[earliestProcess];
//更新带权周转时间 带权周转时间 = 周转时间 /服务时间
turnoverTimesWeight[earliestProcess] =
(float) turnoverTimes[earliestProcess] / (float) serveTimes[earliestProcess];
}
}
/**
* 短进程优先办法
*/
void SJF() {
// 1. 设置初始时间0
int current = 0;
// 2. 复制一份服务时间copy_serveTimes[],到达时间的副本copy_comingTimes[]
int copy_serveTimes[processCounts], copy_comingTimes[processCounts];
for (int i = 0; i < processCounts; i++) {
copy_serveTimes[i] = serveTimes[i];
}
for (int i = 0; i < processCounts; i++) {
copy_comingTimes[i] = comingTimes[i];
}
//3. flag 标识当前时间下有无已经到达的进程 1有0无
int flag = 0;
for (int i = 0; i < processCounts; i++) {
// min_p: 当前调度进程的下标
// min: 当前调度进程的服务时间
// early:当前调度进程的到达时间
int min_p = 0, min = copy_serveTimes[0], early = copy_comingTimes[0];
for (int j = 1; j < processCounts; j++) {
//进程到来而且该进程服务时间小
if (copy_comingTimes[j] <= current && copy_serveTimes[j] < min) {
flag = 1;
min = copy_serveTimes[j];
min_p = j;
}
}
//若当前时间无进程到达，则选择即将最早到达的那个进程
if (flag == 0) {
for (int m = 1; m < processCounts; m++) {
if (copy_comingTimes[m] < early) {
early = copy_comingTimes[m];
min_p = m;
current = early;
}
}
}
// 设置到来时间 服务时间为 禁用
copy_comingTimes[min_p] = MAX_DURANCE;
copy_serveTimes[min_p] = MAX_DURANCE;
//更新其完成时间 = 到来时间+服务时间
finishedTimes[min_p] = current + serveTimes[min_p];
//等待时间 等待时间 = 当前时间 - 到来时间
waitingTimes[min_p] = current - comingTimes[min_p];
//更新周转时间 周转时间 = 服务时间 + 等待时间
current = finishedTimes[min_p];
//更新周转时间 周转时间 = 服务时间 + 等待时间
turnoverTimes[min_p] = waitingTimes[min_p] + serveTimes[min_p];
//更新带权周转时间 带权周转时间 = 周转时间 /服务时间
turnoverTimesWeight[min_p] = (float) turnoverTimes[min_p] / (float) serveTimes[min_p];
}
}
/**
* 打印调度信息
*/
void PrintSchedule() {
cout << "==>进程调度信息打印:" << endl;
cout << "P_name(ID) arrived_time served_time finished_time turnover_time turnover_time_weight"
<< endl;
for (int i = 0; i < processCounts; i++) {
printf("%10d %12d %11d %14d %13d %20f\n", i, comingTimes[i], serveTimes[i], finishedTimes[i],
turnoverTimes[i], turnoverTimesWeight[i]);
}
//平均周转时间和总周转时间
float average_turnover_time, sum_turnover_time = 0;
//平均带权周转时间和总带权周转时间
float average_turnover_time_weight, sum_turnover_time_weight = 0;
for (int i = 0; i < processCounts; i++) {
sum_turnover_time += turnoverTimes[i];
sum_turnover_time_weight += turnoverTimesWeight[i];
}
average_turnover_time = sum_turnover_time / processCounts;
average_turnover_time_weight = sum_turnover_time_weight / processCounts;
cout << "==>平均周转时间为：" << average_turnover_time << endl;
cout << "==>带权平均周转时间为：" << average_turnover_time_weight << endl;
}
/**
* 初始化数组
*/
void Initialize() {
// 1. 完成时间
finishedTimes = new int[processCounts];
// 2. 周转时间
turnoverTimes = new int[processCounts];
// 3. 等待时间
waitingTimes = new int[processCounts];
// 4. 带权周转时间
turnoverTimesWeight = new float[processCounts];
}
标签：processCounts,FCFS,earliestProcess,int,comingTimes,时间,进程,SJF 来源： https://www.cnblogs.com/Slience-me/p/16341835.html