先来先服务调度算法模拟实验程序源代码(C语言)

合集下载

先来先服务调度算法模拟实验程序源代码

先来先服务调度算法模拟实验程序源代码以下是一个使用C语言编写的先来先服务调度算法模拟实验程序的源代码：```C#include <stdio.h>//进程控制块结构体typedef struct ProcessControlBlockint pid; // 进程IDint arrival; // 到达时间int burst; // 执行时间int wait; //等待时间int turnaround; // 周转时间}PCB;//计算平均等待时间和平均周转时间void calculateAverageTime(PCB processes[], int n)int totalWait = 0, totalTurnaround = 0;for (int i = 0; i < n; i++)totalWait += processes[i].wait;totalTurnaround += processes[i].turnaround;}float averageWait = (float)totalWait / n;float averageTurnaround = (float)totalTurnaround / n;printf("\n平均等待时间：%0.2f\n", averageWait);printf("平均周转时间：%0.2f\n", averageTurnaround);//先来先服务调度算法void FCFS(PCB processes[], int n)int currentTime = 0;//计算每个进程的等待时间和周转时间for (int i = 0; i < n; i++)if (currentTime < processes[i].arrival)currentTime = processes[i].arrival;}processes[i].wait = currentTime - processes[i].arrival;processes[i].turnaround = processes[i].burst + processes[i].wait;currentTime += processes[i].burst;}//打印每个进程的信息printf("\n进程ID\t到达时间\t执行时间\t等待时间\t周转时间\n");for (int i = 0; i < n; i++)printf("%d\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].pid, processes[i].arrival, processes[i].burst, processes[i].wait, processes[i].turnaround);}//计算平均等待时间和平均周转时间calculateAverageTime(processes, n);int maiint n; // 进程数量printf("请输入进程数量：");scanf("%d", &n);PCB processes[n];//输入每个进程的到达时间和执行时间for (int i = 0; i < n; i++)processes[i].pid = i + 1;printf("请输入第%d个进程的到达时间：", i + 1);scanf("%d", &processes[i].arrival);printf("请输入第%d个进程的执行时间：", i + 1);scanf("%d", &processes[i].burst);}//调用先来先服务调度算法FCFS(processes, n);return 0;```该程序使用了一个`ProcessControlBlock`结构体来表示进程的相关信息，包括进程ID、到达时间、执行时间、等待时间和周转时间。

先来先服务和优先数调度算法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. 算法原理优先数调度算法是一种非抢占式的进程调度算法。

操作系统实验报告——调度算法

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。

2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。

3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。

该算法按照进程到达的先后顺序进行调度。

在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。

3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。

在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。

如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。

在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。

- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。

- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。

5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。

调度算法C语言实现

调度算法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）调度算法先来先服务（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;输出：。

先来先服务调度算法C语言实现

#include <stdio.h>struct fcfs //定义进程的结构体{char name[10]; //进程名float arrivetime; //到达时间float servicetime; //服务时间float starttime; //开始时间float finishtime; //完成时间float zztime; //周转时间float dqzztime; //带权周转时间};fcfs a[100]; //定义先来先服务算法进程的最大数量void Finput(fcfs *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 FPrint(fcfs *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\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 Fsort(fcfs *p,int N) //按到达时间排序，先到达排在前面{for(int i=0;i<=N-1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){fcfs temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//运行结果void Fdeal(fcfs *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 FCFS(fcfs *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;Fsort(p,N);Fdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);FPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);}void main() //主函数{int N;printf("------先来先服务调度算法------\n");printf("输入进程数:");scanf("%d",&N);Finput(a,N);FCFS(a,N);}。

进程调度模拟设计——先来先服务优先级法

进程调度模拟设计——先来先服务优先级法首先，我们来介绍先来先服务调度算法。

FCFS调度算法的原则是按照进程到达的先后顺序进行调度，即先到先执行。

具体步骤如下：1.首先，将所有等待执行的进程按照到达的时间进行排序，即按照先后顺序排列进程队列。

2.选择队列中的第一个进程执行，其余的进程处于等待状态。

3.当当前进程执行完毕或者发生阻塞时，调度器从进程队列中选择下一个进程执行。

4.重复以上步骤，直到所有进程执行完毕。

虽然FCFS调度算法的实现简单，但是存在一个明显的问题，即“饥饿问题”，即如果队列中存在一个长时间执行的进程，其他进程会一直等待，无法得到执行机会。

为了解决饥饿问题，我们引入优先级法调度算法。

优先级法调度算法基于每个进程的优先级来决定调度顺序，具体步骤如下：1.对每个进程设置一个优先级，取值范围从1到n，数值越高表示优先级越高。

2.调度器根据进程的优先级将进程排序，高优先级的进程排在前面。

3.选择优先级最高的进程执行，其余进程处于等待状态。

4.当当前进程执行完毕或者发生阻塞时，调度器从进程队列中选择下一个优先级最高的进程执行。

5.重复以上步骤，直到所有进程执行完毕。

优先级法调度算法解决了饥饿问题，使得所有进程都有机会执行。

然而，优先级法调度算法可能存在一个问题，即“优先级反转问题”。

如果一个低优先级的进程持有一个高优先级的资源，那么其他高优先级的进程就会一直等待，无法得到高优先级资源的使用权。

为了解决优先级反转问题，可以引入优先级继承机制或者抢占式调度策略。

总结起来，先来先服务调度算法按照进程到达的先后顺序进行调度，实现简单但容易导致饥饿问题；优先级法调度算法根据进程的优先级进行调度，避免了饥饿问题但可能导致优先级反转问题。

需要根据不同的应用场景和需求来选择合适的调度算法。

先来先服务调度算法实验内容

先来先服务调度算法实验内容
先来先服务调度算法是一种非常基本的调度算法，也是比较容易理解和实现的算法之一。

它的基本思想是按照进程到达的先后顺序依次执行，每个进程的执行时间是固定的。

在实际的操作系统中，先来先服务调度算法在某些场景下仍然有一定的应用。

实验内容如下：
1. 编写一个程序模拟先来先服务调度算法的执行过程。

2. 程序中应该包含以下内容：
- 进程的到达时间、需要执行的时间和进程编号等信息
- 调度算法的具体实现
- 输出每个进程的开始时间、完成时间、周转时间和带权周转时间等信息
- 统计并输出平均周转时间和平均带权周转时间
3. 通过调整进程的到达时间和需要执行的时间等参数，观察调度算法的性能表现和结果变化。

4. 进一步思考和探讨先来先服务调度算法的优缺点，以及在实际操作系统中是否有应用场景。

5. 拓展思考：如何改进先来先服务调度算法，以适应更多的应用场景和实际需要？。

操作系统五种进程调度算法的代码

进程调度算法的模拟实现⏹实验目的1．本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。

2．利用程序设计语言编写算法，模拟实现先到先服务算法FCFS、轮转调度算法RR、最短作业优先算法SJF、优先级调度算法PRIOR、最短剩余时间优先算法SRTF。

3．进行算法评价，计算平均等待时间和平均周转时间。

⏹实验内容及结果1．先来先服务算法2．轮转调度算法3. 优先级调度算法4. 最短时间优先算法5. 最短剩余时间优先算法⏹实验总结在此次模拟过程中，将SRTF单独拿了出来用指针表示，而其余均用数组表示。

⏹完整代码【Srtf.cpp代码如下：】//最短剩余时间优先算法的实现#include<stdio.h>#include<stdlib.h>#include<time.h>typedefstruct{int remain_time;//进程剩余执行时间int arrive_time;//进程到达时间int Tp;//进入就绪队列的时间int Tc;//进入执行队列的时间int To;//进程执行结束的时间int number;//进程编号}Process_Block;//定义进程模块typedefstruct _Queue{Process_Block PB;struct _Queue *next;}_Block,*Process;//定义一个进程模块队列中结点typedefstruct{Process head;//队列头指针Process end;//队列尾指针}Process_Queue;//进程队列Process_Queue PQ;//定义一个全局队列变量int t;//全局时间Process Run_Now;//当前正在运行的进程，作为全局变量void InitQueue(Process_Queue PQ){PQ.head ->next = NULL;PQ.end ->next = PQ.head;}/*初始化队列*/int IsEmpty(Process_Queue PQ){if(PQ.end->next == PQ.head)return 1;//队列空的条件为头指针指向尾指针并且尾指针指向头指针elsereturn 0;}/*判定队列是否为空队列*/void EnQueue(Process_Queue PQ,Process P){Process temp =(Process)malloc(sizeof(_Block));temp = PQ.end;temp->next->next = P;PQ.end->next = P;}/*插入队列操作*/Process DeQueue(Process_Queue PQ){if(IsEmpty(PQ))return NULL;Process temp = PQ.head->next;PQ.head->next= temp ->next;if(PQ.end->next == temp)PQ.end->next = PQ.head;return temp;}/*出列操作*/Process ShortestProcess(Process_Queue PQ){if(IsEmpty(PQ))//如果队列为空，返回{if(!Run_Now)return NULL;elsereturn Run_Now;}Process temp,shortest,prev;int min_time;if(Run_Now)//如果当前有进程正在执行，{shortest = Run_Now;//那么最短进程初始化为当前正在执行的进程，min_time = Run_Now->PB.remain_time;}else//如果当前没有进程执行，{shortest = PQ.head->next;//则最短进程初始化为队列中第一个进程min_time = PQ.head->next->PB.remain_time;}temp = PQ.head;prev = temp;while(temp->next){if(temp->next->PB.remain_time <min_time)//如果当前进程的剩余时间比min_time短，{shortest = temp->next;//则保存当前进程，min_time = shortest->PB.remain_time;prev=temp;//及其前驱}temp=temp->next;}if(shortest == PQ.end->next)//如果最短剩余时间进程是队列中最后一个进程，PQ.end->next = prev;//则需要修改尾指针指向其前驱prev->next = shortest->next;//修改指针将最短剩余时间进程插入到队头return shortest;}/*调度最短剩余时间的进程至队头*/void Run(){Run_Now->PB.remain_time--;//某一时间运行它的剩余时间减return;}/*运行函数*/void Wait(){return ;}int sum(intarray[],int n){int i,sum=0;for(i=0;i<n;i++)sum+=array[i];return sum;}int main(){PQ.head = (Process)malloc(sizeof(_Block));PQ.end = (Process)malloc(sizeof(_Block));Run_Now = (Process)malloc(sizeof(_Block));Run_Now =NULL;InitQueue(PQ);int i,N,Total_Time=0;//Total_Time为所有进程的执行时间之和printf("请输入计算机中的进程数目:\n");scanf("%d",&N);Process *P,temp;P = (Process*)malloc(N*sizeof(Process));int *wt,*circle_t;wt =(int*)malloc(N*sizeof(int));circle_t =(int*)malloc(N*sizeof(int));for(i=0;i<N;i++){P[i] = (Process)malloc(sizeof(_Block));P[i]->PB.number =i+1;P[i]->next =NULL;wt[i] =0;circle_t[i] =0;printf("输入第%d个进程的到达时间及剩余执行时间:\n",i+1);scanf("%d %d",&P[i]->PB.arrive_time,&P[i]->PB.remain_time);}for(i=0;i<N;i++)Total_Time+=P[i]->PB.remain_time;printf("\n进程按顺序运行依次为:\n");i=0;int k=0;for(t=0;;t++){if(Run_Now)//如果当前有进程正在执行{Run();if(t == P[i]->PB.arrive_time)//如果当前时间正好有进程进入{if(P[i]->PB.remain_time < Run_Now->PB.remain_time){temp = P[i];P[i] = Run_Now;Run_Now = temp;//则调度它至运行队列中，Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}EnQueue(PQ,P[i]);//并将当前运行进程重新插入队列中P[i]->PB.Tp=t;k++;i=(i+1)>(N-1)?(N-1):(i+1);}if(Run_Now->PB.remain_time == 0)//如果当前进程运行结束，{Run_Now->PB.To=t;//进程运行结束的时间circle_t[Run_Now->PB.number-1] +=t-Run_Now->PB.arrive_time;free(Run_Now);//则将它所占资源释放掉，Run_Now =NULL;//并修改Run_Now为NULLRun_Now = ShortestProcess(PQ);//从就绪队列中调出最短剩余时间进程至队头，if(!Run_Now)//如果队列为空，转为等待状态{if(IsEmpty(PQ) && k >= N) break;Wait();continue;}else{Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}}}else//如果当前运行进程为空，那么{if(t == P[i]->PB.arrive_time)//如果正好这时有进程入队{k++;EnQueue(PQ,P[i]);Run_Now = DeQueue(PQ);//则直接被调入运行队列中Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;printf("%d ",Run_Now->PB.number);i=(i+1)>(N-1)?(N-1):(i+1);}else{Wait();continue;}}}printf("\n");printf("平均等待时间是:\n%f\n",((float)sum(wt,N))/N);printf("平均周转时间是:\n%f\n",((float)sum(circle_t,N))/N);return 0;}//////////////////////////////////////////////////////【Process.cpp代码如下：】#include<iostream>#include<string>usingnamespace std;class Process{public:string ProcessName; // 进程名字int Time; // 进程需要时间int leval; // 进程优先级int LeftTime; // 进程运行一段时间后还需要的时间};void Copy ( Process proc1, Process proc2); // 把proc2赋值给proc1void Sort( Process pr[], int size) ; // 此排序后按优先级从大到小排列void sort1(Process pr[], int size) ; // 此排序后按需要的cpu时间从小到大排列void Fcfs( Process pr[], int num, int Timepice); // 先来先服务算法void TimeTurn( Process process[], int num, int Timepice); // 时间片轮转算法void Priority( Process process[], int num, int Timepice); // 优先级算法void main(){int a;cout<<endl;cout<<" 选择调度算法："<<endl;cout<<" 1: FCFS 2: 时间片轮换3: 优先级调度4: 最短作业优先5: 最短剩余时间优先"<<endl; cin>>a;constint Size =30;Process process[Size] ;int num;int TimePice;cout<<" 输入进程个数:"<<endl;cin>>num;cout<<" 输入此进程时间片大小: "<<endl;cin>>TimePice;for( int i=0; i< num; i++){string name;int CpuTime;int Leval;cout<<" 输入第"<< i+1<<" 个进程的名字、cpu时间和优先级:"<<endl;cin>>name;cin>> CpuTime>>Leval;process[i].ProcessName =name;process[i].Time =CpuTime;process[i].leval =Leval;cout<<endl;}for ( int k=0;k<num;k++)process[k].LeftTime=process[k].Time ;//对进程剩余时间初始化cout<<" ( 说明: 在本程序所列进程信息中，优先级一项是指进程运行后的优先级!! )";cout<<endl; cout<<endl;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl; if(a==1)Fcfs(process,num,TimePice);elseif(a==2)TimeTurn( process, num, TimePice);elseif(a==3){Sort( process, num);Priority( process , num, TimePice);}else// 最短作业算法，先按时间从小到大排序，再调用Fcfs算法即可{sort1(process,num);Fcfs(process,num,TimePice);}}void Copy ( Process proc1, Process proc2){proc1.leval =proc2.leval ;proc1.ProcessName =proc2.ProcessName ;proc1.Time =proc2.Time ;}void Sort( Process pr[], int size) //以进程优先级高低排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.leval<pr[j-1].leval){pr[j] = pr[j-1];j--;}pr[j] = temp;} // 直接插入排序后进程按优先级从小到大排列for( int d=size-1;d>size/2;d--){Process temp;temp=pr [d];pr [d] = pr [size-d-1];pr [size-d-1]=temp;} // 此排序后按优先级从大到小排列}/*最短作业优先算法的实现*/void sort1 ( Process pr[], int size) // 以进程时间从低到高排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.Time < pr[j-1].Time ){pr[j] = pr[j-1];j--;}pr[j] = temp;}}/*先来先服务算法的实现*/void Fcfs( Process process[], int num, int Timepice){ // process[] 是输入的进程，num是进程的数目，Timepice是时间片大小while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}elseif(process[num-1].LeftTime==0){cout<<" 进程"<<process[num-1].ProcessName<< " 已经执行完毕!"<<endl;num--;}else{cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<"";cout<<process[s].LeftTime <<" "<<process[s].leval<<" 等待"<<endl; ;}} // elsecout<<endl;system(" pause");cout<<endl;} // while}/*时间片轮转调度算法实现*/void TimeTurn( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}if( process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! "<<endl;num--;}elseif(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<"";cout<<process[s].LeftTime <<" "<<process[s].leval;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}Process temp;temp = process[0];for( int j=0;j<num;j++)process[j] = process[j+1];process[num-1] = temp;} // elsecout<<endl;system(" pause");cout<<endl;} // while}/*优先级调度算法的实现*/void Priority( Process process[], int num, int Timepice){while( true){if(num==0){cout<< "所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程" << process[0].ProcessName <<" 已经执行完毕! "<<endl;for( int m=0;m<num;m++)process[m] = process[m+1]; //一个进程执行完毕后从数组中删除num--; // 此时进程数目减少一个}if( num!=1 && process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! "<<endl;num--;}if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<"";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行";cout<<endl; // 输出其他进程for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval ; if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}} // elseSort(process, num);cout<<endl;system(" pause");cout<<endl;} // while}。

先来先服务调度算法模拟实验程序源代码(C语言).

《操作系统》课程综合性实验报告
兰大信息学院计算机系综合性实验报告仅为 1.99，据此可知，FCFS 算法有利于 CPU 繁忙的作业，而不利于 I/O 繁忙型的作业（进程）。

5.实验心得本次实验设应用链表结构进行存储并排序，条理清晰，易于理解，程序编写完成以后，实现类预期对结果。

界面设计比较清晰明了，易于阅读。

本程序中灵活地设计调用函数和函数嵌套来简化程序，例如在查找未执行进程和对未执行进程执行时分别设计了 void fcfs(和 void run_fcfs(，多个进程运行时均要调用这两个函数，简化了代码。

另外，在编写程序之前，由于先画来流程图，对应流程图的顺序来实现程序，能对程序有个全局的把握，提高了编写速度，减少了错误。

第 5 页。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

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=head;
for(i=0;i<n;i++)
{
if(p->state=='F')
{
q=p; //标记当前未完成的进程
run_fcfs(q);
（5）分析程序运行的结果，谈一下自己的认识。
四、实验结果及分析
1.实验设计说明
本次实验采用C语言模拟对N个进程采用先来先服务进程调度算法调度。每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：
进程标识数ID[3]、进程名name[10]、进程状态state、进程到达时间arrivetime、进程开始执行时间starttime、进程执行结束时间finishtime、服务时间servicetime、周转时间turnaroundtime、带权周转时间weightedturnaroundtime、队列指针next用来将PCB排成队列。
getInfo();
p=head;
fcfs();
}
3.实验结果
测试用例
进程名
到达时间
服务时间
A
0
1
B
1
100
C
2
1
D
3
100
4.实验结果分析
先来先服务算法顾名思义先到的先参与调度，本利中按照A、B、C、D的顺序。因为只有非抢占方式，所以先到的进程必须执行完来才能执行下一个进程，下一个进程的开始时间也就取决于到达时间和上一个进程的结束时间中较晚的一个，如C进程的到达时间是2，但是B进程的完成时间是101，所以C进程的开始时间为101。
本程序中灵活地设计调用函数和函数嵌套来简化程序，例如在查找未执行进程和对未执行进程执行时分别设计了void fcfs()和void run_fcfs()，多个进程运行时均要调用这两个函数，简化了代码。
另外，在编写程序之前，由于先画来流程图，对应流程图的顺序来实现程序，能对程序有个全局的把握，提高了编写速度，减少了错误。
由实验结果可以看出，短作业C的带权周转时间竟高达100，而长作业D的带权周转时间仅为1.99，据此可知，FCFS算法有利于CPU繁忙的作业，而不利于I/O繁忙型的作业（进程）。
5.实验心得
本次实验设应用链表结构进行存储并排序，条理清晰，易于理解，程序编写完成以后，实现类预期对结果。界面设计比较清晰明了，易于阅读。
q->next=p;
p->starttime=0;
p->finishtime=0;
p->turnaroundtime=0;
p->weightedturnaroundtime=0;
p->next=NULL;
p->state='F';
q=p;
}
}
void main()
{
printf("先来先服务算法模拟");
《操作系统》课程综合性实验报告
开课实验室：2011年05月17日
实验题目
进程调度算法程序设计
一、实验目的
通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状
态和进程调度过程、调度算法的理解。
二、设备与环境
1.硬件设备：PC机一台
2.软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发
printf("\n现在时间是%d,开始运行作业%s\n",time,p1->name);
time+=p1->servicetime;
p1->state='T';
p1->finishtime=time;
p1->turnaroundtime=p1->finishtime-p1->arrivetime;
进程状态STATE。
队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：
进程在就绪队列中呆一个时间片，优先数增加1。
进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显
示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
主要程序流程图(进程的执行过程)：
2.实验代码
#include"stdio.h"
#include"stdlib.h"
typedef struct PCB //定义进程控制块
{
char ID[3]; //进程号
char name[10]; //进程名
char state; //运行状态ห้องสมุดไป่ตู้
int arrivetime; //到达时间
进程已占用CPU时间CPUTIME。
进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片
后，进程将进入阻塞状态。
进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个
时间片后，将转换成就绪状态。
环境，如C \C++\Java等编程语言环境。
三、实验内容
（1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如
动态优先权调度）的调度。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：
进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
int starttime; //进程开始时间
int finishtime; //进程结束时间
int servicetime; //服务时间
float turnaroundtime;//周转时间
float weightedturnaroundtime;//带权周转时间
struct PCB *next; //指向下个进程
}pcb;
int time; //计时器
int n; //进程个数
pcb *head=NULL,*p,*q; //进程链表指针
void run_fcfs(pcb *p1) //运行未完成的进程
{
time = p1->arrivetime > time? p1->arrivetime:time;
p1->starttime=time;
scanf("%s\t%s\t%d\t%d",&p->ID,&p->name,&p->arrivetime,&p->servicetime);
if(head==NULL) {head=p;q=p;time=p->arrivetime;}
if(p->arrivetime < time) time=p->arrivetime;
}
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");