操作系统实验——实现FCFS与SJF算法（C/C++）

最新推荐文章于 2024-07-17 23:24:38 发布
最新推荐文章于 2024-07-17 23:24:38 发布
阅读量456 收藏 9
点赞数 4
文章标签： 算法 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2203_75731003/article/details/133846113
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、FCFS算法思路与代码部分

二、SJF算法思路与代码部分

三、全部代码

前言

本文用于记录我的操作系统实验一 只用了c++的cout cin语句 基本都是c。

文中定义进程为一结构体（已知条件为到达时间cometime与服务时间servetime）：

typedef struct pcb
{
	char id;//进程id
	int cometime;//到达时间
	int servetime;//服务时间
	int starttime;//开始时间
	int endtime;//结束时间
	int cycletime;//周转时间
	float powertime;//带权周转时间
};

一、FCFS算法思路与代码部分

FCFS(First come first serve）即先到先服务，以到达时间为基准，哪个进程的到达时间小就先服务，不过对于第i+1个进程的到达时间在第i个进程的完成时间之前还是之后要进行分类讨论。

首先是按到达时间排序（小的在前）：

void sort_time(pcb p[], int n)//冒泡排序(按到达时间
{
	int i, j;
	pcb t;//中间变量
	for (i = 0; i < n - 1; i++)
	{
		for (j = i + 1; j <= n-1; j++)
			if (p[i].cometime > p[j].cometime)
			{
				t = p[i];
				p[i] = p[j];
				p[j] = t;
			}
	}
}

排完序后对于第一个到达的进程服务（即计算第一个进程的各种时间）：

    p[0].starttime = p[0].cometime;
	p[0].endtime = p[0].starttime + p[0].servetime;
	p[0].cycletime = p[0].endtime - p[0].cometime;
	p[0].powertime = (p[0].cycletime * 1.0) / (p[0].servetime * 1.0);

接着就是遍历p[1]到p[n-1]，进行分类讨论：

for (int i = 1; i <= n - 1; i++)
	{
        //若i-1还未完成时i就来了，则等待i-1完成
		if (p[i].cometime < p[i - 1].endtime)
			p[i].starttime = p[i - 1].endtime;
		else
        //i-1完成后经过一段空闲时间i来了，则直接服务
		{
            p[i].starttime = p[i].cometime;
		    p[i].endtime = p[i].starttime + p[i].servetime;
		    p[i].cycletime = p[i].endtime - p[i].cometime;
		    p[i].powertime = (p[i].cycletime * 1.0) / (p[i].servetime*1.0);
         }
	}

二、SJF算法思路与部分代码

SJF（short job first）短作业优先算法即在等待队列中谁的servetime短谁就先服务，若等待队列中没有进程则对下一个到达的进程服务。

我具体想法是先将所有进程中到达时间cometime最小的筛选出来与p[0]交换位置，

    int k = 0;
	pcb temp;
	//找到最小的come
	for (int i = 0; i < n; i++)
	{
		if (p[k].cometime > p[i].cometime)
			k = i;
	}
    //找到后放到p[0]位置便于后续操作
	temp = p[0];
	p[0] = p[k];
	p[k] = temp;

这个到达时间cometime最小的进程先服务

	p[0].starttime = p[0].cometime;
	p[0].endtime = p[0].starttime + p[0].servetime;
	p[0].cycletime = p[0].endtime - p[0].cometime;
	p[0].powertime = (p[0].cycletime * 1.0) / (p[0].servetime * 1.0);

然后将p[1]到p[n-1]按服务时间servetime进行排序

void sort_servetime(pcb p[], int n)//将进程按完成时间排序（冒泡）
{
	int i, j;
	pcb t;//中间变量
	for (i = 1; i < n - 1; i++)
	{
		for (j = i + 1; j <= n-1; j++)
			if (p[i].servetime > p[j].servetime)
			{
				t = p[i];
				p[i] = p[j];
				p[j] = t;
			}
	}
}

以上的为准备工作，接着设i为当前时刻服务完的进程，j为我们希望找到的下一个接受服务的进程（初值为i+1），对于每个i，遍历数组从i+1开始找寻j

	
    //tag=0标志着对于刚完成的第i个进程，等待队列中啥都没（剩下的进程都还没到）
    int tag = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = i + 1; j < n; j++)
		{
			//等待队列中第一个进程先服务
			if (p[j].cometime <= p[i].endtime)
			{
                //更新tag
				tag = 1;
				p[j].starttime = p[i].endtime;
				p[j].endtime = p[j].starttime + p[j].servetime;
				p[j].cycletime = p[j].endtime - p[j].cometime;
				p[j].powertime = (p[j].cycletime * 1.0) / (p[j].servetime * 1.0);
				//服务完后将进程往前移 利于后续操作
				temp = p[j];
				for (int k = j; k > i + 1; k--)
				{
					p[k] = p[k - 1];
				}
				p[i + 1] = temp;
				break;
				//若进程都不在等待 则谁先到达谁服务
				if (tag = 0)
				{
					int n = i;
					//找最小come
					for (int m = i + 1; i < n; i++)
					{
						if (p[n].cometime > p[i].cometime)
							n = i;
					}
					//此时n为最小come n服务
					p[n].starttime = p[n].cometime;
					p[n].endtime = p[n].starttime + p[n].servetime;
					p[n].cycletime = p[n].endtime - p[n].cometime;
					p[n].powertime = (p[n].cycletime * 1.0) / (p[n].servetime * 1.0);
					//服务完后将进程往前移 利于后续操作
					temp = p[n];
					for (int k = n; k > i + 1; k--)
					{
						p[k] = p[k - 1];
					}
					p[i + 1] = temp;
					break;
				}


			}
		}
	}

三、全部代码

#include <iostream>
using namespace std;
#include "stdio.h"
typedef struct pcb
{
	char id;//进程id
	int cometime;//到达时间
	int servetime;//服务时间
	int starttime;//开始时间
	int endtime;//结束时间
	int cycletime;//周转时间
	float powertime;//带权周转时间
};
void sort_time(pcb p[], int n)//冒泡排序(按时间
{
	int i, j;
	pcb t;//中间变量
	for (i = 0; i < n - 1; i++)
	{
		for (j = i + 1; j <= n-1; j++)
			if (p[i].cometime > p[j].cometime)
			{
				t = p[i];
				p[i] = p[j];
				p[j] = t;
			}
	}
}
void calculate(pcb p[], int n)//计算进程的各种时间
{
	p[0].starttime = p[0].cometime;
	p[0].endtime = p[0].starttime + p[0].servetime;
	p[0].cycletime = p[0].endtime - p[0].cometime;
	p[0].powertime = (p[0].cycletime * 1.0) / (p[0].servetime * 1.0);
	for (int i = 1; i <= n - 1; i++)
	{
		if (p[i].cometime < p[i - 1].endtime)
			p[i].starttime = p[i - 1].endtime;
		else
			p[i].starttime = p[i].cometime;
		p[i].endtime = p[i].starttime + p[i].servetime;
		p[i].cycletime = p[i].endtime - p[i].cometime;
		p[i].powertime = (p[i].cycletime * 1.0) / (p[i].servetime*1.0);
	}
}
void sort_servetime(pcb p[], int n)//将进程按完成时间排序
{
	int i, j;
	pcb t;//中间变量
	for (i = 1; i < n - 1; i++)
	{
		for (j = i + 1; j <= n-1; j++)
			if (p[i].servetime > p[j].servetime)
			{
				t = p[i];
				p[i] = p[j];
				p[j] = t;
			}
	}
}
void FCFS(pcb p[], int n)
{
	sort_time(p, n);//先将进程按到达时间排序
	calculate(p, n);//计算各种时间
}
void SJF(pcb p[], int n)
{

	int k = 0;
	pcb temp;
	//找到最小的come
	for (int i = 0; i < n; i++)
	{
		if (p[k].cometime > p[i].cometime)
			k = i;
	}
	temp = p[0];
	p[0] = p[k];
	p[k] = temp;
	sort_servetime(p, n);//先按serve时间排序
	//先服务
	p[0].starttime = p[0].cometime;
	p[0].endtime = p[0].starttime + p[0].servetime;
	p[0].cycletime = p[0].endtime - p[0].cometime;
	p[0].powertime = (p[0].cycletime * 1.0) / (p[0].servetime * 1.0);
	int tag = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = i + 1; j < n; j++)
		{
			//等待队列中第一个进程先服务
			if (p[j].cometime <= p[i].endtime)
			{
				tag = 1;
				p[j].starttime = p[i].endtime;
				p[j].endtime = p[j].starttime + p[j].servetime;
				p[j].cycletime = p[j].endtime - p[j].cometime;
				p[j].powertime = (p[j].cycletime * 1.0) / (p[j].servetime * 1.0);
				//服务完后将进程往前移
				temp = p[j];
				for (int k = j; k > i + 1; k--)
				{
					p[k] = p[k - 1];
				}
				p[i + 1] = temp;
				break;
				//若进程都不在等待 则谁先到达谁服务
				if (tag = 0)
				{
					int n = i;
					//找最小come
					for (int m = i + 1; i < n; i++)
					{
						if (p[n].cometime > p[i].cometime)
							n = i;
					}
					//此时n为最小come n服务
					p[n].starttime = p[n].cometime;
					p[n].endtime = p[n].starttime + p[n].servetime;
					p[n].cycletime = p[n].endtime - p[n].cometime;
					p[n].powertime = (p[n].cycletime * 1.0) / (p[n].servetime * 1.0);
					//服务完后将进程往前移
					temp = p[n];
					for (int k = n; k > i + 1; k--)
					{
						p[k] = p[k - 1];
					}
					p[i + 1] = temp;
					break;
				}


			}
		}
	}
}
//打印算法模拟结果的函数
void print(pcb p[], int n)
{
	int i;
	double averruntime;
	double averdqzztime;
	int sum_runtime = 0;
	double  sum_dqzztime = 0.00;
	cout << "作业名\t\t到达时间\t运行时间\t完成时间\t周转时间\t带权周转时间\n";
	for (i = 0; i < n; i++)
	{
		cout << p[i].id << "\t\t" << p[i].cometime << "\t\t" << p[i].servetime << "\t\t" << p[i].endtime << "\t\t" << p[i].cycletime << "\t\t" << p[i].powertime << endl;

		sum_runtime = sum_runtime + p[i].cycletime;
		sum_dqzztime = sum_dqzztime + p[i].powertime;
	}
	averruntime = sum_runtime * 1.0 / n;
	averdqzztime = sum_dqzztime * 1.000 / n;
	cout << "平均周转时间:" << averruntime << endl;
	cout << "平均带权周转时间:" << averdqzztime << endl;
	cout << endl;
}

void main()
{
	
		pcb p[50];
		int n, i;

		cout << "输入作业个数:";
		cin >> n;
		cout << "输入每个作业的作业名,到达时间,服务时间:\n";
		for (i = 0; i < n; i++)
		{
			cin >> p[i].id;
			cin >> p[i].cometime;
			cin >>p[i].servetime;
		}
		cout << endl;
		cout << "初始值：" << endl;
		cout << "作业名\t\t到达系统时间\t运行时间" << endl;
		for (i = 0; i < n; i++)
		{
			cout << p[i].id << "\t\t" << p[i].cometime << "\t\t" << p[i].servetime << endl;
		}

		cout << endl;
		FCFS(p, n);
		cout << "先来先服务（FCFS）算法运行结果：" << endl;
		SJF(p, n);
		cout << "SJF运行结果：" << endl;
		print(p, n);




}

nihaonihao123123
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统实验一——FCFS和SJF调度算法
风华正茂百花洲
07-10 2589
实验原理 实现FCFS和SJF调度算法，实验环境为VS2017 图解 SJF： FCFS： 源程序 #include <iostream> #include <string.h> using namespace std; typedef struct node{ char name[4]; float reachTime; float serverTime; float startTime; float finishTime; float crylingTime;
FCFS和SJF调度算法（C++）
12-21
计算机操作系统的调度算法。是txt文本格式的，经编译可用。
进程调度算法——C++实现 [ FCFS,SJF,HPR,HRN + 开源代码 + 详细解析 ]
Wang_Dou_Dou_的博客
04-18 1万+
关键词：运行结果图、进程调度算法、算法的设计思想、算法样例、完整代码 —— C++版本、先来先服务算法(FCFS)的流程图、最短作业优先算法(SJF)的流程图、最高优先级优先(HPR)的流程图、最高响应比优先算法(HRN)的流程图。
操作系统实验FCFS和短作业优先SJF调度算法模拟.pdf
06-03
操作系统实验FCFS和短作业优先SJF调度算法模拟.pdf
计算机操作系统学习之FCFS、SJF和HRRN调度算法
xhy123_的博客
11-22 7782
文章目录一.FCFS算法（先来先服务）二.SJF算法（短作业优先算法）1.不可抢占的情况（即SJF算法）2.可抢占的情况（最短剩余时间优先算法 即SRTN算法）3.优缺点4.补充三.HRRN算法（高响应比优先） 一.FCFS算法（先来先服务） 算法思想：主要从“公平”角度考虑 算法规则：按照作业/进程到达的先后顺序进行服务 用于作业/进程调度： 用于作业调度时，考虑的是哪个作业先到达后备队列； 用于进程调度时，考虑的是哪个进程先到达就绪队列。 是否可抢占：非抢占式的算法 是否会导致饥饿：不会导致饥饿 注：
FCFS调度算法（操作系统）先来先服务
m0_47642376的博客
08-09 2万+
FCFS调度算法(FCFS,First Come First Serve) 算法思想： 主要从“公平的角度考虑”（类似于我们生活中排队买东西） 算法规则： 按照作业/进程到达的先后顺序进行服务 用于作业/进程调度： 用于作业调度时，考虑的是哪个作业先到达后备队列；用于进程调度时，考虑的是哪个进程先到达就绪队列 非抢占式的算法 优缺： 公平、算法实现简单 缺点： 排在长作业（进程）后面的短作业需要等待很长时间，带权周转时间很大，对短作业来说用户体验不好。即，FCFS算法对长作业有利，对短作业不利 不会导致饥饿
操作系统-处理机调度详解（调度层次及FCFS、SPF、RR等算法）
热门推荐
关注网络安全、云原生安全
06-03 4万+
调度层次 1.高级调度（High Level Scheduling)高级调度又称长程调度或作业调度，它的调度对象是作业。主要功能是根据某种算法，决定将外存上处于后备队列中的哪几个作业调入内存，为它们创建进程、分配必要的资源，并将它们放入就绪队列。高级调度主要用于多道批处理系统中，而在分时和实时系统中不设置高级调度。 2.低级调度（Low Level Scheduling)低级调度又称为进程调度或短程调度，其所调度的对象是进程（或内核级线程）。其主要功能是，根据某种算法，决定就绪队列中的哪个进程应获得处理机
调度算法（一）
黄先生的博客
03-22 2604
综合考虑了等待时间和运行时间（要求服务时间） 等待时间相同时，要求服务时间短的优先（SJF 的优点） 要求服务时间相同时，等待时间长的优先（FCFS 的优点） 对于长作业来说，随着等待时间越来越久，其响应比也会 越来越大，从而避免了长作业饥饿的问题。：非抢占式的调度算法，只有当前运行的进程主动放弃CPU时（正常/异常完成，或主动阻塞），才需要进行调度，调度时计算所有就绪进程的响应比，选响应比最高的 进程上处理机。，计算各进程的等待时间、平均等待时间、周转时间、平均周转时间、带权周转时间、平均带权周转时间。
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,...
操作系统八大调度算法c/c++实现
01-22
本主题将详细探讨操作系统中的八大调度算法，并结合C/C++实现进行讲解。 1. **先来先服务（FCFS，First-Come First-Served）算法**：这是一种简单的调度策略，按照进程到达的顺序分配CPU。FCFS算法实现简单，但可能...
操作系统实验_FJFS_SJF算法
05-03
在这个“操作系统实验_FJFS_SJF算法”中，我们聚焦于操作系统中的调度算法，特别是先来先服务（FCFS）和短作业优先（SJF）两种策略。 FCFS调度算法是最简单的调度算法，它按照进程到达的先后顺序进行执行。这种算法...
fcfs&sjf;算法 c++
11-30
用C++编写的先来先服务和最短路径优先算法，经过修改，可以运行
FCFS先来先服务算法C++
alanmian的博客
05-02 1140
FCFS简单的讲就是先到达的先服务，比如A进程3秒到达，B进程2秒到达的话，那么就让B一直执行到满足它所需的服务时间。它是非抢占式的。**
操作系统之FCFS - 先来先服务算法
不知道你是通过何种途径访问到这里，总之欢迎来到red velet的博客
12-30 5321
先来先服务调度算法是最简单的调度方法，计算开始时间、完成时间、周转时间、带权周转时间、平均周转时间、平均带权周转时间
fcfs算法 c语言
mdjsmg的博客
04-01 439
操作系统——SJF算法
进程调度算法FCFS、SJF(SPF)、SRT、RR原理及代码实现
m0_52744273的博客
03-30 3113
使用c++实现四种常见的进程调度算法
fcfs调度算法_磁盘调度算法
weixin_39812577的博客
11-30 3673
常见的磁盘调度算法有：先来先服务（first-come first-serverd,FCFS）最短寻道时间优先（Shortest Seek Time First,SSTF）扫描算法（SCAN）1。先来先服务FCFS算法根据进程请求访问磁盘的先后顺序进行调度，这是一种最简单的调度算法。该算法的优点是具有公平性。如果只有少量进程需要访问，且大部分请求都是访问簇聚的文件扇区，则有望达到较好的性能；但如果...
磁盘调度算法(FCFS、SSTF)例题
Hardworking666的博客
12-19 2万+
一、原理 先来先服务(FCFS，first-come first-service)根据进程请求访问磁盘的先后次序进行调度。 最短寻道时间优先(SSTF，Shortest Seek Time First)选择访问的磁道与当前磁头所在的磁道距离最近的进程，以使每次的寻道时间最短。 二、例题 （一）若干个等待访问磁盘者依次要访问的柱面为20，44，40，4，80，12，76，移动臂当前位于40号柱面，请按下列算法分别计算为完成上述各次访问总共花费的寻找时间。 （1）先来先服务算法； （2）最短寻找时间优先算法。
排序算法(4)之快速排序(1)
最新发布
wer24_25的博客
07-17 1105
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值