操作系统进程调度算法（c语言实现）

进程调度算法

一、先来先服务（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