进程调度--FCFS,SPN,RR算法的实现

最新推荐文章于 2023-10-13 00:15:58 发布
最新推荐文章于 2023-10-13 00:15:58 发布
阅读量1w 收藏 37
点赞数 5
分类专栏： 算法与数据结构 C/C++ 操作系统 文章标签： 操作系统 进程调度 FCFS SPN RR
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wh921021/article/details/8923208
版权

实现操作系统的主要进程调度算法：先来先服务(FCFS)算法，短进程优先(SPN)算法和时间片轮转(RR)算法。


(1)先来先服务调度算法（FCFS）

该算法采用非剥夺策略，算法按照进程提交或进程变为就绪状态的先后次序，分派 CPU。当前进程占用CPU，直到执行完或阻塞，才出让CPU（非抢占方式）。在进程唤醒后（如I/O 完成），并不立即恢复执行，通常等到当前进程出让CPU。这是最简单的调度算法，比较有利于长进程，而不利于短进程，有利于CPU 繁忙的进程，而不利于I/O 繁忙的进程。


(2)短进程优先调度算法（SPN）

该算法也采用非剥夺策略，对预计执行时间短的进程优先分派处理机。通常后来的短进程不抢先正在执行的进程。相比FCFS 算法，该算法可改善平均周转时间和平均带权周转时间，缩短进程的等待时间，提高系统的吞吐量。缺点是对长进程非常不利，可能长时间得不到执行，且未能依据进程的紧迫程度来划分执行的优先级，以及难以准确估计进程的执行时间，从而影响调度性能。


(3)时间片轮转算法（RR）

该算法采用剥夺策略。让就绪进程以FCFS 的方式按时间片轮流使用CPU 的调度方式，即将系统中所有的就绪进程按照FCFS 原则，排成一个队列，每次调度时将CPU 分派给队首进程，让其执行一个时间片，时间片的长度从几个ms 到几百ms。在一个时间片结束时，发生时钟中断，调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程，进程可以未使用完一个时间片，就出让CPU（如阻塞）。时间片轮转调度算法的特点是简单易行、平均响应时间短，但不利于处理紧急作业。在时间片轮转算法中，时间片的大小对系统性能的影响很大，因此时间片的大小应选择恰当。


使用C语言实现FCFS,SPN,RR算法：

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

//先来先服务，最短作业优先算法结构体
typedef struct process_FCFS
{
	char name;			//进程名
	float arrivetime;	//到达时间
	float servetime;	//服务时间
	float finishtime;	//完成时间
	float roundtime;	//周转时间
	float daiquantime;	//带权周转时间
	struct process_FCFS *link;//结构体指针

}FCFS; 

//时间片轮转算法结构体
typedef struct stud
{
	char name;		//进程名
	float arrive;	//进程到达时间
	float run;		//进程运行时间
	float rest;		//运行进程剩余时间
	char *state;	//进程状态
	struct stud *next;	//结构体指针
}stud;

FCFS *p,*q,*head=NULL;

struct process_FCFS a[100];
float avrRoundtime;//平均周转时间
float avrDaiquantime;//平均带权周转时间

FCFS initial(struct process_FCFS a[],int n);
void print(struct process_FCFS a[],int n);
void Fcfs(struct process_FCFS a[],int n);	//FCFS算法
void SPN(struct process_FCFS a[],int n);	//SPN算法
struct process_FCFS *sortarrivetime(struct process_FCFS a[],int n);	//到达时间冒泡排序
struct process_FCFS *sortservetime(struct process_FCFS a[],int n);	//服务时间冒泡排序

struct stud *create(int &a);	//初始化创建时间片轮转算法调度队列
void RR(struct stud *head, int &a);	//时间片轮转RR算法

//按到达时间进行冒泡排序
struct process_FCFS *sortarrivetime(struct process_FCFS a[],int n)
{
	int i,j;
	struct process_FCFS t;
	int flag;
	for(i=1;i<n;i++)
	{
		flag=0;
		for(j=0;j<n-i;j++)
		{
			if(a[j].arrivetime>a[j+1].arrivetime)	//将到达时间短的交换到前边
			{
				t=a[j];
				a[j]=a[j+1];
				a[j+1]=t;
				flag=1;//交换
			}
		}
		if(flag==0)//如果一趟排序中没发生任何交换，则排序结束	
		{
			break;
		}
	}
	return a;	//返回排序后进程数组
}

//按服务时间进行冒泡排序
struct process_FCFS *sortservetime(struct process_FCFS a[],int n)
{
	int i,j;
	struct process_FCFS t;
	int flag;
	for(i=1;i<n;i++)
	{
		flag=0;
		for(j=1;j<n-i;j++)
		{
			if(a[j].servetime>a[j+1].servetime)	//将到达时间短的交换到前边
			{
				t=a[j];
				a[j]=a[j+1];
				a[j+1]=t;
				flag=1;//交换
			}
		}
		if(flag==0)//如果一趟排序中没发生任何交换，则排序结束
		{
			break;
		}
	}
	return a;	//返回排序后进程数组
}


//先来先服务算法
void Fcfs(struct process_FCFS a[],int n,float &t1, float &t2)
{
	int i;
	a[0].finishtime=a[0].arrivetime+a[0].servetime;	//完成时间=到达时间-服务时间
	a[0].roundtime=a[0].finishtime-a[0].arrivetime;	//周转时间=完成时间-提交时间
	a[0].daiquantime=a[0].roundtime/a[0].servetime;	//带权时间=周转时间/服务时间
	for(i=1;i<n;i++)
	{
		if(a[i].arrivetime<a[i-1].finishtime)	//当前到达时间在上一个作业结束时间之前
		{
			a[i].finishtime=a[i-1].finishtime+a[i].servetime;	//完成时间=上一个完成时间+服务时间
			a[i].roundtime=a[i].finishtime-a[i].arrivetime;		//周转时间=完成时间-到达时间
			a[i].daiquantime=a[i].roundtime/a[i].servetime;		//带权时间=周转时间/服务时间
		}
		else	//当前到达时间在上一个作业结束时间之后
		{
			a[i].finishtime=a[i].arrivetime+a[i].servetime;
			a[i].roundtime=a[i].finishtime-a[i].arrivetime;
			a[i].daiquantime=a[i].roundtime/a[i].servetime;
		}

	}
	for(int i=0;i<n;i++)
	{
		printf("进程名：%c",a[i].name);
		printf("到达时间：%f",a[i].arrivetime);
		printf("服务时间：%f",a[i].servetime);
		printf("完成时间：%f",a[i].finishtime);
		printf("周转时间：%f",a[i].roundtime);
		printf("带权周转时间：%f",a[i].daiquantime);
		printf("\n");
		t1 += a[i].roundtime;
		t2 += a[i].daiquantime;
	}
}

//短作业优先算法
void SPN(struct process_FCFS a[],int n,float &t1, float &t2)
{
	int i;

	a[0].finishtime=a[0].arrivetime+a[0].servetime;	//完成时间=到达时间-服务时间
	a[0].roundtime=a[0].finishtime-a[0].arrivetime;	//周转时间=完成时间-提交时间
	a[0].daiquantime=a[0].roundtime/a[0].servetime;	//带权时间=周转时间/服务时间

	for(i=1;i<n;i++)
	{
		if(a[i].arrivetime<a[i-1].finishtime)	//当前到达时间在上一个作业结束时间之前
		{
			a[i].finishtime=a[i-1].finishtime+a[i].servetime;	//完成时间=上一个完成时间+服务时间
			a[i].roundtime=a[i].finishtime-a[i].arrivetime;		//周转时间=完成时间-到达时间
			a[i].daiquantime=a[i].roundtime/a[i].servetime;		//带权时间=周转时间/服务时间
		}
		else	//当前到达时间在上一个作业结束时间之后
		{
			a[i].finishtime=a[i].arrivetime+a[i].servetime;
			a[i].roundtime=a[i].finishtime-a[i].arrivetime;
			a[i].daiquantime=a[i].roundtime/a[i].servetime;
		}

	}
	for(int i=0;i<n;i++)
	{
		printf("进程名：%c",a[i].name);
		printf("到达时间：%f",a[i].arrivetime);
		printf("服务时间：%f",a[i].servetime);
		printf("完成时间：%f",a[i].finishtime);
		printf("周转时间：%f",a[i].roundtime);
		printf("带权周转时间：%f",a[i].daiquantime);
		printf("\n");
		t1 += a[i].roundtime;
		t2 += a[i].daiquantime;
	}
}

//打印输出函数
void print(struct process_FCFS a[],int n)
{
	int i;

	for(i=0;i<n;i++)
	{
		printf("进程名：%c",a[i].name);
		printf("到达时间：%f",a[i].arrivetime);
		printf("服务时间：%f",a[i].servetime);
		printf("完成时间：%f",a[i].finishtime);
		printf("周转时间：%f",a[i].roundtime);
		printf("带权周转时间：%f",a[i].daiquantime);
		printf("\n");
	}

}

//初始化创建调度队列
struct stud *create(int &a)
{
	int i;
	struct stud *head, *rear,*p,*q,*t;
	head=rear=NULL;

	for(i=0;i<a;i++)
	{
		p=(struct stud*)malloc(sizeof(struct stud));

		printf("%d 进程名: ",i+1);
		scanf("%s",&p->name);
		printf("到达时间：");
		scanf("%f",&p->arrive);
		printf("服务时间：");
		scanf("%f",&p->run);

		p->rest = p->run;
		p->state = "ready";		 	 	     	    
		if(rear == NULL)
		{
			head = p;
			p->next = NULL;
			rear = p;
		}
		else
		{
			t = NULL;
			q = head;
			while(q && q->arrive < p->arrive)
			{
				t = q;
				q = q->next;
			}

			if(q == head)
			{
				p->next = head;
				head = p;
			}
			else if(t == rear)
			{
				rear->next = p;
				p->next = NULL;
				rear = p;
			}
			else
			{
				t->next = p;
				p->next = q;
			}
		}

	}
	return head;

}

//时间片轮转算法
void RR(struct stud *head, int &a)
{
	struct stud *p,*t,*r;
	float slice = 0.0f;
	float temp = 0.0f;	//缓存最后一个正数rest
	float m1 = 0.0f , m2 = 0.0f, n1 = 0.0f, n2 = 0.0f;
	float sum_zhouzhuan = 0.0f, sum_daiquan = 0.0f;	//所有进程总周转时间，所有进程总带权周转时间
	float zhouzhuan = 0.0f, daiquan = 0.0f;	//周转时间，带权周转时间
	float avr_zhouzhuan = 0.0f, avr_daiquan = 0.0f;
	printf("请输入时间块大小: ");
	scanf("%f",&slice);
	while(head != NULL)	//队列非空，循环
	{
		r = p = head;
		while(p != NULL)	//遍历队列，结束后跳出当前循环
		{
			t = head;	
			m1 += slice;
			temp = p->rest;
			p->rest = p->rest - slice;	//剩余时间                    

			p->state = "running";	
			if(p->rest <= 0)
			{
				m1 = m1 - slice + temp;		//进程完成时间
				zhouzhuan = m1 - p->arrive;		//进程周转时间
				daiquan = zhouzhuan / (p->run);	//进程带权周转时间
				sum_zhouzhuan += zhouzhuan;				//所有进程周转时间之和
				sum_daiquan += daiquan;
				p->rest = 0;
			}
			printf("\n-----------------------------------------------\n");
			printf("name\tarrive\trun\trest\tstate\n");
			while(t != NULL)
			{
				printf("%d\t%f\t%f\t%f\t%s\n",t->name,t->arrive,t->run,t->rest,t->state);
				t = t->next;
			}
			if(p->rest == 0)/*判断是否删除结点*/
			{ 

				//finishtime += 
				if(p == head)/*删除头结点*/
				{
					head = p->next;
					free(p);
					p = head;
				}
				else
				{
					r->next = p->next;
					p = r->next;
					r = p;
				}
			}
			else 
			{
				r = p;
				p->state = "ready";	 	 
				p = p->next;
			}
		}   	
	}
	printf("\n总周转时间： ");
	printf("%f", sum_zhouzhuan);
	printf("\n总带权周转时间： ");
	printf("%f\n", sum_daiquan);

	avr_zhouzhuan = sum_zhouzhuan / a;
	avr_daiquan = sum_daiquan / a;

	printf("\n平均周转时间： ");
	printf("%f",avr_zhouzhuan);
	printf("\n平均带权周转时间： ");
	printf("%f\n",avr_daiquan);
}


//主函数
void main()
{
	float t1 = 0.0f;	//总周转时间
	float t2 = 0.0f;	//总带权周转时间
	float avr_t1 = 0.0f;	//平均周转时间
	float avr_t2 = 0.0f;	//平均带权周转时间

	int n,i;
	char select = ' ';	//选择算法变量标识
	while (select != 'e' && select != 'E')	//不为退出标识，保持循环
	{
		printf("请选择算法：\na.先来先服务算法\nb.短作业优先算法\nc.时间片轮转算法\ne.退出程序\n输入选择字符标号:  ");
		scanf("%c",&select);
		if (select == 'a' || select == 'A')	//先来先服务算法
		{
			printf("\n\n=================先来先服务算法================\n\n");
			printf("请输入进程数：");
			scanf("%d",&n);
			for(i=0;i<n;i++)
			{
				printf("%d 进程名: ",i+1);
				scanf("%s",&a[i].name);
				printf("到达时间：");
				scanf("%f",&a[i].arrivetime);
				printf("服务时间：");
				scanf("%f",&a[i].servetime);
			}

			sortarrivetime(a, n);	//冒泡排序
			Fcfs(a,n,t1,t2);	//先来先服务算法
			avr_t1 = t1 / n;
			avr_t2 = t2 / n;
			printf("\n");
			printf("平均周转时间为：%f \n", avr_t1);
			printf("平均带权周转时间为：%f \n", avr_t2);
		}

		else if (select == 'b' || select == 'B')	//短作业优先算法
		{
			printf("\n\n=================短作业优先算法================\n\n");

			printf("请输入进程数：");
			scanf("%d",&n);
			for(i=0;i<n;i++)
			{
				printf("%d 进程名: ",i+1);
				scanf("%s",&a[i].name);
				printf("到达时间：");
				scanf("%f",&a[i].arrivetime);
				printf("服务时间：");
				scanf("%f",&a[i].servetime);
			}
			sortservetime(a, n);	//冒泡排序
			SPN(a,n,t1,t2);	//短作业优先算法
			avr_t1 = t1 / n;
			avr_t2 = t2 / n;
			printf("\n");
			printf("平均周转时间为：%f \n", avr_t1);
			printf("平均带权周转时间为：%f \n", avr_t2);
			
		}

		else if (select == 'c' || select == 'C')	//时间片轮转算法
		{
			printf("\n\n=================时间片轮转算法================\n\n");
			int a;
			printf("请输入进程数: ");
			scanf("%d",&a);
			struct stud *head;
			head = create(a);
			RR(head, a) ;  
		}

	}
	system("pause");
}


HugoWen
关注
  • 5
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
12-27
Java平台下的四种进程调度算法的模拟实现，代码精简，内有详细注释，看不懂随时call我。原来的代码有些问题，这个已改正，原来删不掉，没办法，再发了一个，原来下载过的可以直接问我要。
C/C++实现操作系统进程调度算法，FCFS, RR, SPN, SRT, HRRN
crazybobo1207的博客
10-02 690
进程信息定义在方法InitProcedureInfo中，包括：procedureID（进程ID）, arriveTime（进程到达时间）, serviceTime（服务时间）, eclapsedTime（已服务时间）, remainTime（剩余服务时间）, accumulateTime（累计服务时间）。本程序的优点在于，一旦实现了其中一个调度算法，比如实现了最基本的FCFS之后，只要增加一个排序逻辑，即在重载
动态演示操作系统进程调度算法，FCFS, RR, SPN, SRT, HRRN
最新发布
crazybobo1207的博客
10-13 176
定义一个定时器Timer，然后把之前的代码都放到这个Timer里，每隔0.1秒钟执行。部分代码如下，俺是C和C++混用，比如用时候用#define定义符号常量，没用const定义常量。这次改成了动态演示，使用了上古神器MFC（微软基础类库）来做界面-_-#怎么发不了视频，视频要审核？-_- 只能发两个截图。
c语言实现fcfs,rr_1,spn,srt4种调度算法（无数据结构）
prayer的博客
06-04 6490
先科普一下四种算法的含义（个人理解）： FCFS:非剥夺式，意思很明显，先到达就先执行 RR_1：轮转调度算法，时间片为1，在当前时间点或之前到达的，按照顺序一个程序执行一次 SPN:最短进程优先，非剥夺式，当前到达的进程中服务时间最短的优先执行 SRT:剥夺式,最短剩余服务时间优先，当前时间点，选择最短剩余服务时间的进程执行 这里以5个进程为例： （进程名：到达时间：服务时间
【操作系统】 先来先服务算法和短作业优先算法实现
温婉月亮
11-27 4272
【操作系统】 先来先服务算法和短作业优先算法实现 介绍: 1.先来先服务 (FCFS: first come first service) 如果早就绪的进程排在就绪队列的前面，迟就绪的进程排在就绪队列的后面，那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之首的那个进程调度到运行状态。也就说，它只考虑进程进入就绪队列的先后，而不考虑它的下一个CPU周期的长短及其他因素。FCFS算法简单易行，是一种非抢占式策略，但性能却不大好。 简单来说，先来先服务就是那个
判断一个进程是否在执行中
weixin_30650859的博客
06-27 164
有些时候需要些 php 定时脚本，但是必须保证服务器中每次只有一个该进程在执行中，所以可以采用如下方法来判断上一个进程是否在执行中 /** * @Purpose : 判断该进程是否在执行中，保证每一次只有一个 test.php 进程在进行 * @Method Name : whetherPorcessIsExecuting() * @...
C语言判断当前某一个进程是否存在
极客点儿
07-13 5557
#include #include #include #include #include #include #include #define BUFSZ 150 void err_quit(char *msg); int main(int argc, char *argv[]) { FILE* fp; int co
操作系统的调度算法
YangYoung_的博客
07-14 845
1、FCFS：先来先服务算法，顾名思义，谁先来就运行谁。是非抢占式的。 2、时间片轮转：给定一个时间来运行这个进程，时间到了切换，因为有时间限制，所以是抢占式的。 3、最短进程优先：(SPN)：进程谁的时间短谁就先运行，但是是非抢占式的，后面加入了最短时间剩余：（SRT），变成了抢占式的调度算法。 ...
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程...要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间和等待时间，并且计算所有进程的平均周转时间，带权平均周转时间和平均等待时间。
单处理器进程调度算法实现FCFS,RR,SPN,SRT,HRRN
11-14
单处理器进程调度算法实现FCFS,RR,SPN,SRT,HRRN,使用C++实现
操作系统概念：进程调度算法（FCFS、RR）C++实现
02-21
实现了FCFS及RR调度算法； 随机生成进程到达时间、IO请求时间、IO操作时间； 能输出进程平均等待时间及平均周转时间； 完整的vs2010工程； 注释得当； 字符形式表示进程调度过程； 请尊重原创，如有问题，欢迎大家与我探讨。
操作系统调度算法（c语言实现）
11-02
操作系统调度算法——先来先工作调度算法和短作业调度算法
进程调度和作业调度算法C语言实现
04-13
操作系统os进程调度，作业调度以及请求分页系统的实现，其中进程调度涉及FCFS算法，时间片轮转法以及多级反馈队列实现。作业调度涉及FCFS以及短作业优先等。有源代码以及文档解释
FCFS计算周转时间、带权周转时间、平均周转时间和平均带权周转时间。
Yurken的博客
06-07 8481
#include<stdio.h> #include<string.h> #include<conio.h> main() { char pn[10][10],t[10]; int arr[10],bur[10],star[10],finish[10],tat[10],wt[10],i,j,n,temp; int totwt=0,tottat=0; //clrscr(); printf("请输入进程数量:"); scanf("%d"
操作系统进程调度算法图解（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）
热门推荐
光羽住一
01-21 9万+
决策模式 决策模式说明选择函数在执行的瞬间的处理方式，通常分为以下两类： 非抢占：一旦进入运行状态，就不会终止直到运行结束。 抢占：当前正在运行的进程可以被打断，并转移到就绪态。  一个调度算法是否能抢占，对进程的顺序有着极大的影响。 先来先服务FCFS   先来先服务是最简单的策略，也成为先进先出FIFO。首先它是一个非抢占的。如字面的意思，它根据进程到达时间决定先运行哪一个进程。
操作系统笔记6——进程调度
FandonMark的博客
07-26 1173
多道程序系统中，进程数量往往大于处理器的数量，故进程会争用处理机。处理机调度的目标是以满足系统目标的方式通过特定算法决定进程是否执行、在哪一个或者多个处理器上运行。调度决定了哪个进程需要等待哪个进程可以继续运行，有一定的时间和计算能力开销，并且会影响系统的性能。
操作系统概论（4）--进程调度
Sunjihang_123的博客
10-24 865
进程调度：如何分配CPU。（自行回顾进程调度状态图的三模态、五模态） 1.引起进程调度的时机 1）现运行进程运行结束或者因任务完成而正常结束，或者因出现错误而异常结束。 2）现运行进程因某种原因，比如I/O请求，从运行进出入阻塞状态。 3）现运行进程执行某种原语操作，如P操作、阻塞原语等，进入阻塞状态。 4）一个具有更
【调度】操作系统中调度算法（FCFS、RR、SPN（SJF）、SRT、HRRN）
bandaoyu的note
07-03 5100
决策模式 决策模式说明选择函数在执行的瞬间的处理方式，通常分为以下两类： 非抢占：一旦进入运行状态，就不会终止直到运行结束。 抢占：当前正在运行的进程可以被打断，并转移到就绪态。 一个调度算法是否能抢占，对进程的顺序有着极大的影响。 先来先服务FCFS 先来先服务是最简单的策略，也成为先进先出FIFO。首先它是一个非抢占的。如字面的意思，它根据进程到达时间决定先运行哪一个进程。 这里给出一个实际的例子。以表格的形式表现出在FIFO策略下各进程的情况。 简单说就是依次执行完成，从...
java语言实现有界面的FCFS进程调度算法
05-29
为了实现有界面的FCFS进程调度算法，我们需要使用Java语言编写一个图形用户界面（GUI）来模拟进程调度过程。以下是一个简单的实现： 1. 创建一个Java类来表示进程，包含以下属性： - 进程ID - 进程名称 - 进程状态...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值