【操作系统】c语言--进程调度算法(FCFS和SPN)

这篇具有很好参考价值的文章主要介绍了【操作系统】c语言--进程调度算法(FCFS和SPN)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

创作不易,本篇文章如果帮助到了你,还请点赞 关注支持一下♡>𖥦<)!!
主页专栏有更多知识,如有疑问欢迎大家指正讨论,共同进步!
🔥c++系列专栏:C/C++零基础到精通 🔥

给大家跳段街舞感谢支持!ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ

【操作系统】c语言--进程调度算法(FCFS和SPN),c语言,算法,开发语言,笔记,学习

c语言内容💖:

专栏:c语言之路重点知识整合

【c语言】全部知识点总结


一、先到先服务进程调度算法

先来先服务进程调度算法(FCFS)是按照进程到达的先后顺序进行调度的算法。

当一个进程到达时,它会被放到进程队列的末尾,并在前面等待其他进程执行完毕。

一旦轮到该进程执行,它会一直执行直到完成,或者被阻塞,或者需要等待I/O操作完成。

#include <stdlib.h>
#include <stdio.h>

typedef struct 
{   // 定义一个结构体,里面包含的有一个进程相关的信息
	char name[10];        //进程名称 (输入)
	float arrivetime;     //到达时间 (输入)
	float servicetime;    //服务时间 (输入)
	float starttime;      //开始时间
	float finishtime;     //结束时间
	float zztime;        //周转时间=finishtime-arrivetime
	float dqzztime;      //带权周转时间=zztime/servicetime
}pcb;


//输入进程信息
void input(pcb* p, int N)    //p为pdb数组名, N为pcb数组的元素个数
{
	int i;
	printf("\n");
	printf("请输入进程的名字  到达时间  服务时间:  (例如: 进程1 0 100)\n");
	for (i = 0; i <= N - 1; i++)
	{
		printf("请输入进程%d的信息:", i + 1);  // i=0时,输入第1个进程相关信息
		scanf("%s", &p[i].name);
		scanf("%f", &p[i].arrivetime);
		scanf("%f", &p[i].servicetime);
	}
}


//排序: 按照进程的arrivetime(从小到大)对pcb数组中的N个进程进行排序
void sort(pcb* p, int N)
{
	for (int i = 0; i < N - 1; i++)
	{
		for (int j = i + 1; j < N; j++)
		{
			if (p[i].arrivetime > p[j].arrivetime)
			{
				pcb temp;
				temp = p[i];
				p[i] = p[j];
				p[j] = temp;
			}
		}
	}
}


//运行
void run(pcb* p, int N)
{
	int k;
	for (k = 0; k <= N - 1; k++)
	{
		if (k == 0) //第1个进程
		{
			p[k].starttime = p[k].arrivetime; //第1个进程到达之后即可执行
			p[k].finishtime = p[k].starttime + p[k].servicetime;
		}
		else
		{
			p[k].starttime = (p[k - 1].finishtime >= p[k].arrivetime) ? p[k - 1].finishtime : p[k].arrivetime;
			p[k].finishtime = p[k].starttime + p[k].servicetime;

		}
	}

	for (k = 0; k <= N - 1; k++)
	{
		p[k].zztime = p[k].finishtime - p[k].arrivetime;
		p[k].dqzztime = p[k].zztime / p[k].servicetime;
	}
}


//显示
void Print(pcb* p, int N)
{
	int k;
	printf("调用先来先服务算法以后进程运行的顺序是: ");
	printf("%s", p[0].name); //首先运行第一个进程p[0]
	for (k = 1; k < N; k++)
	{
		printf("-->");
		printf("%s", p[k].name); //输出 -->p[k].name
	}

	printf("\n");
	printf("具体进程调度信息:\n");
	printf("进程名  到达时间  服务时间  开始时间  结束时间  周转时间  带权周转时间\n");
	for (k = 0; k <= N - 1; k++)
	{
		printf("%4s", p[k].name);
		printf("%10.3f", p[k].arrivetime);
		printf("%10.3f", p[k].servicetime);
		printf("%10.3f", p[k].starttime);
		printf("%10.3f", p[k].finishtime);
		printf("%10.3f", p[k].zztime);
		printf("%10.3f\n", p[k].dqzztime);
	}
}


//先来先服务算法FCFS
void FCFS(pcb* p, int N)
{
	sort(p, N);
	run(p, N);
	Print(p, N);
	int k;
	float Attime = 0; //平均周转时间
	float AQttime = 0; //平均带权周转时间
	for (k = 0; k <= N - 1; k++)
	{
		Attime += p[k].zztime;
		AQttime += p[k].dqzztime;
	}
	Attime = Attime / N;
	AQttime = AQttime / N;
	printf("调用先来先服务算法的平均周转时间为:");
	printf("%.3f\n", Attime);
	printf("调用先来先服务算法的平均带权周转时间为:");
	printf("%.3f\n", AQttime);
}

int main()
{
	pcb a[100]; //a为pcb数组   a[0]~a[N-1]对象第1个进程到第N个进程的信息
	int N;      //N为进程数目
	printf("\n");
	printf("\n");
	printf("<<----------先到先服务调度算法---------->>");
	printf("\n");
	printf("请输入进程数目:");
	scanf("%d", &N);
	input(a, N); //a是pcb数组名,N是实际使用数组元素个数
	FCFS(a, N); //fcfs模拟调度
	return 0;
}

【操作系统】c语言--进程调度算法(FCFS和SPN),c语言,算法,开发语言,笔记,学习

二、短进程优先调度算法

短进程优先调度算法(SPN)是根据进程执行时间短的优先级进行调度的算法。
当一个进程到达时,系统会估算其执行时间,如果短于当前正在执行的进程,那么该进程就会优先执行。如果有多个进程具有相同的最短执行时间,那么默认使用FCFS算法。

#include <stdlib.h>
#include <stdio.h>

//定义一个结构体:PCB

typedef struct{
char name[10];
float arrivetime;
float servicetime;
float starttime;
float finishtime;
float zztime;
float dqzztime;
}pcb;

 //***输入进程信息,将N个进程的信息写入pcb型数组***
void input(pcb *p,int N)
{
	int i;
	printf("\n");
	printf("请输入进程的名字  到达时间  服务时间:  (例如: a 0 100)\n");

	for(i=0; i <= N-1; i++)
	{
		printf("请输入进程%d的信息:", i+1);
		scanf("%s", &p[i].name);
		scanf("%f", &p[i].arrivetime);
		scanf("%f", &p[i].servicetime);
	}
}



 //***优先级排序***
void sort(pcb *p, int N)
{
	/*
	1、对pcb型数组中的元素进行一个简单的排序
	找到优先级最高的进程
	并把其他进程也进行简单排序,方便后续工作
	*/

	//排序: N次循环,每次找到从i到N-1中优先级最高的进程,放到p[i]
	for(int i=0;i<=N-1;i++)
	{
		//循环比较剩余的变量    //排序后:从0~N-1  arrivetime增加 , arrivetime相同时, servicetime短的优先
		for(int j=i+1;j<N;j++)
		{
			if(p[i].arrivetime>p[j].arrivetime || (p[i].arrivetime==p[j].arrivetime && p[i].servicetime>p[j].servicetime) )
			{
				//p[j]的优先级高于p[i],因此把p[j]放到p[i]
				pcb temp;
				temp = p[i];
				p[i] = p[j];
				p[j] = temp;
             }
		}
	}

	/*
	2、每个进程运行完成之后,找到当前时刻已经到达的最短进程
	P[0]优先级最高,p[0].finishtime=p[0].arrivetime+p[0].servicetime
	m!=0时:p[m].finishtime=p[m-1].finishtime+p[m].servicetime
	*/

	for(int m=0; m<N-1; m++)
	{
		if(m == 0)
			p[m].finishtime = p[m].arrivetime + p[m].servicetime;
		else
			p[m].finishtime = ((p[m-1].finishtime >= p[m].arrivetime)? p[m-1].finishtime: p[m].arrivetime) + p[m].servicetime;

		//(1)找到p[m].finishtime时刻哪些进程已经到达
		int i=0;  //i统计 p[m].finishtime时刻有几个进程已经到达
		//从下一个进程p[m+1]开始寻找
		for(int n = m+1; n <= N-1; n++)
		{
			if(p[n].arrivetime <= p[m].finishtime)
				i++;
			else
				break;

			    /*由于在第1步已经对进程按照到达时间进行了排序
			      故:当p[n].arrivetime > p[m].finishtime时,
				      说明p[n]进程和其后面的其他进程都未到达。
				i的值为p[m].finishtime时刻已经到达的进程数目。
			   */
		}

		//(2)找到p[m].finishtime时刻已经到达的最短进程
		float min = p[m+1].servicetime;   //next进程服务时间为p[m+1].servicetime (初值)
		int next = m+1;                   //next进程为m+1 (初值)
		//p[m+1]至p[m+i]这i个已到达进程中找到最短进程
		for(int k = m+1; k < m+i; k++)       //k为m+1 ~ m+i-1
		{
			//min的初值是p[m+1].servicetime, k+1为m+2 ~m+i
			if(p[k+1].servicetime < min)
			{
				min = p[k+1].servicetime;
				next = k+1;
			}
		}

		//(3)把最短进程放在p[m+1]进程处
		pcb temp;
		temp=p[m+1];
		p[m+1]=p[next];
		p[next]=temp;
	}
}






 //***运行***
void run(pcb *p, int N)
{
	int k;
	//计算各进程的开始时间和结束时间
	for(k=0; k <= N-1; k++)
     {
		if(k==0) //第1个进程
		{
			p[k].starttime = p[k].arrivetime; //第1个进程到达之后即可执行
			p[k].finishtime = p[k].starttime + p[k].servicetime;
		}
		else
		{
			p[k].starttime = (p[k-1].finishtime >= p[k].arrivetime)? p[k-1].finishtime: p[k].arrivetime;
			p[k].finishtime = p[k].starttime + p[k].servicetime;
		}
	}

	//计算各进程的周转时间和带权周转时间
	for(k=0; k<=N-1; k++)
	{
		p[k].zztime = p[k].finishtime - p[k].arrivetime;
		p[k].dqzztime = p[k].zztime / p[k].servicetime;
     }
}




//***显示***
void Print(pcb *p, int N)
{
	int k;
	printf("调用最短进程优先算法以后进程运行的顺序是: ");
	printf("%s",p[0].name);
	for(k=1;k<N;k++)
	{
		printf("-->");
		printf("%s", p[k].name);
	}

	printf("\n");
	printf("具体进程调度信息:\n");
	printf("进程名  到达时间  服务时间  开始时间  结束时间  周转时间  带权周转时间\n");
	for(k=0; k<=N-1; k++)
	{
		printf("%4s", p[k].name);
		//%m.nf:输出共占m列,其中有n位小数,如数值宽度小于m左端补空格
		printf("%10.3f", p[k].arrivetime);
		printf("%10.3f", p[k].servicetime);
		printf("%10.3f", p[k].starttime);
		printf("%10.3f", p[k].finishtime);
		printf("%10.3f", p[k].zztime);
		printf("%10.3f\n", p[k].dqzztime);
	}
}






 //***短进程优先***
void sjff(pcb *p,int N)
{
	sort(p, N);
	run(p, N);
	Print(p, N);
	int k;
	float Attime = 0; // 平均周转时间
	float AQttime = 0; //平均带权周转时间
	for(k=0; k<=N-1; k++)
     {
		Attime += p[k].zztime;
		AQttime += p[k].dqzztime;
     }
	Attime = Attime/N;
	AQttime = AQttime/N;
	printf("调用短进程优先算法的平均周转时间为:");
	printf("%.3f\n", Attime);
	printf("调用短进程优先算法的平均带权周转时间为:");
	printf("%.3f\n", AQttime);
}





//***主函数***
int main()
{
	//定义一个pcb型数组a
	pcb a[100];
	int N;  //进程数目
	printf("\n");
	printf("\n");
	printf("<<----------******短进程优先调度算法******---------->>");
	printf("\n");
	printf("输入进程数目:");
	scanf("%d", &N);
	input(a, N);
	sjff(a, N);
	return 0;
}

【操作系统】c语言--进程调度算法(FCFS和SPN),c语言,算法,开发语言,笔记,学习


【操作系统】c语言--进程调度算法(FCFS和SPN),c语言,算法,开发语言,笔记,学习文章来源地址https://www.toymoban.com/news/detail-525845.html

大家的点赞、收藏、关注将是我更新的最大动力! 欢迎留言或私信建议或问题。
大家的支持和反馈对我来说意义重大,我会继续不断努力提供有价值的内容!如果本文哪里有错误的地方还请大家多多指出(●'◡'●)

到了这里,关于【操作系统】c语言--进程调度算法(FCFS和SPN)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【操作系统】基于动态优先级的进程调度算法-C语言实现(有代码)

    本文章将会介绍如何编写动态优先级的进程调度算法,并使用从语言实现。 一、什么是动态优先级的调度算法        进程运行一个时间片后,如果进程已占用 CPU时间已达到所需要的运行时间,则撤消该进程;如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行

    2024年02月06日
    浏览(50)
  • 「 操作系统 」聊聊进程调度算法

    图文并茂!谈谈进程调度那些算法 Cone 进程调度/页面置换/磁盘调度算法 xiaolinCoding 图解经典的进程调度算法 飞天小牛肉 进程调度算法是操作系统中非常重要的一部分,它决定了操作系统中各个进程的执行顺序和时间片。在单核CPU下,任何时刻都只可能有一个程序在执行,比

    2024年02月04日
    浏览(59)
  • 【操作系统之进程调度算法习题】

    在一个具有三道作业的批处理系统中,作业调度采用先来先服务(FCFS) 调度算法,进程调度采用 短作业优先调度算法。现有如下所示的作业序列, 注意 1.具有三道作业的批处理系统指的是内存最多能有3个作业; 2.表格样式是考试时候的格式,练习时候也按这个格式练习各作业的周

    2024年02月11日
    浏览(46)
  • 操作系统实验—进程调度算法(java)

    目录 文章目录 前言 一、实验原理 二、实验步骤 1.创建PCB类 2.创建创建类 3.设计主窗口类 4.调度界面函数 5.算法类及其调度算法通用函数 6.进程调度算法函数 总结 操作系统实验1:进程调度算法,步骤3、4在一个类中,步骤5、6在一个类中。 (1)先到先服务调度算法:按照进程提

    2024年02月04日
    浏览(49)
  • 操作系统进程调度算法——先来先服务、时间片轮转、优先级调度算法

    (1)算法内容: 先来先服务调度算法是一种最简单的调度算法,可以应用于高级调度也可以运用于低级调度。高级调度时,FCFS调度算法按照作业进入后备作业队列的先后顺序选择作业进入内存,即先进入后备作业队列的作业被优先选择进入内存,然后为选中的作业创建进程

    2023年04月21日
    浏览(44)
  • 【操作系统】期末速成之计算题:进程调度算法

    先来先服务是非抢占式的算法 一个🌰 例题:各进程到达就绪队列的时间、需要的运行时间如下表所示。使用先来先服务调度算法,计算各进程的等待时间、平均等待时间、周转时间、平均周转时间、带权周转时间、平均带权周转时间。 进程 到达时间 运行时间 P1 0 7 P2 2 4

    2024年02月11日
    浏览(41)
  • 用代码模拟操作系统进程调度算法(Python)

     引言 近日,在学习完操作系统的进程调度部分后,我萌生了一个有趣的想法:通过编写代码来模拟进程调度算法,以加深自己对这一知识点的理解。于是,我花了一整天的时间投入到了这个突发奇想的实践中。  背景 进程调度是操作系统中的重要概念,它决定了如何合理地

    2024年02月06日
    浏览(55)
  • 计算机操作系统实验-进程调度模拟算法

    进程调度是处理机管理的核心内容。本实验要求用高级语言编写模拟进程调度程序,以 便加深理解有关进程控制快、进程队列等概念,并体会和了解优先数算法和时间片轮转算法 的具体实施办法。 1.设计进程控制块 PCB 的结构,通常应包括如下信息: 进程名、进程优先数(

    2024年02月05日
    浏览(73)
  • 操作系统:实验一:进程调度实验——最高优先数优先的调度算法以及先来先服务算法 源码

    一、实验目的 (1)了解进程实体PCB结构; (2)理解进程不同状态和状态之间的转换过程; (3)掌握优先数的调度算法和先来先服务算法; 二、实验内容与要求 设计一个有 N个进程共行的进程调度程序 四、实验步骤 (1)实验设计 进程调度算法: 采用最高优先数优先的调

    2024年02月06日
    浏览(45)
  • 操作系统有关进程调度算法(含先来先服务,短作业优先,优先级调度算法和时间片轮转调度算法)

    本文采用的进程调度算法有:先来先服务,短作业优先,优先级调度算法和时间片轮转调度算法。 针对这四种算法,我采用的是建立数组结构体,如: 先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。采用FCFS算法,每次从

    2024年02月03日
    浏览(61)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包