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

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

✅ (原创，库存，第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，烦请指正…)

⭐️ ⭐️

一支王同学
关注
  • 66
    点赞
  • 踩
  • 431
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 22
    评论
专栏目录
C++编程实现进程调度算法（FCFS+RR）
Yuhan2001的CSDN博客
12-04 1万+
操作系统的课程实验，C++编程实现进程调度算法（FCFS和RR）
进程调度模拟算法C++实现
06-03
在Vc6.0下实现的一个进程调度模拟算法，是我们操作系统课程的课设。里面有源码和文档报告。希望对大家有帮助。
C++实现进程调度算法（FCFS&RR&优先级调度&SJF）
学习者的博客
05-12 873
文章根据已给条件（实验课老师给的）对进程调度算法进行分析，应用范围有限，但可以初步了解进程调度算法，由于本人学识浅薄，文章中难免有不足和错误之处，恳请读者批评指正。
操作系统代码实验（进程调度算法）
qq_59675202的博客
11-12 208
(algo == 'r'llalgo =='R))//这个对RR不适应!if(run->needtine < run->round)// 当剩余时间小于时间片轮转时间时的情况。if(run->needtime == 0){// 当run结束时放入finish队列里。if(flag){//执行完如果不是剩一一个的话，就把run放到队尾。//当ready列里只有 -个时做标记。//run每次运行ready的队头。//当ready剩-个时做标记。if(i == 1)/*按顺序插入到ready链表中*/
操作系统课程设计——进程调度（附c++代码）
最新发布
qq_34066926的博客
07-03 1089
进程调度是操作系统中的一项关键功能，负责决定在什么时间由哪个进程使用CPU。调度的目标是提高系统效率和用户满意度。在本次课程设计中，涉及三种典型进程调度算法：非抢占短进程优先（NPSPP）算法、可抢占优先权调度（PPSA）算法以及多级反馈队列（MLFQ）调度算法。
操作系统进程调度C++代码实现
05-25
目的: 在进程控制、请求分页存储器管理、设备管理基础上 实现按先来先服务 FCFS 、短作业优先 SJF 以及时间片 轮转算法调度进程的模拟过程 。 内容 1.在第 1 3 部分基础上扩展； 2.支持 FCFS 、短 作业优先以及时间片调度算法。 3.能够较方便地查看调度过程及平均周转时间、平均带权周转时 间。 4.支持优先权调度算法与其它算法相结合的调度模式。 5.调度时应适当输出调度过程中各进程状态队列的变化情况以及进程的已执行时 间、还需服务时间（针对时间片轮转算法）。 6.完成银行家算法的实现。
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
Johana_C的博客
04-06 1万+
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
C++实现进程调度的算法
12-01
C++实现进程调度的算法
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,...
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
01-01
本文将深入探讨Java环境下实现的四种进程调度算法：先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)以及高响应比优先(HRN)。这些算法在多任务环境中用于决定哪个进程应该获得CPU的执行权，以达到资源分配的公平...
FCFS和SJF进程调度算法实验报告
07-19
FCFS（First-Come, First-Served，先来先服务）和SJF（Shortest Job First，最短作业优先）是两种常见的进程调度算法，在操作系统中用于决定如何为多个进程分配处理器时间。这两种算法在处理多任务环境时具有不同的...
进程调度（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++实现进程调度的模拟
04-22
利用c++模拟进程的调度。模拟操作系统内核对进程的控制和管理：包括进程的创建和撤销、进程状态的切换和简单的内存空间管理。  能够模拟进程的创建与撤销过程；（4 分）  对进程的状态进行全面的控制；（4 分）  按先进先出方式管理就绪和阻塞队列，按队列输出进程状态 （2 分）  完成可变分区的分配与回收 （3 分）  界面清晰友好 （2 分）  实验结束后撰写实验报告（5 分）。
OS.rar_FCFS SJF_OS RR算法_fcfs_sjf_rr_进程调度 FCFS_进程调度算法
09-22
本资料包“OS.rar”涵盖了三种常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR），这些都是操作系统课程中的重点内容。 **先来先服务（FCFS）**是最简单的调度算法，按照进程到达的...
基于C++实现的进程调度算法
毕业作品网站
06-15 2770
为了描述和管制进程的运行，系统为每个进程定义了一个数据结构一进程控制块，程控制块中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息,系统总是通过进程控制块对进程进行控制，亦即，系统是根据进程的进程控制块而不是任何别的什么而感知进程的存在的，进程控制块是进程存在的惟一标志。利用高级语言实现七种不同及进程调度算法：先来先服务调度算法，优先级调度算法，时间片轮转调度算法，短进程优先调度算法，最短剩余时间调度算法，最高响应比优先调度算法，多级反馈队列调度算法。
几个常用的操作系统进程调度算法
热门推荐
luyafei_89430的专栏
10-23 7万+
一、先来先服务和短作业(进程)优先调度算法 1．先来先服务调度算法 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一支王同学

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

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

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

打赏作者

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

抵扣说明：

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

余额充值