FCFS、RR、SPN、SRT、HRRN代码实现

最新推荐文章于 2023-07-05 21:08:13 发布
最新推荐文章于 2023-07-05 21:08:13 发布
阅读量1.2k 收藏 8
点赞数 1
分类专栏： OS 文章标签： 操作系统 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44124632/article/details/109325710
版权

1、FCFS

原理：在这里插入图片描述
代码：

void FCFS(int n[MAX_TASK][3], string pname[MAX_TASK], int num)
{
	int cyc_time[MAX_TASK] = { 0 };//轮转时间
	int fin_time[MAX_TASK] = { 0 };//完成时间
	int ser_time[MAX_TASK] = { 0 };//剩余时间
	for (int i = 0; i < num; i++)//初始化
	{
		ser_time[i] = n[i][1];
	}
	int pos = 0;//运行位置
	for (int i = 1;; i++)
	{
		ser_time[pos]--;
		if (ser_time[pos] == 0)
		{
			fin_time[pos] = i;
			cyc_time[pos] = fin_time[pos] - n[pos][0];
			pos++;
			if (pos == num)
				break;
		}
	}
	for (int i = 0; i < num; i++)
	{
		cout << pname[i] << " " << fin_time[i] << " " << cyc_time[i] << " " << (fin_time[i] - n[i][0] + 0.0) / n[i][1] << endl;;
	}
}

n[][0]为到达时间
n[][1]为需要的服务时间
n[][2]为是否完成
pname为名称
num为进程数量
下同

2、RR

原理：
在这里插入图片描述
代码：

void RR(int n[MAX_TASK][3], string pname[MAX_TASK], int num)
{
	int cyc_time[MAX_TASK] = { 0 };
	int fin_time[MAX_TASK] = { 0 };
	int ser_time[MAX_TASK] = { 0 };
	queue<int> iqueue;//轮转队列
	for (int i = 0; i < num; i++)
	{
		ser_time[i] = n[i][1];
	}
	int now = 0;//现有进程数
	for (int i = 0;; i++)
	{
		if (i == 0)//最初时加入第一个进程
		{
			iqueue.push(now);
			now++;
		}
		else
		{
			bool add = false;//判断是否有加入
			for (int j = 1; j < num; j++)
			{
				if (n[j][0] == i)//到达时间和现在的时间相等
				{
					add = true;
					ser_time[iqueue.front()]--;
					if (ser_time[iqueue.front()]==0)//判断是否完成
					{
						n[iqueue.front()][2] = -1;
						fin_time[iqueue.front()] = i;
						cyc_time[iqueue.front()] = fin_time[iqueue.front()] - n[iqueue.front()][0];
						iqueue.pop();
						iqueue.push(j);
					}
					else
					{
						int temp = iqueue.front();//记录队首
						iqueue.pop();//删除队首
						iqueue.push(j);//队列末放入新加入进程
						iqueue.push(temp);//放入从队首轮转回的进程
						now++;
					}
				}
			}
			if (add == false)//如果未添加
			{
				int temp = iqueue.front();
				ser_time[iqueue.front()]--;
				if (ser_time[iqueue.front()] == 0)
				{
					n[iqueue.front()][2] = -1;
					fin_time[iqueue.front()] = i;
					cyc_time[iqueue.front()] = fin_time[iqueue.front()] - n[iqueue.front()][0];
					iqueue.pop();
				}
				else
				{
					int temp = iqueue.front();
					iqueue.pop();
					iqueue.push(temp);
				}
			}
			
		}
		bool end = true;//判断是否结束
		for (int j = 0; j < num; j++)
		{
			if (ser_time[j] != 0)
			{
				end = false;
				break;
			}
		}
		if (end == true)
			break;
	}
	for (int i = 0; i < num; i++)
	{
		cout << pname[i] << " " << fin_time[i] << " " << cyc_time[i] << " " << (fin_time[i] - n[i][0] + 0.0) / n[i][1] << endl;;
	}
}

易错点：
当用完时间片的进程和新加入的进程在同一时间点进入时，新加入的进程排在用完时间片的进程之前

3、SPN

原理：
在这里插入图片描述
代码：

void SPN(int n[MAX_TASK][3], string pname[MAX_TASK], int num)
{
	int cyc_time[MAX_TASK] = { 0 };
	int fin_time[MAX_TASK] = { 0 };
	int ser_time[MAX_TASK] = { 0 };
	for (int i = 0; i < num; i++)
	{
		ser_time[i] = n[i][1];
	}
	int pos = 0;
	bool over = false;//判断上个进程是否运行结束
	for (int i = 1;; i++)
	{
		if (over == true || i == 1)//在上一个进程结束或是开始时把进程放入
		{
			int min = 0;//进程最短运行时间
			for (int j = 0; j < num; j++)
			{
				if (n[j][2] != -1)
				{
					min = n[j][1];
					pos = j;
					break;
				}
			}
			for (int j = 0; j < num; j++)
			{
				if (n[j][2] != -1 && n[j][1] < min && i > n[j][0])//在未结束且时间短且已经加入的情况下
				{
					pos = j;//调整位置
					min = n[j][1];
				}
			}
			over = false;
		}
		ser_time[pos]--;
		if (ser_time[pos] == 0)//进程结束
		{
			n[pos][2] = -1;
			fin_time[pos] = i;
			cyc_time[pos]=fin_time[pos] - n[pos][0];
			over = true;
		}
		bool judge = false;
		for (int j = 0; j < num; j++)
		{
			if (n[j][2] != -1)
			{
				judge = true;
				break;
			}
		}
		if (judge == false)
			break;
	}
	for (int i = 0; i < num; i++)
	{
		cout << pname[i] << " " << fin_time[i] << " " << cyc_time[i] << " " << (fin_time[i] - n[i][0] + 0.0) / n[i][1] << endl;;
	}
}

注意
为非抢占策略
需要记录进程是否运行完成

4、SRT

原理：
在这里插入图片描述
代码：

void SRT(int n[MAX_TASK][3], string pname[MAX_TASK], int num)
{
	int cyc_time[MAX_TASK] = { 0 };
	int fin_time[MAX_TASK] = { 0 };
	int ser_time[MAX_TASK] = { 0 };
	for (int i = 0; i < num; i++)
	{
		ser_time[i] = n[i][1];
	}
	int pos = 0;
	for (int i = 1;; i++)
	{
		int min = 0;
		for (int j = 0; j < num; j++)//首先把位置调整到第一个未完成的进程
		{
			if (n[j][2] != -1)
			{
				min = ser_time[j];
				pos = j;
				break;
			}
		}
		for (int j = 0; j < num; j++)//每个时间单位运行结束都需要重新进行判断
		{
			if (n[j][2] != -1 && ser_time[j] < min && i > n[j][0])
			{
				pos = j;
				min = ser_time[j];
			}
		}
		ser_time[pos]--;
		if (ser_time[pos] == 0)
		{
			n[pos][2] = -1;
			fin_time[pos] = i;
			cyc_time[pos] = fin_time[pos] - n[pos][0];
		}
		bool judge = false;
		for (int j = 0; j < num; j++)
		{
			if (n[j][2] != -1)
			{
				judge = true;
				break;
			}
		}
		if (judge == false)
			break;
	}
	for (int i = 0; i < num; i++)
	{
		cout << pname[i] << " " << fin_time[i] << " " << cyc_time[i] << " " << (fin_time[i] - n[i][0] + 0.0) / n[i][1] << endl;;
	}
}

5、HRRN

原理：
在这里插入图片描述
代码：

void HRRN(int n[MAX_TASK][3], string pname[MAX_TASK], int num)
{
	int cyc_time[MAX_TASK] = { 0 };
	int fin_time[MAX_TASK] = { 0 };
	int ser_time[MAX_TASK] = { 0 };
	int wai_time[MAX_TASK] = { 0 };//记录等待时间
	double max = 0;
	for (int i = 0; i < num; i++)
	{
		ser_time[i] = n[i][1];
	}
	double response[MAX_TASK];
	int pos = 0;
	bool over = false;
	for (int i = 1;; i++)
	{
		if (over == true || i == 1)//非抢占型
			{
				for (int j = 0; j < num; j++)
				{
					if (n[j][2] != -1)
					{
						max = (wai_time[j] + n[j][1]) / n[j][1];
						pos = j;
						break;
					}
				}
			for (int j = 0; j < num; j++)
			{
				if (n[j][2] != -1 && ((wai_time[j] + n[j][1]) / n[j][1]) > max&& i >= n[j][0])
				{
					pos = j;
					max = (wai_time[j] + n[j][1]) / n[j][1];
				}
				over = false;
			}
		}
		ser_time[pos]--;
		for (int j = 0; j < num; j++)//其余所有到达进程等待时间加一
		{
			if (n[j][2] != -1 && j != pos && i >= n[j][0])
				wai_time[j]++;
		}
		if (ser_time[pos] == 0)
		{
			n[pos][2] = -1;
			fin_time[pos] = i;
			cyc_time[pos] = fin_time[pos] - n[pos][0];
			over = true;
		}
		bool judge = false;
		for (int j = 0; j < num; j++)
		{
			if (n[j][2] != -1)
			{
				judge = true;
				break;
			}
		}
		if (judge == false)
			break;
	}
	for (int i = 0; i < num; i++)
	{
		cout << pname[i] << " " << fin_time[i] << " " << cyc_time[i] << " " << (fin_time[i] - n[i][0] + 0.0) / n[i][1] << endl;;
	}
}

为非抢占式

6、主函数

int main()
{
	int num;//进程数
	string pname[MAX_TASK] = { };//进程名称
	int time[MAX_TASK][3] = {}; 
	string method; //算法名称

	cin >> num; //获取进程数
	for (int i = 0; i < num; i++)//获取每个进程信息
	{
		cin >> pname[i];
		cin >> time[i][0];
		cin >> time[i][1];
	}
	cin >> method; //获取算法名称

	if (method=="FCFS")
	{
		FCFS(time, pname, num);
	}
	else if (method == "RR")
	{
		RR(time, pname, num);
	}
	else if (method == "SPN")
	{
		SPN(time, pname, num);
	}
	else if (method == "SRT")
	{
		SRT(time, pname, num);
	}
	else if (method == "HRRN")
	{
		HRRN(time, pname, num);
	}

		return 0;
}

7、输入输出样例

在这里插入图片描述
在这里插入图片描述

菜鸡骞
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python代码实现HRRN服务
m0_74234482的博客
04-25 95
可以看到，按照HRRN服务的顺序，进程的开始时间、结束时间、等待时间和响应比都被正确计算出来了。# 计算每个进程的结束时间、等待时间和响应比。# 按照开始时间排序。
Python实战——实现进程调度算法：先来先服务（FCFS）、短作业优先（SJF）和动态最高优先数优先（HRRN）
qq_44883083的博客
06-24 1万+
Python实战——实现进程调度算法：FCFS、SJF和HRRN 实验要求 进程调度算法：采用先来先服务、短作业、动态最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）。 每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息： 进程名—进程标示数 ID 优先数 PRIORITY 优先数越大优先权越高（仅HRRN） 到达时间—进程的到达时间为进程输入的时间。、 进程还需...
进程调度（优先级调度）-----编程模拟实现HRRN调度算法。
代码不会敲的博客
04-15 2001
编程模拟实现HRRN（高响应比优先）调度算法。
操作系统之调度算法
一枝会思想的芦苇的博客
07-28 720
目录1. 比较调度算法的准则2. 调度算法2.1 先来先服务算法（FCFS）2.2 短进程优先算法（SPN）2.3 最高响应比优先算法2.4 最短剩余时间优先算法（SRT）2.5 时间片轮转算法2.6 优先级调度算法2.7 多级队列算法2.8 多级反馈队列算法2.9 公平共享调度算法 1. 比较调度算法的准则 CPU 使用率：CPU 处于忙状态的时间百分比 吞吐量：单位时间内完成的进程数量 周转...
操作系统进程调度算法图解（FCFS、轮转、SPN、SRT、HRRN、反馈）
haoshen's blog
10-24 2万+
FCFS: 先来先服务，也可以称为先进先出 轮转： 以一个周期性间隔产生时钟中断，此时当前正在运行的进程被置于就绪队列，基于FCFS选择下一个就绪进程             运行。 SPN：最短进程优先，下一次选择所需处理时间最短的进程 SRT：最短剩余时间优先，总是选择预期剩余时间最短的进程 HRRN：最高响应比优先，R=(w+s)/s，其中R表示响应比，w表示已经等待的时间，s表示期
单处理器进程调度算法实现FCFS,RR,SPN,SRT,HRRN
11-14
本主题将详细探讨五种常见的进程调度算法：先来先服务（FCFS）、时间片轮转（RR）、短作业优先（SPN）、最短剩余时间优先（SRT）以及高响应比优先（HRRN）。所有这些算法都使用C++编程语言进行实现。 1. **先来先...
调度算法，FCFS、RR（q=1）、SPN、SRT、HRRN进行调度各进程的完成时间、周转时间、响应比的值。
10-28
随机给出一个进程调度实例，如： ...模拟进程调度，给出按照算法先来先服务FCFS、轮转RR（q=1）、最短进程优先SPN、最短剩余时间SRT、最高响应比优先HRRN进行调度各进程的完成时间、周转时间、响应比的值。
各种处理器调度算法实现
12-28
随机给出一个进程调度实例，如： ...模拟进程调度，给出按照算法先来先服务FCFS、轮转RR（q=1）、最短进程优先SPN、最短剩余时间SRT、最高响应比优先HRRN进行调度各进程的完成时间、周转时间、响应比的值。
操作系统课后题 课后作业 第三次作业 (2).docx
02-20
在问题 e 中，描述了五个进程的调度过程，使用了 FCFS、RR、SPN、SRT 和 HRRN 等算法。每个进程的周转时间和平均周转时间如下： | 进程 | 周转时间 | 平均周转时间 | | --- | --- | --- | | A | 45 min | 32.2 min ...
操作系统处理器调度实验报告及源码
12-30
模拟进程调度，给出按照算法先来先服务FCFS、轮转RR（q=1）、最短进程优先SPN、最短剩余时间SRT、最高响应比优先HRRN进行调度各进程的完成时间、周转时间、响应比的值。 实验报告（含流程图及运行结果）&源码
JAVA语言实现FCFS、SJF、HRRN三种算法进程调度
06-26
用JAVA来实现操作系统中FCFS、SJF、HRRN三种算法的进程调度
【调度】操作系统中调度算法（FCFS、RR、SPN（SJF）、SRT、HRRN）
bandaoyu的note
07-03 5567
决策模式 决策模式说明选择函数在执行的瞬间的处理方式，通常分为以下两类： 非抢占：一旦进入运行状态，就不会终止直到运行结束。 抢占：当前正在运行的进程可以被打断，并转移到就绪态。 一个调度算法是否能抢占，对进程的顺序有着极大的影响。 先来先服务FCFS 先来先服务是最简单的策略，也成为先进先出FIFO。首先它是一个非抢占的。如字面的意思，它根据进程到达时间决定先运行哪一个进程。 这里给出一个实际的例子。以表格的形式表现出在FIFO策略下各进程的情况。 简单说就是依次执行完成，从...
FCFS,HRRN,SPF,SRT,四种调度算法简单实现（C++版）
qq_44616044的博客
12-02 3068
1.数据 输入数据由三部分组成： 2.结构体 四种算法的数据组成是一样的，所以使用相同的结构体（全局变量在最后完整代码中） struct P { string name; //名称 int arrive,longg,start,endd,cyc;//到达时间，服务时间，开始时间，结束时间，周转时间 double qcyc;//平均周转时间 int id;//数据顺序 }p[10000]; 因为在调度中顺序会改变，所以要保留输入时的数据顺序，这样才能按原本顺序输出 3.FCF
【排序】：冒泡排序以及三种优化
HanSion.Z
06-27 4万+
冒泡排序（BubbleSort） 一般冒泡排序的写法 //假设排序arr[] = { 1, 3, 4, 2, 6, 7, 8, 0 }; void BubbleSort(int arr[],int len) { int i = 0; int tmp = 0; for (i = 0; i &amp;amp;lt; len - 1; i++)//确定排序趟数 { ...
【操作系统】c语言--进程调度算法(FCFS和SPN)
最新发布
努力让自己的能力配得上梦想.
07-05 1595
先到先服务进程调度算法 先来先服务进程调度算法（FCFS）是按照进程到达的先后顺序进行调度的算法。 当一个进程到达时，它会被放到进程队列的末尾，并在前面等待其他进程执行完毕。 一旦轮到该进程执行，它会一直执行直到完成，或者被阻塞，或者需要等待I/O操作完成。短进程优先调度算法 短进程优先调度算法（SPN）是根据进程执行时间短的优先级进行调度的算法。 当一个进程到达时，系统会估算其执行时间，如果短于当前正在执行的进程，那么该进程就会优先执行。如果有多个进程具有相同的最短执行时间，那么默认使用FCFS算法。
舵机控制3.17
m0_51503599的博客
03-17 1593
1.舵机控制 #include <Servo.h> Servo myservo; // 定义Servo对象来控制 int pos = 0; // 角度存储变量 void setup() { myservo.attach(9); // 控制线连接数字9 } void loop() { for (pos = 0; pos <= 180; pos ++) { // 0°到180° // in steps of 1 degree myservo.writ
操作系统中调度算法（FCFS、RR、SPN、SRT、HRRN）
热门推荐
光羽住一
01-21 9万+
决策模式 决策模式说明选择函数在执行的瞬间的处理方式，通常分为以下两类： 非抢占：一旦进入运行状态，就不会终止直到运行结束。 抢占：当前正在运行的进程可以被打断，并转移到就绪态。  一个调度算法是否能抢占，对进程的顺序有着极大的影响。 先来先服务FCFS   先来先服务是最简单的策略，也成为先进先出FIFO。首先它是一个非抢占的。如字面的意思，它根据进程到达时间决定先运行哪一个进程。
选择排序----详细算法分析
qq_45055426的博客
10-18 236
选择排序思路:找到乱序数组中最大元素的位置，再与乱序数组中最后一个元素位置交换,即算完成一次选择排序，再从剩下的数中找最大与剩下乱序数组中最后一个元素位置交换以此循环到排序结束 #include<stdio.h> #define N 6 //findMaxPos找数组中最大元素位置的函数 int findMaxPos(int arr[], int n) { int max = arr[0];//假设最大数为arr[0] int pos = 0;//pos表...
【C++提高编程笔记】三.(一).STL常用容器之string容器
计算机科研杂货铺
01-07 872
C++是一种计算机高级程序设计语言，由C语言扩展升级而产生，最早于1979年由本贾尼·斯特劳斯特卢普在AT&T贝尔工作室研发。C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计。C++拥有计算机运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值