操作系统处理机调度算法的实现c语言源代码

《处理机调度算法的实现》源代码#include "stdio.h"#include <stdlib.h>#include "time.h"#include <math.h>typedef struct{int id;int reach;float service;int prior;int finish;float turnover;float cum_turnover;}process;process p[20];int sort[20];int wait[20];int n;int alltime=0;char c;void in(){printf("请输入要建立的进程数:\n");scanf("%d",&n);int i;int j;int temp;srand(time(0));for(i=0;i<n;i++){printf("\n进程%d号:\n",i);printf("进程uid：");scanf("%d",&p[i].id);p[i].reach=rand()%10+1;printf("到达时间：%d\n",p[i].reach);p[i].service=rand()%10+1;printf("服务时间：%f\n",p[i].service);if(c=='c'){p[i].prior=rand()%10+1;printf("优先权:%d\n",p[i].prior);}else p[i].prior=0;p[i].finish=0;p[i].turnover=p[i].service;p[i].cum_turnover=p[i].prior;sort[i]=i;alltime=alltime+p[i].service;}for(i=1;i<n;i++){for(j=0;j<n-1;j++){if(p[sort[j]].reach>p[sort[j+1]].reach){temp=sort[j];sort[j]=sort[j+1];sort[j+1]=temp;}}}alltime=alltime+p[sort[0]].reach;}void out(){int i;if(c=='c'){printf("进程uid\t到达时间\t服务时间\t优先权\t完成时间\t周转时间\t带权周转时间\n");for(i=0;i<n;i++)printf("%d\t%d\t\t%f\t%d\t%d\t\t%f\t%f\n",p[i].id,p[i].reach,p[i].service,p[i].prior,p[i].finish,p[i].turnover,p[i].cum_turnover );}else {printf("进程uid\t到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");for(i=0;i<n;i++)printf("%d\t%d\t\t%f\t%d\t\t%f\t%f\n",p[i].id,p[i].reach,p[i].service,p[i].finish,p[i].turnover,p[i].cum_turnover);}}void timeslice(){int q;int i;int j;int front=-1;int rear=-1;int t=1;int v;printf("\n请输入时间片：\n");scanf("%d",&q);for(i=0;i<alltime;i++){for(j=0;j<n;j++){if((i==p[sort[j]].reach-1)&&(front!=(rear+1)%20)){rear=(rear+1)%20;wait[rear]=sort[j];sort[j]=-1;}}if((front!=rear)||(front>-1)){if(t==1){front=(front+1)%20;v=wait[front];}if(t<=q){p[v].turnover--;if(p[v].turnover==0){t=0;p[v].finish=i+2;p[v].turnover=p[v].finish-p[v].reach;p[v].cum_turnover=p[v].turnover/p[v].service;if(front==rear){front=-1;rear=-1;}}if((t==q)&&(p[v].turnover!=0)){rear=(rear+1)%20;wait[rear]=v;t=0;}t++;}}}}//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//短作业优先void sjf(){int top=-1;//作用于wait[]int i;int j;int k;int l;int temp;int v=-1;//处理机正在进行处理的进程号for(i=0;i<=alltime;i++){for(j=0;j<n;j++){//将到达的进程放进等待栈if((i==p[sort[j]].reach-1)&&(top<19)){top++;wait[top]=sort[j];for(k=1;k<=top;k++){//将等待栈按进程服务时间从大到小进行排列for(l=0;l<top;l++){if(p[wait[l]].service<p[wait[l+1]].service){temp=wait[l];wait[l]=wait[l+1];wait[l+1]=temp;}//相同服务时间的先到达的先处理if(p[wait[l]].service==p[wait[l+1]].service){if(p[wait[l]].reach < p[wait[l+1]].reach){temp=wait[l];wait[l]=wait[l+1];wait[l+1]=temp;}}}}}}if((v==-1)&&(top>=0)){//出栈一个进程v=wait[top];top--;}if(v>-1){//处理机运行，服务时间自减、这里的"turnover"指的是服务时间p[v].turnover--;if(p[v].turnover==0){p[v].finish=i+2;p[v].turnover=p[v].finish-p[v].reach;p[v].cum_turnover=p[v].turnover/p[v].service;v=-1;}}}} //动态优先级void fpf(){int top=-1;//作用于wait[]int i,j,k,l,temp;int v=-1;//处理机正在进去处理的进程号for(i=0;i<=alltime;i++){//优先权加1if((i>0)&&(top>-1)){for(j=0;j<=top;j++){p[wait[j]].cum_turnover++;}}for(j=0;j<n;j++){//将到达的进程放进等待栈if((i==p[sort[j]].reach-1)&&(top<19)){top++;wait[top]=sort[j];for(k=1;k<=top;k++){//将等待栈按进程优先权从小到大进行排列for(l=0;l<top;l++){if(p[wait[l]].cum_turnover>p[wait[l+1]].cum_turnover){temp=wait[l];wait[l]=wait[l+1];wait[l+1]=temp;}//相同优先权的先到达的先处理if(p[wait[l]].cum_turnover==p[wait[l+1]].cum_turnover){if(p[wait[l]].reach < p[wait[l+1]].reach){temp=wait[l];wait[l]=wait[l+1];wait[l+1]=temp;}}}}}}if((v==-1)&&(top>=0)){//出栈一个进程v=wait[top];top--;}if(v>-1){//处理机运行，服务时间自检，这里的"turnver"指的是服务时间p[v].turnover--;if(p[v].turnover==0){p[v].finish=i+2;p[v].turnover=p[v].finish-p[v].reach;p[v].cum_turnover=p[v].turnover/p[v].service;v=-1;}}}}//主函数int main(){while(1){printf("\n\n请选择调度算法\na:时间片轮法\nb:短作业优先\nc:动态优先级\n");scanf("%s",&c);in();switch(c){case 'a':timeslice();break;case 'b':sjf();break;case 'c':fpf();break;}out();}return 0;}。

操作系统进程调度算法（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）算法思想：①⾸先也是按进程的到达时间进⾏排序。

#include<stdio.h>#include<stdlib.h>#include <conio.h>#include<math.h>#define N 20#define MAX 100typedef struct PCB //pcb进程控制块定义{int num[N]; //进程序号char name[10]; //进程名char state; //进程状态int tijiaotime; //进程到达时间int runtime; //进程开始时间int finishtime; //进程结束时间int needtime; //服务时间int pro;//进程优先级struct PCB *next; //链接指针指向下个作业的}pcb;struct PCB *head_input;struct PCB *head_run;struct PCB *head_run_pre;unsigned long current; //记录系统当前时间的变量int time=10000,n; //计时器pcb *head=NULL,*p,*q;void getInfo() //创建进程{int num;printf("\n请输入要建立的进程个数:");scanf("%d",&n);for(num=0;num<n;num++){p=(pcb *)malloc(sizeof(pcb));if(head==NULL) {head=p;q=p;}printf("依次输入：\n进程号进程名到达时间服务时间 \n");scanf("%s\t%s\t%d\t%d",&p->num,&p->name,&p->tijiaotime,&p->needtime);if(p->tijiaotime < time) time=p->tijiaotime;q->next=p;p->runtime=0;p->finishtime=0;p->next=NULL;p->state='W';q=p;}}// *********************1.先来先服务调度算法******************************* void run_fcfo(pcb *p1)//定义先来先到服务的算法{time = p1->tijiaotime > time? p1->tijiaotime:time;p1->runtime=time;printf("\n现在时间是%d,开始运行进程%s\n",time,p1->name);time+=p1->needtime;p1->state='F';p1->finishtime=time;printf("进程名开始时间所需时间结束时间\n");printf("%s %d %d %d ",p1->name,p1->runtime,p1->needtime,p1->finishtime); }void fcfo()//定义运行进程函数{int i,j,t;for(j=0;j<n;j++){p=head;t=10000;for(i=0;i<n;i++) //找到当前未完成的进程{if(p->tijiaotime<t && p->state=='W'){t=p->tijiaotime;q=p; //标记当前未完成的进程}p=p->next;}run_fcfo(q);}}// ************************2.优先级调度服务算法************************************int readydata(){ //建立就绪队列if(head_input->next==NULL){return 0;}struct PCB *p1=head_input->next,*pmax,*p2;int maxpro=0xffff;pmax=p1;p2=head_input;while(p1!=NULL){if(p1->pro<maxpro){maxpro=p1->pro;head_run_pre=p2;pmax=p1;}p2=p1;p1=p1->next;}head_run=pmax;head_run_pre->next=head_run->next;return 1;}void runprocess() //运行进程函数{head_run->runtime-=10;head_run->pro++;struct PCB *p1,*p2;printf("时间片的大小 %d",current);current+=10;printf(" %s 开始\n",head_run->name);printf("时间片的大小 %d",current);printf(" %s 结束\n",head_run->name);if(head_run->runtime<=0){//判断进程是否运行结束}else{p1=head_input;p2=head_input->next;p1->next=head_run;head_run->next=p2;}}int readyprocess(){while(1){if(readydata()==0)return 0;else runprocess();}}void Init(){head_input=new PCB;head_input->next=NULL;current=0;int numpro;printf("请重新输入要建立的进程个数:");scanf("%d",&numpro);printf("请依次输入进程名运行时间优先级\n");for(int i=0;i<numpro;i++){struct PCB *p1=new PCB;scanf("%s",p1->name);scanf("%d",&p1->runtime);scanf("%d",&p1->pro);p1->state='C';p1->next=NULL;struct PCB *p2=head_input->next;head_input->next=p1;p1->next=p2;}}// ************************3.时间片轮转调度服务算法************************************ void shijianpian(){ int b,i,X,t,k;int a[MAX];//存放进程的剩余时间int cnt[MAX];//存放进程调度次数printf("请输入进程数:");scanf("%d",&X);printf("\n请输入时间片t大小:");scanf("%d",&t);printf("\n请依次输入各个进程的服务时间");for(i=0;i<X;i++){scanf("%d",&a[i]);cnt[i]=0;}printf("被调度进程\t进程调度次数 \t本次运行时间结果\t剩余时间\n");k=1;while(k){for(i=0;i<X;i++){if(a[i]!=0)if(a[i]>=t){a[i]-=t;b+=t;cnt[i]=cnt[i]+1;printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);}else{b=b+a[i];cnt[i]=cnt[i]+1;a[i]=0;printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);}else continue;}for(i=0;i<X;i++)if(a[i]!=0){ k=1;break;}else continue;if(i>=X)k=0;}}void main(){printf(" *******************************");printf("\n 1. 按先来先到服务调度的算法模拟\n"); printf(" *******************************");getInfo();fcfo();printf("\n *******************************");printf("\n 2. 按优先级调度的算法模拟\n");printf("\n *******************************\n"); Init();readyprocess();printf("\n *******************************");printf("\n 3. 按时间片轮转调度的算法模拟\n");printf(" *******************************\n"); shijianpian();printf(" \n");}。

调度算法C语言实现调度算法是操作系统中的重要内容之一，它决定了进程在系统中的运行方式和顺序。

本文将介绍两种常见的调度算法，先来先服务（FCFS）和最短作业优先（SJF），并用C语言实现它们。

一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是最简单的调度算法之一、它按照进程到达的先后顺序进行调度，即谁先到达就先执行。

实现这个算法的关键是记录进程到达的顺序和每个进程的执行时间。

下面是一个用C语言实现先来先服务调度算法的示例程序：```c#include <stdio.h>//进程控制块结构体typedef structint pid; // 进程IDint arrivalTime; // 到达时间int burstTime; // 执行时间} Process;int maiint n; // 进程数量printf("请输入进程数量：");scanf("%d", &n);//输入每个进程的到达时间和执行时间Process process[n];for (int i = 0; i < n; i++)printf("请输入进程 %d 的到达时间和执行时间：", i);scanf("%d%d", &process[i].arrivalTime,&process[i].burstTime);process[i].pid = i;}//根据到达时间排序进程for (int i = 0; i < n - 1; i++)for (int j = i + 1; j < n; j++)if (process[i].arrivalTime > process[j].arrivalTime) Process temp = process[i];process[i] = process[j];process[j] = temp;}}}//计算平均等待时间和平均周转时间float totalWaitingTime = 0; // 总等待时间float totalTurnaroundTime = 0; // 总周转时间int currentTime = 0; // 当前时间for (int i = 0; i < n; i++)if (currentTime < process[i].arrivalTime)currentTime = process[i].arrivalTime;}totalWaitingTime += currentTime - process[i].arrivalTime;totalTurnaroundTime += (currentTime + process[i].burstTime) - process[i].arrivalTime;currentTime += process[i].burstTime;}//输出结果float avgWaitingTime = totalWaitingTime / n;float avgTurnaroundTime = totalTurnaroundTime / n;printf("平均等待时间：%f\n", avgWaitingTime);printf("平均周转时间：%f\n", avgTurnaroundTime);return 0;```以上程序实现了先来先服务（FCFS）调度算法，首先根据进程的到达时间排序，然后依次执行每个进程，并计算总等待时间和总周转时间。

操作系统进程调度C语言代码#include <stdio.h>#define MAX 20//进程控制块typedef struct PCBchar name[10]; // 进程名int AT; // 到达时间int BT; // 服务时间int Pri; // 优先数int FT; // 完成时间int WT; //等待时间int RT; // 响应时间int position; // 第几号进程int flag; // 用来判断进程是否执行过}PCB;//进程调度void schedule(PCB a[], int n, int alg)int i, j, k, flag, temp;int count = 0;int pri_max = 0;float ATAT = 0.0;float AWT = 0.0;float ART = 0.0;PCBt;//各种算法的调度if (alg == 1)printf("采用先来先服务调度：\n"); //根据到达时间执行for (i = 0; i < n; i++)for (j = i + 1; j < n; j++)if (a[i].AT > a[j].AT)t=a[i];a[i]=a[j];a[j]=t;}//按到达时间依次执行for (i = 0; count != n; i++)for (j = 0; j < n; j++)//查找第一个到达时间小于等于当前时间的进程if (a[j].AT <= i && a[j].flag == 0)//记录运行时间a[j].BT--;//如果运行完成，记录完成时间、等待时间、响应时间if (a[j].BT == 0)a[j].FT=i+1;a[j].WT = a[j].FT - a[j].AT - a[j].Pri;a[j].RT=a[j].WT;a[j].flag = 1;count++;}elsebreak;}}}else if (alg == 2)printf("采用最短服务时间优先（非抢占）调度：\n");for (i = 0; count != n; i++)//找出服务时间最短的进程，并将其放置到最前面for (j = 0; j < n; j++)。

《通用处理机调度演示程序源代码》//短作业优先算法#define MaxNum 100#include <stdio.h>#include <stdlib.h>#include <string.h>struct Process_struct{int Number; //进程编号char Name[MaxNum]; //进程名称int ArrivalTime; //到达时间int ServiceTime; //开始运行时间int FinishTime; //运行结束时间int WholeTime; //运行时间int run_flag; //调度标志int order; //运行次序double WeightWholeTime; //周转时间double AverageWT_FCFS,AverageWT_SJF; //平均周转时间double AverageWWT_FCFS,AverageWWT_SJF; //平均带权周转时间}Process[MaxNum];int N; //实际进程个数int SJF(); //短作业优先int SJF(){ //短作业优先算法int temp_time=0; //当期那时间int i=0,j;int number_schedul,temp_counter; //进程编号，当前已执行进程个数float run_time;run_time=Process[i].WholeTime;j=1;while((j<N)&&(Process[i].ArrivalTime==Process[j].ArrivalTime)) //判断是否有两个进程同时到达{if(Process[j].WholeTime<Process[i].WholeTime){run_time=Process[i].WholeTime;i=j;}j++;}//查找下一个被调度的进程//对找到的下一个被调度的进程求相应的参数number_schedul=i;Process[number_schedul].ServiceTime=Process[number_schedul].ArrivalTim e;Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime +Process[number_schedul].WholeTime;Process[number_schedul].run_flag=1;temp_time=Process[number_schedul].FinishTime;Process[number_schedul].order=1;temp_counter=1;while(temp_counter<N){for(j=0;j<N;j++){if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag)){run_time=Process[j].WholeTime;number_schedul=j;break;}}for(j=0;j<N;j++){if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag))if(Process[j].WholeTime<run_time){run_time=Process[j].WholeTime;number_schedul=j;}}//查找下一个被调度的进程//对找到的下一个被调度的进程求相应的参数Process[number_schedul].ServiceTime=temp_time;Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime +Process[number_schedul].WholeTime;Process[number_schedul].run_flag=1;temp_time=Process[number_schedul].FinishTime;temp_counter++;Process[number_schedul].order=temp_counter;}return 0;}int Pinput(); //进程参数输入int Poutput(); //调度结果输出int Pinput() //进程参数输入{int i;printf("请输入进程个数:\n");scanf("%d",&N);for(i=0;i<N;i++){printf("----------------------------------------\n");printf("请输入一个进程:\n",i+1);printf("请输入进程名称:\n");scanf("%s",Process[i].Name);printf("请输入到达时间:\n");scanf("%d",&Process[i].ArrivalTime);printf("请输入服务时间:\n");scanf("%d",&Process[i].WholeTime);Process[i].ServiceTime=0;Process[i].FinishTime=0;Process[i].WeightWholeTime=0;Process[i].order=0;Process[i].run_flag=0;}return 0;}int Poutput() //调度结果输出{int i;float turn_round_time=0,f1,w=0;printf(" 进程名称到达时间运行时间开始运行时间结束时间执行顺序周转时间带权周转时间\n");for(i=0;i<N;i++){Process[i].WeightWholeTime=Process[i].FinishTime-Process[i].ArrivalTime;f1=Process[i].WeightWholeTime/Process[i].WholeTime;turn_round_time+=Process[i].WeightWholeTime;w+=f1;printf("时刻%d :",Process[i].ServiceTime,Process[i].Name);printf(" %s %d %d %d %d %d %f %f\n",Process[i].Name,Process[i].ArrivalTime,Process[i].WholeTime,Process[i].Ser viceTime,Process[i].FinishTime,Process[i].order,Process[i].WeightWholeTime,f1);}printf("average_turn_round_timer=%f\n",turn_round_time/N);printf("weight_average_turn_round_timer=%f\n",w/N);return 0;}//时间片轮转算法typedef struct node{char name[20];int round;int cputime;int arrivetime;int needtime;char state;int count;struct node *next;}PCB;PCB *ready=NULL,*run1=NULL,*finish=NULL; int num,i;void GetFirst();void Output();void InsertTime(PCB *in);void InsertFinish(PCB *in);void TimeCreate();void RoundRun();void GetFirst() /*取得第一个就绪队列节点*/ {run1 = ready;if(ready!=NULL){run1 ->state = 'R';ready = ready ->next;run1 ->next = NULL;}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\tcpu时间\t需要时间\t进程状态\t计数器\n");while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->stat e,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->stat e,p->count);p = p->next;}p = run1;while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->stat e,p->count);p = p->next;}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字到达时间进程所需时间时间片大小：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s %d %d %d",tmp->name,&(tmp->arrivetime),&(tmp->needtime),&(tmp ->round));getchar();tmp ->cputime = 0;tmp ->state ='W';// tmp->prio=0;tmp ->count = 0;InsertTime(tmp);}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run1 != NULL){Output();while(flag){run1->cputime++ ;run1->needtime--;run1->count++;if(run1->needtime == 0){run1 ->state = 'F';InsertFinish(run1);flag = 0;}else if(run1->count == run1->round){run1->state = 'W';run1->count=0;InsertTime(run1);flag = 0;}}flag = 1;GetFirst();}}//先来先服务算法typedef struct PCB //定义进程控制块{char ID[3]; //进程号char name[10]; //进程名char state; //运行状态int arrivetime; //到达时间int starttime; //进程开始时间int finishtime; //进程结束时间int servicetime; //服务时间float turnaroundtime;//周转时间float weightedturnaroundtime;//带权周转时间struct PCB *next; //指向下个进程}pcb;int time; //计时器int n; //进程个数pcb *head1=NULL,*p,*q; //进程链表指针void run_fcfs(pcb *p1) //运行未完成的进程{time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间是%d,开始运行作业%s\n",time,p1->name);time+=p1->servicetime;p1->state='T';p1->finishtime=time;p1->turnaroundtime=p1->finishtime-p1->arrivetime;p1->weightedturnaroundtime=p1->turnaroundtime/p1->servicetime; printf("ID 到达时间开始时间服务时间完成时间周转时间带权周转时间\n"); printf("%s%6d%10d%10d%8d%10.1f%10.2f\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p1->finishtime, p1->turnaroundtime,p1->weightedturnaroundtime);}void fcfs() //找到当前未完成的进程{int i,j;p=head1;for(i=0;i<n;i++){if(p->state=='F'){q=p; //标记当前未完成的进程run_fcfs(q);}p=p->next;}}void getInfo() //获得进程信息并创建进程{int num;printf("\n作业个数:");scanf("%d",&n);for(num=0;num<n;num++){p=(pcb *)malloc(sizeof(pcb));printf("依次输入：\nID 进程名到达时间服务时间\n");scanf("%s\t%s\t%d\t%d",&p->ID,&p->name,&p->arrivetime,&p->servicetime); if(head1==NULL) {head1=p;q=p;time=p->arrivetime;}if(p->arrivetime < time) time=p->arrivetime;q->next=p;p->starttime=0;p->finishtime=0;p->turnaroundtime=0;p->weightedturnaroundtime=0;p->next=NULL;p->state='F';q=p;}}//静态优先权优先算法int SequenceNumber=1; //进程编号int ProcessAmount; //进程数量int StartCount=0; //调入内存进程计数struct PCB1{ //进程控制块int No; //进程号char name[16]; //进程名int enterMemoryTime;//进入内存时间int serviceTime; //服务时间int priority; //优先级struct PCB1 *next;};struct PCB1 *head,*thisP,*newP; //动态接收进程及详细struct PCB1 *readyHead; //动态存储就绪队列//函数声明int getch();int timeOfData(FILE *);void ListAllPCB();void Menu();void printPCB(struct PCB1 *,int,int,int,double);void printPCBP(struct PCB1 *);void printField();void printFieldP();void release(struct PCB1 *);void releaseR(struct PCB1 *);void setNewPCB(char *,int,int,int);struct PCB1 * runTheProcess();void newPCB(){ //建立PCBnewP=(struct PCB1 *)malloc(sizeof(struct PCB1));if(head==NULL){ //判断头节点是否为空head=newP; //为空，头节点指向新开辟的内存}else{thisP=head;while(thisP->next!=NULL){thisP=thisP->next;}thisP->next=newP; //遍历单链表，找到最后一个元素}thisP=newP;thisP->No=SequenceNumber;SequenceNumber++;printf("进程号%d\n",thisP->No);printf("输入进程名：");scanf("%s",thisP->name);printf("输入优先级：");scanf("%d",&thisP->priority);printf("输入进入内存时间：");scanf("%d",&thisP->enterMemoryTime);printf("输入服务时间：");scanf("%d",&thisP->serviceTime);thisP->next=NULL;}void buildProcess(){ //创建进程int i=0;printf("输入进程数量：");scanf("%d",&ProcessAmount);while(i<ProcessAmount){newPCB();i++;}}void readyList(struct PCB1 *pcb){ //单链表的形式创建就绪队列newP=(struct PCB1 *)malloc(sizeof(struct PCB1));if(readyHead==NULL){readyHead=newP;}else{thisP=readyHead;while(thisP->next!=NULL){thisP=thisP->next;}thisP->next=newP;}thisP=newP;strcpy(thisP->name,pcb->name);thisP->No=pcb->No;thisP->priority=pcb->priority;thisP->enterMemoryTime=pcb->enterMemoryTime;thisP->serviceTime=pcb->serviceTime;thisP->next=NULL;}struct PCB1 * callMemory(){ //调入内存，返回调入内存的链表节点int at; //到达时间struct PCB1 *markP;if(head==NULL){printf("程序没有找到。

进程调度算法实现//数据：进程，队列结构//处理流程：//1 初始化--进程队列结构（包括：就绪队列，等待队列，运行队列）等必要的数据结构init(); //2 进入无限循环，反复调度队列#define MAX 5#include<stdio.h>#include<stdlib.h>int total_time=20;int time_slice=3;typedef struct process { // 进程控制块char pname[10];int WaitTime;int BurstTime;int priority; // 数字越小优先级越高struct process *next;}PROCESS;//typedef struct process PROCESS;PROCESS * in_queue(PROCESS *head,PROCESS *p); //声明PROCESS *init() //进程初始化{int i=0;char a;PROCESS *head_new; //队列的队头head_new=(struct process*)malloc(sizeof(struct process));if(!head_new) exit(1);head_new=NULL;do{struct process *s;printf("initialize the process:\n");s=(struct process *)malloc(sizeof(struct process));if(!s) exit(1);printf("please input the pname:WaitTime: BurstTime: priority:\n");scanf("%c",&(s->pname));scanf("%d",&(s->WaitTime));scanf("%d",&(s->BurstTime));scanf("%d",&(s->priority));s->next=NULL;in_queue(head_new,s);i++;printf("do u want to insert process more ?? 'Y'or'N'\n");printf("----------------------------------------'\n");scanf("%c",&a);scanf("%c",&a);// if(a=='Y'||a=='y') continue;// else if(a=='N'||a=='n') break;}while((i<MAX) &&(a=='Y'||a=='y'));return head_new;}///////////////////////////////////////////////////////////PROCESS *in_queue(PROCESS *head,PROCESS *p) //入队函数 {if(head==NULL){head=p;p->next=NULL;}else{p->next=head;head=p;}// printf("the process insert into the mothball queue :\n");return head;}//////////////////////////////////////////////////////////////*void new_queue() //后备队列先来先服务方式进入就绪{return *head_new;}*/PROCESS *FCFS_process(){PROCESS *p,*q,*a; //a用来记录选中结点的前一个结点q=p=init(); //这里是不是有个问题？？while(p->next!=NULL){a=p;if(p->WaitTime>=q->WaitTime){q=p;p=p->next;}}q->WaitTime--;if(q->WaitTime==0) //如果等待时间为0则把该进程从后备队列中移除{a->next=p->next;free(p);}return q; //选择等待时间最久的）}//////////////////////就绪队列，入口函数为就绪队列的头指针/////////////int count=0;PROCESS *ready_queue(PROCESS *head) //就绪队列优先级进入运行4道 {PROCESS *p;while(count<4){p=FCFS_process();p->next=head->next;head=p;count++;printf("the process has inserted into the ready queue :\n"); }return head;}//insert_ready() //PROCESS *high_priority(PROCESS *P) //选择优先级最高的进程 {PROCESS *q,*p; //问题，入口形参中q=p;while(p->next!=NULL){if(q->priority>p->priority)q=p;p=p->next;}return q;}PROCESS *pick_ready(PROCESS *a) //从就绪队列中选择进程运行 {PROCESS *p=ready_queue(a);PROCESS *b=high_priority(p);return b;}void run(PROCESS *a) //运行一个时间片{while((time_slice>0)&&(a->BurstTime>0)) //指针用-> 变量用. {printf("the process %c is runing",a->pname);printf("the process BurstTime time is %d ",a->WaitTime);printf("the process BurstTime time is %d ",a->BurstTime);printf("the process priority is %d ",a->priority);a->BurstTime--;time_slice--;}a->priority--;total_time--;/*if(a->runtime>0)return a;else return NULL;*/}void main(){PROCESS *p;PROCESS *head=init();while(total_time!=0) {ready_queue(head); p=pick_ready(head);if(p->BurstTime==0) {p=p->next;free(p);count--;}run(p);time_slice=3;}}原文已完。

c语言实现进程调度算法进程调度算法是操作系统中的一个重要组成部分，用于决定在多道程序环境下，选择哪个进程来占用CPU并执行。

C语言是一种通用的编程语言，可以用于实现各种进程调度算法。

这里我将分别介绍三种常见的进程调度算法：先来先服务调度算法（FCFS）、最短作业优先调度算法（SJF）和轮转法调度算法（RR），并给出用C语言实现的示例代码。

首先，我们来看先来先服务调度算法（FCFS）。

此算法根据到达时间的先后顺序，按照先来后到的顺序进行处理。

下面是基于C语言的先来先服务调度算法实现示例代码：```c#include<stdio.h>struct Process};void FCFS(struct Process proc[], int n)for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}FCFS(proc, n);return 0;```其次，我们来看最短作业优先调度算法（SJF），该算法选择执行时间最短的进程先执行。

下面是基于C语言的最短作业优先调度算法实现示例代码：```c#include<stdio.h>struct Process};void SJF(struct Process proc[], int n)for (int i = 0; i < n; i++)for (int j = 0; j < i; j++)}shortest_job = i;for (int j = i + 1; j < n; j++)shortest_job = j;}}}for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}SJF(proc, n);return 0;```最后，我们来看轮转法调度算法（RR），该算法分配一个时间片给每个进程，当时间片用完后，将CPU分配给下一个进程。

操作系统进程调度优先级算法C语言模拟```cstruct Processint pid; // 进程IDint priority; // 优先级};```接下来，我们使用一个简单的示例来说明操作系统进程调度优先级算法的模拟实现。

假设有5个进程需要调度执行，它们的初始优先级和运行时间如下：进程ID，优先级，已运行时间--------，--------，------------P1，4，2P2，3，4P3，1，6P4，2，1P5，5，3首先，我们需要将这些进程按照优先级排序，以得到调度队列。

可以使用冒泡排序算法实现，代码如下：```cvoid bubbleSort(struct Process *processes, int n)for (int i = 0; i < n - 1; i++)for (int j = 0; j < n - i - 1; j++)if (processes[j].priority > processes[j + 1].priority)struct Process temp = processes[j];processes[j] = processes[j + 1];processes[j + 1] = temp;}}}``````c#include <stdio.h>void bubbleSort(struct Process *processes, int n);int maistruct Process processes[] = {{1, 4, 2}, {2, 3, 4}, {3, 1, 6}, {4, 2, 1}, {5, 5, 3}};int n = sizeof(processes) / sizeof(struct Process);bubbleSort(processes, n);printf("初始调度队列：\n");printf("进程ID\t优先级\t已运行时间\n");for (int i = 0; i < n; i++)}//模拟进程调度printf("\n开始模拟进程调度...\n");int finished = 0;while (finished < n)struct Process *current_process = &processes[0];printf("执行进程 P%d\n", current_process->pid);finished++;printf("进程 P%d 执行完毕\n", current_process->pid);} else}bubbleSort(processes, n);}printf("\n所有进程执行完毕，调度队列的最终顺序为：\n"); printf("进程ID\t优先级\t已运行时间\n");for (int i = 0; i < n; i++)}return 0;```以上代码中，我们使用了一个变量`finished`来记录已完成的进程数量，当`finished`等于进程数量`n`时，所有进程执行完毕。

操作系统五种进程调度算法的代码一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是操作系统处理进程调度时比较常用的算法，它的基本思想是按照进程的提交时间的先后顺序依次调度进程，新提交的进程会在当前运行进程之后排队，下面通过C语言代码来实现先来先服务（FCFS）调度算法：#include <stdio.h>#include <stdlib.h>//定义进程的数据结构struct Processint pid; // 进程标识符int at; // 到达时间int bt; // 执行时间};//进程调度函数void fcfs_schedule(struct Process *processes, int n)int i, j;//根据进程的到达时间排序for(i = 0; i < n; i++)for(j = i+1; j < n; j++)if(processes[i].at > processes[j].at) struct Process temp = processes[i]; processes[i] = processes[j];processes[j] = temp;//获取各个进程执行完毕的时间int ct[n];ct[0] = processes[0].at + processes[0].bt; for(i = 1; i < n; i++)if(ct[i-1] > processes[i].at)ct[i] = ct[i-1] + processes[i].bt;elsect[i] = processes[i].at + processes[i].bt; //计算各个进程的周转时间和带权周转时间int tat[n], wt[n], wt_r[n];for(i = 0; i < n; i++)tat[i] = ct[i] - processes[i].at;wt[i] = tat[i] - processes[i].bt;wt_r[i] = wt[i] / processes[i].bt;printf("P%d:\tAT=%d\tBT=%d\tCT=%d\tTAT=%d\tWT=%d\tWT_R=%f\n", processes[i].pid, processes[i].at, processes[i].bt, ct[i], tat[i], wt[i], wt_r[i]);//主函数int mainstruct Process processes[] ={1,0,3},{2,3,5},{3,4,6},{4,5,2},{5,6,4}};fcfs_schedule(processes, 5);return 0;输出：。