操作系统实验1（处理机调度）

【操作系统实验1（处理机调度）】识字粗堪供赋役，不须辛苦慕公卿。这篇文章主要讲述操作系统实验1：处理机调度相关的知识，希望能为你提供帮助。

注：本文记录　WHUT-计算机学院-操作系统课程　实验1：处理机调度
纸上得来终觉浅，觉知此事需躬行！

１、实验内容：?实验预备：掌握处理机调度的相关内容，对进程调度算法有深入的理解
?实验内容：模拟实现进程调度功能
?具体要求：

–任选一种计算机高级语言编程实现
–选择1~2种进程调度算法，例如：先来先服务、短进程优先、最高响应比优先、时间片轮转、优先级法等
–能够输入进程的基本信息，如进程名、到达时间和预估运行时间等
–根据选择的调度算法显示进程调度顺序
–显示完成调度后每个进程的开始时间、完成时间、周转时间、带权周转时间
–计算平均周转时间和平均带权周转时间

2、运行结果：2.1 测试用例：

文章图片

2.2 运行截图：

文章图片

3、程序源码：

本次实验难度不大，代码建议参考使用，不建议完全Ctrl+C and Ctrl+V！！！
另：代码有不严谨之处，你能发现吗？

#include < iostream>
#include < iomanip>
using namespace std;

//其中i为作业个数，j为作业列数；
int n = 4; //作业数

//平均周转时间
double T=0;

//带权周转时间
double W = 0;

/*定义作业保存数组，第1—n列分别为：作业号、提交时间、估计运行时间、优先数（0行、0列不用）

作业号提交时间估计运行时间优先数
110.02.02
210.21.04
310.40.51
410.50.33
*/
double work[5][5] =0,0,0,0,0,
0,1,10.0, 2.0,2,
0,2,10.2, 1.0,4,
0,3,10.4, 0.5,1,
0,4,10.5, 0.3,3;

//先来先服务算法使用数组
//1:作业号 2：提交时间 3：运行时间 4：开始时间 5：终止时间 6：周转时间 7：带权周转时间 8：执行顺序
double FCFS[5][9];

//短进程优先法数据保存数组；
//1:作业号 2：提交时间 3：运行时间 4：开始时间 5：终止时间 6：周转时间 7：带权周转时间 8：执行顺序
//double SJF[5][9];
//与FCFS共用一套数组

//优先级算法使用数组
//1:作业号 2：提交时间 3：运行时间 4：优先级 5：开始时间 6：终止时间 7：周转时间 8：带权周转时间 9：执行顺序
double YXJ[5][10];

//HRN算法使用数组
void change(double & a,double & b)
double temp = a;
a = b;
b = temp;

//初始化，按照提交时间（第 2 列）顺序，进行排序操作
int InitFCFS()
//排序
for (int i = 1; i < = n; i++)
for (int j = 1; j < = n - i; j++)
if (work[j][2] > work[j + 1][2])
change(work[j][1], work[j + 1][1]); //作业号交换
change(work[j][2], work[j + 1][2]); //提交时间交换
change(work[j][3], work[j + 1][3]); //运行时间交换
change(work[j][4], work[j + 1][4]); //优先数交换

//赋值
for (int i = 1; i < = n; i++)
FCFS[i][1] = work[i][1]; //更新作业号
FCFS[i][2] = work[i][2]; //更新提交时间
FCFS[i][3] = work[i][3]; //更新运行时间其中优先数在FCFS中用不到

return 1;

//初始化，按照运行时间（第 3 列）顺序，其中最早加入的作业始终置于第一位
int InitSJF()

//寻找提交时间最早的一个,并放在第一位
double early = 100000;
int flag = 0;
for (int i = 1; i < = n; i++)
if (early > work[i][2])
early = work[i][2];
flag = i;

//更新Work表中数据，如果首项不为最早提交的则需要交换，否则不用交换
if (flag != 1)
change(work[1][1], work[flag][1]); //作业号交换
change(work[1][2], work[flag][2]); //提交时间交换
change(work[1][3], work[flag][3]); //运行时间交换
change(work[1][4], work[flag][4]); //优先数交换

//排序,其中第一位不需要考虑了,直接从第二位2开始
for (int i = 2; i < = n; i++)
for (int j = 2; j < = n - i+1; j++)
if (work[j][3] > work[j + 1][3])
change(work[j][1], work[j + 1][1]); //作业号交换
change(work[j][2], work[j + 1][2]); //提交时间交换
change(work[j][3], work[j + 1][3]); //运行时间交换
change(work[j][4], work[j + 1][4]); //优先数交换

//赋值
for (int i = 1; i < = n; i++)
FCFS[i][1] = work[i][1]; //更新作业号
FCFS[i][2] = work[i][2]; //更新提交时间
FCFS[i][3] = work[i][3]; //更新运行时间其中优先数在FCFS中用不到

return 1;

//只要对FCFS或者SJF的前三列基本排序完成，那么后边操作相同，合并算法
void FCFS_SJF()
//置零
T = 0;
W = 0;

for (int i = 1; i < = n; i++)
//如果是第一个任务
if (i == 1)
FCFS[i][4] = FCFS[i][2]; //第一个任务：开始时间=提交时间

else
//如果当前任务提交时间比最后一个任务结束时间晚
FCFS[i][4] = FCFS[i - 1][5]; //第二个任务以后：开始时间=上一个任务的终止时间

FCFS[i][5] = FCFS[i][4] + FCFS[i][3]; //终止时间=开始时间+运行时间
FCFS[i][6] = FCFS[i][5] - FCFS[i][2]; //周转时间=终止时间-提交时间
FCFS[i][7] = FCFS[i][6] / FCFS[i][3]; //带权周转时间=周转时间÷运行时间
FCFS[i][8] = i; //初始化已经对程序执行顺序进行排序，则第i个程序的执行顺序即为i

//计算
for (int i = 1; i < = n; i++)
T += FCFS[i][6];
W += FCFS[i][7];

T /= n;
W /= n;

int InitYXJ()
//寻找提交时间最早的一个,并放在第一位
double early = 100000;
int flag = 0;
for (int i = 1; i < = n; i++)
if (early > work[i][2])
early = work[i][2];
flag = i;

//更新Work表中数据，如果首项不为最早提交的则需要交换，否则不用交换
if (flag != 1)
change(work[1][1], work[flag][1]); //作业号交换
change(work[1][2], work[flag][2]); //提交时间交换
change(work[1][3], work[flag][3]); //运行时间交换
change(work[1][4], work[flag][4]); //优先数交换

//排序,其中第一位不需要考虑了,直接从第二位2开始
for (int i = 2; i < = n; i++)
for (int j = 2; j < = n - i + 1; j++)
if (work[j][4] > work[j + 1][4])
change(work[j][1], work[j + 1][1]); //作业号交换
change(work[j][2], work[j + 1][2]); //提交时间交换
change(work[j][3], work[j + 1][3]); //运行时间交换
change(work[j][4], work[j + 1][4]); //优先数交换

//赋值
for (int i = 1; i < = n; i++)
YXJ[i][1] = work[i][1]; //更新作业号
YXJ[i][2] = work[i][2]; //更新提交时间
YXJ[i][3] = work[i][3]; //更新运行时间
YXJ[i][4] = work[i][4]; //更新优先级

return 1;

void theFCFS()
InitFCFS(); //初始化FCFS数组前三列
FCFS_SJF();

void theSJF()
InitSJF(); //初始化SJF数组前三列
FCFS_SJF();
;

int InitHRN()

return 1;

void theYXJ()
//置零
InitYXJ();

T = 0;
W = 0;

for (int i = 1; i < = n; i++)
//如果是第一个任务
if (i == 1)
YXJ[i][5] = YXJ[i][2]; //第一个任务：开始时间=提交时间

else
YXJ[i][5] = YXJ[i - 1][6]; //第二个任务以后：开始时间=上一个任务的终止时间

YXJ[i][6] = YXJ[i][5] + YXJ[i][3]; //终止时间=开始时间+运行时间
YXJ[i][7] = YXJ[i][6] - YXJ[i][2]; //周转时间=终止时间-提交时间
YXJ[i][8] = YXJ[i][7] / YXJ[i][3]; //带权周转时间=周转时间÷运行时间
YXJ[i][9] = i; //初始化已经对程序执行顺序进行排序，则第i个程序的执行顺序即为i

//计算
for (int i = 1; i < = n; i++)
T += YXJ[i][7];
W += YXJ[i][8];

T /= n;
W /= n;

int main()

cout < < "请按照以下格式输入作业信息表：" < < endl;
cout < < "作业号提交时间运行时间优先数" < < endl;
for (int i = 1; i < = n; i++)
cin > > work[i][1] > > work[i][2] > > work[i][3] > > work[i][4];

cout < < "输入完毕！" < < endl < < endl;

while (1)
cout < < "1、先来先服务\\n2、最短作业优先\\n3、优先级法\\n0、退出" < < endl;

int choice;
cout < < "请选择使用的处理机算法：";

cin > > choice;

switch (choice)
case 1:
cout < < "使用先来先服务算法结果如下：" < < endl;
theFCFS();
cout < < "作业号\\t\\t提交时间\\t运行时间\\t开始时间\\t终止时间\\t周转时间\\t带权周转时间\\t执行顺序" < < endl;
for (int i = 1; i < = n; i++)
for (int j = 1; j < = 8; j++)
cout < < FCFS[i][j] < < "\\t\\t";

cout < < endl;

cout < < "平均周转时间：" < < T < < endl;
cout < < "带权周转时间：" < < W < < endl< < endl;
break;

case 2:
theSJF();
cout < < "使用短作业优先算法结果如下：" < < endl;
cout < < "作业号\\t\\t提交时间\\t运行时间\\t开始时间\\t终止时间\\t周转时间\\t带权周转时间\\t执行顺序" < < endl;
for (int i = 1; i < = n; i++)
for (int j = 1; j < = 8; j++)
cout < < FCFS[i][j] < < "\\t\\t";

cout < < endl;

cout < < "平均周转时间：" < < T < < endl;
cout < < "带权周转时间：" < < W < < endl< < endl;
break;

case 3:
theYXJ();
cout < < "使用优先级算法结果如下：" < < endl;
cout < < "作业号\\t\\t提交时间\\t运行时间\\t优先级\\t\\t开始时间\\t终止时间\\t周转时间\\t带权周转时间\\t执行顺序" < < endl;
for (int i = 1; i < = n; i++)
for (int j = 1; j < = 9; j++)
cout < < YXJ[i][j] < < "\\t\\t";

cout < < endl;

cout < < "平均周转时间：" < < T < < endl;
cout < < "带权周转时间：" < < W < < endl < < endl;
break;

default:
break;

if (choice==0)
cout < < "已退出！" < < endl;
break;

return 0;