纯c语言写先来先服务和时间片轮转这两个进程调度算法

最新推荐文章于 2023-05-29 21:45:41 发布
最新推荐文章于 2023-05-29 21:45:41 发布
阅读量3.2k 收藏 50
点赞数
分类专栏： os
原文链接：www.baidu.com
版权

主要参考链接：

代码绝大多数都是从网上拷下来再自己改了一点。本来想附上参考链接，但时间有点久，找不到主要参考的那个连接。

[声明]本文为转载是因为代码大多数都是网上copy的，然后自己也只是微调加实现过，个人认为不可以当原创。代码全部都贴上来了，txt文档的格式也贴了，也实现过，如果期间遇到困难，希望你们再去找其他的资料，问我的话我未必能答上来。

 

操作系统系列文章：

1.进程调度算法FCFS和RR

2.作业调度算法SJF和HRRN

3.动态分区分配算法的FirstFit和BestFit

4.银行家算法

 

主要的数据结构

struct PCB
{
    char name[10];    //进程名字
    int arrivetime;   //到达时间
    int servicetime;   //服务时间
    int finishtime;   //完成时刻
    int sc;  //sign completion标志是否完成
    int st1;  //剩余服务时间  
    int rtime;//周转时间 
    double drtime;
}*p;

PCB process[N];

static int n;//进程数 
static int T;//轮转时间片 

用到的函数

void input_fcfs(PCB *p);//将存在文档的数据录入到程序中
void input_rr(PCB *p);
void display_fcfs(PCB *p);
void display_rr(PCB *p);
void fcfs(PCB *process,int n);
void rr(PCB *process,int n);

核心算法

先来先服务

void fcfs(PCB *process,int n){
	int i,j;
    
	display_fcfs(process);
	for(i=1;i<=n;i++)
	 for(j=i+1;j<=n;j++)   //按照各进程到达时间升序，对进程排序 注意：稳定的排序  冒泡 
	{
		if(process[j].arrivetime<process[i].arrivetime) 
		{
			process[0]=process[j];            //0作为转换站 
			process[j]=process[i];
			process[i]=process[0];	
		}
	}
	
	//fcfs
	int time=process[1].arrivetime;      //当前时间的初值 
	int sum=0;					//记录完成的进程数 
	printf("\n第几次调度进程 运行进程名 开始运行时间 服务时间  完成时间  周转时间  带权周转时间\n");
	int z=1;   //记录第几次调度进程 
	
	for(i=1;i<=n;i++){
	   if(process[i].arrivetime>time)time=process[i].arrivetime;
	   time=time+process[i].servicetime;
	   process[i].rtime=time-process[i].arrivetime;
	   process[i].drtime=(double)process[i].rtime/process[i].servicetime; 
	   printf("%8d%12s%15d%11d%9d%9d%14.5f\n",z++,process[i].name,time-process[i].servicetime,process[i].servicetime,time,process[i].rtime,process[i].drtime); 
	}	
	
}

时间片轮转 

void rr(PCB *process,int n)
{
	int i,j; 
    display_rr(process);

	for(i=0;i<=n;i++)
	 for(j=i+1;j<=n;j++)   //按照各进程到达时间升序，对进程排序 注意：稳定的排序  冒泡 
	{
		if(process[j].arrivetime<process[i].arrivetime) 
		{
			process[0]=process[j];            //0作为转换站 
			process[j]=process[i];
			process[i]=process[0];	
		}
	}
	
	int time=process[1].arrivetime;      //当前时间的初值 
	int flag=1;
	int sum=0;					//记录完成的进程数 
	printf("\n第几次调度进程 运行进程名 开始运行时间 运行时间 剩余服务时间 结束时间  完成时间  周转时间  带权周转时间\n");
	int z=1;   //记录第几次调度进程 
	int aa=1;  //数组abc的储存变量 
	
while(sum<n)
{
	flag=0;	     //标志就绪队列中是否还有进程 
	
	for(i=1;i<=n;i++)    //时间片轮转法执行各进程 
	{
		if(process[i].sc==1) continue;  //已完成的进程 
		else
		 {
		 	if(process[i].st1<=T&&time>=process[i].arrivetime)//未完成的进程但是还需服务的时间少于等于一个时间片 
		 	{
		 	flag=1;
		 	time=time+process[i].st1;
		 	process[i].sc=1;
		 	process[i].finishtime=time;
            process[i].rtime=time-process[i].arrivetime;
            process[i].drtime=(double)process[i].rtime/process[i].servicetime; 
		 	printf("%8d%12s%15d%11d%11d%11d%9d%9d%14.5f\n",z++,process[i].name,time-process[i].st1,process[i].st1,0,time,time,process[i].rtime,process[i].drtime); 
		 	process[i].st1=0;
		    
		 	}
		 	
		 	else if(process[i].st1>T&&time>=process[i].arrivetime)//未完成的进程但其还需服务时间至少大于一个时间片 
		 	{
		 		flag=1;
		 		time=time+T;
				process[i].st1-=T;
				printf("%8d%12s%15d%11d%11d%11d\n",z++,process[i].name,time-T,T,process[i].st1,time);
			} 
			if(process[i].sc==1) sum++;     //一个进程执行完就+1 
		}
	}
	
	if(flag==0&&sum<n)   // 还有没执行的进程，且没进入就绪队列 
	{
	for(i=1;i<=n;i++)
	if(process[i].sc==0) {time=process[i].arrivetime;break;}
	}
}

}

 主函数（个人感觉指针p有点多余，可以直接用process。）

int main()
{

	int a;
	printf("进程调度算法：1.FCFS 2.RR 3.quit\n");
	scanf("%d",&a);
	while(a!=3){
	
	switch(a){
		case 1:
		printf("\t\t先来先服务调度算法\n");
        input_fcfs(process);
        p=process;
	    fcfs(p,n);
		break; 
		
		case 2:
		printf("\t\t时间片轮转调度算法\n");
        input_rr(process);
        p=process;
	    rr(p,n);
		break; 
		 
		case 3: 
		printf("end.\n");
		
		default:
		 break; 
	}
//    system("cls");
	printf("\n进程调度算法：1.fcfs 2.rr 3.quit\n");
	scanf("%d",&a);
}
	return 0;
}

测试数据的输入

源代码

#include<stdio.h>
#include <string.h>
#include <stdlib.h> 
#include <conio.h> 
#define N 50
struct PCB
{
    char name[10];    //进程名字
	int arrivetime;   //到达时间
	int servicetime;   //服务时间
	int finishtime;   //完成时刻
	int sc;  //sign completion标志是否完成
	int st1;  //剩余服务时间  
    int rtime;//周转时间 
	double drtime;
}*p;

PCB process[N];

static int n;//进程数 
static int T;//轮转时间片 

void input_fcfs(PCB *p);//将存在文档的数据录入到程序中
void input_rr(PCB *p);
void display_fcfs(PCB *p);
void display_rr(PCB *p);
void fcfs(PCB *process,int n);
void rr(PCB *process,int n);

void input_fcfs(PCB *p){
	int i;
	
	FILE *fp;
	fp=fopen("fcfs输入数据.txt","r");
	if(fp==NULL){
		exit(EXIT_FAILURE);
	}
	fscanf(fp,"%d",&n);
	for(i=1;i<=n;i++){
		fscanf(fp,"%s %d %d",&p[i].name,&p[i].arrivetime,&p[i].servicetime);
		p[i].sc=0;
	    p[i].st1=p[i].servicetime;
	}	
	
} 

void input_rr(PCB *p){
	int i;
	
	FILE *fp;
	fp=fopen("rr输入数据.txt","r");
	if(fp==NULL){
		exit(EXIT_FAILURE);
	}
	fscanf(fp,"%d",&T);
	fscanf(fp,"%d",&n);
	for(i=1;i<=n;i++){
		fscanf(fp,"%s %d %d",&p[i].name,&p[i].arrivetime,&p[i].servicetime);
		p[i].sc=0;
	    p[i].st1=p[i].servicetime;
	}	
	
}
 
void display_fcfs(PCB *p){
	printf("输入的数据：\n");
	printf("进程数：%d\n",n);
	printf("进程名 到达时间 服务时间\n");
	for(int i=1;i<=n;i++){
	printf("  %s      %2d       %2d\n",p[i].name,p[i].arrivetime,p[i].servicetime);
   }	
}

void display_rr(PCB *p){
	printf("输入的数据：\n");
	printf("时间片：%d\n",T);
	printf("进程数：%d\n",n);
	printf("进程名 到达时间 服务时间\n");
	for(int i=1;i<=n;i++){
	printf("  %s      %2d       %2d\n",p[i].name,p[i].arrivetime,p[i].servicetime);
   }
}


void fcfs(PCB *process,int n){
	int i,j;
    
	display_fcfs(process);
	for(i=1;i<=n;i++)
	 for(j=i+1;j<=n;j++)   //按照各进程到达时间升序，对进程排序 注意：稳定的排序  冒泡 
	{
		if(process[j].arrivetime<process[i].arrivetime) 
		{
			process[0]=process[j];            //0作为转换站 
			process[j]=process[i];
			process[i]=process[0];	
		}
	}
	
	//fcfs
	int time=process[1].arrivetime;      //当前时间的初值 
	int sum=0;					//记录完成的进程数 
	printf("\n第几次调度进程 运行进程名 开始运行时间 服务时间  完成时间  周转时间  带权周转时间\n");
	int z=1;   //记录第几次调度进程 
	
	for(i=1;i<=n;i++){
	   if(process[i].arrivetime>time)time=process[i].arrivetime;
	   time=time+process[i].servicetime;
	   process[i].rtime=time-process[i].arrivetime;
	   process[i].drtime=(double)process[i].rtime/process[i].servicetime; 
	   printf("%8d%12s%15d%11d%9d%9d%14.5f\n",z++,process[i].name,time-process[i].servicetime,process[i].servicetime,time,process[i].rtime,process[i].drtime); 
	}	
	
}
 
void rr(PCB *process,int n)
{
	int i,j; 
    display_rr(process);

	for(i=0;i<=n;i++)
	 for(j=i+1;j<=n;j++)   //按照各进程到达时间升序，对进程排序 注意：稳定的排序  冒泡 
	{
		if(process[j].arrivetime<process[i].arrivetime) 
		{
			process[0]=process[j];            //0作为转换站 
			process[j]=process[i];
			process[i]=process[0];	
		}
	}
	
	int time=process[1].arrivetime;      //当前时间的初值 
	int flag=1;
	int sum=0;					//记录完成的进程数 
	printf("\n第几次调度进程 运行进程名 开始运行时间 运行时间 剩余服务时间 结束时间  完成时间  周转时间  带权周转时间\n");
	int z=1;   //记录第几次调度进程 
	int aa=1;  //数组abc的储存变量 
	
while(sum<n)
{
	flag=0;	     //标志就绪队列中是否还有进程 
	
	for(i=1;i<=n;i++)    //时间片轮转法执行各进程 
	{
		if(process[i].sc==1) continue;  //已完成的进程 
		else
		 {
		 	if(process[i].st1<=T&&time>=process[i].arrivetime)//未完成的进程但是还需服务的时间少于等于一个时间片 
		 	{
		 	flag=1;
		 	time=time+process[i].st1;
		 	process[i].sc=1;
		 	process[i].finishtime=time;
            process[i].rtime=time-process[i].arrivetime;
            process[i].drtime=(double)process[i].rtime/process[i].servicetime; 
		 	printf("%8d%12s%15d%11d%11d%11d%9d%9d%14.5f\n",z++,process[i].name,time-process[i].st1,process[i].st1,0,time,time,process[i].rtime,process[i].drtime); 
		 	process[i].st1=0;
		    
		 	}
		 	
		 	else if(process[i].st1>T&&time>=process[i].arrivetime)//未完成的进程但其还需服务时间至少大于一个时间片 
		 	{
		 		flag=1;
		 		time=time+T;
				process[i].st1-=T;
				printf("%8d%12s%15d%11d%11d%11d\n",z++,process[i].name,time-T,T,process[i].st1,time);
			} 
			if(process[i].sc==1) sum++;     //一个进程执行完就+1 
		}
	}
	
	if(flag==0&&sum<n)   // 还有没执行的进程，且没进入就绪队列 
	{
	for(i=1;i<=n;i++)
	if(process[i].sc==0) {time=process[i].arrivetime;break;}
	}
}

}
 
int main()
{

	int a;
	printf("进程调度算法：1.FCFS 2.RR 3.quit\n");
	scanf("%d",&a);
	while(a!=3){
	
	switch(a){
		case 1:
		printf("\t\t先来先服务调度算法\n");
        input_fcfs(process);
        p=process;
	    fcfs(p,n);
		break; 
		
		case 2:
		printf("\t\t时间片轮转调度算法\n");
        input_rr(process);
        p=process;
	    rr(p,n);
		break; 
		 
		case 3: 
		printf("end.\n");
		
		default:
		 break; 
	}
//    system("cls");
	printf("\n进程调度算法：1.fcfs 2.rr 3.quit\n");
	scanf("%d",&a);
}
	return 0;
}

 实验截图

先来先服务的实验结果： 

时间片轮转的实验结果

 

 一个粗略的小结：相同的三个进程块，FCFS的平均带权周转时间为1/3(1+5+1)=2.33，RR的平均带权周转时间为1/3(4+1.2+1)=2.07。因此时间片轮转调度算法在一定条件下它的性能好过先来先服务算法。

就爱瞎逛
关注
  • 0
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
进程调度—时间片轮转和先来先服务
link-P
05-05 3682
1、先来先服务（first-come first-server） 它是最简单的非抢占式的进程调度算法，进程按照它们请求cpu的顺序使用cpu，当第一个作业从外部进入系统，就立即运行它所需要运行的时间。不会中断该作业。当其他作业进入时，它们就被安排到队列的尾部。当正在运行的进程被阻塞时，队列中的第一个进程接着运行。在被阻塞的进程重新变为就绪状态，排到队列的末尾，就像新来到的作业一样。 2、时间片...
优先级结合时间片轮转算法c语言,先来先服务/段作业优先/时间片轮转/优先级调度算法详解...
weixin_35020039的博客
05-24 1377
先来先服务调度算法先来先服务(First Come First Served,FCFS)，是一种简单的调度算法，它既适用于作业调度，也适用于进程调度。先来先服务算法是按照作业或进程到达的先后次序来进行调度。当作业调度中采用该算法时，每次调度都是从后备队列中选择一个最先进入该队列中作业，将它调入内存，为其创建进程、分配相应的资源，将该作业的进程放入就绪队列。在进程调度中采用该算法时，每次调度是从就绪...
优先级和时间片轮转调度实验算法（c语言）
05-17
进程调度算法有优先数调度算法，时间片轮转调度算法，分级调度算法。选两种种算法实现。进程调度算法的数据结构主要有：进程函数定义，建立进程函数，进程调度函数。
使用C语言二维数组实现进程调度，先来先服务和时间片轮转发
jinjin510623的博客
12-06 779
① 设计PCB及其数据结构： 进程标识数：ID 进程优先数：PRIORITY（优先数越大，优先级越高） 进程已占用时间片：CPUTIME，每得到一次调度，值加1； 进程还需占用时间片：ALLTIME，每得到一次调度，该值减1，一旦运行完毕，ALLTIME为0） 进程队列指针：NEXT，用来将PCB排成队列 进程状态：STATE（一般为就绪，可以不用） ② 设计进程就绪队列及数据结构； ③ 设计进程调度算法，并画出程序流程图； ④ 设计输入数据...
操作系统先来先服务算法、短作业优先算法、时间片轮转算法C语言模拟
weixin_63071173的博客
05-29 532
【代码】操作系统先来先服务算法、短作业优先算法、时间片轮转算法C语言模拟。
“时间片轮转”调度算法（C语言）
热门推荐
qq_51673383的博客
04-17 1万+
编写并调试一个模拟的进程调度程序，以加深对进程的概念及进程调度算法的理解． 1.调试运行“时间片轮转”调度算法，给出运行结果。 2.采用“时间片轮转”调度算法对进程进行调度。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已用CPU时间、进程状态等等 3.显示进程运行过程，以及进程的带权周转时间和系统的平均带权周转时间。。
操作系统进程调度算法：先来先服务，时间片轮转，优先级调度，短作业优先调度算法
weixin_45035564的博客
11-25 8381
实现四种不同及进程调度算法： 先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。 ////1、 算法流程 ////抽象数据类型的定义：PCB块结构体类型 //struct PCB //{ // int name; // int arrivetime; //到达时间 // int servicetime; //服务时间 // //int starttime[max]; //开始时间 // int finishtime; //完成/结束时间 // int turntime; //周转时间 // i.
进程调度时间片轮转c语言,时间片轮转调度算法的C语言模拟实现
weixin_30300857的博客
05-21 1750
时间片轮转调度是一种最古老，最简单，最公平且使用最广的算法。每个进程被分配一个时间段，称作它的时间片，即该进程允许运行的时间。如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。以下是C算法的模拟实现：#include#define MAX 10struct task_struct{char name[10]; ...
进程调度算法的C语言实现：先到先服务、短作业优先、优先级调度、时间片轮转.zip
最新发布
06-14
本压缩包中的内容涉及四种常见的进程调度算法的C语言实现，包括先到先服务（First-Come, First-Served, FCFS）、短作业优先（Shortest Job First, SJF）、优先级调度（Priority Scheduling）和时间片轮转（Round ...
c语言实现作业调度先来先服务和短进程优先,先来先服务和高响应比优先调度算法C语言实现...
weixin_39924329的博客
05-16 2461
先来先服务和高响应比优先调度算法C语言实现1、进程调度与作业调度的区别：作业调度：根据作业控制块(JCB)中的信息，检查系统中的资源是否满足作业对资源的需求，以及按照一定的调度算法，从外存的后备队列中选取某些作业调入内存，并为它们创建进程，分配必要的资源。然后再将新创建的进程排在就绪队列上等待调度。进程调度：保存当前进程的处理机的现场信息，如程序计数器、多个通用寄存器中的内容等，然后按某种算法从就...
进程调度 时间片轮转调度算法源代码（C语言）
12-18
进程调度 时间片轮转调度算法源代码（C语言）
编程进程或作业先来先服务、高优先权、按时间片轮转调度算法
11-25
在Windows等操作系统下，使用的VC、VB、java或C等编程语言，利用相应的WIN32 API函数，编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法
c++ 进程调度算法RR(时间片轮转算法）
06-21
用c++编写的进程调度算法 RR (时间片轮转算法），在VC6.0下运行，有需要的可以参考一下
C语言模拟单处理器时间片轮转调度算法
06-10
用C语言模拟单处理器时间片轮转调度算法 数据结构..pcb进程控制模块
优先级调度 时间片轮转 c语言
05-07
假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：
先来先服务算法实现（c语言）
cheshiyou4471的博客
12-01 1539
#include<stdio.h> #include<stdlib.h> typedef struct process_FCFS{ float arrivetime;//到达时间 float servetime;//服务时间 float finishtime;/...
c语言实现时间片轮转调度算法
spursping的博客
12-13 5200
#include <stdio.h>//引入输入输出流文件 #include <stdlib.h> struct PCB { int pid;//进程标识符 int rr;//已运行时间 int time;//进程要求运行时间 char sta;//进程的状态 struct PCB *next;//链接指针 }; struct PCB pcb1,pcb2,pcb3,pcb4,pcb5,*tail,*head,*rp; void init()//初始化各个进程的运行时间 { int t
时间片轮转法（c语言）
赵四司机的博客
08-16 6957
C语言实现调度策略中的时间片轮转法
C语言时间片轮转调度算法
weixin_51695739的博客
06-18 3270
输入进程数 选择时间片 再输入进程开始时间和运行时间就可以得到算法运行结果 #pragma warning(disable:4996) #include<stdio.h> #define MAX 10 struct task_struct { char name[10]; /*进程名称*/ float arrivetime; /*到达时间*/ float starttime; /*开始运行时间*/ float runtime;
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值