先来先服务,时间片调度,优先级调度算法实验报告
先来先服务,时间片调度,优先级调度算法实
验报告
实验报告
1. 引言
进程调度是操作系统中非常重要的一部分，它决定了进程在CPU上执行的顺序和时间长度。
在本次实验中，我们通过实现先来先服务调度算法、时间片调度算法和优先级调度算法，并对其性能进行比较，来深入了解各种调度算法的工作原理及优缺点。
2. 先来先服务调度算法
先来先服务调度算法按照进程到达的先后顺序进行调度。
当一个进程到达时，如果CPU空闲，则将其分配给CPU进行执行；如果CPU 正在执行其他进程，则该进程将等待直到CPU空闲。
优点是简单易实现，适用于长作业。
缺点是可能出现饥饿现象，即低优先级的进程可能会一直等待高优先级进程的执行。
3. 时间片调度算法
时间片调度算法将CPU的执行时间划分为固定长度的时间片，每个进程在一个时间片内执行，当时间片用完后，系统将切换到下一个进程执行。
该算法确保每个进程都有公平的执行时间，避免了饥饿
现象。
然而，对于CPU利用率较高的情况下，可能会导致进程频繁地
切换，增加了上下文切换的开销。
4. 优先级调度算法
优先级调度算法根据进程的优先级来进行调度，优先级较高的
进程将具有更高的执行优先级。
当多个进程同时到达CPU时，系统将
选择优先级最高的进程先执行。
该算法可以分为静态优先级调度和动
态优先级调度两种方式。
优点是可以根据进程的重要性灵活调整执行
顺序。
缺点是可能导致优先级低的进程长时间等待，造成饥饿现象。
5. 实验结果与分析
我们通过模拟多个进程的到达和执行过程，在不同的场景下比
较了先来先服务调度算法、时间片调度算法和优先级调度算法的性能。
实验结果显示，在长作业的情况下，先来先服务调度算法表现较好；
在要求公平性的场景下，时间片调度算法比较适合；而对于需要根据
优先级来调度的场景，优先级调度算法可以更好地满足需求。
6. 结论
不同的进程调度算法在不同的场景下有各自的优劣。
先来先服
务调度算法简单易实现，适用于长作业；时间片调度算法保证了公平性，适用于要求公平的场景；而优先级调度算法则可以根据进程的重
要性进行调度。
在实际的操作系统中，可以根据不同的应用场景选择
合适的进程调度算法，以提高系统的性能和用户体验。
总之，通过本次实验，我们对先来先服务调度算法、时间片调度算法和优先级调度算法进行了深入研究和比较，对不同的调度算法有了更加清晰的了解。
这将对我们在实际操作系统开发中的进程调度设计和优化提供重要的指导意义。
用于作业调度的算法
用于作业调度的算法作业调度是计算机操作系统中的一个重要概念，它指的是在多个进程同时运行时，如何合理地分配CPU资源，使得系统能够高效地完成各项任务。
作业调度算法是实现作业调度的关键，下面将详细介绍几种常见的作业调度算法。
一、先来先服务（FCFS）算法先来先服务（FCFS）算法是最简单也是最容易实现的一种作业调度算法。
该算法按照进程到达时间的顺序依次执行，即当一个进程到达后，如果当前没有正在执行的进程，则立即执行该进程；否则将该进程加入等待队列中，并等待前面所有进程执行完毕后再进行处理。
FCFS算法优点在于简单易实现，并且保证了公平性。
但由于没有考虑到不同进程的优先级和执行时间等因素，因此可能会导致长任务等待时间过长、短任务响应时间过长等问题。
二、短作业优先（SJF）算法短作业优先（SJF）算法是一种根据作业长度进行排序的调度策略。
该算法按照各个进程需要占用CPU时间片长度进行排序后依次执行，即当一个新的进程到达时，如果其需要占用的时间片长度比当前正在执行的进程短，则立即切换到该进程进行处理，否则将该进程加入等待队列中，并等待前面所有进程执行完毕后再进行处理。
SJF算法优点在于能够最大限度地缩短作业响应时间，提高系统的吞吐量。
但由于需要预测每个进程需要占用的时间片长度，因此实现起来较为困难，并且可能会出现“饥饿”现象，即长时间等待CPU资源的进程无法得到及时处理。
三、优先级调度算法优先级调度算法是一种按照不同进程的优先级进行排序的调度策略。
该算法将每个进程赋予一个优先级值，根据优先级值高低依次执行，即当一个新的进程到达时，如果其优先级比当前正在执行的进程高，则立即切换到该进程进行处理，否则将该进程加入等待队列中，并等待前面所有优先级更高的进程执行完毕后再进行处理。
优先级调度算法可以根据不同任务类型和紧急性进行灵活调整，并且可以避免长任务等待时间过长、短任务响应时间过长等问题。
但由于可能会出现“饥饿”现象和优先级反转等问题，因此需要进行适当的优化和调整。
作业调度实验报告
一、根据调度算法设计流程图：实验
步骤
}
}
}
三、整合完成所有程序并实现作业调度（见源代码）。
四、进行调试阶段，对程序修改优化，进行数据测试。
五、实验结果分析
六、总结
实验
WindowsXP和CV++6.0集成开发环境
环境
实验运行的初始界面：
实验结
果与分
析
测试数据：
a1 1 2 a1
a2 2 3 a2
运行结果：
进行多次循环录入：返回算法选择界面：
测试数据：
b1 2 4 b1
b2 1 3 b2
运行结果：
实验分析和总结：
1）测试的数据必须是符合JCB模块中相同类型的，如在源码中式int类型的，而在测试的时候输入float类型就出错。
2）各个库函数的运用需要掌握相应的功能，否则会照成代码冗余、繁杂、不优化等各种问题。
3）通常在dos下运用的都是英文，而想要用汉字提示就必须考虑一些问题。
在源码中我们用制表符（\t）来控制提示，输出的数字是不能与之对齐的，所以我们要将“\t”改成空格。
4）这编写和调试程序时，为了尽快调通程序应该按照流程图的结构（保证流程图思路是对的情况下）来建立编程思路。
5）此程序也借用了现有的一些代码，并且它还不是最优化的，它还可以进行改进和优化，比如：在回调函数的引用时跳到了另一个页面，见下图：
继续Enter的时候就到下一页：
而不是在同一页面。
6）总之，在编程旅途中是一个很艰辛的过程，要在这里开拓一片蓝天就必须有孜孜不倦的精神。
常用的调度算法
常用的调度算法调度算法是指操作系统中用于决定进程何时执行、何时暂停等的一种算法。
常用的调度算法包括先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转等。
下面将对这些常用的调度算法进行详细介绍。
一、先来先服务（FCFS）先来先服务是最简单的调度算法之一，它按照进程到达的顺序进行调度，即谁先到谁先执行。
这种算法容易实现，但是存在“饥饿”现象，即如果某个进程长时间等待，则其他进程可能会一直占用CPU资源，导致该进程无法得到执行。
因此，在实际应用中，FCFS很少被使用。
二、短作业优先（SJF）短作业优先是一种以作业运行时间为依据的调度算法。
它通过预测每个进程需要运行的时间，并将其按照运行时间从小到大排序，然后依次执行。
这种算法可以最大限度地减少平均等待时间和平均周转时间，并且不会出现“饥饿”现象。
但是，在实际应用中，由于很难准确预测每个进程需要运行的时间，因此SJF也存在缺陷。
如果预测不准确，那么就会出现长作业等待短作业的情况，导致长作业的等待时间变长。
三、优先级调度优先级调度是一种按照进程优先级进行调度的算法。
每个进程都有一个优先级，系统会根据进程的优先级来决定下一个要执行的进程。
通常情况下，优先级越高的进程越有可能得到CPU资源。
但是，如果某个进程的优先级一直比其他进程高，那么其他进程就会一直等待，导致“饥饿”现象。
此外，在实际应用中，由于不同进程之间的优先级差别较大，因此可能会导致低优先级的进程长时间等待。
四、时间片轮转时间片轮转是一种按照时间片进行调度的算法。
它将CPU资源划分成若干个时间片，并将每个时间片分配给一个正在运行或等待运行的进程。
当一个进程用完了它所分配到的时间片后，系统会将其挂起，并将CPU资源分配给下一个等待运行的进程。
这种算法可以避免“饥饿”现象，并且能够保证所有正在运行或等待运行的进程都能够得到CPU资源。
但是，如果时间片太小，会导致进程频繁切换，影响系统性能；如果时间片太大，会导致长作业等待时间变长。
实验一、进程调度实验报告
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 CPU 资源给各个进程，以提高系统的整体性能和资源利用率。
通过本次实验，我们旨在深入理解进程调度的原理和算法，掌握进程状态的转换，观察不同调度策略对系统性能的影响，并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验原理1、进程状态进程在其生命周期中会经历不同的状态，包括就绪态、运行态和阻塞态。
就绪态表示进程已经准备好执行，只等待 CPU 分配；运行态表示进程正在 CPU 上执行；阻塞态表示进程由于等待某个事件（如 I/O操作完成）而暂时无法执行。
2、调度算法常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。
先来先服务算法按照进程到达的先后顺序进行调度。
短作业优先算法优先调度执行时间短的进程。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片执行。
四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体，包含进程 ID、到达时间、执行时间、剩余时间等信息。
实现进程的创建、插入、删除等操作。
实现不同的调度算法。
2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。
分别采用先来先服务、短作业优先和时间片轮转算法进行调度。
记录每个算法下的平均周转时间、平均等待时间等性能指标。
五、实验步骤1、进程结构体的定义｀｀｀c+＋struct Process ｛int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;｝；｀｀｀2、进程创建函数｀｀｀c+＋void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) ｛processesnumProcessespid ＝ pid;processesnumProcessesarrivalTime ＝ arrivalTime;processesnumProcessesexecutionTime ＝ executionTime;processesnumProcessesremainingTime ＝ executionTime;numProcesses+＋；｝｀｀｀3、先来先服务调度算法实现｀｀｀c+＋void fcfsScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （currentTime ＜ processesiarrivalTime) ｛currentTime ＝ processesiarrivalTime;｝processesistartTime ＝ currentTime;currentTime ＋＝ processesiexecutionTime;processesifinishTime ＝ currentTime;processesiwaitingTime ＝ processesistartTime processesiarrivalTime;processesiturnaroundTime ＝ processesifinishTime processesiarrivalTime;｝｝｀｀｀4、短作业优先调度算法实现｀｀｀c+＋void sjfScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;int minExecutionTime, selectedProcess;bool found;while （true) ｛found ＝ false;minExecutionTime ＝ INT_MAX;selectedProcess ＝－1;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （processesiarrivalTime ＜＝ currentTime ＆＆processesiremainingTime ＜ minExecutionTime ＆＆processesiremainingTime ＞ 0) ｛found ＝ true;minExecutionTime ＝ processesiremainingTime;selectedProcess ＝ i;｝｝if （！found) ｛break;｝processesselectedProcessstartTime ＝ currentTime;currentTime ＋＝ processesselectedProcessremainingTime;processesselectedProcessfinishTime ＝ currentTime;processesselectedProcesswaitingTime ＝processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime ＝processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime ＝ 0;｝｝｀｀｀5、时间片轮转调度算法实现｀｀｀c+＋void rrScheduling(Process processes, int numProcesses, int timeSlice) ｛int currentTime ＝ 0;Queue<int> readyQueue;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛readyQueueenqueue(i)；｝while （！readyQueueisEmpty(））｛int currentProcess ＝ readyQueuedequeue(）；if （processescurrentProcessarrivalTime ＞ currentTime) ｛currentTime ＝ processescurrentProcessarrivalTime;｝if （processescurrentProcessremainingTime ＜＝ timeSlice) ｛currentTime ＋＝ processescurrentProcessremainingTime;processescurrentProcessfinishTime ＝ currentTime;processescurrentProcesswaitingTime ＝processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime ＝processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime ＝ 0;｝ else ｛currentTime ＋＝ timeSlice;processescurrentProcessremainingTime ＝ timeSlice;readyQueueenqueue(currentProcess)；｝｝｝｀｀｀6、性能指标计算函数｀｀｀c+＋void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) ｛double totalWaitingTime ＝ 0, totalTurnaroundTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛totalWaitingTime ＋＝ processesiwaitingTime;totalTurnaroundTime ＋＝ processesiturnaroundTime;｝averageWaitingTime ＝ totalWaitingTime ／ numProcesses; averageTurnaroundTime ＝ totalTurnaroundTime ／ numProcesses;｝｀｀｀7、主函数｀｀｀c+＋int main(）｛Process processes100;int numProcesses ＝ 0;／／创建进程createProcess(processes, numProcesses, 1, 0, 5)；createProcess(processes, numProcesses, 2, 1, 3)；createProcess(processes, numProcesses, 3, 2, 4)；createProcess(processes, numProcesses, 4, 3, 2)；／／先来先服务调度fcfsScheduling(processes, numProcesses)；double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime)；cout ＜＜＂先来先服务调度的平均等待时间：＂＜＜fcfsAverageWaitingTime ＜＜ endl;cout ＜＜＂先来先服务调度的平均周转时间：＂＜＜fcfsAverageTurnaroundTime ＜＜ endl;／／短作业优先调度sjfScheduling(processes, numProcesses)；double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime)；cout ＜＜＂短作业优先调度的平均等待时间：＂＜＜sjfAverageWaitingTime ＜＜ endl;cout ＜＜＂短作业优先调度的平均周转时间：＂＜＜sjfAverageTurnaroundTime ＜＜ endl;／／时间片轮转调度（时间片为 2）rrScheduling(processes, numProcesses, 2)；double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime)；cout ＜＜＂时间片轮转调度（时间片为 2）的平均等待时间：＂＜＜ rrAverageWaitingTime ＜＜ endl;cout ＜＜＂时间片轮转调度（时间片为 2）的平均周转时间：＂＜＜ rrAverageTurnaroundTime ＜＜ endl;return 0;｝｀｀｀六、实验结果与分析1、先来先服务调度平均等待时间：40平均周转时间：85分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。
进程调度算法总结
进程调度算法总结所谓进程，简单来说是计算机中的各种任务，那么计算机如何分配系统资源以供这些任务使⽤呢？此篇博客⽬的就是为⼤家整理⼀下⼏种常见进程调度算法。
进度调度就是按照⼀定的策略，动态地把处理机分配给处于就绪队列的进程，使之执⾏。
常见的进程调度算法：1、先来先服务和短作业（进程）优先调度算法2、⾼优先权优先调度算法3、基于时间⽚的轮转调度算法下⾯细说：1、先来先服务和短作业优先调度算法1.1、先来先服务调度算法这种调度算法由字⾯意思理解很直观，所谓先来先服务，就是谁先来先服务谁。
结合进程，先来先服务调度算法就是对于优先到达就绪队列的进程采取优先服务的策略，直到该进程运⾏结束或发⽣某事件导致阻塞才放弃处理机。
这种调度算法是⼀种最简单的调度算法，适⽤于作业和进程。
当⽤于作业时，先进⼊后备队列的作业先运⾏。
1.2、短作业（进程）优先调度算法短作业（进程）优先调度算法，是对短作业或短进程进⾏得调度算法。
何为短？就是估计运⾏时间短。
该算法从后备队列或就绪队列选择估计运⾏时间较短的作业或进程，将他们调⼊内存运⾏，直到该进程运⾏结束或发⽣某事件导致阻塞才放弃处理机重新进⾏调度。
2、⾼优先权优先调度算法2.1、优先权调度算法上述所说的两种调度算法，过于简单，当系统中有紧急作业或进程，且不满⾜先进队列或运⾏时间短时，这些作业或进程将很难得到资源。
那么对于这些作业或进程，⼜该怎么办呢？因此，⼜有了优先权调度算法，所谓优先权调度算法，顾名思义就是谁的优先权⾼，谁就西安得到资源得以运⾏。
进⼀步将算法分为以下两种：2.1.1、⾮抢占式优先权算法在这种⽅式下，系统⼀旦把处理机分配给就绪队列中优先权最⾼的进程后，该进程便⼀直执⾏下去，直⾄完成；或因发⽣某事件使该进程放弃处理机时，系统⽅可再将处理机重新分配给另⼀优先权最⾼的进程。
这种调度算法主要⽤于批处理系统中；也可⽤于某些对实时性要求不严的实时系统中。
2.1.2、抢占式优先权算法在这种⽅式下，系统同样是把处理机分配给优先权最⾼的进程，使之执⾏。
先来先服务实验报告
先来先服务调度算法一，实验目的1.加深对先来先服务算法的理解。
2.利用C语言编写算法，模拟实现先来先服务算法。
3.模拟先来先服务算法，并计算平均周转时间和平均带权周转时间。
二，实验开发平台。
Microsoft Visual C++6.0三，调度算法说明先来先服务调度算法，是一种简单的调度算法，该算法即可用于作业调度，也可用于进程调度，就是每次从就绪队列中选择一个最先进入队列的进程，该算法比较有利于长作业，而不利于短作业。
另外，FCFS调度算法对CPU繁忙型作业比较有利，而不利于I/O繁忙作业。
四，实验源程序。
#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct jcb {char name[10];char state;/*状态*/int atime; /*到达时刻*/int ntime; /*所需时间*/int ctime; /*完成时刻*/int stime; /*开始时刻*/int ttime; /*周转时间*/float bttime;/*带权周转时间*/struct jcb* link;}*ready=NULL,*p,*q;typedef struct jcb JCB;float wtime=0,wttime=0,wbttime=0;sort(){ if(ready==NULL){p->link=ready;ready=p;q=p;}else{ q->link=p;q=p;}}input(){ int i,num;printf("\n 请输入作业数:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 作业号No.%d:\n",i);p=getpch(JCB);printf("\n 输入作业名:");scanf("%s",p->name);printf("\n 输入作业所需时间:");scanf("%d",&p->ntime);printf("\n");p->atime=i;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; JCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp1(JCB* pr) /*建立作业显示函数,用于显示当前作业*/{printf("\n作业名|状态|开始时刻|完成时刻|周转时间|带权周转时间\n"); printf("%s\t",pr->name);printf("%c\t",pr->state);printf("%d\t",pr->stime);printf("%d\t",pr->ctime);printf("%d\t",pr->ttime);printf("%f\t",pr->bttime);printf("\n");}disp2(JCB* pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n作业名|状态|到达时刻|所需时间\n");printf("%s\t",pr->name);printf("%c\t",pr->state);printf("%d\t",pr->atime);printf("%d\t",pr->ntime);printf("\n");}check() /* 建立作业查看函数*/{JCB* pr;pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp2(pr);pr=pr->link;}}destroy() /*建立作业撤消函数(作业运行结束,撤消作业)*/{printf("\n 作业[%s] 已完成.\n",p->name);free(p);}running(){p->stime=wtime;p->ctime=p->stime+p->ntime;p->ttime=p->ctime-p->atime;p->bttime=(float)p->ttime/(float)p->ntime;wtime=wtime+p->ntime;/*printf("时间:%f",wtime);*/wttime=wttime+p->ttime;wbttime=wbttime+p->bttime;printf("\n **** 当前正在运行的作业是:%s",p->name); /*显示当前运行作业*/ disp1(p);destroy();}main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';running();check();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 作业已经完成.\n");printf("\n该次作业调度平均周转时间:%f\n",wttime/len); printf("\n该次作业调度带权平均周转时间:%f\n",wbttime/len); ch=getchar();}五，实验结果。
操作系统中常用作业调度算法的分析
操作系统中常用作业调度算法的分析作业调度是操作系统中的一个重要组成部分，它负责对待执行的作业进行排队和调度，以最大化系统资源的利用效率、满足用户需求、保证系统稳定性等目标。
常见的作业调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度、时间片轮转（RR）等，接下来我们分别对这几种算法进行分析。
1. FCFS调度算法先来先服务调度算法是操作系统中最简单的一种调度算法，也是最常用的一种调度算法。
它的处理方式是根据提交时间顺序，按照FIFO的顺序进行调度。
该算法的优点是简单易用，而且很容易实现。
同时，对于大多数情况下，该算法的资源分配相对公平。
但是，该算法存在着一些问题。
当一个作业的执行时间较长时，会大大降低系统的吞吐量，严重影响系统的效率。
因此，在实际应用中，该算法往往不能满足对作业的实时响应和高效完成的要求。
最短作业优先调度算法是一种非抢占式调度算法，它将作业按照其需要执行的时间长短大小进行排序，然后从执行时间最短的作业开始调度。
在实际应用中，该算法可以减少平均等待时间和平均周转时间，提高系统的效率和性能。
但是，该算法有个致命的缺点——它无法预测作业的执行时间。
如果一个长作业被排在了等待队列的前面，那么所有后续的短作业都要等待非常长的时间，这可能导致饥饿现象的出现。
3. 优先级调度算法优先调度算法是一种根据作业优先级大小进行调度的算法，可以根据作业的重要程度或紧急程度来设置不同的优先级。
该算法可以提高系统的响应速度和稳定性，满足系统特定的需求。
但是，该算法也存在着一些问题。
如果一个作业的优先级太高，那么其余的作业可能会一直处于等待状态，这种情况也会导致饥饿现象的出现。
此外，该算法的优先级设置需要有一定的经验和技巧，否则可能会对系统的性能产生不良影响。
4. 时间片轮转算法时间片轮转算法是一种循环调度算法，它将CPU的时间分成多个固定大小的时间片，然后在每个时间片内轮流执行等待队列中的作业，以便平均分配CPU资源。
资源分配的四种算法
资源分配的四种算法资源分配是计算机中一个非常重要的概念，它涉及到如何使用计算机资源来满足对系统的各种需求。
在实际应用中，常见的资源包括CPU时间、内存空间、磁盘I/O等，而如何高效地分配这些资源，则需要使用一些算法来进行优化。
本文将介绍资源分配中常用的四种算法，分别是FCFS算法、SJF算法、优先级调度算法和时间片轮转算法。
1. FCFS算法FCFS（First Come First Serve，先到先服务）算法是资源分配中最简单的一种算法，它的原则是按照作业的到达顺序进行分配，即先来先服务。
FCFS算法将所有作业根据它们的到达时间进行排序，然后按队列的顺序依次将资源分配给它们。
FCFS算法的优点是实现简单，无需过多的计算量和调度算法；但是，由于FCFS算法无法考虑每个作业的长度和重要性，因此在实际应用中可能出现一些缺陷，比如，作业的等待时间可能很久，导致处理时间长，效率低下。
2. SJF算法SJF（Shortest Job First，最短作业优先）算法是一种对作业的长度进行优先级判断的调度算法，其准则是排队的作业中，选择需要处理时间最短的作业先进行处理。
SJF算法通过紧凑排列作业处理的先后，来达到提高系统资源利用率、缩短作业周转时间、减轻繁忙度、提高用户满意度等效果。
SJF算法中可能出现的问题是，由于某些小作业可能会一直处在等待状态，导致这些小作业长时间得不到处理，最终可能会形成“饥饿现象”（即一些长作业得不到处理）。
3. 优先级调度算法优先级调度算法是根据每个作业的优先级来选择下一个要运行的作业的一种调度算法。
高优先级的作业具有更高的运行优先级，即比低优先级的作业更容易获取CPU时间片。
优先级调度算法可以为不同的作业分配不同的优先级，根据作业的特点来调整各个作业之间的优先级。
优先级调度算法的好处是能够优先完成重要的任务，使系统更加高效、安全、可靠。
但是如果优先级设置不当，可能会导致低优先级的大型作业无法完成，最终可能导致其他作业等待时间过长。
进程调度算法实验报告
操作系统实验报告（二）实验题目：进程调度算法实验环境：C++实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较各种算法的性能优劣。
实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。
设计分析：程序流程图：1.先来先服务算法2.短进程优先算法3.时间片轮转调度算法实验代码：1.先来先服务算法#include <iostream.h>#define n 20typedef struct{int id; //进程名int atime; //进程到达时间int runtime; //进程运行时间}fcs;void main(){int amount,i,j,diao,huan;fcs f[n];cout<<"请输入进程个数:"<<endl;cin>>amount;for(i=0;i<amount;i++){cout<<"请输入进程名，进程到达时间，进程运行时间:"<<endl; cin>>f[i].id;cin>>f[i].atime;cin>>f[i].runtime;}for(i=0;i<amount;i++) //按进程到达时间的先后排序{ //如果两个进程同时到达，按在屏幕先输入的先运行for(j=0;j<amount-i-1;j++){ if(f[j].atime>f[j+1].atime){diao=f[j].atime;f[j].atime=f[j+1].atime;f[j+1].atime=diao;huan=f[j].id;f[j].id=f[j+1].id;f[j+1].id=huan;}}}for(i=0;i<amount;i++){cout<<"进程:"<<f[i].id<<"从"<<f[i].atime<<"开始"<<","<<"在"<<f[i].atime+f[i].runtime<<"之前结束。
操作系统实验(时间片轮转)
操作系统实验报告实验名称：时间片轮转调度班级：姓名：学号：实验目的：用高级语言编写和调试一个简单的时间片轮转调度程序，算法要求使用高优先权优先来进行进程调度。
实验内容：（1）用户输入进程名和优先级，并发执行的进程调度程序，每一个进程用一个进程控制块PCB 来代表。
PCB中应包含下列信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间及进程的状态等，各进程的优先数以及进程运行需要地时间片数，由用户输入。
（2）根据先来先服务原则，执行进程，每执行一次，需要时间减1，CPU时间片加1，在进程运行结束后，会显示进程的周转时间；（3）每个进程处于运行R、就绪W和完成F 三种状态之一，假定初始状态都为就绪状态W。
（4）系统能显示或打印各进程状态和参数的变化情况。
实验步骤：一、输入运行进程数目（测试数据为3）；二、输入选择项（选择时间片轮转调度R）；三、输入进程名称和服务时间；实验结果：小结：在这次试验中，主要掌握的是时间片轮转算法的执行过程，按照先来先服务原则，将进程排成一个队列，进程在所分配的时间片内运行的时候，修改自己的状态位，还有计数器加1操作，所需时间减1操作，时间片用完后，排在进程执行队列的尾部，处理机进行切换。
在进程运行结束后打印周转时间。
在最初实现算法的时候，没有添加计算周转时间的函数，后来通过在修改状态位的循环中添加计数器的累加语句，实现了在进程将状态位修改为“F”的时候系统输出周转时间。
源码：#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W--就绪态，R--执行态，F--完成态*/int count;/*记录执行的次数*/int count2; /*周转时间*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高*/void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*/void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*/void RoundRun(); /*时间片轮转调度*/int main(void){char chose;printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("输入进程的调度方法：(P/R)\n");scanf("%c",&chose);switch(chose){case 'P':case 'p':PrioCreate();Priority();break;case 'R':case 'r':TimeCreate();RoundRun();break;default:break;}Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\t周转时间\n"); while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\t%d\n",p->name,p->prio,p->round,p->cputime,p-> needtime,p->state,p->count,p->count2);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\t%d\n",p->name,p->prio,p->round,p->cputime,p-> needtime,p->state,p->count,p->count2);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needt ime,p->state,p->count,p->count2);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低*/{PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空，则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大，则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->round = 0;tmp ->count = 0;tmp ->count2 = 0;InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 0;tmp ->round = 1; /*假设每个进程所分配的时间片是1*/tmp ->count = 0;tmp ->count2 = 0;InsertTime(tmp);}}void Priority() /*按照优先级调度，每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行*/{Output(); /*输出每次调度过程中各个节点的状态*/while(flag){int count3;run->prio -= 2; /*优先级减去2*/run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/run ->count2++;count3 = run ->count2;if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/{run ->state = 'F';run->count++; /*进程执行的次数加一*/run ->count2=count3;InsertFinish(run);flag = 0;}else /*将进程状态置为W，入就绪队列*/{run->state = 'W';run->count++; /*进程执行的次数加一*/run->count2++;InsertTime(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){int count3;run->count++;run->cputime++;run->needtime--;run->count2++;count3 = run ->count2;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';run ->count2++;run ->count2=count3;// printf("进程运行结束,shijian %d\n",&count2);InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/{run->state = 'W';run ->count++;run ->count2++;//run->count++;// run->round++;/*计数器清零，为下次做准备*/InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。