先来先服务调度算法模拟实验程序源代码(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 页。
处理器调度算法c语言
处理器调度算法c语言一、概述处理器调度算法是操作系统中一个非常重要的问题。
在多任务操作系统中，有多个进程同时运行，而处理器只有一个，因此需要对进程进行调度，使得每个进程都能够得到适当的执行时间。
二、常见的处理器调度算法1. 先来先服务（FCFS）FCFS算法是最简单的调度算法之一。
它按照进程到达时间的先后顺序进行调度，即先到达的进程先执行。
这种算法容易实现，但可能会导致长作业等待时间过长。
2. 最短作业优先（SJF）SJF算法是根据每个进程所需的CPU时间来进行排序，并按照顺序进行调度。
这种算法可以减少平均等待时间和平均周转时间，并且可以最大限度地利用CPU资源。
3. 优先级调度优先级调度是根据每个进程的优先级来进行排序，并按照顺序进行调度。
这种算法可以确保高优先级进程得到更多的CPU时间，但可能会出现低优先级进程饥饿问题。
4. 时间片轮转（RR）RR算法将CPU分配给每个任务一定量的时间片，在该时间片内运行任务。
如果任务在该时间片内未完成，则将其放回队列尾部，并分配给下一个任务时间片。
这种算法可以确保公平性，并且可以避免长作业等待时间过长。
三、C语言中的处理器调度算法实现1. FCFS算法实现#include <stdio.h>int main(){int n, i, j;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}2. SJF算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0; printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n]; printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(burst_time[i] > burst_time[j]){temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_time += waiting_time[i];avg_turnaround_time += turnaround_time[i];}avg_waiting_time /= n;avg_turnaround_time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround_ time);return 0;}3. 优先级调度算法实现#include <stdio.h>int main(){int n, i, j, temp;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], waiting_time[n], turnaround_time[n], priority[n];printf("Enter the burst time and priority for each process:\n"); for(i=0; i<n; i++)scanf("%d %d", &burst_time[i], &priority[i]);for(i=0; i<n-1; i++)for(j=i+1; j<n; j++)if(priority[i] > priority[j]){temp = priority[i];priority[i] = priority[j];priority[j] = temp;temp = burst_time[i];burst_time[i] = burst_time[j]; burst_time[j] = temp;}waiting_time[0] = 0;turnaround_time[0] = burst_time[0];for(i=1; i<n; i++){waiting_time[i] = waiting_time[i-1] + burst_time[i-1];turnaround_time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround_ time += turnaround_ time[i];}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tPriority\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", i+1, burst_ time[i], priority[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}4. RR算法实现#include <stdio.h>int main(){int n, i, j, time_quantum;float avg_waiting_time = 0, avg_turnaround_time = 0;printf("Enter the number of processes: ");scanf("%d", &n);int burst_time[n], remaining_time[n], waiting_time[n], turnaround_time[n];printf("Enter the burst time for each process:\n");for(i=0; i<n; i++)scanf("%d", &burst_time[i]);printf("Enter the time quantum: ");scanf("%d", &time_quantum);for(i=0; i<n; i++)remaining_time[i] = burst_time[i];int t=0;while(1){int done = 1;for(i=0; i<n; i++){if(remaining_time[i] > 0){done = 0;if(remaining_ time[i] > time_ quantum){t += time_ quantum;remaining_ time[i] -= time_ quantum;}else{t += remaining _ time[i];waiting_time[i] = t - burst_time[i];remaining_ time[i] = 0;turnaround_ time[i] = waiting_time[i] + burst_time[i];avg_waiting_ time += waiting_ time[i];avg_turnaround _ time += turnaround_ time[i];}}}if(done == 1)break;}avg_waiting_ time /= n;avg_turnaround_ time /= n;printf("\nProcess\tBurst Time\tWaiting Time\tTurnaround Time\n");for(i=0; i<n; i++)printf("P%d\t%d\t\t%d\t\t%d\n", i+1, burst_time[i], waiting_time[i], turnaround_time[i]);printf("\nAverage Waiting Time: %.2f\n", avg_waiting_ time);printf("Average Turnaround Time: %.2f\n", avg_turnaround _ time);return 0;}四、总结以上是常见的处理器调度算法的C语言实现方式。
操作系统 先来先服务(FCFS)进程调度模拟
long STARTBLOCK;// 进程的阻塞时间
long BLOCKTIME;// 进程被阻塞的时间
int STATE; // 进程状态
Q->Qlen--;
return e;
}
pPCB InputData(int n)
{
int i=0;
pPCB p= (pPCB)malloc(sizeof(PCB)*n);
for(i=0; i<n; i++)
{
time_t t;
p->e.FinishTime,p->e.zzTime,p->e.dqzzTime);
avgzzTime+=p->e.zzTime;
avgdqzzTime+=p->e.dqzzTime;
if(!Q->front)exit(-1);
Q->front->next=NULL;
(*Q).Qlen=0;
return TRUE;
}
Status DestoryQueue(LinkQueue*Q)
{
while(Q->front)
பைடு நூலகம் {
}
Status SortQueue(pPCB ppcb,int n)
{
int i,j;
PCB pcb;
if(!ppcb)return FALSE;
for(i=0; i<n; i++)
{
for(j=i+1; j<n; j++)
先来先服务调度和最短作业优先调度算法实验报告
实验报告说明
1．实验项目名称：要用最简练的语言反映实验的内容。
要求与实验指导书中相一致。
2．实验类型：一般需说明是验证型实验还是设计型实验，是创新型实验还是综合型实验。
3．实验目的与要求：目的要明确，要抓住重点，符合实验指导书中的要求。
4．实验原理：简要说明本实验项目所涉及的理论知识。
5．实验环境：实验用的软硬件环境（配置）。
6．实验方案设计（思路、步骤和方法等）：这是实验报告极其重要的内容。
概括整个实验过程。
对于操作型实验，要写明依据何种原理、操作方法进行实验，要写明需要经过哪几个步骤来实现其操作。
对于设计型和综合型实验，在上述内容基础上还应该画出流程图、设计思路和设计方法，再配以相应的文字说明。
对于创新型实验，还应注明其创新点、特色。
7．实验过程（实验中涉及的记录、数据、分析）：写明具体上述实验方案的具体实施，包括实验过程中的记录、数据和相应的分析。
8．结论（结果）：即根据实验过程中所见到的现象和测得的数据，做出结论。
9．小结：对本次实验的心得体会、思考和建议。
10．指导教师评语及成绩：指导教师依据学生的实际报告内容，用简练语言给出本次实验报告的评价和价值。
注意：
实验报告将记入实验成绩；
每次实验开始时，交上一次的实验报告，否则将扣除此次实验成绩。
先来先服务调度算法模拟实验程序源代码C语言
《操作系统》课程综合性实验报告
D 3 100
4.实验结果分析
先来先服务算法顾名思义先到的先参与调度，本利中按照A、B、C、D的顺序。
因为只有非抢占方式，所以先到的进程必须执行完来才能执行下一个进程，下一个进程的开始时间也就取决于到达时间和上一个进程的结束时间中较晚的一个，如C进程的到达时间是2，但是B进程的完成时间是101，所以C进程的开始时间为101。
由实验结果可以看出，短作业C的带权周转时间竟高达100，而长作业D的带权周转时间仅为1.99，据此可知，FCFS算法有利于CPU繁忙的作业，而不利于I/O繁忙型的作业（进程）。
5.实验心得
本次实验设应用链表结构进行存储并排序，条理清晰，易于理解，程序编写完成以后，实现类预期对结果。
界面设计比较清晰明了，易于阅读。
本程序中灵活地设计调用函数和函数嵌套来简化程序，例如在查找未执行进程和对未执行进程执行时分别设计了void fcfs()和void run_fcfs()，多个进程运行时均要调用这两个函数，简化了代码。
先来先服务调度和最短作业优先调度算法实验报告
实验概述:
【实验目的及要求】
理解并掌握处理机调度算法
【实验原理】
基于先来先服务调度和最短作业优先调度算法思想用C语言编程实现
【实验环境】（使用的软件）
Visual C++6.0
输入：3 <回车>
屏幕显示：You have in put a wrong nu mber, please in put aga in.
输入：1＜回车＞
屏幕输出结果：
submit run start ing final wait tur naro und
3
8.0
1.0
8.0
9.0
0.0
1.0
2
8.5
0.5
9.0
9.5
0.5
1.0
1
9.0
0.2
9.5
9.7
0.5
0.7
4
9.1
0.1
9.7
9.8
0.6
0.7
屏幕显示：
The average turn aro und time is 0.85
What kind of algorithm do you want? Please in put 1 to select FCFS, or 2 to select
测试数据二：
submit run
160.5
250.9
36.30.1
FCFS和SJF算法结果一样：
submit
run
starti ng
final
先来先服务调度算法实验报告-杨俊光
int sum=0;
linknode *p;
p=head->next;
while(p)
{
sum=sum+p->time;
p->averageTime=sum;
p=p->next;
SUM+=sum;
}
}
实验结果:
void print(linknode *head)
{
linknode *p;
p=head->next;
linknode *creat()
{
int n,m;
linknode *head,*r,*s;
head=r=(linknode *)malloc(sizeof(linknode));
printf("输入各进程的处理时间和优先级并以两个0为结束标志:\n");
while(scanf("%d %d",&n,&m)&&n&&m)
课程名称
计算机操作系统
实验室名称
X4313
实验名称
先来先服务算法实现
指导教师
朱明华
成绩
实验目的：
熟悉进程调度算法，用C语言实现先来先服务调度算法。
实验原理和内容
题目：
根据先来先服务算法，求个进程的处理时间和总的平均时间。
实验步骤
分析问题，提出解决问题的算法
编制程序
程序调试
记录实验结果，以及思考是否能够改善算法
printf("各进程处理时间为：");
while(p)
{
printf("%-4d",p->averageTime);
先来先服务进程调度实验
设计先来先服务进程调度模拟算法
实验提示：
进程个数至少5个以上（动态），也可让用户动态输入，每个进程由一个进程控制块来标识，进程控制块的内容根据情况自己设计，但至少要有进程名、进程状态、到达时间、估计运行时间信息；
设计一个先进先出队列和系统时间，调度时，总是选择队列头部（到达时间最早）的进程；当进程到达时间小于系统时间时，进程执行，当在当前时间没有到达的进程时，可安排延时来模拟闲逛进程。
由于本实验为模拟实验，所以被选中调度进程并不实际启动运行，而仅执行按估计运行时间延时，并输出进程的开始和结束运行信息模拟进程的运行，而且省去进程的现场保护和现场恢复工作。
在所设计的程序中应有显示或打印语句，能显示或打印就绪队列中的进程、正运行进程的进程名、开始运行时间、结束运行时间等，给出各进程的周转时间和平均周转时间。
实验要求：
实验报告中要给出流程图和源程序，源程序中要附有详细的注释，
给出程序运行时的输入值和运行结果
总结收获或对该题的改进意见和见解。
计算机操作系统 模拟调度算法实验报告
实验二调度算法的模拟实现一、实验目的1.加深对先来先服务算法，短作业优先算法，最高优先权优先调度算法等三种调度算法的理解2.利用C语言编写算法，模拟实现先来先服务算法，短作业优先算法，最高优先权优先调度算法。
3.模拟三种调度算法，对比三种调度算法的优缺点，并计算平均周转时间和平均带权周转时间。
二、实验开发平台Microsoft Visual C++ 6.0（使用C语言）三、三个调度算法说明先来先服务调度算法，是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度，就是每次从就绪队列中选择一个最先进入队列的进程，该算法比较有利于长作业，而不利于短作业。
另处，FCFS调度算法对CPU繁忙型作业较有利，而不利于I/O繁忙作业。
短作业优先调度算法（SWF），是指对短作业或短进程优先调度的算法，是指分派CPU时，把CPU优先分给最短的作业。
它的缺点是对长作业不利，不能保证及时处理解紧迫性的作业。
最高优先权优先调度算法，常用于批处理系统中，既照顾了短作业，又考虑了作业到达的先后次序，不会使长作业长期得不到服务。
它实现了一种较好的折衷,但每要进行高度之前，都须先做响应比的计算，这会增加系统开销。
四、实验源程序#include <stdio.h>struct process{char name[10];int dtime;int ftime;int youxian;};struct process pro[3];struct process tempPro[3];void fcfs()//先来先服务{//先对这些线程排序,使用冒泡法排序，从小到大int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].dtime>pro[j+1].dtime){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void sjf()//短作业优先{//使用冒泡法排序,从小到大int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].ftime>pro[j+1].ftime){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void youxian()//最高优先权优先，假定此处为优先数最大的进程优先服务{ //使用冒泡法排序，从大到小int i,j;for (i=0;i<3-1;i++){for (j=0;j<2-i;j++){if (pro[j].youxian<pro[j+1].youxian){tempPro[j]=pro[j];pro[j]=pro[j+1];pro[j+1]=tempPro[j];}}}}void print()//输出进程名称{int i;for (i=0;i<3;i++){printf("%s\n",pro[i].name);}}void main(){printf("请输入第一个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[0].name,&pro[0].dtime,&pro[0].ftime,&pro[0].youxian);printf("请输入第二个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[1].name,&pro[1].dtime,&pro[1].ftime,&pro[1].youxian);printf("请输入第三个进程的名字到达时间服务时间优先数\n");scanf("%s %3d %3d %3d",&pro[2].name,&pro[2].dtime,&pro[2].ftime,&pro[2].youxian);printf("先来先服务调度执行顺序：\n");fcfs();print();printf("短作业优先调度执行顺序：\n");sjf();print();printf("最高优先权优先调度执行顺序：\n");youxian();print();}五、运行结果。
操作系统FCFS先来先服务和SPF短进程调度算法
操作系统实验：（FCFS和SPF调度算法）1. 先来先服务（FCFS）调度算法请粘贴程序代码及运行结果：#include <iostream>using namespace std;class Fcfs {private:int num[10]; //作业编号double arriveTime[10]; //到达时间double startTime[10]; //开始时间，进内存时间double workTime[10]; //工作时间double finishTime[10]; //完成时间double cirTime[10]; //存放每一个作业的周转时间//double freeTime[10]; //上一个作业已结束，但下一个作业还未到，存放这一段空闲时间public:Fcfs(int n) //n为作业数目{cout<<"默认第一个作业的到达时间为0。
"<<endl;for(int i=0;i<n;i++){num[i]=i+1; //给作业编号cout<<"第"<<num[i]<<"个作业："<<endl;cout<<"请输入该作业的到达时间：";cin>>arriveTime[i];if(i==0)arriveTime[i]=0; //默认第一个作业的到达时间为0cout<<"请输入该作业的执行时间：";cin>>workTime[i];if(i==0){startTime[i]=0;finishTime[i]=workTime[i];}else if(arriveTime[i]<=finishTime[i-1]){startTime[i]=finishTime[i-1];finishTime[i]=startTime[i]+workTime[i];}else if(arriveTime[i]>finishTime[i-1]){//freeTime[i]=arriveTime[i]-finishTime[i-1];//计算空闲时间，前一个作业已完成，但后一个作业还没到，中间空闲时间startTime[i]=arriveTime[i];//由于来的时候前一个作业已完成，则该作业的开始时间即为它的到达时间finishTime[i]=startTime[i]+workTime[i];}cirTime[i]=finishTime[i]-arriveTime[i];}}//计算平均周转时间double getAverageCir(int n) //n为作业数{double averageCir,sumCir=0;for(int i=0;i<n;i++)sumCir+=cirTime[i];averageCir=sumCir/n;return averageCir;}//打印输出void print(int n) //n为作业数{cout<<"num\t"<<"arrive\t"<<"start\t"<<"work\t"<<"finish\t"<<"cir\t"<<endl; for(int i=0;i<n;i++){cout<<num[i]<<"\t"<<arriveTime[i]<<"\t"<<startTime[i]<<"\t"<<workTime[i]<<"\t"<<finishTi me[i]<<"\t"<<cirTime[i]<<"\t"<<endl;}cout<<endl;cout<<"平均周转时间："<<getAverageCir(n)<<endl;}};int main(){int n; //n为作业数目cout<<"请输入作业数目：";cin>>n;Fcfs f=Fcfs(n);f.print(n);return 0;}2.短进程优先（SPF）调度算法请粘贴程序代码及运行结果：#include<iostream>using namespace std;class SJF{private:int num[10]; //作业编号double arriveTime[10]; //到达时间double startTime[10]; //开始时间，进内存时间double workTime[10]; //工作时间double finishTime[10]; //完成时间double cirTime[10]; //存放每一个作业的周转时间public:SJF(int n) //n为作业数目{int i;cout<<"默认第一个作业的到达时间为0。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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");