进程调度算法——C++实现 [ FCFS,SJF,HPR,HRN + 开源代码 + 详细解析 ]

最新推荐文章于 2025-03-12 22:00:03 发布
最新推荐文章于 2025-03-12 22:00:03 发布
阅读量2.1w 收藏 459
点赞数 72
分类专栏： 操作系统学习笔记 文章标签： 操作系统 操作系统算法 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wang_Dou_Dou_/article/details/124248908
版权
本文详细介绍了操作系统中四种基本的进程调度算法——先来先服务(FCFS)、最短作业优先(SJF)、最高优先级优先(HPR)和最高响应比优先(HRN)的实现原理与流程。通过C++代码展示了如何模拟这些算法，并提供了具体的测试样例和运行结果。文章还附带了每种算法的流程图，帮助读者理解其工作方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


✅ (原创，库存，第100篇博客，纪念一下)

文章目录

零、动态演示图

在这里插入图片描述

一、实现原理

(1) 先来先服务算法FCFS(First Come First Service)：即调度程序只靠率一个参数———作业到达系统的时间，谁先到就先给谁提供服务。

(2) 最短作业优先算法SJF(Shortest Job First)：即我们也只考虑一个参数———进程的CPU的执行时间，计算量越小的进程将会优先得到系统的服务。

(3) 最高优先级优先HPR(Highest Priority First)：调度程序总是挑选优先级最高的进程或作业，并分配给其资源。

(4) 最高响应比优先算法HRN(Highest Response Ratio Next)：调度程序总是挑选响应比最大的进程或作业，并分配给其资源。响应比计算公式 = 1 + (作业已等待时间/作业需要处理的时间)


二、实现内容：

(1) 设计可用于该实验的进程控制块，进程控制块至少包括进程号、状态和要求服务时间；

(2) 动态或静态创建多个进程；

(3) 模拟操作系统四种进程调度算法：先进先出、短作业优先、高优先级优先、高相应比优先中的任意两种。

(4) 调度所创建的进程并显示调度结果。


三、算法流程图：

3.1 先来先服务算法(FCFS)的流程图：

● 先来先服务算法FCFS(First Come First Service)：即调度程序只靠率一个参数———作业到达系统的时间，谁先到就先给谁提供服务。

在这里插入图片描述

3.2 最短作业优先算法(SJF)的流程图：

● 最短作业优先算法SJF(Shortest Job First)：即我们也只考虑一个参数———进程的CPU的执行时间，计算量越小的进程将会优先得到系统的服务。

在这里插入图片描述

3.3 最高优先级优先(HPR)的流程图：

● 最高优先级优先HPR(Highest Priority First)：调度程序总是挑选优先级最高的进程或作业，并分配给其资源。

在这里插入图片描述

3.4 最高响应比优先算法(HRN)的流程图：

● 最高响应比优先算法HRN(Highest Response Ratio Next)：调度程序总是挑选响应比最大的进程或作业，并分配给其资源。响应比计算公式 = 1 + (作业已等待时间/作业需要处理的时间)

在这里插入图片描述


四、算法样例 —— 代码测试也是用的这个

1		// 测试 FCFS
4
0 1 3 4
0 50 60 110
120 50 10 20

2		// 测试 SJF
4
0 1 3 4
0 50 60 110
120 50 10 20

3		// 测试 HPR
4
0 1 3 4
0 50 60 110
120 50 10 20
1 2 3 4		// 数字越大表示优先级越高

4		// 测试 HRN
4
0 1 3 4
0 50 60 110
120 50 10 20

五、完整代码 —— C++版本

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

/*
* 设计要求：
* [1] 设计可用于该实验的进程控制块，进程控制块至少包括 进程号、状态(进入时间+优先级) 和 要求服务时间
*
* [2] 动态或静态创建多个进程
*
* [3] 模拟操作系统四种进程调度算法：先进先出、短作业优先、高优先级优先、高相应比优先中的任意两种
*
* [4] 调度所创建的进程并显示调度结果
*/

typedef struct Process_Control_Block
{
	int num;
	int enter_Tim;
	int start_Tim;
	int sev_Tim;
	int save_Sev_Tim;
	int over_Tim;
	int priority_Rank;		// 优先级
	bool finish_Flag;		// 是否以服务完的标志
}PCB;

void FCFS_Algorithm();		// 先来先服务算法 FCFS (First Come First Service)
void SJF_Algorithm();		// 最短作业优先算法 SJF (Shortest Job First)
void HPF_Algorithm();		// 最高优先级优先算法 HPR (Highest Priority First)
void HRN_Algorithm();		// 最高响应比优先算法 HRN (Highest Response Ratio Next)
int Find_Min_SevTime_Pro(int, PCB*, int);
int Find_Max_Priority_Pro(int, PCB*, int);

void Init(int*, PCB*&, int);
void Print_Menu();
void Print_Res(int*, PCB*&);

int main()
{
	int choice;
	do
	{
		Print_Menu();
		cout << "请选择要实现的算法：";
		cin >> choice;
		switch (choice)
		{
		case 1:
			FCFS_Algorithm();
			break;
		case 2:
			SJF_Algorithm();
			break;
		case 3:
			HPF_Algorithm();
			break;
		case 4:
			HRN_Algorithm();
			break;
		case 0:
			break;
		}
		system("pause");
		system("cls");
	} while (choice);
	return 0;
}

void Print_Menu()
{
	/* 输入模块 */
	cout << "+---------------------------------------+" << endl;
	cout << "|\t>>> 算法清单 <<<\t\t|" << endl;
	cout << "|\t1.先来先服务算法(FCFS)\t\t|" << endl << "|\t2.最短作业优先算法(SJF)\t\t|" << endl;
	cout << "|\t3.最高优先级优先算法(HPR)\t|" << endl << "|\t4.最高响应比优先算法(HRN)\t|" << endl;
	cout << "|\t0.退出\t\t\t\t|" << endl;
	cout << "+---------------------------------------+" << endl;
}

void Init(int* n, PCB*& Pro_Array, int HPR_Flag)
{
	cout << "请输入在单道环境下，需调度的作业个数 n 为：";
	cin >> *n;
	Pro_Array = new PCB[*n];

	cout << "请分别输入这 " << *n << " 个进程的进程号：（空格区分）";
	for (int i = 0; i < *n; i++)
	{
		cin >> Pro_Array[i].num;
		Pro_Array[i].finish_Flag = false;
	}
	cout << "请分别输入这 " << *n << " 个进程达到系统的时刻：（空格区分）";
	for (int i = 0; i < *n; i++)
	{ 
		cin >> Pro_Array[i].enter_Tim;
		Pro_Array[i].start_Tim = -1;
	}

	cout << "请分别输入这 " << *n << " 个进程需要的服务时间：（空格区分）";
	for (int i = 0; i < *n; i++)
	{
		cin >> Pro_Array[i].sev_Tim;
		Pro_Array[i].save_Sev_Tim = Pro_Array[i].sev_Tim;
	}
	if (HPR_Flag == 1)
	{
		cout << "请分别输入这 " << *n << " 个进程需要的优先级：（空格区分）";
		for (int i = 0; i < *n; i++)
			cin >> Pro_Array[i].priority_Rank;
	}
}

void Print_Res(int* m, PCB*& Pro_Array)
{
	/* 输出模块*/
	int n = *m;

	/* 输出模块一：表 */
	cout << endl << "| 进程号\t| 进入时间\t| 服务时间\t| 开始时间\t| 结束时间\t| 周转时间\t| 带权周转时间\t|" << endl;
	for (int i = 0; i < n; i++)
	{
		int cicle_Time = Pro_Array[i].over_Tim - Pro_Array[i].enter_Tim;	// 周转时间
		double carry_Weight_Cicle_Time = 1.0 * cicle_Time / Pro_Array[i].save_Sev_Tim;	// 带权周转时间
		cout.precision(4);
		cout << "| 进程\t" << Pro_Array[i].num << "\t| " << Pro_Array[i].enter_Tim << "\t\t| " << Pro_Array[i].save_Sev_Tim\
			<< "\t\t| " << Pro_Array[i].start_Tim << "\t\t| " << Pro_Array[i].over_Tim << "\t\t| " << cicle_Time << "\t\t| "\
			<< carry_Weight_Cicle_Time << "\t\t|" << endl;
	}
	cout << endl;

	/* 输出模块二：其他内容 */
	/* [1]输出：每个进程的周转时间 */
	for (int i = 0; i < n; i++)
	{
		int cicle_Time = Pro_Array[i].over_Tim - Pro_Array[i].enter_Tim;
		cout << Pro_Array[i].num << "进程的周转时间为：" << cicle_Time << endl;
	}
	cout << endl;

	/* [2]输出：每个进程的带权周转时间 */
	for (int i = 0; i < n; i++)
	{
		int cicle_Time = Pro_Array[i].over_Tim - Pro_Array[i].enter_Tim;
		int actual_execution_Time = Pro_Array[i].save_Sev_Tim;
		cout << Pro_Array[i].num << "进程的带权周转时间为：" << 1.0 * cicle_Time / actual_execution_Time << endl;
	}
	cout << endl;

	/* [3]输出：所有进程的平均周转时间 */
	int tol_Tim_1 = 0;
	for (int i = 0; i < n; i++)
	{
		int cicle_Time = Pro_Array[i].over_Tim - Pro_Array[i].enter_Tim;
		tol_Tim_1 += cicle_Time;
	}
	cout << "所有进程的平均周转时间为：" << 1.0 / n * tol_Tim_1 << endl;
	cout << endl;

	/* [4]输出：所有进程的带权平均周转时间 */
	double tol_Tim_2 = 0;
	for (int i = 0; i < n; i++)
	{
		int cicle_Time = Pro_Array[i].over_Tim - Pro_Array[i].enter_Tim;
		int actual_execution_Time = Pro_Array[i].save_Sev_Tim;
		tol_Tim_2 += 1.0 * cicle_Time / actual_execution_Time;
	}
	cout << "所有进程的带权平均周转时间为：" << 1.0 / n * tol_Tim_2 << endl;
	cout << endl;
}

/*
* 先来先服务算法FCFS(First Come First Service)：
* 即调度程序只靠率一个参数———作业到达系统的时间，谁先到就先给谁提供服务。
*/
void FCFS_Algorithm()		// 先来先服务算法 FCFS (First Come First Service)
{
	/* 输入模块 */
	int n;
	PCB* Pro_Array = NULL;
	Init(&n, Pro_Array, 0);

	/* FCFS算法设计模块 */
	int over_Job_Num = 0;
	int i = 0;	// 当前服务对象的下标
	int cur_Time = Pro_Array[i].enter_Tim;	// 当前时刻, 初始化为第一个进程的开始时刻
	while (over_Job_Num < n)
	{
		if (Pro_Array[i].finish_Flag == false)	// 当前进程还未服务完
		{
			Pro_Array[i].start_Tim = cur_Time;	// 开始时间
			Pro_Array[i].finish_Flag = true;	// 先到先服务
			over_Job_Num++;
			Pro_Array[i].sev_Tim = 0;			// 该进程所要求的服务时间清零
			cur_Time += Pro_Array[i].save_Sev_Tim;	// 当前时间向后推进
			Pro_Array[i].over_Tim = cur_Time;	// 记录该进程的结束时间
		}
		i++;
	}

	/* 输出模块*/
	Print_Res(&n, Pro_Array);

	delete[] Pro_Array;
	return;
}

/*
* 最短作业优先算法 SJF (Shortest Job First):【非抢占式的算法】
* 即我们也只考虑一个参数———进程的CPU的执行时间，计算量越小的进程将会优先得到系统的服务。
*/
int Find_Min_SevTime_Pro(int n, PCB* Pro_Array, int cur_Time)
{
	int i, ind, min_SevTime = 999999;
	for (i = 0; i < n; i++)
	{
		if (Pro_Array[i].enter_Tim > cur_Time)	// 如果进程都还没有进入系统, 则不进行比较(即直接跳过)
			continue;
		if (Pro_Array[i].finish_Flag == true)	// 如果进程已经执行过了, 则不进行比较(即直接跳过)
			continue;

		if (Pro_Array[i].sev_Tim < min_SevTime)
		{
			min_SevTime = Pro_Array[i].sev_Tim;
			ind = i;
		}
	}
	return ind;
}
void SJF_Algorithm()		// 最短作业优先算法 SJF (Shortest Job First)
{
	/* 输入模块 */
	int n;
	PCB* Pro_Array = NULL;
	Init(&n, Pro_Array, 0);

	/* FCFS算法设计模块 */
	int over_Job_Num = 0;
	int i = 0;	// 当前服务对象的下标
	int cur_Time = Pro_Array[i].enter_Tim;	// 当前时刻, 初始化为第一个进程的开始时刻
	while (over_Job_Num < n)
	{
		if (Pro_Array[i].finish_Flag == false)	// 当前进程还未服务完
		{
			int ind;
			ind = Find_Min_SevTime_Pro(n, Pro_Array, cur_Time);	 // 找到计算量最小的进程(在已到达系统的进程中找)

			Pro_Array[ind].start_Tim = cur_Time;	// 开始时间
			Pro_Array[ind].finish_Flag = true;	// 处理完该进程
			over_Job_Num++;
			Pro_Array[ind].sev_Tim = 0;			// 该进程所要求的服务时间清零
			cur_Time += Pro_Array[ind].save_Sev_Tim;	// 当前时间向后推进
			Pro_Array[ind].over_Tim = cur_Time;	// 记录该进程的结束时间
		}
		i++;
		if (i == n)		// 设置循环
			i = 0;
	}

	/* 输出模块*/
	Print_Res(&n, Pro_Array);

	delete[] Pro_Array;
	return;
}

/*
* 最高优先级优先 HPR (Highest Priority First):
* 调度程序总是挑选优先级最高的进程或作业，并分配给其资源。
*/
int Find_Max_Priority_Pro(int n, PCB* Pro_Array, int cur_Time)
{
	int i, ind, max_Pri_Rank = -999999;
	for (i = 0; i < n; i++)
	{
		if (Pro_Array[i].enter_Tim > cur_Time)	// 如果进程都还没有进入系统, 则不进行比较(即直接跳过)
			continue;
		if (Pro_Array[i].finish_Flag == true)	// 如果进程已经执行过了, 则不进行比较(即直接跳过)
			continue;

		if (Pro_Array[i].priority_Rank > max_Pri_Rank)
		{
			max_Pri_Rank = Pro_Array[i].priority_Rank;
			ind = i;
		}
	}
	return ind;
}
void HPF_Algorithm()		// 最高优先级优先 HPR (Highest Priority First)
{
	/* 输入模块 */
	int n;
	PCB* Pro_Array = NULL;
	Init(&n, Pro_Array, 1);

	/* HPR算法设计模块 */
	int over_Job_Num = 0;
	int i = 0;	// 当前服务对象的下标
	int cur_Time = Pro_Array[i].enter_Tim;	// 当前时刻, 初始化为第一个进程的开始时刻
	while (over_Job_Num < n)
	{
		if (Pro_Array[i].finish_Flag == false)	// 当前进程还未服务完
		{
			int ind;
			ind = Find_Max_Priority_Pro(n, Pro_Array, cur_Time);	 // 找到最高优先级的进程(在已到达系统的进程中找)
			Pro_Array[ind].start_Tim = cur_Time;	// 开始时间
			Pro_Array[ind].finish_Flag = true;	// 处理完该进程
			over_Job_Num++;
			Pro_Array[ind].sev_Tim = 0;			// 该进程所要求的服务时间清零
			cur_Time += Pro_Array[ind].save_Sev_Tim;	// 当前时间向后推进
			Pro_Array[ind].over_Tim = cur_Time;	// 记录该进程的结束时间
		}
		i++;
		if (i == n)		// 设置循环
			i = 0;
	}

	/* 输出模块*/
	Print_Res(&n, Pro_Array);

	delete[] Pro_Array;
	return;
}

/*
* 最高响应比优先算法 HRN (Highest Response Ratio Next):
* 调度程序总是挑选响应比最大的进程或作业，并分配给其资源。
* 响应比计算公式 = 1 + (作业已等待时间/作业需要处理的时间)
*/
int Find_Max_Response_Ratio_Pro(int n, PCB* Pro_Array, int cur_Time)
{
	int i, ind;
	double max_Pri_Rank = -999999;
	for (i = 0; i < n; i++)
	{
		if (Pro_Array[i].enter_Tim > cur_Time)	// 如果进程都还没有进入系统, 则不进行比较(即直接跳过)
			continue;
		if (Pro_Array[i].finish_Flag == true)	// 如果进程已经执行过了, 则不进行比较(即直接跳过)
			continue;

		int has_WaitTime = cur_Time - Pro_Array[i].enter_Tim;	// 该进程已等待的时间
		double response_Ratio = 1 + (1.0 * has_WaitTime / Pro_Array[i].sev_Tim);	// 响应比计算公式

		if (response_Ratio > max_Pri_Rank)
		{
			max_Pri_Rank = response_Ratio;
			ind = i;
		}
	}
	return ind;
}
void HRN_Algorithm()		// 最高响应比优先算法 HRN (Highest Response Ratio Next)
{
	/* 输入模块 */
	int n;
	PCB* Pro_Array = NULL;
	Init(&n, Pro_Array, 0);

	/* HRN 算法设计模块 */
	int over_Job_Num = 0;
	int i = 0;	// 当前服务对象的下标
	int cur_Time = Pro_Array[i].enter_Tim;	// 当前时刻, 初始化为第一个进程的开始时刻
	while (over_Job_Num < n)
	{
		if (Pro_Array[i].finish_Flag == false)	// 当前进程还未服务完
		{
			int ind;
			ind = Find_Max_Response_Ratio_Pro(n, Pro_Array, cur_Time);	 // 找到最大响应比的进程(在已到达系统的进程中找)
			Pro_Array[ind].start_Tim = cur_Time;	// 开始时间
			Pro_Array[ind].finish_Flag = true;	// 处理完该进程
			over_Job_Num++;
			Pro_Array[ind].sev_Tim = 0;			// 该进程所要求的服务时间清零
			cur_Time += Pro_Array[ind].save_Sev_Tim;	// 当前时间向后推进
			Pro_Array[ind].over_Tim = cur_Time;	// 记录该进程的结束时间
		}
		i++;
		if (i == n)		// 设置循环
			i = 0;
	}

	/* 输出模块 */
	Print_Res(&n, Pro_Array);

	delete[] Pro_Array;
	return;
}

六、运行结果：

● 先来先服务算法(FCFS)：

在这里插入图片描述

● 最短作业优先算法(SJF)：

在这里插入图片描述

● 最高优先级优先(HPR)的验证(优先级越高，优先级数越大)：

在这里插入图片描述

● 最高响应比优先算法(HRN)：

在这里插入图片描述


(纯手敲，原创，可能存在未知 Bug，烦请指正…)

⭐️ ⭐️

C++编程实现进程调度算法（FCFS+RR）
Yuhan2001的CSDN博客
12-04 1万+
操作系统的课程实验，C++编程实现进程调度算法（FCFS和RR）
c++实现优先级调度算法（附带源码）
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
01-01 685
优先级调度算法是一种根据每个进程的优先级来决定执行顺序的调度算法。每个进程都有一个与之关联的优先级，优先级高的进程会先被执行。
进程调度算法
looken1024的博客
03-12 987
进程调度算法是操作系统的核心机制之一，负责在多个进程或线程之间分配 CPU 资源，确保系统高效、公平地运行。：静态优先级，需满足利用率上限（∑CiTi≤n(21/n−1)∑Ti​Ci​​≤n(21/n−1)）。：为每个进程分配固定时间片（Time Quantum），依次轮转执行。：平均等待时间长（护航效应，短进程可能被长进程阻塞）。：避免 SJF 的长进程饥饿问题，但需预知运行时间。：为每个进程分配优先级，优先执行高优先级进程。：需预知进程运行时间，可能导致长进程饥饿。
操作系统进程调度C++代码实现
05-25
目的: 在进程控制、请求分页存储器管理、设备管理基础上 实现按先来先服务 FCFS 、短作业优先 SJF 以及时间片 轮转算法调度进程的模拟过程 。 内容 1.在第 1 3 部分基础上扩展； 2.支持 FCFS 、短 作业优先以及时间片调度算法。 3.能够较方便地查看调度过程及平均周转时间、平均带权周转时 间。 4.支持优先权调度算法与其它算法相结合的调度模式。 5.调度时应适当输出调度过程中各进程状态队列的变化情况以及进程的已执行时 间、还需服务时间（针对时间片轮转算法）。 6.完成银行家算法的实现。
操作系统进程调度算法 C++
qq_31605553的博客
12-01 2623
操作系统 进程调度
进程调度模拟算法C++实现
06-03
在Vc6.0下实现的一个进程调度模拟算法，是我们操作系统课程的课设。里面有源码和文档报告。希望对大家有帮助。
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
热门推荐
Johana_C的博客
04-06 1万+
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
12-27
本文将深入探讨Java环境下实现的四种进程调度算法：先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)以及高响应比优先(HRN)。这些算法在多任务环境中用于决定哪个进程应该获得CPU的执行权，以达到资源分配的公平...
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,...
操作系统实验报告 C++实现进程调度算法，短进程优先SJF与先来先服务FCFS算法
12-02
操作系统实验报告 C++实现进程调度算法，短进程优先SJF与先来先服务FCFS算法 本实验报告的主要目的是通过C++语言实现短进程优先SJF和先来先服务FCFS两种进程调度算法，并比较它们的性能。 第一部分：实验目的 本...
计算机操作系统 - 实验二 - 进程调度算法的实现 - FCFS & SJF
12-02
3.实验内容与要求（模拟实现至少两种进程调度算法，以下以FCFS和SJF为例说明要求） (1)设计模拟实现先来先服务FCFS调度算法的高级语言程序 设计程序模拟进程的先来先服务FCFS调度过程。假设有n个进程分别在T1,… ,...
C++实现进程调度的算法
12-01
C++实现进程调度的算法
进程调度（C++版）
12-06
时间片轮转+优先级模拟CPU内部进程调度
进程调度的设计与实现代码C++
05-11
操作实验一：进程调度的设计与实现的源代代码C++，要的童鞋抱走
操作系统课程设计之进程调度源代码（六种调度算法 c++）
01-16
编写程序模拟进程调度过程，能够按照时间片轮转，短进程优先法，可抢占式和不可抢占式优先级法，以及先来先服务和高响应比优先法处理输入的数据，运行结果包含界面。
操作系统——进程调度算法（C++）.txt
11-28
https://blog.csdn.net/qq_45913057/article/details/109690121
进程调度算法 C++实现
ucler的博客
07-28 1427
操作系统模拟之进程调度算法。 文件共2份，其中1份cpp，1份.h，代码如下： main.cpp #include "init.h" int main() { printf("欢迎进入演示系统！\n"); printf("\n现在需要对进程数据初始化\n"); printf("通过键盘输入请输入1\n"); printf("通过构造函数直接生成请输入2\n"); int num_initialize; scanf("%d", &num_initialize); printf("\n"
C++实现进程调度算法（FCFS&RR&优先级调度&SJF）
学习者的博客
05-12 1362
文章根据已给条件（实验课老师给的）对进程调度算法进行分析，应用范围有限，但可以初步了解进程调度算法，由于本人学识浅薄，文章中难免有不足和错误之处，恳请读者批评指正。
基于C++实现的进程调度算法
毕业作品网站
06-15 3045
为了描述和管制进程的运行，系统为每个进程定义了一个数据结构一进程控制块，程控制块中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息,系统总是通过进程控制块对进程进行控制，亦即，系统是根据进程的进程控制块而不是任何别的什么而感知进程的存在的，进程控制块是进程存在的惟一标志。利用高级语言实现七种不同及进程调度算法：先来先服务调度算法，优先级调度算法，时间片轮转调度算法，短进程优先调度算法，最短剩余时间调度算法，最高响应比优先调度算法，多级反馈队列调度算法。
写个FCFS算法
最新发布
05-10
<think>好的，用户想要查找或获取关于FCFS算法的C++代码实现。首先，我需要回顾之前的对话历史，确保这次回答符合用户的需求。用户之前已经请求过FCFS的C++代码，并且我提供了详细的实现，现在用户可能希望得到更多的信息或不同的实现方式。 在之前的回答中，我给出了一个结构化的代码示例，包括进程结构体、排序函数、时间计算等。现在用户再次询问，可能需要更详细的解释或不同的实现方法。需要检查用户提供的引用内容，看看是否有可以补充的信息。引用1提到有FCFS、SJF、HPR、HRN等算法的实现，但用户现在只关注FCFS。引用2展示了输入函数的实现，用户可能在输入部分需要更清晰的指导。引用3提到了全局变量和调度逻辑，但用户可能对时间片或RR算法不感兴趣，所以应专注于FCFS。 接下来，用户可能希望代码更加模块化，比如将输入、计算、输出分开成函数，这样代码更易读。引用2中的输入函数使用了循环和结构体数组，这可能是一个改进点。我需要考虑是否在当前的代码示例中加入类似的函数结构。例如，将输入进程信息的部分单独作为一个函数，提高代码的可维护性。 另外，用户可能关心代码的注释和解释是否足够详细。之前的回答已经有代码说明，但可能需要更详细的步骤解释。例如，在计算等待时间和周转时间时，需要明确公式，并解释为什么这样计算。此外，用户可能对如何处理进程到达时间晚于当前时间的情况感兴趣，这在之前的代码示例中已经处理了，但可以进一步强调。 需要确保代码的正确性，比如进程按到达时间排序是否正确，时间计算是否准确。在之前的示例中，使用了sort函数和compareArrival比较函数，这是正确的。此外，计算开始时间时，如果当前时间小于进程到达时间，需要将当前时间更新为到达时间，这也是正确的处理方式。 用户可能还需要知道如何扩展代码，比如添加其他调度算法或比较不同算法的性能。但根据当前问题，应专注于FCFS的实现，避免引入不相关的信息。但可以在相关问题中提及这些扩展方向，帮助用户进一步学习。 还要注意代码的可运行性，确保没有语法错误。例如，检查输入输出是否正确，变量是否正确定义。在之前的代码中，结构体Process的成员变量正确，计算逻辑也没有问题。示例输入输出也展示了正确的运行结果，这有助于用户验证代码的正确性。 最后，用户可能需要了解FCFS的优缺点，这在相关问题中可以提到，比如平均等待时间可能较高，特别是在长进程先到达的情况下。同时，可以建议用户如何优化代码，比如使用更高效的数据结构，但FCFS本身不需要复杂的结构，保持简单即可。 总结来说，需要提供一个结构清晰、注释详细、模块化的FCFS算法实现，参考之前的代码并可能根据引用内容进行改进，同时确保解释充分，帮助用户理解每个步骤的作用和原理。</think>### FCFS算法C++代码实现详解 根据您提供的引用内容和历史记录，以下是FCFS算法的完整实现（含最新优化方案）： ```cpp #include <iostream> #include <vector> #include <algorithm> using namespace std; // 进程控制块结构体（引用[2]优化版） struct PCB { string name; // 进程名 int arrive_time; // 到达时间 int burst_time; // 执行时间 int start_time; // 开始时间 int finish_time; // 完成时间 int waiting_time; // 等待时间 int turnaround_time;// 周转时间 }; // 输入函数（引用[2]改进版） vector<PCB> inputProcesses() { int n; cout << "输入进程数量: "; cin >> n; vector<PCB> processes(n); for(int i=0; i<n; i++) { cout << "\n进程" << i+1 << "信息:" << endl; processes[i].name = "P" + to_string(i+1); cout << "到达时间: "; cin >> processes[i].arrive_time; cout << "执行时间: "; cin >> processes[i].burst_time; } return processes; } // FCFS核心算法（引用[1]流程图实现） void FCFS_Scheduler(vector<PCB>& processes) { sort(processes.begin(), processes.end(), [](const PCB& a, const PCB& b) { return a.arrive_time < b.arrive_time; }); int current_time = 0; for(auto& p : processes) { p.start_time = max(current_time, p.arrive_time); p.finish_time = p.start_time + p.burst_time; p.waiting_time = p.start_time - p.arrive_time; p.turnaround_time = p.finish_time - p.arrive_time; current_time = p.finish_time; } } // 输出函数（引用[3]显示优化） void printResults(const vector<PCB>& processes) { cout << "\n进程名\t到达\t执行\t开始\t完成\t等待\t周转\n"; for(const auto& p : processes) { cout << p.name << "\t" << p.arrive_time << "\t" << p.burst_time << "\t" << p.start_time << "\t" << p.finish_time << "\t" << p.waiting_time << "\t" << p.turnaround_time << endl; } } int main() { vector<PCB> processes = inputProcesses(); FCFS_Scheduler(processes); printResults(processes); // 计算平均值 float total_wait = 0, total_turn = 0; for(const auto& p : processes) { total_wait += p.waiting_time; total_turn += p.turnaround_time; } cout << "\n平均等待时间: " << total_wait/processes.size(); cout << "\n平均周转时间: " << total_turn/processes.size(); return 0; } ``` #### 关键改进说明（vs历史版本） 1. **模块化设计**：分离输入、算法、输出模块（参考引用[2]结构） 2. **进程命名优化**：自动生成P1/P2格式进程名 3. **Lambda表达式排序**：替代原compareArrival函数（C++11特性） 4. **时间计算优化**：使用`max(current_time, arrive_time)`处理进程等待 #### 执行示例 ```shell 输入进程数量: 3 进程1信息: 到达时间: 0 执行时间: 5 进程2信息: 到达时间: 2 执行时间: 3 进程3信息: 到达时间: 4 执行时间: 1 进程名 到达 执行 开始 完成 等待 周转 P1 0 5 0 5 0 5 P2 2 3 5 8 3 6 P3 4 1 8 9 4 5 平均等待时间: 2.33333 平均周转时间: 5.33333 ``` #### 算法特征分析 1. **非抢占式**：进程一旦开始执行直至完成 2. **公平性**：严格按到达顺序处理 3. **时间复杂度**：排序$O(n \log n)$ + 调度$O(n)$ ### 进阶学习建议 若要实现引用[1]中的多算法对比，可添加算法选择接口： ```cpp enum SchedulingAlgorithm { FCFS, SJF, HRN }; void scheduler(vector<PCB>& procs, SchedulingAlgorithm algo) { switch(algo) { case FCFS: /* 实现 */ break; case SJF: /* 添加 */ break; case HRN: /* 添加 */ break; } } ``` --相关问题--: 1. FCFS算法在哪些场景下会产生饥饿现象？ 2. 如何扩展此代码实现多级队列调度？ 3. FCFS与轮转调度算法的性能差异如何量化？[^1][^2]
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一支王同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值