进程调度算法5种全

最新推荐文章于 2022-04-06 21:09:49 发布
最新推荐文章于 2022-04-06 21:09:49 发布
阅读量1k 收藏 13
点赞数 3
分类专栏： 操作系统 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43902812/article/details/105484304
版权

操作系统进程调度算法

5种方式都包含
我这里的短作业优先采用的是按照时间和短作业比较方法，判断执行的。

# include <stdio.h>
# include <stdlib.h> 
# include <string.h>
# include<iostream>
# include<queue>
# include<list>
#include <Windows.h>
using namespace std;
struct input{
	int num;
	char name;
    double daoda;
    double service;  
    
}input[ ]={
    { 0, 'A', 0, 3 },
    { 1, 'B', 2, 6 },
    { 2, 'C', 4, 4 },
    { 3, 'D', 6, 5 },
    { 4, 'E', 8, 2 }
}; 
struct FCFS{
	char name;
	double wancheng;
    double changetime;//平均周转时间
	double powertime;//带权周转时间 
}FCFS[6];
struct SJF{
	char name;
	double wancheng;
    double changetime;//平均周转时间
	double powertime;//带权周转时间 
}SJF[6];
struct GXY{
	char name;
	double wancheng;
    double changetime;//平均周转时间
	double powertime;//带权周转时间 
	double zanshi;//存放暂时的优先权 
}GXY[6];
struct RR{
	char name;
	double wancheng;
    double changetime;//平均周转时间
	double powertime;//带权周转时间 
	double ser;//存放任务经历的时间 
}RR[6];
struct MFQ{
	char name;
	double wancheng;
    double changetime;//平均周转时间
	double powertime;//带权周转时间 
	double ser;
}MFQ[7];
//list<node>ListQ;   //链表队列
char jincheng[6]={'A','B','C','D','E'};//进程名 
int  daoda[6]={0,2,4,6,8};//到达时间 
int service[6]={3,6,4,5,2};//服务时间 
int time[7];//到达时间排序之后的表 
int duan[7];//按照作业长短排序 
double FCFSchangetime=0;
double FCFSpowertime=0; 
double SJFchangetime=0;
double SJFpowertime=0;
double GXYchangetime=0;
double GXYpowertime=0;
double RRchangetime=0;
double RRpowertime=0;
double MFQchangetime=0;
double MFQpowertime=0;


void  shurujincheng();//1输入作业模拟情况； 
void perform();//显示作业情况
void xianlaixianfuwu();//先来先服务 
void performFCFS();//先来先服务算法输出时间 
void paixutime();//按照到达时间排序 
void duanzuoye();//短作业优先
void paixuwork();//按照作业服务时间排序 
void performSJF();//输出短作业优先 
void gaoxingying();//高响应比 
void performGXY();//输出高响应比 
void timeswitch();//时间片轮转
void performRR() ;//输出时间片轮转 
void duojiMFQ();//多级反馈队列 
void performMFQ();//输出多级反馈队列 
int main()
{
	int n = 1;
	while( n!=0 )
	{
		printf("**************************\n") ;
		printf("进程调度模拟程序：\n");
		printf("1: 输入作业模拟情况\n");
		printf("2: 显示作业情况\n");
		printf("3: 先来先服务\n");
		printf("4: 短作业优先算法\n");
		printf("5: 高响应比优先算法\n");
		printf("6: 时间片轮转算法\n");
		printf("7: 多级反馈队列\n");
		printf("8: 算法结果比较\n");
		printf("0: 退出\n");
		printf("请输入选择：\n");
		printf("*****************************\n");
		//printf("%d\n",n);
		scanf("%d",&n);	
		switch(n)
		{
		    case 1:
		    	   printf("\n*****************************\n");
		    	    shurujincheng();
		    	    perform();
		    	    printf("\n*****************************\n");
		    	break;
		    case 2:
		    	    printf("\n*****************************\n");
		    	    perform();
		    	    printf("\n*****************************\n");
		    	break;
		    case 3:
		    	   printf("\n*****************************\n");
		    	   xianlaixianfuwu();
		    	   perform();
		    	   performFCFS();
		    	   printf("\n*****************************\n");
		    	break;
		    case 4:
		    	   printf("\n*****************************\n");
		    	   //duanzuoye();
		    	   duanzuoye(); 
		    	   perform();
		    	   performSJF();
		    	   printf("\n*****************************\n");
		    	break;
		    case 5:
		    	   printf("\n*****************************\n");
		    	   gaoxingying(); 
		    	   perform();
		    	   performGXY();
		    	   printf("\n*****************************\n");
		    	break;
		    case 6:
		    	   printf("\n*****************************\n");
		    	   timeswitch(); 
		    	   perform();
		    	   performRR();
		    	   printf("\n*****************************\n");
		    	break;
		    case 7:
		    	   printf("\n*****************************\n");
		    	   duojiMFQ();
		    	   perform();
		    	   performMFQ();
		    	   printf("\n*****************************\n");
		    	break;
		    case 8:
		    	   printf("\n*****************************\n");
		    	   perform();
		    	   printf("\n*****************************\n");
		    	   performFCFS();
		    	   printf("\n*****************************\n");
				   performSJF();
				   printf("\n*****************************\n");
		    	   performGXY();
		    	   printf("\n*****************************\n");
		    	   performRR();
		    	   printf("\n*****************************\n");
		    	   performMFQ();
		    	   printf("\n*****************************\n");
		    	break;
		    case 0: 
		           printf("\n*****************************\n");
		           n=0;
		           
		           printf("\n*****************************\n");
		    	break;
		    default :
			    printf("\n输入错误。请重新输入：\n");
			    continue;
						
		}	
	 } 
}


void  shurujincheng()
{
	int n;
	printf("输入5个作业：\n");
	printf("\n输入进程信息(进程名,到达时间,服务时间)：\n");
	for(int i=0;i<5;i++)
	{
		getchar();
		printf("进程 %d :",i);
		input[i].name=getchar();
		printf("%c\n",input[i].name);
		printf("到达时间：");
		scanf("%lf",&input[i].daoda);
		printf("服务时间：");
		scanf("%lf",&input[i].service);	
		input[i].num=i;
	}	
	return ;
} 

void perform()
{
   printf("进程名      ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8c",input[i].name);
   }
   printf("\n");
   printf("到达时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",input[i].daoda);
   }
   printf("\n");
   printf("服务时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",input[i].service);
   }
   printf("\n");
	
	
	
	return ;
}

void xianlaixianfuwu()//先来先服务 
{
	
	int daoda=0;//到达时间 
	int ser=0;//服务时间 
	daoda=input[time[0]].daoda+daoda; 
	paixutime();
	for(int i=0 ; i<5 ; i++)
	{
		
		if(daoda >= input[time[i]].daoda)//到达时间总是小于服务时间 
		{
			FCFS[time[i]].name=input[time[i]].name;
			FCFS[time[i]].wancheng=input[time[i]].service+daoda;
			FCFS[time[i]].changetime=FCFS[time[i]].wancheng-input[time[i]].daoda;
			FCFS[time[i]].powertime=FCFS[time[i]].changetime/input[time[i]].service;	
			daoda=daoda+input[time[i]].service;
		}
		else
		{
			daoda=input[time[i]].daoda;
			FCFS[time[i]].name=input[time[i]].name;
			FCFS[time[i]].wancheng=input[time[i]].service+daoda;
			FCFS[time[i]].changetime=FCFS[time[i]].wancheng-input[time[i]].daoda;
			FCFS[time[i]].powertime=FCFS[time[i]].changetime/input[time[i]].service;	
			daoda=daoda+input[time[i]].service;
		}
	    
	} 
	return ;
}

void performFCFS()
{ 
   double sumchange=0;
   double sumpower=0;
   //printf("\n");
   printf("完成时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",FCFS[i].wancheng);
   }
   printf("\n");
   printf("周转时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",FCFS[i].changetime);
   	    sumchange+=FCFS[i].changetime; 
   }
    printf("\n");
   printf("带全周转时间：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",FCFS[i].powertime);
   	    sumpower+=FCFS[i].powertime;
   }
   printf("\n");
   FCFSchangetime=sumchange/5;
   FCFSpowertime=sumpower/5;
   printf("平均周转时间\t\t带权周转时间\t\t\n");
   printf("%8.2lf\t\t%8.2lf\t\t\n",FCFSchangetime,FCFSpowertime);
   return ;
}

void duanzuoye()//短作业优先 
{
	paixutime();
	paixuwork();
    int daoda=0;//到达时间 
    //int ser=0;
    int i=0,j=0; 
    int flag[7];
    memset(flag,0,sizeof(flag)); 
    if(input[time[i]].name!=input[duan[j]].name)
	{
		daoda+=input[time[i]].daoda;
		SJF[time[i]].wancheng=daoda+input[time[i]].service;
		daoda+=input[time[i]].service;
		flag[time[i]]=1;
		SJF[time[i]].changetime=SJF[time[i]].wancheng-input[time[i]].daoda;
		SJF[time[i]].powertime=SJF[time[i]].changetime/input[time[i]].service;
	}
	printf("%d\n ",daoda);
    for(int k=1;k<5;k++)
	{
	    j=0;
	    i=0;
	    while(flag[time[i]]==1)
		{
			i++;
		}//保证每次比较的都是没有执行过的 
		while(flag[duan[j]]==1)
		{
			j++;
		}//保证每次比较的都是没有执行过的 
		//printf("%c %c\n",input[time[i]].name,input[duan[j]].name);
		if(daoda<input[time[i]].daoda && daoda<input[duan[j]].daoda)//保证2个都还没到达 
		{    
		    //printf("1%c  %c\n",input[time[i]].name,input[duan[j]].name);
			if(flag[time[i]]==0)
			{
				if(input[time[i]].daoda < input[duan[i]].daoda)
				{
					daoda=daoda+input[time[i]].daoda;
		            SJF[time[i]].wancheng=daoda+input[time[i]].service;
			        daoda+=input[time[i]].service;
			        flag[time[i]]=1;
					SJF[time[i]].changetime=SJF[time[i]].wancheng-input[time[i]].daoda;
					SJF[time[i]].powertime=SJF[time[i]].changetime/input[time[i]].service;
				}
				else
				{
					daoda+=input[duan[j]].daoda;
		    		SJF[duan[j]].wancheng=daoda+input[duan[j]].service;
					daoda+=input[duan[j]].service;
					flag[duan[j]]=1;
					SJF[duan[j]].changetime=SJF[duan[j]].wancheng-input[duan[j]].daoda;
					SJF[duan[j]].powertime=SJF[duan[j]].changetime/input[duan[j]].service;
				}
			}
			
			printf("%d \n ",daoda);
		}
		else if(input[time[i]].name==input[duan[j]].name && daoda>input[time[i]].name)//两个都到达了 
		{
		//	printf("2%c  %c\n",input[time[i]].name,input[duan[j]].name);
			if(input[time[i]].service < input[duan[j]].service)
			{
				//daoda=input[time[i]].daoda;
				//printf("%d",daoda);
		        SJF[time[i]].wancheng=daoda+input[time[i]].service;
			    daoda+=input[time[i]].service;
			    flag[time[i]]=1;
				SJF[time[i]].changetime=SJF[time[i]].wancheng-input[time[i]].daoda;
				SJF[time[i]].powertime=SJF[time[i]].changetime/input[time[i]].service;
				
			}
			else
			{
				   //daoda=input[duan[j]].daoda;
				   //printf("%d\n ",daoda);
		    		SJF[duan[j]].wancheng=daoda+input[duan[j]].service;
					daoda+=input[duan[j]].service;
					flag[duan[j]]=1;
					SJF[duan[j]].changetime=SJF[duan[j]].wancheng-input[duan[j]].daoda;
					SJF[duan[j]].powertime=SJF[duan[j]].changetime/input[duan[j]].service;
			}
		}
		else if(input[time[i]].daoda <daoda && input[duan[j]].daoda>daoda)//两个都到达了，此时比较的是 
		{
			//printf("3%c  %c\n",input[time[i]].name,input[duan[j]].name);
			//if(input[time[i]].service < input[duan[j]].service )
		    {
		    	//daoda=input[time[i]].daoda;
		    	//printf("%d\n",daoda);
		    	//printf("%c\n",input[time[i]].name);
		        SJF[time[i]].wancheng=daoda+input[time[i]].service;
			    daoda+=input[time[i]].service;
			    flag[time[i]]=1;
				SJF[time[i]].changetime=SJF[time[i]].wancheng-input[time[i]].daoda;
				SJF[time[i]].powertime=SJF[time[i]].changetime/input[time[i]].service;
			}
		 
		}
		else if(input[time[i]].daoda >daoda && input[duan[j]].daoda< daoda)
		{
					//printf("%d\n",daoda);
				    //printf("%c\n",input[duan[j]].name);
		    		SJF[duan[j]].wancheng=daoda+input[duan[j]].service;
					daoda+=input[duan[j]].service;
					flag[duan[j]]=1;
					SJF[duan[j]].changetime=SJF[duan[j]].wancheng-input[duan[j]].daoda;
					SJF[duan[j]].powertime=SJF[duan[j]].changetime/input[duan[j]].service;
		}
		else
		{
			//printf("3%c  %c\n",input[time[i]].name,input[duan[j]].name);
			if(input[time[i]].service < input[duan[j]].service )
		    {
		    	//daoda=input[time[i]].daoda;
		    	//printf("%d\n",daoda);
		    	//printf("%c\n",input[time[i]].name);
		        SJF[time[i]].wancheng=daoda+input[time[i]].service;
			    daoda+=input[time[i]].service;
			    flag[time[i]]=1;
				SJF[time[i]].changetime=SJF[time[i]].wancheng-input[time[i]].daoda;
				SJF[time[i]].powertime=SJF[time[i]].changetime/input[time[i]].service;
			}
			else
			{
				    //daoda=input[duan[j]].daoda;
				    //printf("%d\n",daoda);
				    //printf("%c\n",input[duan[j]].name);
		    		SJF[duan[j]].wancheng=daoda+input[duan[j]].service;
					daoda+=input[duan[j]].service;
					flag[duan[j]]=1;
					SJF[duan[j]].changetime=SJF[duan[j]].wancheng-input[duan[j]].daoda;
					SJF[duan[j]].powertime=SJF[duan[j]].changetime/input[duan[j]].service;
			}
		}	
	 } 
	
	
	return ;
}

void performSJF()
{ 
   double sumchange=0;
   double sumpower=0;
   //printf("\n");
   printf("完成时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",SJF[i].wancheng);
   }
   printf("\n");
   printf("周转时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",SJF[i].changetime);
   	    sumchange+=SJF[i].changetime; 
   }
    printf("\n");
   printf("带全周转时间：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",SJF[i].powertime);
   	    sumpower+=SJF[i].powertime;
   }
   printf("\n");
   SJFchangetime=sumchange/5;
   SJFpowertime=sumpower/5;
   printf("平均周转时间\t\t带权周转时间\t\t\n");
   printf("%8.2lf\t\t%8.2lf\t\t\n",SJFchangetime,SJFpowertime);
   return ;
}
void gaoxingying()
{
	paixutime();
	int flag[7];
	int num[7];
	int daoda=0;
    memset(flag,0,sizeof(flag)); 
	daoda+=input[time[0]].daoda;
	GXY[time[0]].wancheng=daoda+input[time[0]].service;
	daoda+=input[time[0]].service;
	flag[time[0]]=1;
	GXY[time[0]].changetime=GXY[time[0]].wancheng-input[time[0]].daoda;
	GXY[time[0]].powertime=GXY[time[0]].changetime/input[time[0]].service;
	int zanshi[7];
	memset(zanshi,0,sizeof(zanshi)); 
	int maxnum=0;
	int max=0;
	for(int i=1;i<5;i++)
	{
		if(daoda < input[time[i]].daoda)//还没到 
		{
			printf("%c ",input[time[i]].name);
			daoda=input[time[i]].daoda; 
			GXY[time[i]].wancheng=daoda+input[time[i]].service;
	        daoda+=input[time[i]].service;
	        flag[time[i]]=1;
	        GXY[time[i]].changetime=GXY[time[i]].wancheng-input[time[i]].daoda;
	        GXY[time[i]].powertime=GXY[time[i]].changetime/input[time[i]].service;
		}
		else//已经到了 
		{
			for(int j=1;j<5;j++)//找到已经到了的 ,算出优先权存放起来 
			{
				if(time[j]<daoda)
				{
					if(flag[time[j]]==0)
					{
						printf("%c ",input[time[j]].name);
			             //printf("%d \n",daoda);
						//GXY[time[j]].wancheng=;
	                    //daoda+=input[time[j]].service;
	                    zanshi[time[j]]=1;
	                    GXY[time[j]].zanshi=(daoda+input[time[j]].service-input[time[j]].daoda)/input[time[j]].service+1;
	                    //GXY[time[j]].changetime=GXY[time[j]].wancheng-input[time[j]].daoda;
	                    //GXY[time[j]].powertime=GXY[time[j]].changetime/input[time[j]].service;
					}
				}
			}
			for(int j=1;j<5;j++)
			{
				if(zanshi[time[j]]==1)
				{
					if(max<GXY[time[j]].zanshi)
					{
						max=GXY[time[j]].zanshi;
						maxnum=time[j];
					}
				}
			}
			memset(zanshi,0,sizeof(zanshi)); 
			//daoda=input[time[i]].daoda; 
			printf("%c ",input[maxnum].name);
			printf("%d \n",daoda);
			GXY[maxnum].wancheng=daoda+input[maxnum].service;
	        daoda+=input[maxnum].service;
	        flag[maxnum]=1;
	        GXY[maxnum].changetime=GXY[maxnum].wancheng-input[maxnum].daoda;
	        GXY[maxnum].powertime=GXY[maxnum].changetime/input[maxnum].service; 
			maxnum=0;
			max=0;
		}	
	}
	return ;
}
void performGXY()
{ 
   double sumchange=0;
   double sumpower=0;
   //printf("\n");
   printf("完成时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",GXY[i].wancheng);
   }
   printf("\n");
   printf("周转时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",GXY[i].changetime);
   	    sumchange+=GXY[i].changetime; 
   }
    printf("\n");
   printf("带全周转时间：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",GXY[i].powertime);
   	    sumpower+=GXY[i].powertime;
   }
   printf("\n");
   GXYchangetime=sumchange/5;
   GXYpowertime=sumpower/5;
   printf("平均周转时间\t\t带权周转时间\t\t\n");
   printf("%8.2lf\t\t%8.2lf\t\t\n",GXYchangetime,GXYpowertime);
   return ;
}
void timeswitch()//时间片轮转 
{
   queue<int>q;
   int daoda=0; 
   int num;
   int zanshi=0;//存放没用完的时间片； 
   int z=0;
   int flag[7];
    memset(flag,0,sizeof(flag)); 
   printf("输入时间片长度：\n");
   scanf("%d",&num); 
   //printf("%d",num);
   paixutime();
   q.push(time[0]);
   flag[0]=1;
   for(int i=0;i<5;i++)
	 {
	 	RR[i].changetime=0;
	 	RR[i].wancheng=0;
	 	RR[i].ser=0;
	 	RR[i].powertime=0;
	 	
	 }
    while(!q.empty())
   {
	   //printf("q.size:%d \n",q.size());
   	   //printf("daoda:%d  zanshi:%d\n",daoda,zanshi); 
	   daoda+=num;
	   for(int i=1;i<5;i++)
	    {
	  		if(daoda>=input[time[i]].daoda &&flag[time[i]]==0)
	  		{
	  			q.push(input[time[i]].num);
	  			flag[time[i]]=1;
	  			//printf("进入队列:%c \n",input[time[i]].name);	
			}						 				 	
	   	}
			if((RR[q.front()].ser+num) >= input[q.front()].service)//任务可以执行完 
			{
				zanshi=num-(input[q.front()].service-RR[q.front()].ser);
				//printf("   任务完成:%c 到达时间:%d  剩余时间片:%d\n",input[q.front()].name,daoda,zanshi); 
				daoda=daoda-zanshi;
				RR[q.front()].ser=input[q.front()].service;	
				RR[q.front()].wancheng=daoda;
				
				RR[q.front()].changetime=RR[q.front()].wancheng-input[q.front()].daoda;
				RR[q.front()].powertime=RR[q.front()].changetime/input[q.front()].service;
				q.pop();
				
			}
			else //任务执行不完 
			{
			        RR[q.front()].ser+=num;
				    //printf("运行名字:%c 服务:%.2lf ",input[q.front()].name,RR[q.front()].ser);
				    
				    //printf("   任务未完成:%c 到达:%d  \n",input[q.front()].name,daoda);
					
				    z=q.front();
				    q.push(z);
				    //printf("进入队列 %c \n",input[q.back()].name);
				    q.pop();
				    zanshi=0;
			}	    
    }
  
} 

void performRR()
{
	double sumchange=0;
   double sumpower=0;
   //printf("\n");
   printf("完成时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",RR[i].wancheng);
   }
   printf("\n");
   printf("周转时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",RR[i].changetime);
   	    sumchange+=RR[i].changetime; 
   }
    printf("\n");
   printf("带全周转时间：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",RR[i].powertime);
   	    sumpower+=RR[i].powertime;
   }
   printf("\n");
   RRchangetime=sumchange/5;
   RRpowertime=sumpower/5;
   printf("平均周转时间\t\t带权周转时间\t\t\n");
   printf("%8.2lf\t\t%8.2lf\t\t\n",RRchangetime,RRpowertime);
   return ;
	
}


void duojiMFQ()//多级反馈队列 
{
    int daoda=0; 
     int num=0;
     int zanshi=0;//存放没用完的时间片； 
     int z=0;
     int flag[7],wan[7];//wan标记完成与否，flag标记进去没 
     memset(flag,0,sizeof(flag));
      memset(flag,0,sizeof(wan));
      paixutime();
     //q.push(time[0]);
     flag[0]=1;
     printf("申请队列数：\n");
     int n;
     scanf("%d",&n);
     queue<int>q[n];
	 q[0].push(time[0]);
	 int index=0;
	 for(int i=0;i<5;i++)
	 {
	 	MFQ[i].changetime=0;
	 	MFQ[i].wancheng=0;
	 	MFQ[i].ser=0;
	 	MFQ[i].powertime=0;
	 	
	 }
	 while(1)
	 {
	 	   for(int i=0;i<5;i++)//退出条件:所有的都执行了 
		    {
				if(wan[i]==1)
				{
					if(i==4)
					{
						printf("%d\n",i);
						return ;
					}
				}
				else
				{
					break;
				}
			}
			num=index+1;
			daoda+=num;//到达时间加运行时间
	 	    printf("daoda时间：%d 运行时间: %d\n",daoda,index+1);
			 for(int i=1;i<5;i++)//加入 
            {
            	if(daoda >= input[time[i]].daoda &&flag[time[i]]==0)
            	{
            		q[0].push(time[i]);
					flag[time[i]]=1;
					printf("进入队列的是 %c\n",input[time[i]].name); 
				}	
			} 
			if((MFQ[q[index].front()].ser+num) >= input[q[index].front()].service)//任务可以执行完 
			{
				zanshi=num-(input[q[index].front()].service-MFQ[q[index].front()].ser);
				printf("   任务完成:%c 到达时间:%d  \n",input[q[index].front()].name,daoda); 
				daoda=daoda-zanshi;
				MFQ[q[index].front()].ser=input[q[index].front()].service;	
				MFQ[q[index].front()].wancheng=daoda;
				
				MFQ[q[index].front()].changetime=MFQ[q[index].front()].wancheng-input[q[index].front()].daoda;
				MFQ[q[index].front()].powertime=MFQ[q[index].front()].changetime/input[q[index].front()].service;
				printf("完成时间：%d \n",MFQ[q[index].front()].wancheng); 
				wan[time[q[index].front()]]=1;
				q[index].pop();
			
			}
			else //任务执行不完 
			{
			        MFQ[q[index].front()].ser+=num;
				    printf("运行名字:%c 服务:%.2lf ",input[q[index].front()].name,MFQ[q[index].front()].ser);
				    
				    printf("   任务未完成:%c 到达:%d  \n",input[q[index].front()].name,daoda);
					
				    z=q[index].front();
				    if(index<(n-1))
				    {
				    	q[index+1].push(z);
				    	printf("%d %d \n",n-1,index+1);
					}
				      
				    else
				    {
				    	q[index].push(z);
					}
				    //printf("进入队列 %c 此时需转换队列 %d \n",input[q[index+1].back()].name,index+1);
				    q[index].pop();
				    zanshi=0;
			}
				for(int j=0; j<n;j++)
					{
						if(q[j].size()!=0)
						{
							index=j;
							break;
						}
						/*if(q[index].size()!=0)
						{
							break;
						}*/
					}
			
				    
	 }
     
	 return ;
}

void performMFQ()//输出多级反馈队列 
{
   double sumchange=0;
   double sumpower=0;
   //printf("\n");
   printf("完成时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",MFQ[i].wancheng);
   }
   printf("\n");
   printf("周转时间    ：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",MFQ[i].changetime);
   	    sumchange+=MFQ[i].changetime; 
   }
    printf("\n");
   printf("带全周转时间：");
   for(int i=0;i<5;i++)
   {
   	    printf("%8.2lf",MFQ[i].powertime);
   	    sumpower+=MFQ[i].powertime;
   }
   printf("\n");
   MFQchangetime=sumchange/5;
   MFQpowertime=sumpower/5;
   printf("平均周转时间\t\t带权周转时间\t\t\n");
   printf("%8.2lf\t\t%8.2lf\t\t\n",MFQchangetime,MFQpowertime);
   return ;

	
}

void paixutime()
{
	int zanshi1[6];
	int zanshi2[6];
	int num;
	for(int i=0;i<5;i++)
	{
		zanshi1[i]=input[i].daoda;
		zanshi2[i]=input[i].num;
	}
	for(int i=0;i<5;i++)
	{	
		for(int j=i+1;j<5;j++)
		{		
			if(zanshi1[i]>zanshi1[j])
			{
				num=zanshi2[i];
				zanshi2[i]=zanshi2[j];
				zanshi2[j]=num;
				
				num=zanshi1[i];
				zanshi1[i]=zanshi1[j];
				zanshi1[j]=num;				
			}
		 } 
	} 
	for(int i=0;i<5;i++)
	{
		time[i]=zanshi2[i];
		printf("%d ",time[i]);
	}//排序，按照到达时间长短
	printf("\n");
}

void paixuwork()
{
	int zanshi1[6];
	int zanshi2[6];
	int num;
	for(int i=0;i<5;i++)
	{
		zanshi1[i]=input[i].service;
		zanshi2[i]=input[i].num;
	}
	for(int i=0;i<5;i++)
	{	
		for(int j=i+1;j<5;j++)
		{		
			if(zanshi1[i]>zanshi1[j])
			{
				num=zanshi2[i];
				zanshi2[i]=zanshi2[j];
				zanshi2[j]=num;
				
				num=zanshi1[i];
				zanshi1[i]=zanshi1[j];
				zanshi1[j]=num;				
			}
		 } 
	} 
	for(int i=0;i<5;i++)
	{
		duan[i]=zanshi2[i];
		printf("%d ",duan[i]);
	}//排序，按照到达时间长短
	printf("\n");
	
	return ;
 }

运行结果
实验输入需要先执行了3，4，5，6，7步，才可以执行2，显示所有作业情况

输入数据情况
输入数据情况
输入显示，接上图输入数据情况
执行先来先服务执行先来先服务执行短作业优先执行短作业优先

执行高响应比优先执行高响应比优先
蓝色字部分是过程中的测试可以后续自己删掉

时间片轮转时间片轮转
在这里插入图片描述多级反馈队列，过程可以自己注销

在这里插入图片描述
多级反馈队列所有过程最后结果输出在这里插入图片描述所有过程最后结果输出

我站在桥上看风景1024
关注
专栏目录
操作系统的五种进程调度算法
08-03
本代码实现了五种调度算法 1、 先来先服务 2、 轮转调度 3、 最短作业优先 4、 最短剩余时间优先 5、 最高相应比优先
几个常用的操作系统进程调度算法
热门推荐
luyafei_89430的专栏
10-23 7万+
一、先来先服务和短作业(进程)优先调度算法 1．先来先服务调度算法 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的
计算机操作系统的进程调度的五种算法
Young卡卡的博客
11-24 3289
计算机操作系统进程调度五种算法为：1.先来先服务算法  2.短作业优先算法 3.高响应比优先算法 4.时间片轮转法  5.多级反馈队列算法 public class jcdu { String name; int id; int enter_time; int ser_time; jcdu(){}
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
Johana_C的博客
04-06 1万+
五种进程调度算法C++代码实现（FCFS、SJF、Priority、SRTF，Round Robin）
五种进程调度算法的总结;
虚心求学
01-22 1万+
五种进程调度算法总结
操作系统实验：时间片轮转RR进程调度算法.doc
05-11
时间片轮转RR进程调度算法是一种常用的进程调度算法，能够合理地分配CPU时间片，提高系统的效率和公平性。通过对算法的实现和分析，我们可以更好地理解该算法的原理和实现细节，并应用于实际的操作系统中。
关于进程调度算法很多程序.rar_调度算法_进程调度_进程调度程序模拟程序_进程调度算法
09-19
本压缩包文件"关于进程调度算法很多程序.rar"包含了多个与进程调度相关的程序和资料，旨在帮助我们理解并实现不同的调度算法。 在操作系统中，进程调度的目标是决定哪些进程应该获得CPU执行权以及它们应该按照什么...
2020初学者理解的操作系统——进程调度算法简单例题
01-09
对于下列每种调度算法，计算其平均周转时间和平均等待时间，进程切换开销可忽略： （a）时间片轮转（假设时间片尾2min） （b）优先级调度 （c）先来先服务（按照次序10、6、2、4、8） （d）最短作业优先 对于以上...
os.rar_os 进程调度_操作系统进程调度_进程调度_进程调度算法
09-19
在操作系统中，常见的进程调度算法有以下几种： 1. 先进先出（FIFO，First In First Out）：这是一种简单的调度策略，按照进程到达的顺序分配CPU。新到的进程排在队列末尾，等待运行。FIFO算法易于实现，但可能导致...
main_进程调度_操作系统优先级进程调度算法_
09-29
本文将深入探讨“非抢占式优先级进程调度算法”，并结合`main.c`源代码进行详细阐述。 首先，我们要理解什么是进程调度。在多任务环境下，操作系统必须管理多个并发运行的进程，确保每个进程都能公平地获取计算资源...
编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
10-16
编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
进程调度算法实现
11-10
先来先服务算法和短作业优先调度算法的实现 直接就可以编译运行
操作系统 进程调度算法实现（Android实现带界面）
01-01
广工操作系统实验：进程调度算法，Android实现，带简洁界面，包含项目源代码
进程调度算法
清欢Viki的博客
05-08 1469
需求分析 分别实现先到先服务调度(FCFS)、最短作业优先调度(SJF)、高响应比优先调度、（抢占式）优先权调度和时间片轮转调度五种进程调度算法。 概要设计 1.先到先服务调度(FCFS) 按照进程的到来顺序运行，先来的进程先服务，后到的进程后服务。 2.最短作业优先调度(SJF) 按照作业的长短即要求服务时间运行，短作业优先服务。 3.高响应比优先调度(HRRN) 每...
五种进程调度的算法实现（二）
weixin_30786617的博客
08-06 176
程序设计 一、数据结构 1.1 事件类型 由于要求是基于事件的进程调度，所以必须创建一个存放事件的队列。 enum EventType{ ARRIVALEVENT, FINISHEVENT, TIMEREVENT }; //事件类型 1.2 任务结构（每一项数据都是输入）： struct Job { char name[50]; //作业名 ...
操作系统---进程调度算法实现
IT_xiaoye的博客
05-22 2万+
本次实现的是模拟在单处理器情况下的处理器调度，目的是设计一个按优先数调度算法实现处理器调度的程序。 内容 (1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为： 进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。 指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“...
操作系统进程作业调度算法
qq_30242987的博客
09-24 624
调度算法是指：根据系统的资源分配策略所规定的资源分配算法。常见的进程调度算法有： 1.先来先去服务 2.时间片轮转法 3.多级反馈队列算法 4.最短进程优先 5.最短剩余时间优先 6.最高响应比优先 7.多级反馈队列调度算法 一、先来先去服务 先来先去服务调度算法是一种最简单的调度算法，也称为先进先出或严格排队方案。当每个进程就绪后，它加入就绪队列。当前正运行的进程停止执行，选择在就绪队列中存在时...
操作系统五种调度算法总结(含源码)
Blank_Tt的博客
04-22 2万+
今天操作系统实验课我们做了作业调度算法的模拟。网上的调度算法参差不齐，零散杂乱。我在这里进行一个总结，并且分享给大家操作系统的五种常用算法（FCFS,SJF,HRRF,HPF,RR）并且附上代码和结果图 作业调度 作业调度又称高级调度，不涉及处理机的分配，主要任务是按一定的原则从外存上处于后备状态的作业中挑选一个（或多个）作业调入主存，为其分配内存、I/O设备等必要的资源...
C语言编写的高效进程调度算法
在进程调度算法领域，有几种经典的算法，包括但不限于以下几种： 1. 先来先服务（FCFS，First-Come, First-Served）：这是最简单的一种进程调度算法，按照进程到达的顺序进行调度。FCFS算法的实现简单，但可能导致...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值