操作系统进程调度算法(c语言实现)

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

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

Jetbrains全家桶1年46,售后保障稳定

进程调度算法

一、先来先服务(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));
}

Jetbrains全家桶1年46,售后保障稳定

(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
在这里插入图片描述

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

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/198330.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(1)


相关推荐

  • 把list转为JSON字符串

    把list转为JSON字符串把list转为字符串,把对象转为字符串,toJSONString(),json的jar包

    2022年10月17日
  • 介绍你所使用的linux系统_linux系统官网

    介绍你所使用的linux系统_linux系统官网简介作者:刘明,软件工程师,上海交通大学通信与电子工程系本文讲解SNMPTrap,在介绍Trap概念之前,首先认识一下SNMP吧。简单网络管理协议(SimpleNetworkManagementProtocol)是一种应用层协议,是TCP/IP协议族的一部分。它使网络设备之间能够方便地交换管理信息。能够让网络管理员管理网络的性能,发现和解决网络问题及进

  • siamfc++代码_asic芯片设计

    siamfc++代码_asic芯片设计SiamFC论文解读及代码实现摘要:传统上,任意目标跟踪的问题是通过专门在线学习目标外观的模型来解决的,使用视频本身作为唯一的训练数据。尽管这些方法取得了成功,但他们的纯在线方法固有地限制了他们可以学习的模型的丰富性。最近,有人试图利用深层卷积网络的表达能力。然而,当要跟踪的目标事先未知时,需要在线执行随机梯度下降以适应网络的权重,这严重影响了系统的速度。在本文中,我们在ILSVRC15数据集上为视频中的目标检测配备了一个基本的跟踪算法和一个新的端到端训练的孪生神经网络。我们的跟踪器以超过实时的帧速率运

  • 部署、收回和删除解决方式—-STSADM和PowerShell「建议收藏」

    部署、收回和删除解决方式—-STSADM和PowerShell

  • java一个字符输入字符串_在java中如何用键盘输入一个数,字符,字符串 (转)…

    java一个字符输入字符串_在java中如何用键盘输入一个数,字符,字符串 (转)…Java代码importjava.util.Scanner;publicclassTest{publicstaticvoidmain(String[]args){Scannerscan=newScanner(System.in);System.out.println(“请输入一个字符串:”);System.out.println(“您输入的字符串是:”+scan.next());}}…

  • Java 实习生(月薪 3k-5k 水平)应具备哪些知识、能力?给学弟学妹们支招

    我10年前在一家外企做Java实习生的时候,就差不多这个水平((月薪3k-5k),10多年过去了,可以稍微把目标放得大一点,比如说8k-10k,我觉得也不是不可能!在一线城市找一份靠谱的实习工作我觉得还是不难的,怕就怕有些学弟学妹盲目乐观,以为能找一份不错的实习工作,结果碰一鼻子灰,最后心灰意冷,可能就转行了。或者盲目悲观,大四了呀,学历不咋滴呀,整天恍恍惚惚的,无心学习,最后也转行了。注意注意,只要现在立刻马上开始按照我说的学习路线开始,就一点不晚。第一,IntellijIDEA、G

发表回复

您的电子邮箱地址不会被公开。

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