作业调度源程序C语言

先来先服务和优先数调度算法c语言先来先服务和优先数调度算法c语言一、前言操作系统中的进程调度是指在多道程序环境下，按照一定的规则从就绪队列中选择一个进程，将CPU分配给它运行。

常用的进程调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。

本文将介绍两种常见的进程调度算法：先来先服务和优先数调度算法，并给出相应的C语言实现。

二、先来先服务算法1. 算法原理FCFS即First Come First Served，也称为FIFO（First In First Out），是一种非抢占式的进程调度算法。

按照任务到达时间的顺序进行处理，即谁先到达谁就被处理。

2. 算法流程（1）按照任务到达时间排序；（2）依次执行每个任务，直至所有任务都完成。

3. C语言实现下面是一个简单的FCFS程序：```c#include <stdio.h>struct process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间int waiting_time; // 等待时间};int main() {struct process p[10];int n, i, j;float avg_waiting_time = 0;printf("请输入进程数：");scanf("%d", &n);for (i = 0; i < n; i++) {printf("请输入第%d个进程的信息：\n", i + 1); printf("进程ID：");scanf("%d", &p[i].pid);printf("到达时间：");scanf("%d", &p[i].arrival_time);printf("执行时间：");scanf("%d", &p[i].burst_time);}for (i = 0; i < n; i++) {for (j = 0; j < i; j++) {if (p[j].arrival_time > p[j + 1].arrival_time) { struct process temp = p[j];p[j] = p[j + 1];p[j + 1] = temp;}}}int current_time = p[0].arrival_time;for (i = 0; i < n; i++) {if (current_time < p[i].arrival_time) {current_time = p[i].arrival_time;}p[i].waiting_time = current_time - p[i].arrival_time;current_time += p[i].burst_time;}printf("进程ID\t到达时间\t执行时间\t等待时间\n");for (i = 0; i < n; i++) {printf("%d\t%d\t%d\t%d\n", p[i].pid, p[i].arrival_time, p[i].burst_time, p[i].waiting_time);avg_waiting_time += (float)p[i].waiting_time / n;}printf("平均等待时间：%f\n", avg_waiting_time);return 0;}```三、优先数调度算法1. 算法原理优先数调度算法是一种非抢占式的进程调度算法。

#include <stdio.h>struct sjf //定义进程的结构体{char name[10]; //进程名float arrivetime; //到达时间float servicetime; //服务时间float starttime; //开始时间float finishtime; //完成时间float zztime; //周转时间float dqzztime; //带权周转时间};sjf b[100]; //定义短作业优先算法进程的最大数量void Sinput(sjf *p,int N) //输入函数{int i;printf("输入进程的名称、到达时间、服务时间:（例如: x 0 100）\n");for(i=0;i<=N-1;i++){printf("输入第%d进程的名称、到达时间、服务时间:",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}//输出函数void SPrint(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;printf("\n执行顺序:\n");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-%s",p[k].name);}printf("\n进程名\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[k].name,p[k].arrivetime,p[k].ser vicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);}}void Ssort(sjf *p,int N) //按短作业优先算法排序{for(int i=1;i<=N-1;i++)for(int j=1;j<=i;j++)if(p[i].servicetime<p[j].servicetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//运行结果void Sdeal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime; //开始时间=前一个进程的完成时间p[k].finishtime=p[k-1].finishtime+p[k].servicetime; //结束时间=前一个进程的完成时间+现在进程的服务时间}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime; //周转时间=完成时间-到达时间p[k].dqzztime=p[k].zztime/p[k].servicetime; //带权周转时间=周转时间/服务时间}}void SJF(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;Ssort(p,N);Sdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);SPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);}void main() //主函数{ int M;printf("------------短作业优先调度算法-----------\n");printf("输入进程数:");scanf("%d",&M);Sinput(b,M);SJF(b,M);}。

调度算法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）调度算法，首先根据进程的到达时间排序，然后依次执行每个进程，并计算总等待时间和总周转时间。

fcfs调度算法c语言实现-回复FCFS调度算法（First-Come, First-Served）是操作系统中的一种简单且常见的进程调度算法。

在该算法中，进程按照到达的先后顺序被依次执行，即先到先服务。

本文将详细介绍FCFS调度算法的实现原理和步骤，并通过C语言代码实现。

一、概述进程调度是操作系统中的重要组成部分，它负责按照一定的策略和规则决定哪个进程可以执行，并分配处理器时间给它。

FCFS调度算法是最简单的调度算法之一，它不考虑进程的优先级或执行时间，只关注进程到达的先后顺序。

二、FCFS调度算法的实现步骤下面是FCFS调度算法的实现步骤：1. 定义进程控制块（PCB）结构体：PCB是描述进程的数据结构，其中包括进程ID、到达时间、执行时间等信息。

可以使用C语言的结构体来定义PCB。

2. 输入进程信息：通过键盘输入进程的到达时间和执行时间，创建多个进程，并将它们存储在一个进程队列中。

3. 按到达时间排序：对进程队列按照到达时间进行排序，以确保进程按照到达的先后顺序执行。

可以使用C语言的排序算法（如冒泡排序）来实现。

4. 计算等待时间和周转时间：对于排好序的进程队列，逐个计算每个进程的等待时间和周转时间。

等待时间等于前面所有进程的执行时间之和，而周转时间等于等待时间加上执行时间。

5. 输出结果：打印每个进程的信息，包括进程ID、到达时间、执行时间、等待时间和周转时间。

同时，计算平均等待时间和平均周转时间并输出。

三、C语言实现代码以下是使用C语言实现FCFS调度算法的示例代码：c#include <stdio.h>typedef struct {int processId;int arrivalTime;int burstTime;int waitingTime;int turnaroundTime;} PCB;void sortByArrivalTime(PCB *processes, int n) {for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) {if (processes[j].arrivalTime > processes[j +1].arrivalTime) {PCB temp = processes[j];processes[j] = processes[j + 1];processes[j + 1] = temp;}}}}void calculateWaitingTime(PCB *processes, int n) {processes[0].waitingTime = 0;for (int i = 1; i < n; i++) {processes[i].waitingTime = processes[i - 1].waitingTime + processes[i - 1].burstTime;}}void calculateTurnaroundTime(PCB *processes, int n) { for (int i = 0; i < n; i++) {processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;}void printResult(PCB *processes, int n) {printf("Process\tArrival Time\tBurst Time\tWaitingTime\tTurnaround Time\n");for (int i = 0; i < n; i++) {printf("d\td\t\td\t\td\t\td\n", processes[i].processId, processes[i].arrivalTime,processes[i].burstTime, processes[i].waitingTime, processes[i].turnaroundTime);}int totalWaitingTime = 0;int totalTurnaroundTime = 0;for (int i = 0; i < n; i++) {totalWaitingTime += processes[i].waitingTime;totalTurnaroundTime += processes[i].turnaroundTime;}printf("Average waiting time: .2f\n", (float) totalWaitingTime / n);printf("Average turnaround time: .2f\n", (float) totalTurnaroundTime / n);}int main() {int n;printf("Enter the number of processes: ");scanf("d", &n);PCB processes[n];printf("Enter the arrival time and burst time of each process:\n");for (int i = 0; i < n; i++) {printf("Process d: ", i + 1);scanf("dd", &processes[i].arrivalTime,&processes[i].burstTime);processes[i].processId = i + 1;}sortByArrivalTime(processes, n);calculateWaitingTime(processes, n);calculateTurnaroundTime(processes, n);printResult(processes, n);return 0;}以上代码首先定义了PCB结构体，然后通过键盘输入进程的到达时间和执行时间，创建进程队列。

操作系统进程调度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++)。

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语言代码(总16页)本页仅作为文档封面，使用时可以删除This document is for reference only-rar21year.March// sun.cpp : 定义控制台应用程序的入口点。

//本算法包含四种调度:先到先服务，短作业优先，时间片轮转，优先级优先！#include"stdio.h"#define N 50void main(){ void sjp();void fcfs();void sjf();void yxj();int a;while(true){printf("\n\n");printf("\t\t/*************************/");printf("\n\t\t/* 1、先到先服务调度 */");printf("\n\t\t/* 2、短作业优先调度 */");printf("\n\t\t/* 3、时间片轮转调度 */");printf("\n\t\t/* 4、优先级优先调度 */");printf("\n\t\t/* 0、退出 */\n");printf("\t\t/*************************/");printf("\n\n\t请选择菜单项：\t");scanf("%d",&a);printf("\n");switch(a){case 1: fcfs();break;case 2: sjf();break;case 3: sjp();break;case 4: yxj();break;default: break;}if(a<0&&a>4) break;}}void sjp(){int i,j,n,min,px,sjp,time;float sum1,sum2;bool flag=true;printf("\t请输入有n个进程(0<n<=50):\t"); scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入： ");scanf("%d",&n);}printf("\n\n");printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sjp);while(sjp<=0){printf("n\t请重新输入： ");scanf("%d",&sjp);}struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间： ");scanf("%d",&a[i].dt);printf("\t服务时间： ");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].st2;a[i].st2=a[i+1].st2;a[i+1].st2=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}time = a[0].dt;//printf("赋值后TIME值为：%d\n",time);min = 0;while(min<n){flag = true;for(i = 0;i<n;i++){if(a[i].st2>0&&a[i].dt<=time)flag = false;}for(i=0;i<n;i++){if(a[i].st2 > 0 ){if(a[i].dt<=time){//printf("当前a[%d].st2值为：%d\n",i,a[i].st2);a[i].st2 = a[i].st2 - sjp;//printf("运算后当前a[%d].st2值为：%d\n",i,a[i].st2);//printf("当前TIME值为：%d\n",time);time = time + sjp;//printf("增加之后TIME值为：%d\n",time);if(a[i].st2<=0){a[i].wct = time + a[i].st2;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;min++;}}else if(flag){for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt>time){time = a[i].dt;break;}}}}}}printf("\t1、按id号依次输出\n");printf("\t2、按完成顺序依次输出\n");printf("\n\t请选择输出顺序:\t");scanf("%d",&px);printf("\nid：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i]. zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i]. zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}void fcfs(){int i,j,n,min,px;float sum1,sum2;printf("\t请输入有n个进程(0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入： ");scanf("%d",&n);}printf("\n\n");struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间： ");scanf("%d",&a[i].dt);printf("\t服务时间： ");scanf("%d",&a[i].st);printf("\n");}for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}printf("\t1、按id号依次输出\n");printf("\t2、按完成顺序依次输出\n");printf("\n\t请选择输出顺序:\t");scanf("%d",&px);printf("\nid：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i]. zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i]. zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}void sjf(){int i,j,n,min,px;int b=0,z;float sum1,sum2;printf("\n\t\t请输入有n个进程(0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入： ");scanf("%d",&n);}printf("\n");struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间： ");scanf("%d",&a[i].dt);printf("\t服务时间： ");scanf("%d",&a[i].st);printf("\n");}min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}if(a[i].dt==a[i+1].dt&&a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b=b+1;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st; a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].st>a[z+1].st){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n\t请选择输出顺序\n");printf("\t1、按id号依次输出\n");printf("\t2、按完成顺序依次输出\n");scanf("%d",&px);printf("\nid：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i]. zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d： %d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i]. zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n); break;}default: break;}}void yxj(){int i,j,n,min,px;int b=0,z;float sum1,sum2;printf("\n\t\t请输入有n个进程(0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入： ");scanf("%d",&n);}printf("\n");struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int yxj; //优先级int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间： ");scanf("%d",&a[i].dt);printf("\t服务时间： ");scanf("%d",&a[i].st);printf("\t优先级： ");scanf("%d",&a[i].yxj);printf("\n");}min=a[0].dt;for(j=n-1;j>=0;j--) {for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}if(a[i].dt==a[i+1].dt&&a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++) {if(a[i].dt>a[0].wct) ;else b++;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].yxj<a[z+1].yxj){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n\t请选择输出顺序\n");printf("\t1、按id号依次输出\n");printf("\t2、按完成顺序依次输出\n");scanf("%d",&px);printf("\nid：到达时间\t服务时间\t优先级\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;switch(px){case 2:{for(i=0;i<n;i++){printf("%d： %d\t\t%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].s t,a[i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}case 1:{for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d： %d\t\t%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].s t,a[i].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("\n平均周转时间：%.2f\n",sum1/n);printf("\n平均带权周转时间：%.2f\n\n",sum2/n);break;}default: break;}}17。

时间片轮转调度算法是一种操作系统进程调度算法，它是先进先出（FIFO）调度算法的一种改进版本。

以下是一个用C语言实现的时间片轮转调度算法的简单示例：```c#include <stdio.h>#include <stdlib.h>#define QUANTUM 2 // 定义时间片长度#define PROCESSES 5 // 定义进程数量// 进程结构体typedef struct {int process_id;int arrival_time;int burst_time;int remaining_time;int finished;} Process;// 初始化进程队列void init_processes(Process *processes, int processes_num) {for (int i = 0; i < processes_num; i++) {processes[i].process_id = i + 1;processes[i].arrival_time = i % 5 + 1;processes[i].burst_time = 5;processes[i].remaining_time = processes[i].burst_time;processes[i].finished = 0;}}// 时间片轮转调度void round_robin(Process *processes, int processes_num) {int time = 0;int finished_processes = 0;while (finished_processes < processes_num) {for (int i = 0; i < processes_num; i++) {if (processes[i].arrival_time <= time && !processes[i].finished) { if (processes[i].remaining_time > QUANTUM) {processes[i].remaining_time -= QUANTUM;printf("Time %d: Process %d is running\n", time, processes[i].process_id);} else {processes[i].finished = 1;finished_processes++;printf("Time %d: Process %d is finished\n", time, processes[i].process_id);}}}time++;}}int main() {Process processes[PROCESSES];init_processes(processes, PROCESSES);round_robin(processes, PROCESSES);return 0;}```这个示例中，我们定义了一个进程结构体，包括进程ID、到达时间、运行时间、剩余时间和是否完成。

作业调度算法源代码#include <stdio.h>#include <stdlib.h>#define ReadyLimit 5typedef struct job{int id;int needtime;int arrivetime;int starttime;int finishtime;int remainder;float priority;struct job *next;} jobnode,*jobnodeptr;jobnodeptr joblist,readylist,runlist,collectlist; int systime;void init(void){joblist=(jobnodeptr)malloc(sizeof(jobnode)); joblist->id=-1;joblist->next=NULL;readylist=(jobnodeptr)malloc(sizeof(jobnode)); readylist->id=-1;readylist->next=NULL;collectlist=(jobnodeptr)malloc(sizeof(jobnode));collectlist->id=-1;collectlist->next=NULL;runlist=NULL;systime=-1;}void file2joblist(void){FILE *fp;jobnodeptr p,q;int i,j;fp=fopen("input.txt","rt");if (!fp){printf("Can't open file");exit(1);}p=joblist;fscanf(fp,"%d",&i);for (j=0;j<i;j++){q=(jobnodeptr)malloc(sizeof(jobnode));fscanf(fp,"%d%d%d",&q->id,&q->needtime,&q->arrivetime); q->starttime=0;q->finishtime=0;q->remainder=q->needtime;q->priority=-1.0;p->next=q;p=q;}p->next=NULL;fclose(fp);}void jobdispatch(void)/*作业调度*/{jobnodeptr p,q;int count=0;float maxpri;p=readylist;/*计算readylist中进程的个数*/while (p->next){count++;p=p->next;}if (count>=ReadyLimit) return;p=joblist->next;/*计算已到达作业的响应比*/while (p){if (p->arrivetime<=systime)p->priority=(systime-p->arrivetime)/(float)p->needtime; p=p->next;}while (count<ReadyLimit){maxpri=-1.0;p=joblist;q=NULL;while (p->next){if (p->next->priority > maxpri){maxpri = p->next->priority; q = p;}p=p->next;}if (q){p=q->next;q->next=p->next;p->next=NULL;q=readylist;while (q->next)q=q->next;q->next=p;p->starttime=systime;count++;}else break;}}void processdispatch(void)/*进程调度*/{runlist=readylist->next;if (runlist) {readylist->next=runlist->next;runlist->next=NULL;}}void running(void)/*模拟运行*/{jobnodeptr p;if (runlist){printf("%4d:%-4d ",systime,runlist->id);runlist->remainder--;if (runlist->remainder){p=readylist;while (p->next)p=p->next;p->next=runlist;}else{runlist->finishtime=systime;p=collectlist;while (p->next&& (p->next->starttime < runlist->starttime) /*&& (p->next->id < runlist->id)*/)p=p->next;runlist->next=p->next;p->next=runlist;}runlist=NULL;}else printf("%4d:idle ",systime);}void display(void)/*显示信息*/{jobnodeptr p;printf("id----- need--- arrive- start-- finish-\n");p=collectlist->next;while (p){printf("%-7d %-7d %-7d %-7d %-7d\n",p->id,\p->needtime,p->arrivetime,p->starttime,p->finishtime); p=p->next;}}void freeall(void){jobnodeptr p,q;p=collectlist;while (p){q=p;p=p->next;free(q);}free(joblist);free(readylist);}int main(void){init();file2joblist();while (1){systime++;jobdispatch();processdispatch();running();if (joblist->next==NULL && readylist->next==NULL)break;}printf("\n\n"); display();freeall();getchar();return 0;}。

实验二作业调度一.实验题目1、编写并调试一个单道处理系统的作业等待模拟程序。

作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。

（1）先来先服务算法：按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。

（2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。

（3）响应比高者优先算法：是在每次调度前都要计算所有被选作业（在后备队列中）的响应比，然后选择响应比最高的作业执行。

2、编写并调度一个多道程序系统的作业调度模拟程序。

作业调度算法：采用基于先来先服务的调度算法。

可以参考课本中的方法进行设计。

对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。

二.实验目的：本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解三 .实验过程<一>单道处理系统作业调度1)单道处理程序作业调度实验的源程序: zuoye.c执行程序: zuoye.exe2)实验分析：1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU 时限等因素。

2、每个作业由一个作业控制块JCB 表示，JCB 可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。

每个作业的最初状态总是等待W 。

3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间。

3)流程图:二.最短作业优先算法三.高响应比算法图一.先来先服务流程图4)源程序:#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0int n;float T1=0,T2=0;int times=0;代替代替struct jcb //作业控制块{char name[10]; //作业名int reachtime; //作业到达时间int starttime; //作业开始时间int needtime; //作业需要运行的时间float super; //作业的响应比int finishtime; //作业完成时间float cycletime; //作业周转时间float cltime; //作业带权周转时间char state; //作业状态struct jcb *next; //结构体指针}*ready=NULL,*p,*q;typedef struct jcb JCB;void inize() //初始化界面{printf("\n\n\t\t******************************************* **\t\t\n");printf("\t\t\t\t实验二作业调度\n");printf("\t\t*********************************************\t\t\n");printf("\n\n\n\t\t\t\t\t计算机学院软件四班\n");printf("\t\t\t\t\t蓝小花\n");printf("\t\t\t\t\t完成日期：2006年11月17号");printf("\n\n\n\t\t请输入任意键进入演示过程\n");getch();}void inital() //建立作业控制块队列,先将其排成先来先服务的模式队列{int i;printf("\n输入作业数:");scanf("%d",&n);for(i=0;i<n;i++){p=getpch(JCB);printf("\n输入作业名:");scanf("%s",p->name);getch();p->reachtime=i;printf("作业默认到达时间:%d",i);printf("\n输入作业要运行的时间:");scanf("%d",&p->needtime);p->state='W';p->next=NULL;if(ready==NULL) ready=q=p;else{q->next=p;q=p;}}}void disp(JCB* q,int m) //显示作业运行后的周转时间及带权周转时间等{if(m==3) //显示高响应比算法调度作业后的运行情况{printf("\n作业%s正在运行，估计其运行情况：\n",q->name);printf("开始运行时刻：%d\n",q->starttime);printf("完成时刻：%d\n",q->finishtime);printf("周转时间：%f\n",q->cycletime);printf("带权周转时间：%f\n",q->cltime);printf("相应比:%f\n",q->super);getch();}else // 显示先来先服务,最短作业优先算法调度后作业的运行情况{printf("\n作业%s正在运行，估计其运行情况：\n",q->name); printf("开始运行时刻：%d\n",q->starttime);printf("完成时刻：%d\n",q->finishtime);printf("周转时间：%f\n",q->cycletime);printf("带权周转时间：%f\n",q->cltime);getch();}}void running(JCB *p,int m) //运行作业{if(p==ready) //先将要运行的作业从队列中分离出来{ready=p->next;p->next=NULL;}else{q=ready;while(q->next!=p) q=q->next;q->next=p->next;}p->starttime=times; //计算作业运行后的完成时间,周转时间等等p->state='R';p->finishtime=p->starttime+p->needtime;p->cycletime=(float)(p->finishtime-p->reachtime); p->cltime=(float)(p->cycletime/p->needtime);T1+=p->cycletime;T2+=p->cltime;disp(p,m); //调用disp()函数,显示作业运行情况times+=p->needtime;p->state='F';printf("\n%s has been finished!\npress any key to continue...\n",p->name);free(p); //释放运行后的作业getch();}void super() //计算队列中作业的高响应比{JCB *padv;padv=ready;do{if(padv->state=='W'&&padv->reachtime<=times)padv->super=(float)(times-padv->reachtime+padv->needtime)/p adv->needtimepadv=padv->next;}while(padv!=NULL);}void final() //最后打印作业的平均周转时间,平均带权周转时间{float s,t;t=T1/n;s=T2/n;getch();printf("\n\n作业已经全部完成!");printf("\n%d个作业的平均周转时间是：%f",n,t);printf("\n%d个作业的平均带权周转时间是%f：\n\n\n",n,s); }void hrn(int m) //高响应比算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;super();do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p;p=p->next;}while(p!=NULL);if(iden){i--;times++;//printf("\ntime=%d:\tno JCB submib...wait...",time);if(times>1000){printf("\nruntime is too long...error...");getch();}}else{running(min,m); //调用running()函数}} //forfinal(); //调用running()函数}void sjf(int m) // 最短作业优先算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++)p=min=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->needtime<min->needtime) min=p;p=p->next;}while(p!=NULL) ;if(iden) {i--; //printf("\ntime=%d:\tno JCB submib...wait...",time);times++;if(times>100){printf("\nruntime is too long...error");getch();}}else{running(min,m); //调用running()函数}} //forfinal(); //调用running()函数void fcfs(int m) //先来先服务算法{int i,iden;system("cls");inital();for(i=0;i<n;i++){p=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times) iden=0; if(iden)p=p->next;}while(p!=NULL&&iden) ;if(iden){i--;printf("\n没有满足要求的进程,需等待");times++;if(times>100){printf("\n时间过长");getch();}}else{running(p,m); //调用running()函数}}final(); //调用running()函数}void mune(){int m;system("cls");printf("\n\n\t\t******************************************* **\t\t\n");printf("\t\t\t\t作业调度演示\n");printf("\t\t*********************************************\t \t\n");printf("\n\n\n\t\t\t1.先来先服务算法.");printf("\n\t\t\t2.最短作业优先算法.");printf("\n\t\t\t3.响应比高者优先算法");printf("\n\t\t\t0.退出程序.");printf("\n\n\t\t\t\t选择所要操作:");scanf("%d",&m);switch(m){case 1:fcfs(m);getch();system("cls"); mune();break;case 2:sjf(m);getch();system("cls"); mune();break;case 3:hrn(m);getch();system("cls"); mune();break;case 0:system("cls"); break;default:printf("选择错误,重新选择.");getch();system("cls");mune();}}main() //主函数{inize();mune();}5)调试结果:1.选择操作的界面2.输入操作初始信息:3.先来先服务算法作业调度结果: (调度顺序:a->b->c->d->e)4.最短作业优先算法作业调度结果(调度顺序: a->d->b->e->c)5.高响应比算法作业调度结果: (调度顺序 a->b->d->c->e)<二>多道处理系统作业调度1)多道处理程序作业调度实验的源程序: duodao.c执行程序: duodao.exe2)实验分析：采用多道程序设计方法的操作系统，在系统中要经常保留多个运行的作业，以提高系统效率。