操作系统课程Linux环境下使用C语言实现先来先服务调度算法复习过程
操作系统课程设计磁盘调度先来先服务算法
操作系统课程设计磁盘调度先来先服务算法集团企业公司编码：（LL3698-KKI1269-TM2483-LUI12689-ITT289-《操作系统原理》课程设计报告书题目：磁盘调度先来先服务算法学号：学生姓名：专业：计算机科学与技术指导教师：2014年5月29目录1功能描述根据进程请求访问磁盘的先后次序进行调度，从而计算出磁头移动的总距离和平均寻道长度。
1.1功能实现思想这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
1.2功能详述根据进程请求访问磁盘的先后次序进行调度，首先根据提示输入总的磁道数、提出磁盘I/O申请的进程数、开始磁道号和磁道序列。
通过程序调用函数输出磁盘请求序列和磁盘扫描序列，从而计算出磁头移动的总距离和平均寻道长度。
2系统设计2.1系统总体设计2.1.1数据结构描述void?FCFS(int?cidao[],int?m)输入磁道号，按先来先服务的策略输出磁盘请求序列和磁盘扫描序列，求移动的总距离和平均寻道长度，输出移动的总磁道数和平均寻道长度。
2.1.2函数功能分析由于一开始要对键盘输入的磁道数和要使用的算法进行一次有效性的判断，我使用了int?decide(char?str[])，如果输入的信息不是0~9之间的数都将被判定为不合法，合法后才能进行下一步。
判断完合法性后，要将输入的字符转化为数字，这里我用了inttrans(charstr[],inta)。
先来先服务调度算法我使用了void?FCFS(int?cidao[],int?m)，该算法主要完成按原来键盘输入的次序来寻道，然后输出移动的总磁道数和平均寻道长度。
先来先服务和优先数调度算法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. 算法原理优先数调度算法是一种非抢占式的进程调度算法。
linux磁盘调度算法c语言 -回复
linux磁盘调度算法c语言-回复什么是磁盘调度算法？磁盘调度算法是操作系统中的一种重要算法，用于管理磁盘访问请求的顺序，以提高磁盘IO的效率。
在现代计算机系统中，磁盘是一种常用的存储设备，用于存储大量的数据。
然而，磁盘的读写速度相对较慢，而且磁盘上的数据是按照物理位置存储的，因此需要一种调度算法来决定磁盘访问请求的执行顺序，以减少磁头的移动，提高数据的读写效率。
磁盘调度算法的基本原理磁盘调度算法的基本原理是通过优化磁盘访问请求的顺序，减少寻道和旋转延迟，提高磁盘IO的效率。
以下是一些常见的磁盘调度算法：1. 先来先服务（FCFS）先来先服务是最简单的磁盘调度算法之一。
它按照磁盘访问请求的到达顺序来执行IO操作。
当一个请求完成后，才会执行下一个请求。
尽管这种算法简单，但由于没有考虑磁头的位置及磁盘的旋转延迟，可能导致磁头频繁移动，降低IO效率。
2. 最短寻道时间优先（SSTF）最短寻道时间优先是一种以最小化寻道时间为目标的磁盘调度算法。
它选择离当前磁头位置最近的请求进行执行。
这种算法可以减少寻道时间，提高磁盘IO效率。
然而，由于总是选择最短寻道时间的请求，可能导致某些请求长时间等待，造成请求的不公平性。
3. 扫描算法（SCAN）扫描算法又称电梯算法，模拟了磁头在磁盘上移动的方式。
它从一个方向开始，按磁道的顺序执行访问请求，当达到磁盘的边界时，改变方向并继续执行请求。
这种算法可以减少磁头的移动距离，提高IO效率。
但是，如果某些请求集中在边界附近，可能导致某些请求长时间等待。
4. 循环扫描算法（C-SCAN）循环扫描算法是扫描算法的一种变体，它避免了某些请求长时间等待的问题。
当磁头达到磁盘的边界时，不返回原来的方向，而是直接返回到磁盘的另一侧继续执行请求。
这样可以确保所有的请求都能被处理到，减少等待时间，提高IO效率。
编写一个简单的磁盘调度算法（SSTF）的C语言实现下面是一个简单的SSTF磁盘调度算法的C语言实现：include<stdio.h>include<stdlib.h>int main(){int n, head, sum = 0;printf("Enter the number of disk requests: ");scanf("d", &n);printf("Enter the initial position of head: ");scanf("d", &head);int *requests = (int *)malloc(sizeof(int) * n);printf("Enter the disk requests: ");for (int i = 0; i < n; i++){scanf("d", &requests[i]);}for (int i = 0; i < n; i++){int min = abs(head - requests[i]);int index = i;for (int j = i + 1; j < n; j++){if (abs(head - requests[j]) < min){min = abs(head - requests[j]);index = j;}}sum += abs(head - requests[index]);head = requests[index];int temp = requests[i];requests[i] = requests[index];requests[index] = temp;}printf("Total head movement: d\n", sum);free(requests);return 0;}以上C语言程序实现了SSTF磁盘调度算法。
先来先服务调度和最短作业优先调度算法实验报告
实验报告说明
1．实验项目名称：要用最简练的语言反映实验的内容。
要求与实验指导书中相一致。
2．实验类型：一般需说明是验证型实验还是设计型实验，是创新型实验还是综合型实验。
3．实验目的与要求：目的要明确，要抓住重点，符合实验指导书中的要求。
4．实验原理：简要说明本实验项目所涉及的理论知识。
5．实验环境：实验用的软硬件环境（配置）。
6．实验方案设计（思路、步骤和方法等）：这是实验报告极其重要的内容。
概括整个实验过程。
对于操作型实验，要写明依据何种原理、操作方法进行实验，要写明需要经过哪几个步骤来实现其操作。
对于设计型和综合型实验，在上述内容基础上还应该画出流程图、设计思路和设计方法，再配以相应的文字说明。
对于创新型实验，还应注明其创新点、特色。
7．实验过程（实验中涉及的记录、数据、分析）：写明具体上述实验方案的具体实施，包括实验过程中的记录、数据和相应的分析。
8．结论（结果）：即根据实验过程中所见到的现象和测得的数据，做出结论。
9．小结：对本次实验的心得体会、思考和建议。
10．指导教师评语及成绩：指导教师依据学生的实际报告内容，用简练语言给出本次实验报告的评价和价值。
注意：
实验报告将记入实验成绩；
每次实验开始时，交上一次的实验报告，否则将扣除此次实验成绩。
操作系统进程调度C语言代码
操作系统进程调度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;}```在实现时间片轮转算法之前，需要先定义一些全局变量，包括就绪队列、当前时间、时间片大小和进程数量等。
调度算法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）调度算法，首先根据进程的到达时间排序，然后依次执行每个进程，并计算总等待时间和总周转时间。
操作系统课设-进程调度模拟设计(先来先服务、优先级法)
cout<<"进程运行时间：";
cin>>r;
cout<<"进程到达时间：";
cin>>a;
cout<<"进程优先级：";
cin>>p;
cout<<endl;
Node *tp;
tp=new Node;
tp->num=n;
tp->name=na;
tp->run_time=r;
tp->arrive_time=a;
<<setw(12)<<"结束时间"<<endl;
while(tp!=NULL){
cout<<" "<<setw(10)<<tp->num<<setw(10)<<tp->name
<<setw(12)<<tp->arrive_time<<setw(12)<<tp->run_time;
cout<<setw(12)<<tp->start_time<<setw(12)<<tp->end_time<<endl;
q->priority=tp->priority;
q->next=NULL;
tp=tp->next;
p=temp;
while( p->next!=NULL && p->next->priority < q->priority){
进程调度模拟设计——先来先服务、优先级法复习过程
进程调度模拟设计——先来先服务、优先级法学号：课程设计题目进程调度模拟设计——先来先服务、优先级法学院计算机科学与技术专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名：专业班级：指导教师：吴利军工作单位：计算机科学与技术学院题目: 进程调度模拟设计——先来先服务、优先级法初始条件：1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟进程调度，能够处理以下的情形：⑴能够选择不同的调度算法（要求中给出的调度算法）；⑵能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；⑶根据选择的调度算法显示进程调度队列；⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2．设计报告内容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，一律按0分记）指导教师签名：年月日系主任（或责任教师）签名：年月日进程调度模拟设计——先来先服务、优先级法1、背景：当计算机系统是多道程序设计系统时，通常会有多个进程或线程同时竞争CPU。
只要有两个或更多的进程处于就绪状态，这种情形就会发生。
如果只有一个CPU可用，那么就必须选择下一个要运行的进程。
在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法成为调度算法。
作业调度算法先来先服务算法短作业算法页
作业调度算法: 先来先服务算法、短作业优先算法引言在计算机操作系统中，作业调度算法是一种重要的技术，用于管理和调度计算机系统中的作业。
作业调度算法决定了如何分配计算机资源，以便最大化系统的效率和吞吐量。
本文将介绍两种常见的作业调度算法：先来先服务算法（First Come First Serve，FCFS）和短作业优先算法（Shortest Job First，SJF）。
先来先服务算法（FCFS）先来先服务算法是最简单的作业调度算法之一。
按照作业提交的顺序进行调度，先提交的作业先执行，后提交的作业则等待。
这种调度算法不考虑作业的执行时间或优先级，只根据作业提交的先后顺序来进行调度。
算法流程1.将作业按照提交的先后顺序排列。
2.按照排列顺序执行作业。
优点•算法实现简单，易于理解和实现。
•适用于短作业或者作业提交顺序代表了作业的优先级的情况。
缺点•短作业可能因为长作业的存在而等待时间过长，导致响应时间较长。
•不考虑作业执行时间，可能导致平均等待时间和平均周转时间较长。
•无法适应不同作业的执行时间需求。
短作业优先算法（SJF）短作业优先算法是一种将作业按照执行时间长度进行排序的作业调度算法。
在短作业优先算法中，最短执行时间的作业先执行，以此类推。
该算法可以最大程度地减少作业的等待时间和周转时间。
算法流程1.将作业按照执行时间长度从短到长进行排序。
2.按照排列顺序执行作业。
优点•可以最大程度地减少作业的等待时间和周转时间。
•适用于短作业和长作业相互混合的情况。
缺点•难以准确估计作业的执行时间，可能导致长作业等待时间过长。
•需要预先知道作业的执行时间长度才能进行排序。
•不适用于长作业占主导地位的情况。
性能对比与选择先来先服务算法和短作业优先算法都有其优点和缺点。
选择合适的算法取决于具体的应用场景和需求。
•如果作业都很短，并且没有严格的截止时间要求，先来先服务算法可以简单高效地满足需求。
•如果作业的执行时间非常重要，并且具有较严格的截止时间要求，短作业优先算法可以最大程度地减少作业的等待时间和周转时间。
先来先服务,时间片调度,优先级调度算法实验报告
先来先服务,时间片调度,优先级调度算法实验报告先来先服务、时间片调度、优先级调度算法实验报告1. 引言本次实验旨在研究和比较先来先服务（FCFS）、时间片调度（RR）和优先级调度（Priority Scheduling）三种常见的进程调度算法。
进程调度是操作系统中的重要概念之一，合理的进程调度算法可以提高系统效率，优化资源利用。
2. 先来先服务算法•先来先服务算法是一种简单的调度算法，按照进程到达的顺序进行调度。
•优点：简单易实现，适用于长作业。
•缺点：容易造成短作业等待时间过长，无法满足实时性要求。
3. 时间片调度算法•时间片调度算法将CPU时间划分为一段一段的时间片，每个进程在一个时间片内执行。
•若进程未完成，会被放入就绪队列的末尾，等待下一个时间片。
•优点：公平，适用于短作业，能满足实时性要求。
•缺点：时间片过长，会导致长作业等待时间过长。
4. 优先级调度算法•优先级调度算法根据进程的优先级来确定调度顺序，拥有最高优先级的进程先执行。
•静态优先级可在创建进程时确定，动态优先级可根据进程执行情况进行调整。
•优点：适用于实时任务和长作业，可根据需求调整优先级。
•缺点：可能导致低优先级任务等待时间过长，存在优先级反转问题。
5. 实验结果与分析通过对三种调度算法的实验测试，得出以下结论：•FCFS算法在长作业的情况下表现较好，但对于短作业不友好，容易造成长时间等待；•RR算法适用于短作业，能保证公平性，但时间片过长可能导致长作业等待时间过长；•优先级调度算法较为灵活，能满足实时性要求，但可能导致低优先级任务长时间等待。
综上所述，不同的调度算法适用于不同的场景，根据需求选择合适的算法可提高系统效率。
6. 总结本次实验对先来先服务、时间片调度和优先级调度算法进行了研究和比较。
通过对三种算法的分析，我们可以根据任务特点和需求选择合适的调度算法，以提高系统的效率和资源利用率。
同时，在实际应用中也需要考虑进程的实时性要求，避免长时间等待等问题的出现。
先来先服务调度算法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);}。
【操作系统】先来先服务和短作业优先算法（C语言实现）
【操作系统】先来先服务和短作业优先算法（C语⾔实现）【操作系统】先来先服务算法和短作业优先算法实现介绍:1.先来先服务 (FCFS: first come first service)如果早就绪的进程排在就绪队列的前⾯，迟就绪的进程排在就绪队列的后⾯，那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之⾸的那个进程调度到运⾏状态。
也就说，它只考虑进程进⼊就绪队列的先后，⽽不考虑它的下⼀个CPU周期的长短及其他因素。
FCFS算法简单易⾏，是⼀种⾮抢占式策略，但性能却不⼤好。
简单来说，先来先服务就是那个进程到达时间最早，那么CPU就先处理哪个进程。
2.短作业优先（SJF, Shortest Job First）对预计执⾏时间短的作业（进程）优先分派处理机。
通常后来的短作业不抢先正在执⾏的作业。
也就是说，不但要考虑进程的到达时间，还要考虑进程需要运⾏的时间。
当⼀个进程正在运⾏时，假如有其他的进程到达，那么这些到达的进程就需要按照其需要运⾏的时间长短排序，运⾏时间短的在前，运⾏时间长的在后。
3.例⼦：4.运⾏截图1.先来先服务2.短作业优先5.话不多说，直接上代码。
第⼀次写，有很多不⾜的地⽅。
希望⼤家看到可以帮忙纠正⼀下，谢谢⼤家。
#include <stdio.h>#include <stdlib.h>#define MAX 10typedef struct PCB {int id,arrive_time,service_time,start_time,finish_time; //进程id、到达时间、服务时间、开始时间、完成时间float zhouzhuan_time,daiquanzhouzhuan_time; //周转时间、带权周转时间。
只能说我的拼英。
emm，。
尴尬。
int status;}PCB;typedef enum {OK,ERROR}Status;typedef enum {FALSE,TRUE}Bool;typedef PCB datatype;typedef struct LinkQueue {int front;int rear;int length;datatype* base;}quene;int arrive[MAX]; // 记录每个作业的到达时间int service[MAX]; //记录每个作业的服务时间int num; //输⼊的进程个数quene init(){quene q_pcb;q_pcb.base = (datatype *)malloc(sizeof(datatype)*MAX);q_pcb.front = q_pcb.rear = 0;q_pcb.length = 0;return q_pcb;}Bool isFull(quene *q) {if ((q->rear + 1) % MAX == q->front) {return TRUE;}return FALSE;}Bool isEmpty(quene *q) {if (q->rear == q->front) {return TRUE;}return FALSE;}Status rudui(quene *q,datatype p){ //⼊队。
操作系统-先来先服务算法FCFS(C语言)
time+=p1->ServiceTime;
p1->state='T';
p1->FinishTime=time;
p1->WholeTime=p1->FinishTime-p1->ArriveTime;
p1->WeightWholeTime=p1->WholeTime/p1->ServiceTime;
理
及
所
参
考
的
资
料
算法原理：
设计程序模拟进程的先来先服务FCFS过程。假设有n个进程分别在T1,…,Tn时刻到达系统，它们需要的服务时间分别为S1,…,Sn。分别采用先来先服务FCFS调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
程序要求如下：
run_FCFS(q);
}
p=p->next;
}
}
void getInfo() //获得进程信息并创建进程
{
int num;
printf("\n进程个数:");
scanf("%d",&n);
for(num=0;num<n;num++)
{
p=(pcb *)malloc(sizeof(pcb));
printf("依次输入：\n进程名到达时间服务时间\n");
intServiceTime[MaxNum];
intFinishTime[MaxNum];
操作系统实验_先来先服务FCFS和短作业优先SJF进程调度算法
操作系统实验报告实验一先来先服务FCFS和短作业优先SJF进程调度算法学号：班级：：【实验题目】：先来先服务FCFS和短作业优先SJF进程调度算法【实验目的】通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
【实验容】问题描述：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。
假设有n 个进程分别在T1, …,T n时刻到达系统，它们需要的服务时间分别为S1, …,S n。
分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
程序要求如下：1）进程个数n；每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n；选择算法1-FCFS，2-SJF。
2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。
实现提示：用C++语言实现提示：1）程序中进程调度时间变量描述如下：static int MaxNum=100;int ArrivalTime[MaxNum];int ServiceTime[MaxNum];int FinishTime[MaxNum];int WholeTime[MaxNum];double WeightWholeTime[MaxNum];double AverageWT_FCFS,AverageWT_SJF;double AverageWWT_FCFS,AverageWWT_SJF;2）进程调度的实现过程如下：➢变量初始化；➢接收用户输入n，T1, … ,T n，S1, … ,S n；算法选择1-FCFS，2-SJF；➢按照选择算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
【计算机专业】操作系统 先来先服务算法详解
【计算机专业】操作系统先来先服务算法详解设计一个按先来先服务调度的算法提示：（1）假设系统中有5个进程，每个进程由一个进程控制块（PCB）来标识。
进程控制块内容如图1-1所示。
进程名即进程标识。
链接指针：按照进程到达系统的时间将处于就绪状态的进程连接成衣个就绪队列。
指针指出下一个到达进程的进程控制块首地址。
最后一个进程的链接指针为NULL。
估计运行时间：可由设计者任意指定一个时间值。
到达时间：进程创建时的系统时间或由用户指定。
调度时，总是选择到达时间最早的进程。
进程状态：为简单起见，这里假定进程有两种状态：就绪和完成。
并假定进程一创建就处于就绪状态，用R表示。
当一个进程运行结束时，就将其设置成完成态，用C表示。
（2）设置一个队首指针head，用来指出最先进入系统的进程。
各就绪进程通过链接指针连在一起。
（3）处理机调度时总是选择队首指针指向的进程投入运行。
由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而只是执行：估计运行时间减1。
用这个操作来模拟进程的一次运行，而且省去进程的现场保护和现场恢复工作。
（4）在所设计的程序中应有显示或打印语句，能显示或打印正运行进程的进程名、已运行时间、还剩时间、就绪队列中的进程等。
所有进程运行完成时，给出各进程的周转时间和平均周转时间。
/****************************************************************************** ************** 实验一先来先服务算法模拟程序* writen by daysky* 2007-11-19******************************************************************************** *************/#include <iostream>#include <list>#include <string>#include <fstream>using namespace std;//控制块结构体struct PCB{char name;//进程名PCB *next;//链接指针int reach_time;//到达时间int left_time;//估计运行时间int begin_time;char status;//R就绪c完成PCB();PCB(char aname,int areach_time,int aleft_time,int abegin_time=-1,char astatus='R',PCB *anext=NULL);PCB(const PCB &from);};PCB:CB(){next=NULL;reach_time = -1;left_time = -1;begin_time = -1;status = 'R';}PCB:CB(char aname,int areach_time,int aleft_time,int abegin_time,char astatus,PCB *anext){name = aname;reach_time = areach_time;left_time = aleft_time;begin_time = abegin_time;status = astatus;next = anext;}PCB:CB(const PCB &from){name = ;next = NULL;reach_time = from.reach_time;left_time = from.left_time;begin_time = -1;status = 'R';}/*** 先来先服务类**/class FirstServe{private:int systime;//系统时间list<CB *> *ready_list,*all_task;// 就绪队列所有任务int together_time;ofstream fout;public:FirstServe();FirstServe(list<CB *> *a_all_task,const char *logfile);bool run();void check_task();void run_ready();void print_ready();~FirstServe();};FirstServe::FirstServe(){systime=0;together_time = 0;ready_list=new list<CB *>();all_task=new list<CB *>();}FirstServe::FirstServe(list<CB *> *a_all_task,const char *logfile){systime=0;together_time = 0;ready_list = new list<CB *>();all_task = a_all_task;fout.open(logfile,ios::trunc);}//服务执行总调度bool FirstServe::run(){int num = all_task->size();while(ready_list->empty()){//添加新进程,同时从所有队列中删除刚添加的进程check_task();systime++;//运行直到有任务}do{//打印就绪队列print_ready();//执行就绪队列run_ready();systime++;check_task();}while(!ready_list->empty());//打印平均周转时间fout << "平均周转时间为:" << together_time/num << "!" << endl; return true;}//检查到达的任务，添加到就绪队列的尾部void FirstServe::check_task(){PCB *current;list<CB *>::iterator it;it = all_task->begin();//这里用循环处理，因为可能有多个同时到达的任务while(it!=all_task->end()){current=(*it);if(current->reach_time==systime){PCB *a_pcb = new PCB(*current);//复制进程信息a_pcb->status = 'R';ready_list->push_back(a_pcb);//添加在就绪队列的尾部it = all_task->erase(it); //从所有任务中删除这个任务fout << "进程" << a_pcb->name << "在时刻:" << systime << "进入就绪队列!" << endl;}elseit++;}}//执行就绪队列，运行队列的第一个进程void FirstServe::run_ready(){if(ready_list->empty()) return;//就绪队列为空就不执行,否则PCB *front = ready_list->front();if(front->begin_time == -1)//进程第一次运行，设置运行起始时间front->begin_time = systime;front->left_time --;//执行一次，估计时间减一fout << "进程" << front->name << "执行在时刻:" << systime << "!" << endl;fout << "进程" << front->name << "已运行时间:" << (systime-front->begin_time+1)<< "!" << endl;fout << "进程" << front->name << "还剩时间为:" << front->left_time << "!" << endl;//当进程完成，改变进程的状态if(front->left_time == 0){front->status = 'C';//打印并计算周转时间,systime-1为完成时间fout << "进程" << front->name << "在时刻:" << systime << "结束!" << endl;int a_time = systime-1-front->reach_time;together_time += a_time;fout << "进程" << front->name << "的周转时间为:" << a_time << "!" <<endl;ready_list->pop_front();//删除第一个元素}}void FirstServe::print_ready(){fout << "就绪队列中的进程有：";list<CB *>::iterator it=ready_list->begin();while(it!=ready_list->end()){fout << (*it)->name << "、";it++;}fout << endl;}FirstServe::~FirstServe(){fout.close();}int main(){PCB *a_pcb[5];list<CB *> *all_task=new list<CB *>();cout << "正在初始化........" << endl;//五个进程的到达时间各不相同a_pcb[0] = new PCB('A',9,10);a_pcb[1] = new PCB('B',1,30);a_pcb[2] = new PCB('C',3,25);a_pcb[3] = new PCB('D',5,40);a_pcb[4] = new PCB('E',2,33);for(int i=0;i<5;i++){all_task->push_back(a_pcb);}FirstServe fs(all_task,"fcfs_log.txt");cout << "正在执行........" << endl;fs.run();cout << "执行完毕！" << endl;return 0;}。
实现作业调度算法先来先服务+最短作业+最短剩余时间
0956104 朱文君操作系统上机报告一、实验目的：1.学习处理器各种调度算法的基本思想；2.通过上机实习，编写程序实现处理器的调度加深对各种算法的理解。
二、实验内容：1.实验平台：Microsoft Visual C++ 6.0编程环境、Microsoft Office Word软件平台；2.用C语言编程实现处理器的调度算法：①先来先服务算法②最短作业优先算法③最短剩余时间优先算法；三、实验步骤：（一）先来先服务算法1.说明：先来先服务算法（First Come First Served，FCFS）按照作业进入系统后备作业队列的先后次序来挑选作业，先进入系统的作业将优先被挑选进入主存，创建用户进程，分配所需资源，然后，移入就绪队列。
2.算法实现：#include<stdio.h>void main(){int i,a,T=0,N,add;float sum=0;printf("输入进程数：");scanf("%d",&N);for(i=1;i<=N;i++){printf("\n第%d个进程所需的时间：",i);scanf("%d",&a);T=T+a;sum+=T;printf("\n是否有新的进程进入，输入新的进程数：");scanf("%d",&add);N=N+add;}printf("\n T=%f",sum/N);}3.运行结果演示：(二)最短作业优先算法1.说明：最短作业优先算法（Shortest Job First，SFJ）以进入系统的作业所要求的CPU运行时间的长短为标准，总是选取预计计算时间最短的作业投入运行。
2.算法实现：#include<stdio.h>int De_a(int x,int y,int a[]){int i;if(x==y)a[x]=0;else{for(i=x;i<y;i++){a[i]=a[i+1];}a[i]=0;}return 1;}void main(){int N,M,i,j,k,add,flag,a[1000]={0};float T=0.000,W=0.000,sum=0;printf("输入进程数：");scanf("%d",&N);for(i=1;i<=N;i++){printf("\n第%d个进程所需的时间：",i);scanf("%d",&a[i]);}M=N;for(i=1;i<=N;i++){a[0]=a[1];for(j=1;j<=M;j++){if(a[0]>=a[j]){a[0]=a[j];flag=j;}}T=T+(float)a[flag];sum+=T;W=W+(float)T/a[flag];printf(" %f ",W);De_a(flag,M,a);printf("\n是否有新的进程进入，输入新的进程数：");scanf("%d",&add);for(k=1;k<=add;k++){printf("\n第%d个进程所需的时间：",i);scanf("%d",&a[k+M-1]);}N=N+add;M=M+add-1;}printf("平均作业周转时间T=%f\n",sum/N);printf("平均带权作业周转时间W=%f\n",W/N);}3.运行结果演示：（三）最短剩余时间优先算法1.说明：最短剩余时间优先算法（Shortest Remaining Time First，SRTF）即当前某进程/线程正在运行，如果有新进程/线程移入就绪队列，若它所需要的CPU运行时间比当前运行进程/线程所需要的剩余CPU时间还短，抢占式最短作业优先算法强行剥夺当前执行者的控制权，调度新进程/线程执行。
操作系统(先来先服务 短作业优先)进程调度算法模拟程序设计
《操作系统》课程综合性实验指导单适用专业：计算机科学与技术一、实验题目：进程调度算法模拟程序设计二、实验目的：通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。
三、实验设备及环境：1. 硬件设备：PC机一台2. 软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java 等编程语言环境。
四、实验内容及要求：（1）用C语言（或其它语言，如Java）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：✧进程标识数ID。
✧进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
✧进程已占用CPU时间CPUTIME。
✧进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
✧进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
✧进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
✧进程状态STATE。
✧队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：✧进程在就绪队列中呆一个时间片，优先数增加1。
✧进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
（5）分析程序运行的结果，谈一下自己的认识。
五、考核标准：优秀：能很直观方便地定义各个进程，采用一种算法模拟进程调度的过程，算法思想正确；程序设计结构清晰明了；语法、语义正确；实验结果正确；界面美观，布局合理；报告规范，解析完整，文字流畅，题解正确。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
作业模拟调度实验1 课程设计的目的通过该题目的设计过程，可以初步掌握作业调度的原理、软件开发方法并提高解决实际问题的能力。
了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序。
2 课程设计的开发语言程序设计所选用的程序设计语言为C语言。
3 功能描述先来先服务算法比较有利于长作业，而不利于短作业。
（1）短作业（SJF）的调度算法可以照顾到实际上在所有作业中占很大比例的短作业，使它能比长作业优先执行。
SPF优先调度算法：是从就绪队列中选出一估计运行时间最短的进程，将处理机分配给它，使它立即执行到完成，或发生某事件而被阻塞放弃处理机时，再重新调度。
为了和FCFS调度算法进行比较，我们利用FCFS算法中所使用的实例并改用SJ（P）F算法重新调度，再进行性能分析。
采用SJF算法后，不论是平均周转时间还是平均带权周转时间都有较明显的改善，尤其是对短作业D，其周转时间由FCFS算法的11降为SJF算法中的3；而平均带权周转时间是从5.5降到1.5。
这说明SJF调度算法能有效地降低作业的平均等待时间和提高系统的吐量。
短作业优先调度算法对比先来先服务，不论是平均周转时间还是平均带权周转时间，都有较明显的改善，尤其是对短作业。
该算法对长作业不利，而且未考虑作业的紧迫程度，因而不能保证紧迫性作业会被及时处理。
如作业C的周转时间由10增至16，带权周转时间由2增至3.1。
更严重的是，如果有一长作业（进程）进入系统的后备队列（就绪队列），由于调度程序总是优先调度那些（即使是后进来的）短作业（进程），将致使长作业（进程）得不到调度。
（2）该算法完全未考虑作业的紧迫程度，因而不能保证紧迫性作业（进程），会得到及时处理；（3）由于作业（进程）的长短只是根据用户所提供的估计执行时间而定，而用户又可能会有意或无意地缩短其作业的估计执行时间，致使该算法不一定能真正做到短作业优先调度。
高响应比优先调度算法在批处理系统中，用作作业调度的短作业优先算法是一个比较好的算法。
其主要缺点是作业的运行得不到保证。
如果我们能为每个作业引入前面所述的动态优先权机制，并使以速率a增加，则长作业在等待一定的时间后，必须有机会分配到处理机。
该优先权的变化可描述为：优先权=（等待时间+要求服务时间）/要求服务时间由于等待时间加上要求服务时间，就是系统对该作业的响应时间，故该优先权又相当于响应比Rp = 等待时间加要求服务时间/要求服务时间=响应时间/要求服务时间由上式可以看出：（1）如果作业的等待时间相同，则要求服务的时间愈短，其优先权愈高，因而该算法有利于短作业；（2）当要求服务的时间相同时，作业的优先权决定于其等待时间，因而实现了先来先服务；（3）对于长作业，当其等待时间足够长时，其优先权便可升到很高，从而也可获得处理机。
该算法既照顾了短作业，又考虑了作业到达的先后顺序，也不会使作业长期得不到服务。
因此，该算法实现了一种较好的折衷。
当然，再利用该算法时，每要进行调度之前，都需先进行响应应比的计算，这会增加系统的开销。
4 方案论证4.1 概要设计假设在单道批处理环境下有四个作业JOB1、JOB2、JOB3、JOB4，已知它们进入系统的时间、估计运行时间。
分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法，计算出作业的平均周转时间和带权的平均周转时间。
作业i 的周转时间：Ti=Tci-Tsi作业的平均周转时间：T=作业i的带权周转时间：Wi=Ti/Tri作业的平均带权周转时间：W=先来先服务调度算法（FCFS）：每次调度都是从后备作业队列中，选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
在进程调度中采用FCFS算法时，这每次调度是从就绪队列中，选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某事件阻赛后，才放弃处理机。
短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。
它们可分别用于作业调度和进程调度。
该调度算法是从后备（就绪）队列中选择一个或若干个估计运行时间最短的作业（进程），将它们调度内存运行。
响应比高者优先（HRN）：每次从后备队列中选择一个或若干个估计响应比最高的作业，将它们调入内存运行。
响应比Rp=作业响应时间/运行时间=作业等待时间+作业运行时间=1+作业等待时间每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W。
各个等待的作业按照提交时刻的先后次序排队，总是首先调度等待队列中队首的作业。
每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。
4.2 详细设计4.2.1 程序设计过程中的部分算法（1）用类C语言定义相关的数据类型定义头文件：#include <stdio.h>#include <stdlib.h>#define getpch(type) (type*)malloc(sizeof(type))定义结构体：struct worktime{float Tb; //作业运行时刻float Tc; //作业完成时刻float Ti; //周转时间float Wi; //带权周转时间};struct jcb { //定义作业控制块JCBchar name[10]; //作业名float subtime; //作业提交时间float runtime; //作业所需的运行时间char resource; //所需资源float Rp; //后备作业响应比char state; //作业状态struct worktime wt;struct jcb* link; //链指针}*jcb_ready=NULL,*j;（2）各模块伪码void SJFget() // 获取队列中的最短作业{JCB *front,*mintime,*rear; //定义JCB指针int ipmove=0;mintime=jcb_ready;rear=mintime->link;while(rear!=NULL)if((rear!=NULL)&&(T>=rear->subtime)&&(mintime->runtime)>(rear->runtime)) { //队列不空时，给作业排队front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;if (ipmove==1){ //队首作业完成，后续作业重新排队front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;}void HRNget() // 获取队列中的最高响应作业{JCB *front,*mintime,*rear;int ipmove=0;//初始化mintime=jcb_ready;rear=mintime->link;while(rear!=NULL)if ((rear!=NULL)&&(T>=rear->subtime)&&(mintime->Rp)<(rear->Rp)){ //队尾不空时，作业按运行时间排队front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;if (ipmove==1){ //队首作业完成，改变指针front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;}4.2.2 主程序流程图:开始初始化所有的JCB使JCB按作业提交的时刻的先后顺序排队时间量Ｔ：＝０调度队首的作业投入运行：（更改队首指针，使作业的状态为R，记住作业开始运行的时刻Tb等）计算并打印运行作业i的完成时刻Tc，周转时间Ti，带权周转时间Wi（完成时刻Tc=开始运行时刻+运行时间更改时间量T的值（T：=T+作业i的运行时间）队列为空?计算并打印这组作业的平均周转时间及带权平均周转时间结束图1 调度算法流程图图25 运行结果图3 运行结果6 心得体会经过一周的努力，我的课程设计基本完成了，这次课程设计培养了我耐心、慎密、全面地考虑问题的能力，从而加快了问题解决的速度、提高了个人的工作效率，以及锻炼围绕问题在短时间内得以解决的顽强意志。
在编写程序的过程中，我的能力得到了提高，同时养成了科学、严谨的作风和习惯。
为此我要感谢信息学院开设了这门操作系统课程设计，为我们提供了进一步学习算法、操作系统和巩固C语言程序计设这个平台并。
同时还要感谢对同一题目进行攻关的同学们给予的帮助，没他们的帮助可能有很多问题我个人不能进行很好的解决。
在此我对他们帮助给予衷心的感谢。
7 附录#include "stdio.h"#include <stdlib.h>#define getpch(type) (type*)malloc(sizeof(type))struct worktime{float Tb; //作业运行时刻float Tc; //作业完成时刻float Ti; //周转时间float Wi; //带权周转时间};struct jcb { /*定义作业控制块JCB */char name[10]; //作业名float subtime; //作业提交时间float runtime; //作业所需的运行时间char resource; //所需资源float Rp; //后备作业响应比char state; //作业状态struct worktime wt;struct jcb* link; //链指针}*jcb_ready=NULL,*j;typedef struct jcb JCB;float T=0;void sort() /* 建立对作业进行提交时间排列函数*/{JCB *first, *second;int insert=0;if((jcb_ready==NULL)||((j->subtime)<(jcb_ready->subtime))) /*作业提交时间最短的,插入队首*/ {j->link=jcb_ready;jcb_ready=j;T=j->subtime;j->Rp=1;}else /* 作业比较提交时间,插入适当的位置中*/{first=jcb_ready;second=first->link;while(second!=NULL){if((j->subtime)<(second->subtime)) /*若插入作业比当前作业提交时间短,*/{ /*插入到当前作业前面*/j->link=second;first->link=j;second=NULL;insert=1;}Else /* 插入作业优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if (insert==0) first->link=j;}}void SJFget() /* 获取队列中的最短作业*/{JCB *front,*mintime,*rear;int ipmove=0;mintime=jcb_ready;rear=mintime->link;while(rear!=NULL)if((rear!=NULL)&&(T>=rear->subtime)&&(mintime->runtime)>(rear->runtime)) {front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;if (ipmove==1){front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;}void HRNget() /* 获取队列中的最高响应作业*/{JCB *front,*mintime,*rear;int ipmove=0;mintime=jcb_ready;rear=mintime->link;while(rear!=NULL)if ((rear!=NULL)&&(T>=rear->subtime)&&(mintime->Rp)<(rear->Rp)){front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;if (ipmove==1){front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;}void input() /* 建立作业控制块函数*/{ int i,num;printf("\n 请输入作业数:?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 作业号No.%d:\n",i);j=getpch(JCB);printf("\n 输入作业名:");scanf("%s",j->name);printf("\n 输入作业提交时刻:");scanf("%f",&j->subtime);printf("\n 输入作业运行时间:");scanf("%f",&j->runtime);printf("\n");j->state='w';j->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; JCB* jr=jcb_ready;while(jr!=NULL){l++;jr=jr->link;}return(l);}void disp(JCB* jr,int select) /*建立作业显示函数,用于显示当前作业*/{if (select==3) printf("\n 作业服务时间响应比运行时刻完成时刻周转时间带权周转时间\n");else printf("\n 作业服务时间运行时刻完成时刻周转时间带权周转时间\n");printf(" |%s\t",jr->name);printf(" |%.2f\t ",jr->runtime);if (select==3) printf(" |%.2f ",jr->Rp);if (j==jr){printf(" |%.2f\t",jr->wt.Tb);printf(" |%.2f ",jr->wt.Tc);printf(" |%.2f \t",jr->wt.Ti);printf(" |%.2f",jr->wt.Wi);}printf("\n");}void check(int select) /* 建立作业查看函数*/{ JCB* jr;printf("\n **** 当前正在运行的作业是:%s",j->name); /*显示当前运行作业*/disp(j,select);jr=jcb_ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(jr!=NULL){jr->Rp=(T-jr->subtime)/jr->runtime;disp(jr,select);jr=jr->link;}destroy();}int destroy() /*建立作业撤消函数(作业运行结束,撤消作业)*/{printf("\n 作业[%s] 已完成.\n",j->name);free(j);}void running(JCB* jr) /* 建立作业就绪函数(作业运行时间到,置就绪状态*/ {if (T>=jr->subtime) jr->wt.Tb=T; else jr->wt.Tb=jr->subtime;jr->wt.Tc=jr->wt.Tb+jr->runtime;jr->wt.Ti=jr->wt.Tc-jr->subtime;jr->wt.Wi=jr->wt.Ti/jr->runtime;T=jr->wt.Tc;}int main() /*主函数*/{int select=0,len,h=0;float sumTi=0,sumWi=0;input();len=space();printf("\n\t1.FCFS 2.SJF 3.HRN\n\n请选择作业调度算法:?");scanf("%d",&select);while((len!=0)&&(jcb_ready!=NULL)){ h++;printf("\n 执行第%d个作业\n",h);j=jcb_ready;jcb_ready=j->link;j->link=NULL;j->state='R';running(j);sumTi+=j->wt.Ti;sumWi+=j->wt.Wi;check(select);if (select==2&&h<len-1) SJFget();if (select==3&&h<len-1) HRNget();printf("\n 按任一键继续......\n");getchar();getchar();}printf("\n\n 作业已经完成.\n");printf("\t 此组作业的平均周转时间：%.2f\n",sumTi/h);printf("\t 此组作业的带权平均周转时间：%.2f\n",sumWi/h);getchar(); }参考文献[1]汤子瀛，哲凤屏.计算机操作系统[M].西安电子科技大学学出版社.[2]王清，李光明.计算机操作系统[M].冶金工业出版社.[3]孙钟秀. 操作系统教程[M]. 高等教育出版社[4]曾明. Linux操作系统应用教程[M]. 陕西科学技术出版社.[5]张丽芬，刘利雄.操作系统实验教程[M]. 清华大学出版社.[6]孟静，操作系统教程－－原理和实例分析[M]. 高等教育出版社.[7]周长林，计算机操作系统教程[M]. 高等教育出版社[8]张尧学，计算机操作系统教程[M]，清华大学出版社[9]任满杰，操作系统原理实用教程[M]，电子工业出版社。