1. 全栈程序员必看首页

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

全栈程序员-用户IM • • 未分类

操作系统 进程调度算法_进程调度算法实验报告进程调度算法一、先来先服务（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
在这里插入图片描述

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

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

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

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

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0
blank

相关推荐

  • 【Linux】进程间通信「建议收藏」

    【Linux】进程间通信「建议收藏」

    【Linux】进程间通信「建议收藏」目录1.进程间通信1.1.进程间通信的目的1.2.如何实现进程间通信2.管道通信2.1.匿名管道2.1.1创建匿名管道2.1.2.深入理解匿名管道2.2.命名管道2.2.1.创建命名管道3.systemV标准进程间通信3.1.共享内存3.1.1.实现原理3.1.2.代码实现3.2.消息队列(了解)3.2.1实现原理3.3.信号量(了解)3.3.1.实现原理1.进程间通信1.1.

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月11日
  • sqlserver数据库置疑_sqlserver2008数据库可疑

    sqlserver数据库置疑_sqlserver2008数据库可疑

    sqlserver数据库置疑_sqlserver2008数据库可疑一、数据库异常我们平时在使用SQLServer时，可能会遇到以下情况：1、数据库变为置疑状态2、使用数据库文件恢复数据库时，附加的数据库显示为置疑状态3、无法附加数据库数据库置疑的原因：SQLServer所在分区空间是否够？数据库文件大小是否达到最大文件限制？FAT的格式只支持四G以内的文件　　2、数据库文件损坏或被非正常删除时出现这种情况　　3、病毒防火墙的扫…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年8月20日
  • R-L模型算法的优缺点_审计重要性特征

    R-L模型算法的优缺点_审计重要性特征

    R-L模型算法的优缺点_审计重要性特征1.特征重要性的意义LR模型也就是逻辑回归模型，作为一个简单的常用的模型，其有非常多的有点，除了模型简单，容易实现分布式，还有一个重要的优点就是模型的可解释性非常好。因为每个特征都对应一个模型参数wiw_{i}wi​，该参数越大，那么该特征对模型预测结果的影响就会越大，我们就说该特征就越重要，因此LR模型的特征重要性评估方式就是wiw_{i}wi​的大小。2.逻辑回归模型特征重要性及排序Ta…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月8日
  • 有意思的批处理

    有意思的批处理

    有意思的批处理

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年7月26日
  • ubuntu kill命令_killall命令

    ubuntu kill命令_killall命令

    ubuntu kill命令_killall命令Linux中的kill命令用来终止指定的进程（terminate a process）的运行，是Linux下进程管理的常用命令。通常，终止一个前台进程可以使用Ctrl+C键，但是，对于一个后台进程就须用kill命令来终止，我们就需要先使用ps/pidof/pstree/top等工具获取进程PID，然后使用kill命令来杀掉该进程。kill命令是通过向进程发送指定的信号来结束相应进程的。在默认情况下…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月30日
  • thread count_ThreadPool

    thread count_ThreadPool

    thread count_ThreadPoolThreadPool类提供一个线程池，该线程池可用于发送工作项、处理异步I/O、代表其他线程等待以及处理计时器。许多应用程序创建的线程都要在休眠状态中消耗大量时间，以等待事件发生。其他线程可能进入休眠状态，只被定期唤醒以轮询更改或更新状态信息。线程池通过为应用程序提供一个由系统管理的辅助线程池使您可以更为有效地使用线程。一个线程监视排到线程池的若干个等待操作的状态。当一个等待操作

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年9月24日

发表回复

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

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