进程调度算法 C C++

最新推荐文章于 2024-05-17 19:31:17 发布
最新推荐文章于 2024-05-17 19:31:17 发布
阅读量2.3k 收藏 66
点赞数 9
分类专栏： 笔记 计算机操作系统 文章标签： 算法 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lushixuan12345/article/details/121002140
版权

进程调度算法 C C++

一、先来先服务

1.1 代码

#include <stdio.h>
#include <string.h>
double avg_TurnaroundTime;//平均周转时间
double AQTT;//平均带权周转时间
struct progress{
	char proName[80]; 
	int arriveTime;//到达时间
	int serviceTime;//服务时间
	//int flag;		//访问标志，未访问1，访问0
	int finishTime;//完成时间
	int cyclingTime;//周转时间
	double float_Wi;//带权周转时间
};

struct progress course[80];

//struct progress course[80]={{0,4},{1,3},{2,5},{3,2},{4,4}};
void health_Examine(int *courseNum)//输入合法性检查
{return;	}

void progressNum(int *courseNum)//进程数目
{int i=0;
	for(i=0; i<*courseNum;i++){
		printf("请输入第%d个进程的相应信息。\n", i+1);
		printf("请输入进程名:");
		scanf("%s", course[i].proName); 
		printf("请输入到达时间:");
		scanf("%d", &course[i].arriveTime); 
		printf("请输入服务时间:");
		scanf("%d", &course[i].serviceTime); }
	return;
}
 

void finish_Time(int *courseNum)//进程的完成时间
{int i=0;
	if(course[0].arriveTime != 0)//第一个进程的时间
	{course[0].finishTime=course[0].arriveTime + course[0].serviceTime; }
	course[0].finishTime=course[0].serviceTime;
	for(i=1; i<*courseNum; i++){
		if(course[i-1].finishTime >= course[i].arriveTime) {
			course[i].finishTime=course[i-1].finishTime + course[i].serviceTime;
		}else{
			course[i].finishTime=course[i].arriveTime + course[i].serviceTime;
		}
	}
return;
}
void cyclingTime(int *courseNum)//周转时间
{int i=0;
	for(i=0; i<*courseNum; i++)	{
		course[i].cyclingTime=course[i].finishTime - course[i].arriveTime;
	}
	return;
}
 
void float_Wi(int *courseNum)//带权周转时间
{int i=0;
	for(i=0; i<*courseNum; i++){
		course[i].float_Wi=(double)course[i].cyclingTime/course[i].serviceTime;
	}
	return;
}
 
void avgTurnaroundTime(int *courseNum)//平均周转时间
{	int i=0,sum_TurnaroundTime=0;
	for(i=0; i<*courseNum; i++){
		sum_TurnaroundTime += course[i].cyclingTime;
	}
	avg_TurnaroundTime=sum_TurnaroundTime/(*courseNum);
	return;
}
void _AQTT(int *courseNum)//平均带权周转时间
{int i=0;
	double sum_float_Wi=0;
	for(i=0; i<*courseNum; i++){
		sum_float_Wi += course[i].float_Wi;
	}
	AQTT=sum_float_Wi/(*courseNum);
	return;
}
 
void print_FIFO(int *courseNum)//输出进程相关的信息
{int i=0;
	printf("进程的相应信息。\n");
	printf("进程\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转\n");//
	for(i=0; i<*courseNum;i++)	{
		//printf("第%个进程的相应信息。\n", i+1);
	printf("%s\t    %d\t\t    %d\t\t    %d\t\t   %d\t\t   %.002lf\t\t\n", course[i].proName,course[i].arriveTime,	course[i].serviceTime,course[i].finishTime,course[i].cyclingTime,course[i].float_Wi);
		//putchar('\n');
	}
	printf("平均周转时间\t平均带权周转时间\n");
	printf("   %.002lf\t\t   %.002lf\n",avg_TurnaroundTime,AQTT);
	return;	
}
int main(){
	int courseNum=5;
	printf("请输入进程数：");
	scanf("%d", &courseNum);
	progressNum(&courseNum);//
	finish_Time(&courseNum);//进程的完成时间
	cyclingTime(&courseNum);//周转时间
	float_Wi(&courseNum);//带权周转时间
	avgTurnaroundTime(&courseNum);//平均周转时间
	_AQTT(&courseNum);//平均带权周转时间
	print_FIFO(&courseNum);// 
	return 0;
}

1.2 运行截图

在这里插入图片描述

二、短进程优先

2.1 代码

#include <stdlib.h>
#include <stdio.h>
 
//定义一个结构体：PCB
typedef struct PCB{   
	char processName[10]; //进程名
	float arriveTime; //到达时间  
	float serviceTime; //服务时间
	float startTime;   //开始执行时间
	float finishTime; //结束时间
	float turnroundTime;   //周转时间
	float weightedTurnaroundTime; //带权周转时间
}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].processName);	
		scanf("%f", &p[i].arriveTime);
		scanf("%f", &p[i].serviceTime);	 
	}   
}
   
//对服务先后优先级排序
void sort(pcb *p, int N)   
{   
	
	/*
	1、对pcb型数组中的元素进行一个简单的排序
	找到优先级最高的进程
	并把其他进程也进行简单排序，方便后续工作
	*/
	//排序: N次循环,每次找到从i到N-1中优先级最高的进程，放到p[i]
	int i,j,m,n,k;
	for(i=0;i<=N-1;i++)  
	{
		//循环比较剩余的变量    //排序后：从0~N-1  arriveTime增加 ， arriveTime相同时， serviceTime短的优先 
		for(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]优先级最高，
	for(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(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(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].turnroundTime = p[k].finishTime - p[k].arriveTime;   
		p[k].weightedTurnaroundTime = p[k].turnroundTime / p[k].serviceTime;   
     }   
}  
 
//打印结果
void Print(pcb *p, int N)   
{
	int k;      
	printf("\n调用最短进程优先算法以后进程运行的顺序是: ");
	printf("%s",p[0].processName); 
	for(k=1;k<N;k++)   
	{
		printf("-->");		
		printf("%s", p[k].processName); 
	}    
	printf("\n"); 
	printf("具体进程调度信息:\n");
	printf("进程名  到达时间  服务时间  开始时间  结束时间  周转时间  带权周转时间\n");
	for(k=0; k<=N-1; k++)        
	{	
		printf("%4s", p[k].processName);
		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].turnroundTime);
		printf("%10.3f\n", p[k].weightedTurnaroundTime);
	}         
}  
  
//短进程优先
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].turnroundTime;  
		AQTTime += p[k].weightedTurnaroundTime;		
     }  
	atTime = atTime/N; 
	AQTTime = AQTTime/N;
	printf("\n调用短进程优先算法的平均周转时间为:");
	printf("%.3f\n", atTime);
	printf("调用短进程优先算法的平均带权周转时间为:");
	printf("%.3f\n", AQTTime);      
}   
 

int main()   
{ 
	
	pcb a[50]; 
	int N;  //进程数目                    		
	printf("\n");                          			
	printf("\n");	
	printf("输入进程数目:");
	scanf("%d", &N);                 		
	input(a, N);  		
	sjff(a, N);
	return 0; 
}

2.2 运行截图

在这里插入图片描述

三、时间片轮转

3.1 代码

#include<stdio.h>
#define N 50
struct PCB
{
	int pn;   //process name进程名字
	int at;   //arrival time到达时间
	int st;   //service time服务时间
	int ct;   //completion time完成时刻
	int sc;  //sign completion标志是否完成
	int st1;  //剩余服务时间  
}process[N];
 
int sjp(int n)
{
	int i,j,T;
	printf("\n请输入时间片：\n");
	scanf("%d",&T);
	for(i=1;i<=n;i++)      //收集进程信息 
	{
		process[i].sc=0;
		printf("\n%d:\n请依次输入进程的信息\n请输入pn:",i);
		scanf("%d",&process[i].pn);
		printf("请输入at:");
		scanf("%d",&process[i].at);
		printf("请输入st:");
		scanf("%d",&process[i].st);
		process[i].st1=process[i].st;
	}
	for(i=1;i<=n;i++)
	for(j=i+1;j<=n;j++)   //按照各进程到达时间升序，对进程排序 注意：稳定的排序 
	{
		if(process[j].at<process[i].at)
		{
			process[0]=process[j];
			process[j]=process[i];
			process[i]=process[0];	
		}
	}
	//for(i=1;i<=n;i++)    //检查排序是否正确
	//printf("%d\t",process[i].pn);
	
	int time=process[1].at;      //当前时间的初值 
	int flag=1;
	int sum=0;					//记录完成的进程数 
	printf("\n第几次调度进程 运行的进程pn 开始运行时间 运行时间 剩余服务时间 结束时间\n");
	int z=1;   //记录第几次调度进程 
	
        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].at)//未完成的进程但是还需服务的时间少于等于一个时间片 
		 	{
		 	flag=1;
		 	time=time+process[i].st1;
		 	process[i].sc=1;
		 	process[i].ct=time;
		 	printf("%8d%12d%15d%11d%11d%11d\n",z++,process[i].pn,time-process[i].st1,process[i].st1,0,time); 
		 	process[i].st1=0;
		 	}
		 	
		 	else if(process[i].st1>T&&time>=process[i].at)//未完成的进程但其还需服务时间至少大于一个时间片 
		 	{
		 		flag=1;
		 		time=time+T;
				process[i].st1-=T;
				printf("%8d%12d%15d%11d%11d%11d\n",z++,process[i].pn,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].at;break;}
	}
    }
}
 
int main()
{
	int n;
	printf("\t\t时间片轮转调度算法\n");
	printf("请输入总进程数：\n");
	scanf("%d",&n);
	sjp(n);
	return 0;
}

3.2 运行截图

在这里插入图片描述

四、多级队列

擅长开发Bug的Mr.NaCl
关注
  • 9
    点赞
  • 踩
  • 66
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C/C++ 进程调度算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-29 5653
优点是能够灵活调整进程的执行顺序，缺点是可能出现优先级反转的问题，即低优先级的进程一直无法执行。优点是平均等待时间较短，缺点是无法预测作业的执行时间，可能出现长作业等待时间过长的情况，且容易受到“饥饿”现象影响。进程调度算法的实现原理是根据不同的调度策略和规则，按照一定的调度算法进行进程的选择和分配。进程调度算法是操作系统中的重要组成部分，其作用是决定进程在系统资源上的分配和调度顺序。用户需要输入时间片的大小和每个进程的执行时间，然后程序会按照时间片轮转的方式进行调度，输出每个进程的执行情况。
几种进程调度算法模拟C++实现
A_Bo的博客
06-05 1万+
先到先服务（FCFS）
操作系统-------进程调度算法(C++实现)
M_GSir的博客
11-10 6560
(1)    优先数法 进程就绪队列按优先数大小从高到低排列，链首进程首先投入运行。进程每执行一次，进程需要的时间片数减1、该进程的优先数减3。这样，该进程如果在一个时间片中没有完成，其优先数降低一级。接着仍是用该进程降低一级后的优先数与就绪队列中链首进程的优先数进行比较，如果仍是该进程的优先数高或相同，便让该进程继续执行；否则，调度就绪队列的链首进程投入运行。原运行过的进程按其现行优先数大小插
进程调度算法
最新发布
qq_50993361的博客
05-17 2111
当一个进程的状态发生改变时，操作系统需要考虑是否要换一个进程执行，这就需要用到“进程调度算法”。
操作系统进程调度算法 C++
qq_31605553的博客
12-01 1949
操作系统 进程调度
C++编程实现进程调度算法（FCFS+RR）
Yuhan2001的CSDN博客
12-04 1万+
操作系统的课程实验，C++编程实现进程调度算法（FCFS和RR）
模拟进程调度算法c语言版,《进程调度算法的模拟实现》.doc
weixin_34526152的博客
05-24 982
操作系统课程设计(2015)进程调度算法的模拟实现PAGE 2PAGE 1操作系统课程设计报告题目： 进程调度算法的模拟实现_专业计算机科学与技术学生姓名班级学号指导教师发放日期2015.1.30信 息 工 程 学 院目 录TOC \o "1-2" \h \z \u HYPERLINK \l _Toc28843 1 概述 PAGEREF _Toc28843 1HYPERLINK \l ...
进程调度算法 C++实现
ucler的博客
07-28 1289
操作系统模拟之进程调度算法。 文件共2份，其中1份cpp，1份.h，代码如下： main.cpp #include "init.h" int main() { printf("欢迎进入演示系统！\n"); printf("\n现在需要对进程数据初始化\n"); printf("通过键盘输入请输入1\n"); printf("通过构造函数直接生成请输入2\n"); int num_initialize; scanf("%d", &num_initialize); printf("\n"
操作系统——进程调度算法（C++）
MYKDL
11-14 6494
1. 实验目的： 多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机，本实验模拟实现处理机调度，以加深了解处理机调度的工作 2. 实验内容： 选择一个调度算法，实现处理机调度。 FCFS(先到先服务)，SJF(短进程优先) ，PSA(优先权调度算法)， RR(时间片轮转调度算法) 3. 源代码： 进程调度算法（C++）完整代码的链接 以下为代码架构 #include <iostream> #include<string.h> //#include <queue> ....
操作系统_进程调度算法C/C++语言实现
赵满刚的博客
11-29 4108
操作系统课程实验，C/C++实现四种进程调度算法。包括先到先执行、优先级原则、短作业优先、时间片轮转。本篇主要讲述整体框架及几个调度算法的具体实现。之所以说是C/C++是因为程序整体框架为C结构化没有使用面向对象。但是使用了c++标准输入输出以及c++标准库里的queue队列 一、整体框架 整体框架流程图 二、调度算法实现 四种调度算法不懂的可以参考此篇［操作系统］调度...
操作系统进程调度算法 c语言实现
04-07
实现进程调度算法，具有后备序列的调度 题目：设计一个有 N个进程共行的进程调度程序。 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。 每个进程有一个进程...
操作系统进程调度C++代码实现
05-25
2.支持 FCFS 、短 作业优先以及时间片调度算法。 3.能够较方便地查看调度过程及平均周转时间、平均带权周转时 间。 4.支持优先权调度算法与其它算法相结合的调度模式。 5.调度时应适当输出调度过程中各进程状态队列...
操作系统八大调度算法c/c++实现
01-22
本主题将详细探讨操作系统中的八大调度算法，并结合C/C++实现进行讲解。 1. **先来先服务（FCFS，First-Come First-Served）算法**：这是一种简单的调度策略，按照进程到达的顺序分配CPU。FCFS算法实现简单，但可能...
基于visual C++的进程调度算法模拟(C语言)
01-17
本项目“基于Visual C++的进程调度算法模拟”是用C语言实现的一个实践工具，它允许用户模拟不同的进程调度算法，以便理解和分析这些算法在实际操作系统中的行为。 首先，我们要理解什么是进程调度。进程是操作系统...
动态优先数高者优先进程调度算法C++源码.zip
11-03
而`TaskManager`可能是实际的C++源代码文件，实现了动态优先数高者优先进程调度算法。 通过分析和实现这个算法，开发者不仅可以深化对操作系统原理的理解，还能提高C++编程能力，尤其是对于并发控制和数据结构的...
【eNSP】解决virtualbox不兼容/无法运行问题
热门推荐
lushixuan12345的博客
04-17 2万+
【eNSP】解决virtualbox不兼容/无法运行问题
【zlib】linux安装zlib
lushixuan12345的博客
01-17 8372
【zlib】linux安装zlib
【已解决】Cannot resolve org.springframework:spring-core:5.1.6.RELEASE
lushixuan12345的博客
01-12 7363
【已解决】Cannot resolve org.springframework:spring-core:5.1.6.RELEASE
进程调度算法模拟c++代码
12-22
下面是一个简单的进程调度算法模拟c代码示例： ```c #include int main() { int n, i, j; float burst_time[10], process[50]; printf("请输入进程数："); scanf("%d", &n); printf("请输入每个进程的执行时间...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值