一、运行效果

二、实现过程

①FCFS

void FCFS(PCB pro[], int num) {
	int time,doneTime;
	int count=0,proNum=1;  //count为计数器，proNum记录当前的进程数量
	float sumTTime = 0,sumWTTime = 0; //总周转时间和总加权周转时间
	PCB pro1[100]; //用来存放当前进程的信息
	PCB *currentPro,*tempPCB;

	printf("\n\t先来先服务调度算法模拟\n\n");
	printf("\n");
	sortProWithArrivalTime(pro, num);  //按照进程到达时间进行排序

	//定义就绪队列
	PCBQueue* queue = (PCBQueue*)malloc(sizeof(PCBQueue));
	queueInit(queue); //就绪队列初始化
	enterQueue(queue, &pro[0]);   //将第一个进程送入就绪队列中
	time = pro[0].arrivalTime;    //记录第一个进程的到达时间

	while (queue->size > 0) {
		currentPro = poll(queue);  //从进程队列中取出一个进程
		if (time < currentPro->arrivalTime){
			time = currentPro->arrivalTime;
		}

		//计算进程的结束时间、周转时间，加权周转时间
		//结束时间=到达时间+运行时间
		doneTime = time + currentPro->runtime;
		currentPro->startTime = time;
		currentPro->doneTime = doneTime;
		//周转时间=结束时间-到达时间
		currentPro->turnaroundTime = doneTime - currentPro->arrivalTime;
		//加权周转时间=周转时间/运行时间
		currentPro->wTurnaroundTime = (currentPro->turnaroundTime) / (currentPro->runtime);
		sumTTime += currentPro->turnaroundTime; //计算周转时间之和
		sumWTTime += currentPro->wTurnaroundTime; //计算加权周转时间之和

		//模拟进程的执行过程
		for (int tt = time; tt <= doneTime && proNum < num; tt++){
			if (tt >= pro[proNum].arrivalTime) {
				enterQueue(queue, &pro[proNum]);
				proNum++;
			}
		}
		copyProcessInfo(&pro1[count],currentPro); //复制当前进程信息给一个新进程模板
		printRunningProInfo(&pro1[count]); //输出正在运行进程的信息
		count++;

		//输出就绪队列进程中的信息
		if(queue->size!=0) {
			printf("\t就绪队列：\n");
			printf("\t————————————————————————————————————————————————\n");
			printf("\t进程 到达时间  运行时间 \n");
			tempPCB=queue->firstProg->next;
			for(int i=queue->size; i>0; i--) {
				printf("\t%s\t%d\t%d\n",tempPCB->processName,tempPCB->arrivalTime,tempPCB->runtime);
				tempPCB=tempPCB->next;
			}
			printf("\t————————————————————————————————————————————————\n");
			printf("\n\n\n");
		}
		else {
			printf("\t无进程处于就绪状态!\n");
			printf("\t————————————————————————————————————————————————\n\n\n");
		}
		time += currentPro->runtime;

		//防止出现前一个进程执行完到下一个进程到达之间无进程进入
		if (queue->size == 0 && proNum < num) {
			enterQueue(queue, &pro[proNum]);
			proNum++;
		}
	}

	//输出所有进程的信息
	printProRunningOrder(pro1,count);
	printf("\t平均周转时间为:%.2f\n", sumTTime /num);
	printf("\t平均带权周转时间为:%.2f\n",sumWTTime/num);
}

②SJF

void SJF(PCB pro[],int num) {
	int i=0,proNum=1; //proNum记录当前的进程
	int time,done_time;
	float sumTTime=0,sumWTTime=0;
	PCBQueue *ready_queue;
	PCB *currentPro,pro1[MAXSIZE];

	printf("\n\t短作业优先调度算法模拟\n\n");
	printf("\n");
	sortProWithArrivalTime(pro, num);
	ready_queue = (PCBQueue*)malloc(sizeof(PCBQueue));
	if(!ready_queue) {
		printf("分配就绪队列头结点空间失败！");
		exit(1);
	}
	queueInit(ready_queue);
	enterQueueOfRuntime(ready_queue,&pro[0]);
	time = pro[0].arrivalTime;

	while(ready_queue->size>0) {
        //就绪队列中的队头进程入队
		currentPro=poll(ready_queue);
		//如果该进程与上一次运行的进程结束时间之间有间隔，则将CPU运行时间变为该进程到达时间
		if(time<currentPro->arrivalTime){
			time=currentPro->arrivalTime;
		}
		done_time=time+currentPro->runtime;
		currentPro->startTime=time;
		currentPro->doneTime=done_time;
		currentPro->turnaroundTime = done_time - currentPro->arrivalTime;//周转时间
		currentPro->wTurnaroundTime = currentPro->turnaroundTime / currentPro->runtime;//带权周转时间
		//打印正在运行的进程
		printRunningProInfo(currentPro);
		//将curpro的信息复制到pro1[i]中
		copyProcessInfo(&pro1[i],currentPro);
		i++;
		sumTTime += currentPro->turnaroundTime;
		sumWTTime += currentPro->wTurnaroundTime;

		while(proNum<num) {
		    //将在CPU中的进程运行的时间内到达的进程放入就绪队列
			if(pro[proNum].arrivalTime<=done_time) {
				enterQueueOfRuntime(ready_queue,&pro[proNum]);
				proNum++;
			}
			else {
				break;
			}
		}
		printReadyQueueInfo(ready_queue);//打印就绪队列
		time=done_time;

		//防止出现前一个进程执行完到下一个进程到达之间无进程进入
		if(ready_queue->size==0&&proNum<num) {
			enterQueueOfRuntime(ready_queue,&pro[proNum]);
			proNum++;
		}
	}

	//输出所有进程的信息
	printProRunningOrder(pro1,num);
	printf("\t平均周转时间为:%.2f\n", sumTTime / num);
	printf("\t平均带权周转时间为:%.2f\n",sumWTTime/num);
}

③HRRF

void proControlBlock::HRRF(int n) {
	sortWithArrivalTime(n); //根据进程到达时间进行排序
	float t = 0;
	for (int i = 0; i < n; i++) {
		//计算前一个进程的结束时间
		if (i == 0) {
			prov[i].finishedTime = t + prov[i].runningTime + prov[i].arrivalTime;
			t = prov[i].finishedTime;
		}
		else {
			if (prov[i].arrivalTime > t)
				t = prov[i].arrivalTime;
			prov[i].finishedTime = t + prov[i].runningTime;
			t += prov[i].runningTime;
		}
		//找到在前一个进程结束之前到达且响应比最高的进程放在后一个
		if (i < n - 1) {
			//选出在前一个进程结束前到达的进程
			int j = i + 1;
			while (prov[j].arrivalTime <= prov[i].finishedTime && j < n - 1) {
				j++;
			}
			//计算响应比
			for (int k = i + 1; k <= j; k++) {
				prov[k].responseRatio = (prov[i].finishedTime - prov[k].arrivalTime + prov[k].runningTime) / prov[k].runningTime;
			}
			//选出响应比最高的进程
			unsigned index;
			index = i + 1;
			for (int k = i + 1; k <= j; k++) {
				if (prov[index].responseRatio < prov[k].responseRatio)
					index = k;
			}
			arrElementSwap(i + 1, index);
		}
	}

	cout << "进程执行顺序：";
	for (int i = 0; i < n; i++) {
		cout << prov[i].proNum << " ";
	}
	cout << "\n";
	timeCalculate(n);
}

三、项目结构图

四、小结

本项目模拟实现作业调度中先来先服务、短作业优先和最高响应比调度算法。可任意选择作业数量、各作业的提交时间（时钟时刻）和运行时间（小时）。可以模拟出作业调度过程并显示，即每次作业调度时，各作业的执行情况（开始执行时间，结束时间，周转时间），最后计算并列出平均周转时间，并对相同情况下不同调度算法进行性能分析比较。