1. 全栈程序员必看首页

操作系统 进程调度算法_进程调度算法实验报告

全栈程序员-站长 • • 未分类 • 阅读 3

操作系统 进程调度算法_进程调度算法实验报告进程调度算法一、先来先服务（FCFS）基本思想：先到达的进程先进入就绪队列，先进行调度的原则。非抢占方式。二、短作业优先（SJF）基本思想：根据进程中的执行时间，选取执行时间最短的作业优先调度；可有抢占或非抢占方式。三、优先权高者优先（HPF）基本思想：系统根据作业的优先权进行作业调度，每次选取优先权高的作业优先调度。作业的优先权通常用一个整数表示，也叫做优先数。可有抢占或非抢占方式。…

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

进程调度算法

一、先来先服务（FCFS）
基本思想：先到达的进程先进入就绪队列，先进行调度的原则。非抢占方式。
二、短作业优先（SJF）
基本思想：根据进程中的执行时间，选取执行时间最短的作业优先调度；可有抢占或非抢占方式。
三、优先权高者优先（HPF）
基本思想：系统根据作业的优先权进行作业调度，每次选取优先权高的作业优先调度。作业的优先权通常用一个整数表示，也叫做优先数。可有抢占或非抢占方式。
四、时间片轮转（RR）
基本思想：系统将所有的就绪进程按先来先服务的原则，排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。时间片结束之后，将该进程加到就绪队列队尾；然后再把处理机分配给就绪队列中新的首进程。

各程序的实现算法

（1）FCFS先来先服务
算法思想：①首先将输入的进程放入一个进程数组中，然后根据进程的到达时间进行排序（冒泡排序）。将最先到达的进程放入进程就绪队列中。②当队列不空时，从队头取出一个进程来执行，直至此进程执行完，并将在此进程执行期间到达的进程依次加入进程就绪队列。③如果队列为空，但进程数组中仍存在未到达的进程，这时将要到达进程加入进程就绪队列。

void FCFS(program pro[],int num){ 
   
	printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
	sortWithEnterTime(pro,num);    //按照到达顺序排序 
	programQueue* queue = (programQueue*)malloc(sizeof(programQueue)); 
	Queueinit(queue);   //初始化进程就绪队列
	EnterQueue(queue,&pro[0]);   //将第一个进程放入队列
	int time = pro[0].enter_time;
	int pronum=1;    //记录当前已进入的进程 
	float sum_T_time = 0,sum_QT_time = 0 ; 
	while(queue->size>0){ 
       //当队列不为空
		program* curpro = poll(queue);   //从进程队列中取出进程 
		if(time<curpro->enter_time)      //如果此进程的进入时间大于此时的时间，需要将时间转换到此进程的到达时间
			time =  curpro->enter_time;
		int done_time = time+curpro->running_time;  //记录完成时间
		int T_time = done_time - curpro->enter_time;  //记录周转时间
		sum_T_time += T_time;    
		float QT_time = T_time / (curpro->running_time+0.0) ; //记录带权周转
		sum_QT_time += QT_time;
		for(int tt = time;tt<=done_time&&pronum<num;tt++){ 
       //模拟进程的执行过程 
		
			if(tt>=pro[pronum].enter_time){ 
      //程序执行时有程序到达则进入程序队列
				EnterQueue(queue,&pro[pronum]);
				pronum++;
			}
		}
		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time,T_time,QT_time); //输出结果
		time +=  curpro->running_time;
		if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
			EnterQueue(queue,&pro[pronum]);
			pronum++; 
		}
	}
	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
}

（2）短作业优先（SJF）
算法思想：①首先也是按进程的到达时间进行排序。让最先到达的进程入队。②当队列不空时，从队头取出一个进程来执行，直至此进程执行完，设置一个变量记录此进程执行过程中所有到达的进程。③将这些到达的进程进行排序，按照进程服务时间的大小。然后将排序好的进程数组中的进程依次加入进程队列。（只排当前进程执行期间到达的进程）④此时也要考虑如果队列为空，但进程数组中仍存在未到达的进程，这时将要到达进程加入进程就绪队列。

void SJF(program pro[],int num) { 
   
	printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
	sortWithEnterTime(pro,num);
	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
	Queueinit(queue);
	EnterQueue(queue,&pro[0]);   //第一个进程入队
	int time = pro[0].enter_time;
	int pronum=1;    //记录当前的进程 
	float sum_T_time = 0,sum_QT_time = 0;
	while(queue->size>0){ 
   
		program* curpro = poll(queue);   //从进程队列中取出进程 
		if(time<curpro->enter_time)
			time =  curpro->enter_time;
		int done_time = time+curpro->running_time;
		int T_time = done_time - curpro->enter_time;
		float QT_time = T_time / (curpro->running_time+0.0) ;
		sum_T_time += T_time;
		sum_QT_time += QT_time;
		int pre = pronum;  //记录此进程执行期间第一个到达的进程的位置
		for(int tt = time;tt<=done_time&&pronum<num;tt++){ 
       //模拟进程的执行过程 
			if(tt>=pro[pronum].enter_time){ 
    // 统计从此任务开始到结束之间有几个进程到达 
				pronum++;
			}
		}
		sortWithLongth(pro,pre,pronum);//将到达的进程按照服务时间排序
		for(int i=pre;i<pronum;i++){ 
       //到达的进程入队进程链入队列 
			EnterQueue(queue,&pro[i]);
		}
		pre = pronum;
		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time,T_time,QT_time);
		time +=  curpro->running_time;
		if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
			EnterQueue(queue,&pro[pronum]);
			pronum++; 
		}
	}
	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/num);
}

（3）优先权高者优先（HPF）
算法思想：①首先也是按进程的到达时间进行排序。让最先到达的进程入队。②当队列不空时，从队头取出一个进程来执行，直至此进程执行完，设置一个变量记录此进程执行过程中所有到达的进程。③将这些到达的进程进行排序，按照进程优先权排序（权值小的先入）。然后将排序好的进程数组中的进程依次加入进程队列。（只排当前进程执行期间到达的进程）④此时也要考虑如果队列为空，但进程数组中仍存在未到达的进程，这时将要到达进程加入进程就绪队列。

void HPF(program pro[],int num){ 
   
	printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
	sortWithEnterTime(pro,num);
	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
	Queueinit(queue);
	EnterQueue(queue,&pro[0]);
	int time = pro[0].enter_time;
	int pronum=1;    //记录当前的进程 
	float sum_T_time = 0,sum_QT_time = 0;
	while(queue->size>0){ 
   
		program* curpro = poll(queue);   //从进程队列中取出进程 
		if(time<curpro->enter_time)
			time =  curpro->enter_time;
		int done_time = time+curpro->running_time;
		int T_time = done_time - curpro->enter_time;
		float QT_time = T_time / (curpro->running_time+0.0) ;
		sum_T_time += T_time;
		sum_QT_time += QT_time;
		int pre = pronum;
		for(int tt = time;tt<=done_time&&pronum<num;tt++){ 
       //模拟进程的执行过程 
			if(tt>=pro[pronum].enter_time){ 
    // 统计从此任务开始到结束之间有几个进程到达 
				pronum++;
			}
		}
		sortWithPriority(pro,pre,pronum);//将到达的进程按照服务时间排序
		for(int i=pre;i<pronum;i++){ 
       //将进程链入队列 
			EnterQueue(queue,&pro[i]);
		}
		pre = pronum;
		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time
			,T_time,QT_time);
		time +=  curpro->running_time;
		if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
			EnterQueue(queue,&pro[pronum]);
			pronum++; 
		}
	} 
	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
}

（4）时间片轮转（RR）
算法思想：
①首先也是按进程的到达时间进行排序。让最先到达的进程入队。
②当队列不空时，从队头取出一个进程来执行。此时分两种情况
2.1、如果当前进程的剩余服务时间不大于时间片大小，说明此次将会将这个进程执 行完毕，在此进程执行过程中到达的进程需要添加到进程就绪队列中，这时就可以输出 此进程执行完毕。
2.2、如果当前进程的剩余服务时间大于时间片大小，还需将此进程执行过程中到达 的进程需要添加到进程就绪队列中，然后此进程的剩余服务时间减少时间片大小，此进 程重新进入进程就绪队列。
③此时也要考虑如果队列为空，但进程数组中仍存在未到达的进程，这时将要到达进程加入进程就绪队列。

void RR(program pro[],int num){ 
   
	printf("请输入时间片大小"); 
	int timeslice;scanf("%d",&timeslice);
	printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
	sortWithEnterTime(pro,num);
	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
	Queueinit(queue);
	pro[0].start_time = pro[0].enter_time;
	EnterQueue(queue,&pro[0]);
	int time = 0;
	int pronum = 1;
	float sum_T_time = 0,sum_QT_time = 0;
	while(queue->size>0){ 
   
		program* curpro = poll(queue);    // 从队列中取出头节点 
		if(time<curpro->enter_time)
			time = curpro->enter_time;
		if(timeslice >= curpro->running_time){ 
      // 如果剩余时间小于时间片 则此任务完成
			for(int tt = time;tt<=time+curpro->running_time&&pronum<num;tt++){ 
       // 模拟进程的执行过程 
				if(tt>=pro[pronum].enter_time){ 
    // 统计从此任务开始到结束之间有几个进程到达 
					pro[pronum].start_time = tt;
					EnterQueue(queue,&pro[pronum]);
					pronum++;
				}
			}
			time += curpro->running_time;
			curpro->running_time = 0;
			curpro->done_time = time;
			int T_time = curpro->done_time-curpro->start_time;
			float QT_time = T_time / (curpro->copyRunning_time+0.0);
			sum_T_time += T_time;
			sum_QT_time += QT_time;
			printf("%s\t%d\t%d\t %d\t %d\t %d\t %.2f\n",curpro->name,curpro->enter_time,curpro->copyRunning_time,
				curpro->start_time,curpro->done_time,T_time,QT_time);
			if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
				pro[pronum].start_time = pro[pronum].enter_time;
				EnterQueue(queue,&pro[pronum]);
				pronum++; 
			}
			continue; 
		}
		for(int tt = time;tt<=time+timeslice&&pronum<num;tt++){ 
       //模拟进程的执行过程 
			if(tt>=pro[pronum].enter_time){ 
    // 统计从此任务开始到结束之间有几个进程到达 
				pro[pronum].start_time = tt;
				EnterQueue(queue,&pro[pronum]);
				pronum++;
			}
		}
		time += timeslice;
		curpro->running_time -= timeslice; 
		EnterQueue(queue,curpro);    //当前程序未完成 继续添加到队列中 
		if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
			pro[pronum].start_time = pro[pronum].enter_time;
			EnterQueue(queue,&pro[pronum]);
			pronum++; 
		}
	}
	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
}

完整c语言代码

#include<stdio.h>
#include<malloc.h>
#include<string.h> 
#include<stdlib.h>
typedef struct program{ 
   
	char name[20];
	int running_time;
	int enter_time;
	int priority;
	int done_time;    //用于时间片轮转
	int copyRunning_time;  //用于时间片轮转
	int start_time; 
	program* next;
} Program;
typedef struct programQueue{ 
   
	program* firstProg;
	program* LastProg;
	int size;
} programQueue;
void Queueinit(programQueue* queue){ 
   
	if(queue==NULL){ 
   
		return ;
	}
	queue->size = 0;
	queue->LastProg = (program*)malloc(sizeof(program));
	queue->firstProg = queue->LastProg;
}
void print(program pro[],int num){ 
   
	for(int i=0;i<num;i++){ 
   
		printf("%d ",pro[i].enter_time);
	}
}
void printQueue(programQueue* queue){ 
   
	program* p=queue->firstProg->next;
	while(p!=NULL){ 
   
		printf("%s ",p->name);
		p=p->next;
	}
	printf("\n");
} 
void EnterQueue(programQueue* queue,program* pro){ 
      //加入进程队列 
	queue->LastProg->next = (program*)malloc(sizeof(program));
	queue->LastProg = queue->LastProg->next; 
	queue->LastProg->enter_time = pro->enter_time;
	memcpy(queue->LastProg->name,pro->name,sizeof(pro->name));   
	queue->LastProg->priority = pro->priority;
	queue->LastProg->running_time = pro->running_time;
	queue->LastProg->copyRunning_time = pro->copyRunning_time;
	queue->LastProg->start_time = pro->start_time;
	queue->size++;
}
program* poll(programQueue* queue){ 
   
	program* temp = queue->firstProg->next;
	if(temp == queue->LastProg){ 
   
		queue->LastProg=queue->firstProg;
		queue->size--;
		return temp;
	}
	queue->firstProg->next = queue->firstProg->next->next;
	queue->size--;
	return temp;
}
void inputProgram(program pro[],int num){ 
   
	for(int i=0;i<num;i++){ 
   
		program prog ;
		printf("请输入第%d个进程的名字，到达时间，服务时间，优先级\n",i+1);
		scanf("%s",prog.name);
		scanf("%d",&prog.enter_time) ;
		scanf("%d",&prog.running_time);
		prog.copyRunning_time = prog.running_time; 
		scanf("%d",&prog.priority);
		pro[i]=prog;
	}
}
void sortWithEnterTime(program pro[],int num){ 
   
	for(int i=1;i<num;i++){ 
   
		for(int j= 0;j<num-i;j++){ 
   
			if(pro[j].enter_time>pro[j+1].enter_time){ 
   
				program temp = pro[j];
				pro[j] = pro[j+1];
				pro[j+1] = temp;
			}
		}
	}
}

void FCFS(program pro[],int num){ 
   
	printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
	sortWithEnterTime(pro,num);    //按照进入顺序排序 
	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));
	Queueinit(queue);
	EnterQueue(queue,&pro[0]);
	int time = pro[0].enter_time;
	int pronum=1;    //记录当前的进程 
	float sum_T_time = 0,sum_QT_time = 0 ; 
	while(queue->size>0){ 
   
		program* curpro = poll(queue);   //从进程队列中取出进程 
		if(time<curpro->enter_time)
			time =  curpro->enter_time;
		int done_time = time+curpro->running_time;
		int T_time = done_time - curpro->enter_time;
		sum_T_time += T_time;
		float QT_time = T_time / (curpro->running_time+0.0) ;
		sum_QT_time += QT_time;
		for(int tt = time;tt<=done_time&&pronum<num;tt++){ 
       //模拟进程的执行过程 
		
			if(tt>=pro[pronum].enter_time){ 
   
				EnterQueue(queue,&pro[pronum]);
				pronum++;
			}
		}
		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time
			,T_time,QT_time);
		time +=  curpro->running_time;
		if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
			EnterQueue(queue,&pro[pronum]);
			pronum++; 
		}
	}
	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
}
void sortWithLongth(program pro[],int start,int end){ 
   
	int len = end - start;
	if(len == 1) return ;
	for(int i=1;i<len;i++){ 
   
		for(int j= start;j<end-i;j++){ 
   
			if(pro[j].running_time>pro[j+1].running_time){ 
   
				program temp = pro[j];
				pro[j] = pro[j+1];
				pro[j+1] = temp;
			} 
		}
	}
}
void SJF(program pro[],int num) { 
   
	printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
	sortWithEnterTime(pro,num);
	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
	Queueinit(queue);
	EnterQueue(queue,&pro[0]);
	int time = pro[0].enter_time;
	int pronum=1;    //记录当前的进程 
	float sum_T_time = 0,sum_QT_time = 0;
	while(queue->size>0){ 
   
		program* curpro = poll(queue);   //从进程队列中取出进程 
		if(time<curpro->enter_time)
			time =  curpro->enter_time;
		int done_time = time+curpro->running_time;
		int T_time = done_time - curpro->enter_time;
		float QT_time = T_time / (curpro->running_time+0.0) ;
		sum_T_time += T_time;
		sum_QT_time += QT_time;
		int pre = pronum;
		for(int tt = time;tt<=done_time&&pronum<num;tt++){ 
       //模拟进程的执行过程 
			if(tt>=pro[pronum].enter_time){ 
    // 统计从此任务开始到结束之间有几个进程到达 
				pronum++;
			}
		}
		sortWithLongth(pro,pre,pronum);//将到达的进程按照服务时间排序
		for(int i=pre;i<pronum;i++){ 
       //将进程链入队列 
			EnterQueue(queue,&pro[i]);
		}
		pre = pronum;
		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time
			,T_time,QT_time);
		time +=  curpro->running_time;
		if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
			EnterQueue(queue,&pro[pronum]);
			pronum++; 
		}
	}
	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/num);
}
void sortWithPriority(program pro[],int start,int end){ 
   
	int len = end - start;
	if(len == 1) return ;
	for(int i=1;i<len;i++){ 
   
		for(int j= start;j<end-i;j++){ 
   
			if(pro[j].priority>pro[j+1].priority){ 
   
				program temp = pro[j];
				pro[j] = pro[j+1];
				pro[j+1] = temp;
			} 
		}
	}
}
void HPF(program pro[],int num){ 
   
	printf("进程 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
	sortWithEnterTime(pro,num);
	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
	Queueinit(queue);
	EnterQueue(queue,&pro[0]);
	int time = pro[0].enter_time;
	int pronum=1;    //记录当前的进程 
	float sum_T_time = 0,sum_QT_time = 0;
	while(queue->size>0){ 
   
		program* curpro = poll(queue);   //从进程队列中取出进程 
		if(time<curpro->enter_time)
			time =  curpro->enter_time;
		int done_time = time+curpro->running_time;
		int T_time = done_time - curpro->enter_time;
		float QT_time = T_time / (curpro->running_time+0.0) ;
		sum_T_time += T_time;
		sum_QT_time += QT_time;
		int pre = pronum;
		for(int tt = time;tt<=done_time&&pronum<num;tt++){ 
       //模拟进程的执行过程 
			if(tt>=pro[pronum].enter_time){ 
    // 统计从此任务开始到结束之间有几个进程到达 
				pronum++;
			}
		}
		sortWithPriority(pro,pre,pronum);//将到达的进程按照服务时间排序
		for(int i=pre;i<pronum;i++){ 
       //将进程链入队列 
			EnterQueue(queue,&pro[i]);
		}
		pre = pronum;
		printf("%s\t%d\t%d\t%d\t%d\t%d\t%.2f\n",curpro->name,curpro->enter_time,curpro->running_time,time,done_time
			,T_time,QT_time);
		time +=  curpro->running_time;
		if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
			EnterQueue(queue,&pro[pronum]);
			pronum++; 
		}
	} 
	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
}
void RR(program pro[],int num){ 
   
	printf("请输入时间片大小"); 
	int timeslice;scanf("%d",&timeslice);
	printf("进程 到达时间 服务时间 进入时间 完成时间 周转时间 带权周转时间\n");
	sortWithEnterTime(pro,num);
	programQueue* queue = (programQueue*)malloc(sizeof(programQueue));;
	Queueinit(queue);
	pro[0].start_time = pro[0].enter_time;
	EnterQueue(queue,&pro[0]);
	int time = 0;
	int pronum = 1;
	float sum_T_time = 0,sum_QT_time = 0;
	while(queue->size>0){ 
   
		program* curpro = poll(queue);    // 从队列中取出头节点 
		if(time<curpro->enter_time)
			time = curpro->enter_time;
		if(timeslice >= curpro->running_time){ 
      // 如果剩余时间小于时间片 则此任务完成
			for(int tt = time;tt<=time+curpro->running_time&&pronum<num;tt++){ 
       // 模拟进程的执行过程 
				if(tt>=pro[pronum].enter_time){ 
    // 统计从此任务开始到结束之间有几个进程到达 
					pro[pronum].start_time = tt;
					EnterQueue(queue,&pro[pronum]);
					pronum++;
				}
			}
			time += curpro->running_time;
			curpro->running_time = 0;
			curpro->done_time = time;
			int T_time = curpro->done_time-curpro->start_time;
			float QT_time = T_time / (curpro->copyRunning_time+0.0);
			sum_T_time += T_time;
			sum_QT_time += QT_time;
			printf("%s\t%d\t%d\t %d\t %d\t %d\t %.2f\n",curpro->name,curpro->enter_time,curpro->copyRunning_time,
				curpro->start_time,curpro->done_time,T_time,QT_time);
			if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
				pro[pronum].start_time = pro[pronum].enter_time;
				EnterQueue(queue,&pro[pronum]);
				pronum++; 
			}
			continue; 
		}
		for(int tt = time;tt<=time+timeslice&&pronum<num;tt++){ 
       //模拟进程的执行过程 
			if(tt>=pro[pronum].enter_time){ 
    // 统计从此任务开始到结束之间有几个进程到达 
				pro[pronum].start_time = tt;
				EnterQueue(queue,&pro[pronum]);
				pronum++;
			}
		}
		time += timeslice;
		curpro->running_time -= timeslice; 
		EnterQueue(queue,curpro);    //当前程序未完成 继续添加到队列中 
		if(queue->size==0&&pronum<num){ 
      //防止出现前一个进程执行完到下一个进程到达之间无进程进入 
			pro[pronum].start_time = pro[pronum].enter_time;
			EnterQueue(queue,&pro[pronum]);
			pronum++; 
		}
	}
	printf("平均周转时间为%.2f\t平均带权周转时间为%.2f\n\n",sum_T_time/(num+0.0),sum_QT_time/(num+0.0));
} 
void choiceMenu(){ 
   
	printf("请选择进程调度算法：\n\n");
	printf("1.先来先服务算法\n2.短进程优先算法\n3.高优先级优先\n4.时间片轮转算法\n\n"); 
}
void menu(){ 
   
	int proNum;
	printf("请输入进程的个数：");
	scanf("%d",&proNum);
	program pro[proNum];
	inputProgram(pro,proNum);
	choiceMenu();
	int choice;
	while(1){ 
   
		scanf("%d",&choice);
		switch(choice){ 
   
			case 1:system("cls");FCFS(pro,proNum);choiceMenu();break; 
			case 2:system("cls");SJF(pro,proNum);choiceMenu();break; 
			case 3:system("cls");HPF(pro,proNum);choiceMenu();break;
			case 4:system("cls");RR(pro,proNum);choiceMenu();break;
			case 5:return;
		}
	}
	
}
int main(){ 
   
	menu();
	return 0;
}

结果测试

在这里插入图片描述

结果按照完成时间输出

先来先服务
在这里插入图片描述
短进程优先
在这里插入图片描述
高优先级优先
在这里插入图片描述
时间片轮转 时间片大小为10
在这里插入图片描述

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/187759.html原文链接：https://javaforall.net

赞 (0)
全栈程序员-站长的头像全栈程序员-站长
0 0


相关推荐

  • dirsearch讲解_中国指南网

    dirsearch讲解_中国指南网

    dirsearch讲解_中国指南网获取更多学习资料、想加入社群、深入学习，请扫我的二维码或加Memory20000427。在本文中，我们将学习如何使用Dirsearch。说起国内的御剑套装，相信各位都已经非常熟悉了。但御剑已经好多年不更新了，而且需要windows，有时候线程设置大了点，扫了半天中途还可能卡住不动了，也没有实时的数据保存，前功尽弃。总之各种不爽。现在好用的webscanner也层出不穷，我根据自己的需求和实际使用体验，最终选择了dirsearch这款工具。基本情况它是一个命令行工具，旨在暴力激活成功教程网站中的目录和

    全栈程序员-站长的头像 全栈程序员-站长
    2022年9月28日
    3
  • mac idea 2022 激活码【2022免费激活】2022.01.27[通俗易懂] idea

    mac idea 2022 激活码【2022免费激活】2022.01.27[通俗易懂]

    (mac idea 2022 激活码)本文适用于JetBrains家族所有ide，包括IntelliJidea，phpstorm，webstorm，pycharm，datagrip等。IntelliJ2021最新激活注册码，破解教程可免费永久激活，亲测有效，下面是详细链接哦~https://javaforall.net/100143.html…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年3月31日
    271
  • 说一下java的运行机制_Java运行机制是什么？「建议收藏」

    说一下java的运行机制_Java运行机制是什么？「建议收藏」

    说一下java的运行机制_Java运行机制是什么？「建议收藏」不管是学习Java还是其他什么变成语言，我们不仅要了解它的特性，充分的使用Java语言完成各种程序开发工作，还要了解Java的运行机制。只有了解其底层的运行机制，才能更好的利用Java完成各项工作。Java运行机制是什么？Java程序运行时，必须经过编译和运行两个步骤。首先将后缀名师“.java”的源文件进行编译，最终生成后缀名为“.class”的字节码文件。然后Java虚拟机将编译后的字节码文件…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年7月7日
    23
  • Prometheus TSDB存储原理

    Prometheus TSDB存储原理

    Prometheus TSDB存储原理Python 微信订餐小程序课程视频 https blog csdn net m0 article details Python 实战量化交易理财系统 https blog csdn net m0 article details Prometheus 包含一个存储在本地磁盘的时间序列数据库 同时也支持与远程存储系统集成 比如 grafanacloud 提供的免费云存储 API 只需将 remote write 接口信息填写在 Prome

    全栈程序员-站长的头像 全栈程序员-站长
    2025年7月16日
    4
  • ASP.NET跳转网页的三种方法的比较(转+修)

    ASP.NET跳转网页的三种方法的比较(转+修)

    ASP.NET跳转网页的三种方法的比较(转+修)方法1response.redirect这个跳转页面的方法跳转的速度不快，因为它要走2个来回（2次postback），但他可以跳转到任何页面，没有站点页面限制（即可以由雅虎跳到新浪），同时不能跳过登录保护。但速度慢是其最大缺陷！redirect跳转机制：首先是发送一个http请求到客户端，通知需要跳转到新页面，然后客户端在发送跳转请求到服务器端。需要注意的是跳转后内部空间保存的所…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年7月20日
    15
  • 香农编码的matlab实现实验总结_香农编码C语言

    香农编码的matlab实现实验总结_香农编码C语言

    香农编码的matlab实现实验总结_香农编码C语言中南大学《信息论与编码》实验报告题目信源编码实验指导教师学院专业班级姓名学号日期目录一、香农编码…………………………………………..3实验目的………………………………………………………………………3实验要求……………..

    全栈程序员-站长的头像 全栈程序员-站长
    2025年10月18日
    0

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号