实验一进程调度
实验一进程调度实验
实验一，进程调度实验一、实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解.二、实验内容及要求1.编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。
可以采用静态或动态最高优先数优先的算法。
2、编写并调试一个模拟的进程调度程序，采用简单轮转法和多队列轮转法的“轮转法”调度算法对五个进程进行调度。
三、实验主要仪器设备和材料硬件环境：LBM-PC或兼容机软件坏境：C语言编程环境四、实验设计方案及原理每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W (Wait).运行R (Rim)、或完成F (Finish)三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
(静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变；动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。
例如：在进程获得一次CPU后就将其优先数减少1或者，进程等待的时间超过某一时限时增加其优先数的值，等等。
) 简单轮转法的基本思想是：所有就绪进程按FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。
如果运行进程用完它的时间片后还为完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。
直至所有的进程运行完毕。
多队列轮转法的基本思想是：设置多个就绪队列，每个队列的优先级不同，每个队列的CPU 时间片人小不等：一个新的进程进入内存后，首先将它放入第一队列的末尾，按FCFS原则排队等待调度：仅当第一队列空闲时，调度程序才调度第二队列中的进程运行，后面的队列同理。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。
其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。
在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。
2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。
3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。
实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。
因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。
同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。
实验一、进程调度实验报告
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 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分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。
进程调度实验报告
实验一进程调度实验小组成员：09信管06班余俭3109005857曾昭术3109005859一、实验目的：用高级语言编写和测试一个进程调度程序，通过本实验可以加深理解有关进程控制块、进程队列的概念，以加深对进程的概念及进程调度算法的理解，并体会和了解优先数调度算法的具体实施方法。
二、实验内容：设计一个有N个进程并发的进程调度程序。
要求采用最高优先数优先算法，时间片轮转算法这两种算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
当执行进程在工作的时候，就绪队列中的进程优先级都加一。
当要进行进程调度的时候，如果排在队列前面的进程优先级相等，则按照需要运行的时间大小来排序，需要时间小的排在前面，符合短作业优先算法。
如果运行一个时间片后，进程的已占用CPU时间已到达所需要的运行时间，则撤销该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
三、源代码：/*进程调度*/#include "stdio.h"#include "stdlib.h"#include "conio.h"/*#define NULL 0*/#define getpch(type)(type *)malloc(sizeof(type))struct pcb /*定义进程控制块PCB*/{char name[10];char state;int supper;int ntime;int rtime;struct pcb *link;}*ready=NULL,*p;typedef struct pcb PCB;sort() /*建立对进程进行优先级排列函数*/{PCB *first,*second;int insert=0;if((ready==NULL)||((p->supper)>(ready->supper))) /*优先级最大者，插入队首*/{p->link=ready;ready=p;}else if((p->supper)<(ready->supper))/*进程比较优先级，插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->supper)>=(second->supper)) /*若插入进程比当前进程优先数大*/{ if((p->supper)==(second->supper)) /*修改的代码,实现了当进程优先级相等时，将需要运行时间小的进程放在队列首位*/{if((p->ntime)>(second->ntime)){p->link=second->link;second->link=p;second=NULL;insert=1;}else{p->link=second;first->link=p;second=NULL;insert=1;}}else{p->link=second;first->link=p;second=NULL;insert=1;}}else /*插入进程优先数最低，则插入到队尾*/first=first->link;second=second->link;}}if(insert==0) first->link=p;}else{if((p->ntime)<(ready->ntime)){p->link=ready;ready=p;}else{p->link=ready->link;ready->link=p;}}}input() /*建立进程控制块函数*/{int i,num;printf("\n 请输入要执行进程的个数：");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 请输入进程号:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->supper);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /*调用sort函数*/}system("cls");/*清屏*/}int space(){int l=0;PCB *pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp(PCB *pr) /*建立进程显示函数，用于显示当前进程*/{printf("\nqname\tstate\tsupper\tndtime\truntime\n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->supper);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}check() /*建立进程查看函数*/{PCB *pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}destroy() /*建立进程撤销函数（进程运行结束，撤销进程）*/{printf("\n 进程[%s] 已完成。
实验进程调度
淮海工学院计算机科学系实验报告书课程名：《操作系统原理》题目：实验一进程管理班级：Z软件52学号：2017140595姓名：郭文静1、实验目的与要求进程是操作系统最重要的概念之一，进程调度是操作系统内核的重要功能，本实验要求用C/C++语言编写一个进程调度模拟程序，至少使用最高优先权优先或时间片轮转法两种算法来实现进程调度。
通过本实验可加深对进程调度算法的理解。
1、设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2、模拟调度程序至少使用最高优先权优先或时间片轮转法两种算法来实现进程调度。
3、程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
2、实验内容或题目2.1优先级算法说明（1）PCB的结构：优先级算法中，设PCB的结构如右图所示，其中各数据项的含义Array如下：Id：进程标识符号，取值1—5。
Prior：优先级，随机产生，范围5—10。
Used：目前已占用的CPU时间数，初值为0；当该进程被调用执行时，每执行一个时间片，Used加1。
Need：进程尚需的CPU时间数，初值表示该进程需要运行的总时间，取值范围为1—5。
并随机产生，每运行一个时间片need减1；need为0则进程结束。
Status：进程状态R（运行），J（就绪），F（完成）；初始时都处于就绪状态。
Next：指向就绪队列中下一个进程的PCB的指针。
（2）初始状态及就绪队列组织：5个进程初始都处于就绪状态，进程标识1—5，used初值都为0。
各进程的优先级随机产生，范围1—5。
处于就绪状态的进程，用队列加以组织，队列按优先级由高到低依次排列，队首指针设为head。
（3）调度原则以及运行时间的处理：正在执行的进程每执行一个时间片，其优先级减1（允许优先级为负）。
进程调度将在以下情况发生：当正在运行的程序其优先级小于就绪队列队首进程的优先级时。
程序中进程的运行时间以逻辑时间片为单位。
2.2时间片轮转算法说明（1）PCB的结构（如下图所示）：轮转法中，设PCB的结构如右图所示，其中各数据项的含义如下：Span：在某一轮中，分配给先运行进程的时间片数，取值1—3。
操作系统进程调度实验报告
《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号2015年10月21日实验一进程调度1.实验目的：通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。
2.实验内容：用C语言实现对N个进程采用某种进程调度算法先来先服务调度、短作业优先调度的调度。
3.设计实现：要求给出设计源码，设计源码要有详细注释，#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/int atime; /*到达时间*/int stime; /*服务时间*/int ftime; /*完成时间*/int rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("根据到达时间重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++)if(a[i].atime>a[i+1].atime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %d %d |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void fcfs(struct program a[],int n){int i;int time=0;for(i=0;i<n;i++){time=time+a[i].stime;a[i].ftime=a[0].atime+time;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=(float)a[i].rtime/a[i].stime;}printf("\nFCFS算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %d %.2d %.2d %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******先来先服务算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);fcfs(pro,m);getchar();}#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/float atime; /*到达时间*/float stime; /*服务时间*/float ftime; /*完成时间*/float rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=1;i<n-1-j;i++)if(a[i].stime>a[i+1].stime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %f %f |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void SJF(struct program a[],int n){int i;a[0].ftime=a[0].atime+a[0].stime;a[0].rtime=a[0].ftime-a[0].atime;a[0].qrtime=a[0].rtime/a[0].stime;for(i=1;i<n;i++){a[i].ftime=a[i-1].ftime+a[i].stime;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=a[i].rtime/a[i].stime;}printf("\nSJF算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %.2f %.2f %.2f %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******短作业优先算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);SJF(pro,m); getchar(); }4.实验结果5.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。
实验进程调度的实验报告
一、实验目的1. 加深对进程概念和进程调度算法的理解。
2. 掌握进程调度算法的基本原理和实现方法。
3. 培养编程能力和系统分析能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块（PCB）3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一，负责将CPU分配给就绪队列中的进程。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转（RR）等。
1. 先来先服务（FCFS）算法：按照进程到达就绪队列的顺序进行调度。
2. 短作业优先（SJF）算法：优先调度运行时间最短的进程。
3. 优先级调度算法：根据进程的优先级进行调度，优先级高的进程优先执行。
4. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行，时间片结束后进行调度。
五、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、运行时间、优先级、状态等信息。
2. 创建进程队列，用于存储就绪队列、等待队列和完成队列。
3. 实现进程调度算法：a. FCFS算法：按照进程到达就绪队列的顺序进行调度。
b. SJF算法：优先调度运行时间最短的进程。
c. 优先级调度算法：根据进程的优先级进行调度。
d. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行。
4. 模拟进程调度过程：a. 初始化进程队列，将进程添加到就绪队列。
b. 循环执行调度算法，将CPU分配给就绪队列中的进程。
c. 更新进程状态，统计进程执行时间、等待时间等指标。
d. 当进程完成时，将其移至完成队列。
六、实验结果与分析1. FCFS算法：按照进程到达就绪队列的顺序进行调度，简单易实现，但可能导致短作业等待时间过长。
2. SJF算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
实验一进程控制和调度
实验报告调试过先来先服务算法（FCFS调度法）：及实验结果短作业（进程）优先调度算法（SJ调度算法）：最高优先权优先调度算法（优先调度算法）：时间片轮转算法（RR调度算法）：总结优点：程序中的数组采用了动态开辟的方法，有效地减少了对于空间的占用。
提高了空间的利用率。
输出的界面比较的简洁，直接给出了分配资源的顺序。
资源请求算法则直接给出了请求后造成的情况，比较的明了。
缺点：程序仍然存在很多地方可以改进。
比如输出界面，可以做的更漂亮。
部分地方可以采用其他的方法。
附录#include<stdio.h>#include<stdlib.h>#define Ready 0#define Running 1#define Block 3#define Over 4typedef struct PCBNode{int ID;int Priority;int CPUtime;int Alltime;int Arrivetime;int state;int counter;struct PCBNode *next;}PCB;//定义数据结构PCB *run;PCB *ready;PCB *over;PCB *head;//定义状态量int Min(PCB *head)//挑选出队列中的拥有最小alltime 值的块，返回块号,用于sjf算法{PCB *p;//q用来记录这个块的地址int min,id;//记录最小值和块号p=head->next;if(p){min=p->Alltime;id=p->ID;while(p->next){if(min>p->next->Alltime){min=p->next->Alltime;id=p->next->ID;p=p->next;}else{p=p->next;}}}return id;}int Max(PCB *head)//挑选出队列中的拥有最大优先级的块，返回块号，用于prio 算法{PCB *p;//q用来记录这个块的地址int max,id;//记录最大和块号p=head->next;if(p){max=p->Priority;id=p->ID;while(p->next){if(max<=p->next->Priority){max=p->next->Priority;id=p->next->ID;p=p->next;}else{p=p->next;}}}return id;}PCB *CreatPCB(int n){int i;PCB *p,*q;head=(PCB*)malloc(sizeof(PCB));head->next=NULL;p=head;for(i=1;i<=n;i++){q=(PCB*)malloc(sizeof(PCB));q->ID=i;q->CPUtime=0;q->Alltime=rand()%200;q->Priority=rand()%10;q->state=Ready;q->Arrivetime=0;p->next=q;p=q;q->next=NULL;}head->next->Priority=0;return head;}//创建pcb块void Display(PCB *head){PCB *p;p=head->next;printf("ID Arrivetime CPUtime(已占用) Alltime Priority state \n");while(p){printf("%d ",p->ID);printf("%d ",p->Arrivetime);printf("%d ",p->CPUtime);printf("%d ",p->Alltime);printf("%d ",p->Priority);printf("%d \n",p->state);p=p->next;}}//显示PCB块void FCFS(PCB *head,PCB *over){PCB *p,*q;int j=0;int n=0,s=0;double m;ready=head;p=ready->next;q=over;while(p){p->state=Running;ready->next=p->next;n=p->Alltime+n;p->CPUtime=p->Alltime;p->Alltime=0;s=s+n;p->next=NULL;q->next=p;p->state=Over;q=q->next;q->next=NULL;p=head->next;j++;printf("第%d次执行算法后的就绪队列：\n",j);Display(head);}m=(double)s/j;printf("完成顺寻为：\n");Display(over);printf("\n");printf("每个进程等待的平均时间为：%lf\n",m);printf("所有进程等待的总时间为：%d",s);}void SJF(PCB *head,PCB *over)//sjf算法{PCB *p,*q,*b,*o;//b 用来记录该块的地址int s;//记录块号int m,n,h=0,d=0,j=0;double f;p=head->next;q=over;o=head;printf("完成顺寻为：\n");m=p->ID;n=p->Alltime;s=Min(head);b=p->next;printf("%d：\n",s);while(head->next){while(s!=p->ID){o=p;p=p->next;}d=p->Alltime+d;p->CPUtime=p->Alltime;p->Alltime=0;h=d+h;b=p;q->next=b;o->next=p->next;p=head->next;b->next=NULL;o=head;q=q->next;s=Min(head);j++;printf("第%d次执行算法后的就绪队列：\n",j);Display(head);}f=(double)h/j;printf("完成顺寻为：\n");Display(over);printf("每个进程等待的平均时间为：%lf\n",f);printf("所有进程等待的总时间为：%d",h);}void Prio(PCB *head,PCB *over){PCB *p,*q,*b,*o;//b 用来记录该块的地址int s;//记录块号int m,n,h=0,d=0,j=0;double f;p=head->next;o=head;q=over;printf("当前拥有最大优先级的块号为：\n");m=p->ID;n=p->Alltime;s=Max(head);b=p->next;printf("%d：\n",s);while(head->next){while(s!=p->ID){o=p;p=p->next;}d=p->Alltime+d;p->CPUtime=p->Alltime;p->Alltime=0;h=d+h;b=p;q->next=b;o->next=p->next;p=head->next;b->next=NULL;o=head;q=q->next;s=Max(head);j++;printf("第%d次执行算法后的就绪队列：\n",j);Display(head);}f=(double)h/j;printf("完成顺寻为：\n");Display(over);printf("每个进程等待的平均时间为%lf\n",f);printf("所有进程等待的总时间为：%d",h);}void RR(PCB *head,PCB *over,int t,int k)//时间片轮转法{ //k用来记录剩余要执行的进程数目 PCB *p,*q,*r,*o,*tail;//o用来记录当前块的地址int n=0,s=0,f;double h;f=k;p=head->next;while(p->next){tail=p;p=p->next;}printf("执行顺序为：\n");tail=p;o=p;//前驱tail->next=head->next;p=head->next;q=over;while(k>0){r=head->next;if(p->Alltime>t)//该进程还未执行完成{p->Alltime=p->Alltime-t;n=n+t;s=s+n;o=p;printf("执行进程%d ",p->ID);printf("该进程的Alltime变为%d\n",p->Alltime);p=p->next;}else//该进程可以完成了{printf(" 完成进程：%d \n",p->ID);n=n+p->Alltime;s=s+n;p->Alltime=0;o->next=p->next;q->next=p;q=q->next;q->next=NULL;p=o->next;k--;}}h=(double)s/f;printf("完成顺寻为：\n");Display(over);printf("每个进程等待的平均时间为：%lf\n",h);printf("所有进程等待的总时间为：%d",s);}void main(){int n,m,t;printf("|------------------------------------------------------------------------------|");printf("| 进程调度的模拟|");printf("|------------------------------------------------------------------------------|");printf("\t\t\t|----选项--------------------|\n");printf("\t\t\t| 1. FCFS调度法 |\n");printf("\t\t\t|----------------------------|\n");printf("\t\t\t| 2. SJF调度算法 |\n");printf("\t\t\t|----------------------------|\n");printf("\t\t\t| 3. 优先调度算法 |\n");printf("\t\t\t|----------------------------|\n");printf("\t\t\t| 4. RR调度算法 |\n");printf("\t\t\t|----------------------------|\n");printf("\n");printf("请输入要创建的进程数目：");scanf("%d",&n);head=CreatPCB(n);printf("创建的就绪队列为：\n");Display(head);printf("请选择要进行的操作：");scanf("%d",&m);over=(PCB*)malloc(sizeof(PCB));over->next=NULL;switch(m){case 1:system("CLS");FCFS(head,over);break;case 2:system("CLS");SJF(head,over);break;case 3:system("CLS");Prio(head,over);break;case 4:system("CLS");printf("请输入时间片的大小：");scanf("%d",&t);RR(head,over,t,n);break;}//Release(head);}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一进程调度
1．目的和要求
通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。
2．实验内容
阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。
编写程序模拟实现进程的时间片轮转调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。
假设初始状态为：有n个进程处于就绪状态，有m个进程处于阻塞状态。
采用时间片轮转调度算法进行调度(调度过程中，假设处于执行状态的进程不会阻塞)，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。
程序要求如下：
1）按时间片顺序输出系统中进程的调度次序；
2）计算CPU利用率。
3．实验环境
Windows操作系统、VC++
C语言
4．实验提示
用C语言实现提示：
1）程序中进程可用PCB表示，其类型描述如下：
struct PCB_type
{
int pid ; 实验要求：
1）上机前认真使用C语言编写好程序，采用Visual C++作为编译环境；
2）上机时独立调试程序
3）根据具体实验要求，填写好实验报告（包括目的和要求、实验内容、实验环境、设计思想、源程序、实例运行结果、总结）。
4）测试用数据：
n=2
m=3
t=5
blocked_head
p取ready队首元素p->置“运行”
输出p->
p->
use_cpu++。