下载文档原格式
操作系统进程调度C语言代码操作系统是计算机系统中的重要组成部分，用于管理和控制计算机资源的分配和使用。
在操作系统中，进程调度是指将系统资源（如 CPU、内存、磁盘、网络等）分配给运行中的进程的过程。
进程调度是操作系统实现多任务、多用户和分时系统的关键。
进程调度的算法有多种。
最常见的是时间片轮转算法、优先级调度算法、最短进程优先算法和先到先服务算法等。
下面我们将介绍一下时间片轮转算法的 C 语言代码实现。
1. 时间片轮转算法时间片轮转算法是一种基于时间片的调度算法，它给每个进程分配一个时间片，当时间片用完后，系统将进程暂停，并将 CPU 分配给下一个进程。
时间片轮转算法可以让所有进程公平地使用 CPU 时间，并且可以避免进程饥饿的情况发生。
2. C 语言代码实现在 C 语言中，可以用结构体来表示一个进程，包括进程 ID、进程状态、优先级、到达时间和需要运行的时间片等属性。
下面是一个简单的进程结构体的定义：```struct Process processes[5];在实现时间片轮转算法之前，需要先实现一个进程调度函数，它的作用是找到就绪进程中优先级最高的进程，并返回它的位置。
下面是一个简单的进程调度函数：```int find_highest_priority_process(struct Process *processes, int n) {int highest_priority = -1;int highest_priority_index = -1;for (int i = 0; i < n; i++) {if (processes[i].state != 2 && processes[i].priority >highest_priority) {highest_priority = processes[i].priority;highest_priority_index = i;}}return highest_priority_index;}```在实现时间片轮转算法之前，需要先定义一些全局变量，包括就绪队列、当前时间、时间片大小和进程数量等。
#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");}。
第1篇---进程管理实验报告一、实验目的1. 理解进程的概念和进程管理的基本原理。
2. 掌握进程的创建、调度、同步和通信等操作。
3. 通过编程实现简单的进程管理功能。
二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);sleep(1); // 模拟任务执行pthread_mutex_unlock(&mutex); // 解锁return NULL;}int main() {pthread_t thread1, thread2;// 初始化互斥锁pthread_mutex_init(&mutex, NULL);// 创建线程pthread_create(&thread1, NULL, thread_func, (void )1); pthread_create(&thread2, NULL, thread_func, (void )2); // 等待线程结束pthread_join(thread1, NULL);pthread_join(thread2, NULL);// 销毁互斥锁pthread_mutex_destroy(&mutex);return 0;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。
操作系统原理实验——进程调度实验报告1目的与要求:1）本实验目的是通过对进程调度算法的实现和实验模拟，加深对操作系统进程调度操作功能和进程调度算法的完整理解，培养和提高学生对操作系统开发的兴趣，以及进程调度程序的开发与应用能力；2）理论上必须深刻理解优先权调度算法和时间片轮转调度算法的基本思想和原理；3）独立使用C或VC++编程语言编写优先权调度或时间片轮转算算法调度模拟程序；4）按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）5）于2009年10月15日以前提交本次实验报告（含电子和纸质报告，由学习委员以班为单位统一打包提交）。
2 实验内容或题目1）设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2）模拟调度程序可任选两种调度算法之一实现（有能力的同学可同时实现两个调度算法）。
3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
4）本次实验内容（项目）的详细说明以及要求请参见实验指导书。
3 实验步骤与源程序#include <stdio.h>#include <string.h>void Check();typedef struct node{char name[10];int span;//轮转时间int take;//占用时间int used;//已用的时间int need;//还需要的时间char status;//状态struct node *next;}PCB;PCB *ready,*finish,*tail,*rear;void Print(PCB *p){while(p!=NULL){printf("%3s%5d%5d%5d%5d%5c\n",p->name,p->used,p->need,p->take,p->span,p->status); p=p->next;}}void Creat(int N){PCB *p;int time;char na[10];ready=NULL; /*就绪队列头指针*/finish=NULL; /*完成队列头指针*/tail=NULL;rear=NULL;printf("Enter name and time of round process \n");for(int i=1;i<=N;i++)//创建就绪队列{p=(PCB *)malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->span=2;p->take=0;p->used=0;p->need=time;p->status='J';if(ready==NULL){ready=p;tail=p;}else{tail->next=p;tail=p;}}printf("……………………运行结果……………………\n");}void Print1(){//输出ready与finish队列PCB *p;p=ready;printf("name,used,need,take,span,state\n");Print(p);p=finish;Print(p);}void Run(){Print1();ready->used+=1;ready->need-=1;ready->take+=1;ready->status='R';if(ready->need!=0)//进程时间need片是否为0{if(ready->take<ready->span)/*占用时间是否到轮转时间，没到就继续，到了就排到就绪队列尾*/ {Run();}else{tail->next=ready;ready=ready->next;tail=tail->next;tail->status='J';tail->take=0;tail->next=NULL;Check();}}else//进程撤销，放入撤销队列{if(finish==NULL){finish=ready;rear=finish;}else{rear->next=ready;rear=rear->next;}ready=ready->next;rear->next=NULL;rear->status='F';rear->take=0;Check();}//Check();由于上多次文调用Run本身递归，此句也会被多调用，产生在结束时的冗余结果；void Check(){if(ready!=NULL) {Run();}else Print1();}main(){int N=0;printf("输入进程数目：");scanf("%d",&N);Creat(N);Check();}4 测试数据与实验结果（可以抓图粘贴）。
进程调度算法实现//数据：进程，队列结构//处理流程：//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;}}。
实验三进程调度1．目的和要求进程调度是处理机管理的核心内容。
本实验要求用C语言编写和调试一个简单的进程调度程序。
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施办法。
2．实验内容①设计进程控制块PCB表结构，分别适用于优先数调度算法和循环轮转调度算法。
②建立进程就绪队列。
对两种不同算法编制入链子程序。
③编制两种进程调度算法：1）优先数调度；2）循环轮转调度3．实验环境①PC兼容机②Windows、DOS系统、Turbo c 2.0③C语言4．实验提示①本程序用两种算法对五个进程进行调度，每个进程可有三个状态，并假设初始状态为就绪状态。
②为了便于处理，程序中的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
③在优先数算法中，优先数可以先取值为50-进程执行时间，进程每执行一次，优先数减3，CPU时间片数加1，进程还需要的时间片数减1。
在轮转算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了2个单位），这时，CPU时间片数加2，进程还需要的时间片数减2，并排列到就绪队列的尾上。
④对于遇到优先数一致的情况，采用FIFO策略解决。
5.有关实验的改进意见:在实验操作过程中，发现用户输入的数据量太大且每次用户输入的大多数数据为重复数据，因此考虑采用文件输入方式，用户只需指定特定的输入文件的文件名来输入数据。
另一方面，程序的输出量较大，可以考虑采用文件输出的方式来储存程序的运行结果。
也可以用实时的输出界面来输出程序结果。
6.实验过程（1）打开vc++,写入代码并编译，无错；（2）调试源程序，出现一个错误；（3）查找错误，进行修改，删除两个“sleep（5）”，编译并调试均无错；（4）按1是优先数算法，根据提示分别输入三个进程名和所需时间；（5）按2是轮转算法，根据提示分别输入三个进程名和所需时间；（6）按3退出；。
一、实验题目进程调度二、实验目的加深对进程、处理机调度的概念及进程调度各种算法（先来先服务、短作业优先、高响应比优先）的理解。
三、实验要求要求用Ｃ语言设计一个模拟单处理机系统下各种调度算法的思想。
要求各种算法均采用非抢占式的调度方式。
四、实验内容设计按先来先服务调度的算法、短作业优先调度的算法和高响应比优先调度算法要求：１、输出进程的执行顺序２、输出算法的平均周转时间和平均带权周转时间五、实验原理先来先服务调度算法的基本思想是：每次调度是从就绪队列中，选择一个最先进入该队列的进程，把处理机分配给它，使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后，才放弃处理机。
短作业优先调度算法的基本思想是：每次调度是从就绪队列中，选择一个运行时间最短的作业，把处理机分配给它，使之投入运行。
该作业程一直运行到完成或发生某事件而阻塞后，才放弃处理机。
高响应比优先调度算法的基本思想是：……………………………………………………六、实验步骤程序设计：#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请输入任意键进入演示过程\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)/padv->needtime padv=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);{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();}调试结果:1.选择操作的界面2.输入操作初始信息:3.先来先服务算法作业调度结果: (调度顺序:a->b->c->d->e)4.最短作业优先算法作业调度结果(调度顺序: a->d->b->e->c)5.高响应比算法作业调度结果: (调度顺序 a->b->d->c->e)七.实验总结：通过本次试验我掌握了作业调度的三种方法：先来先服务调度、短作业优先调度、高响应比优先调度、明确了各种调度算法的优缺点及使用情况和条件，学会了各种算法的原理，能熟练地运用。
操作系统进程调度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++)。
