进程调度模拟实验说明书
实验三 模拟进程调度
实验三模拟进程调度一实验目的理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块PCB。
理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况二实验要求编写一个允许多个进程并发执行的进程调度程序。
1）进程调度算法：进程的调度采用最高优先数优先的调度算法和先来先服务调度算法相结合的算法，并且采用动态优先数策略，选择进程占用处理器后该进程仅能使用一个时间片，运行完后优先数减1。
2）每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等.3）进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为输入进程的时间。
4）进程的运行时间以时间片为单位进行计算。
5）每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
.6）就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
7）如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
8）每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止三概要设计进程控制块：描述进程的状态信息，用结构体定义typedef struct process{ char name[10]; //进程名int priority; //优先数Time ReachTime; //到达时间Time NeedTime; //需要运行时间Time UsedTime; //已用时间char state; //进程状态}PCB; //进程控制块图1.进程调度模拟程序模块图算法思想：定义结构体PCB描述进程的进程控制块，定义数组PCB pcb[Max]存放进程。
实验5 进程调度
实验
实验目的
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数和时间片轮转调度算法的具体实施办法。
预习1．实验指导书 Nhomakorabea实验内容及要求
用高级语言模拟实现进程调度，完成下列指标：
③在优先数算法中，优先数可以先取值为98，进程每执行一次，优先数减3，CPU时间片数加1，进程还需要的时间片数减1。在轮转算法中，采用固定时间片。
④对于遇到优先数一致的情况，采用FIFO策略解决。
实验结果（可续页）
（续前页）
后记
①设计进程控制块PCB表结构，分别适用于优先数调度算法和循环轮转调度算法。
②建立进程就绪队列。对两种不同算法编制入链子程序。
③编制两种进程调度算法：1）优先数调度；2）循环轮转调度
实验提示
①本程序用两种算法对五个进程进行调度，每个进程可有三个状态（如就绪、执行、结束），并假设初始状态为就绪状态。
②为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
操作系统原理 实验一：进程调度实验报告书-模板
计算机科学系实验报告书课程名：《操作系统原理》题目：进程调度班级：学号：姓名：操作系统原理实验——进程调度实验报告一、目的与要求1）进程是操作系统最重要的概念之一，进程调度是操作系统内核的重要功能，本实验要求用C 语言编写一个进程调度模拟程序，使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
2）按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）3）于2012年10月22日以前提交本次实验报告（含电子和纸质报告，由学习委员以班为单位统一打包提交）。
2 实验内容或题目1）设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2）模拟调度程序可任选两种调度算法之一实现（有能力的同学可同时实现两个调度算法）。
3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
4）本次实验内容（项目）的详细说明以及要求请参见实验指导书。
3 实验步骤与源程序实验步骤：1、理解本实验中关于两种调度算法的说明。
2、根据调度算法的说明，画出相应的程序流程图。
3、按照程序流程图，用C语言编程并实现。
源程序：#include <stdlib.h>/*进程调度优先权法*/#include <stdio.h>#include <time.h>#define null 0struct PCB{int id;int prior;int used;int need;int run;char status;struct PCB * next;};main(){struct PCB *head,*rear,*temp,*run,*small,*p,*q;int i,j,t;printf("优先权进程调度算法\n\n 5个初始进程详细信息如下：\n\n");printf("\t进程号\t优先级\tused\tneed\t状态\t下一PCB\n\n");head=null;rear=null;for(i=1;i<=5;i++) { //动态生成含5个元素的队列temp=malloc(sizeof(struct PCB)); //动态分配一个PCB temp->id=i;temp->prior=rand()%5;temp->status='W';temp->next=null;if (head==null){head=temp;rear=head;}else{rear->next=temp;rear=temp;}}temp=head;while(temp!=null){printf("\t%d\t%d\t%c\t%d\n",temp->id,temp->prior,temp->status,temp->next);temp=temp->next;}getchar(); //让程序停下来，可以查看结果。
操作系统进程调度实验
操作系统进程调度实验操作系统进程调度是操作系统中非常重要的一个功能，它决定了多个进程的执行顺序和调度策略。
进程调度的好坏直接影响着系统的性能和资源利用率。
本实验旨在通过实现一个简单的进程调度模拟，了解不同的调度算法，探讨其优劣和适用场景。
一、实验目的和原理本实验的目标是实现进程调度模拟，并探究不同调度算法的性能和适用场景。
通过实验，我们可以了解以下内容：1.进程调度算法的基本原理和实现方式；2.比较不同调度算法的优劣和特点；3.了解不同调度算法在不同场景下的应用。
二、实验环境和工具本实验使用C语言进行实现，可以选择任何一种编程环境和工具，例如Dev-C++、Visual Studio等。
三、实验过程及方法1.实现一个进程控制块（PCB）的数据结构，用来保存进程的相关信息，包括进程ID、进程状态、优先级等。
2.实现一个进程队列，用来保存就绪队列中的进程。
可以使用数组或链表等数据结构实现。
3. 实现不同调度算法的函数，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和时间片轮转（Round Robin）等。
4.根据实际需求生成一批进程，设置其信息，并根据不同算法进行调度。
5.对比不同算法的运行结果和性能，分析其优劣。
四、实验结果和分析通过实验，我们可以得到每个算法的平均等待时间、平均周转时间和吞吐量等性能指标。
根据这些指标，我们可以对不同算法进行评价和分析。
1.先来先服务（FCFS）算法FCFS算法是最简单的调度算法，按照进程到达的顺序进行调度。
它的主要优点是实现简单、公平性好。
然而，FCFS算法有明显的缺点，会导致长作业等待时间过长，产生"饥饿"现象。
2.最短作业优先（SJF）算法SJF算法是按照进程的执行时间长短进行调度的算法。
它能够最大限度地减少平均等待时间和周转时间，但是需要提前知道所有进程的执行时间，这在实际中是很难做到的。
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。
二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法：FCFS、RR和DP。
3. 创建一个进程队列，用于存储所有进程。
4. 实现调度函数，根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程，打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
操作系统进程调度说明书
中北大学中北大学软件学院实训说明书实训名称: 操作系统课程设计 题目名称：基于Linux 的模拟进程调度算法的实现 专班 级： 12210A03班小组成员学号： 1221010821 姓名：__严 晗 成绩： 学号： 1221010916 姓名： 许 钰 成绩： 学号： 1221011024 姓名： 张 悦 成绩：2015 年 1 月1需求分析在操作系统中，进程调度实际就是给进程分配内存资源，随着计算机系统的发展，为了更充分的利用系统资源以及提高计算机的运行效率，因此需要在不同的环境下采用不同的调度算法，使得系统具有合理的响应时间，就要求系统能按照某种算法，动态的把处理机分配给就绪队列中的一个进程，使之执行。
因此，就需要设计出几种不同的算法，通过比较，选出一种最优的。
本程序主要实现基于linux的进程调度算法的实现。
共实现了三种不同的调度算法，分别是：先来先服务调度算法，短作业优先调度，高响应比调度算法。
在程序的执行过程中，可以自主输入进程的个数以及进程必要的信息，如：进程的创建时间，服务时间等，然后通过不同的调度算法实现进程的调度，每一种算法都能动态的演示进程调度的过程，时间间隔为一秒钟，并且可以计算出每种调度算法下的平均周转时间和平均带权周转时间，通过排序比较各种调度算法的优劣。
2总体设计本程序主要分为四大模块：1.创建进程：可以手动创建进程，用户可以自主决定进程的个数，并且在创建进程时自主决定进程名，进程的创建时间以及执行时间。
2.几种不同的调度算法：分别是先来先服务调度算法，短作业优先调度和高响应比调度算法。
3.显示结果函数：在各个调度算法中，每一步执行完后都会以表格的形式显示出进程的信息，包括：进程名，创建时间，服务时间，开始执行时间，完成时间，周转时间，带权周转时间。
4.比较各算法的优劣：对平均周转时间和平均带权周转时间按照由小到大的顺序进行排序比较。
程序中采用结构体来存储进程信息，其中包括：进程名，进程的创建时间，服务时间，执行时间，完成时间，周转时间，带权周转时间，等待时间，优先权，时候完成等，各个进程共同组成一个结构体数组。
进程调度模拟实验任务书
《操作系统》课程设计任务书题目：进程调度模拟实验学生姓名：温天波学号：10240220班级：计算机（2）班题目类型：软件工程（R）指导教师：李睿一、设计目的学生通过该题目的设计过程，可以初步掌握进程调度的原理、软件开发方法并提高解决实际问题的能力。
二、设计任务1、了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序。
2、编写进程调度程序，允许多个进程共行的进程调度程序。
进程调度算法采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
三、设计要求1、分析设计要求，给出解决方案（要说明设计实现所用的原理、采用的数据结构）。
2、设计合适的测试用例，对得到的运行结果要有分析。
3、设计中遇到的问题，设计的心得体会。
4、文档：课程设计打印文档每个学生一份，并装在统一的资料袋中，资料袋前面要贴有学校统一的资料袋封面。
5、光盘：每个学生文档和程序资料分别建在一个以自己学号和姓名命名的文件夹下，并要求每班负责人汇总每个学生的文件放在以班级姓名命名的文件夹下，刻录成5寸光盘，并复制四份（共五张内容相同的光盘），放在一个专门的资料袋中，不必再装软盘四、提交的成果1. 设计任务书一本（学校统一格式）2. 设计说明书一份，内容包括：1) 中文摘要100字；关键词3-5个；2) 设计思想；3）各模块的伪码算法；4）函数的调用关系图；5）测试结果；6）设计总结；7) 参考文献、致谢等。
五、主要参考文献1. 汤子瀛，哲凤屏.《计算机操作系统》.西安电子科技大学学出版社.2. 王清，李光明.《计算机操作系统》.冶金工业出版社.3.孙钟秀等. 操作系统教程. 高等教育出版社4.曾明. Linux操作系统应用教程. 陕西科学技术出版社.5. 张丽芬，刘利雄.《操作系统实验教程》. 清华大学出版社.6. 孟静，操作系统教程－－原理和实例分析. 高等教育出版社7. 周长林，计算机操作系统教程. 高等教育出版社8. 张尧学，计算机操作系统教程，清华大学出版社9.任满杰，操作系统原理实用教程，电子工业出版社六、各阶段时间安排（共2周）周次日期内容地点完成情况教师签字第1周星期一~二教师讲解设计要求查找参考资料教室图书馆星期三~五算法设计，编程实现实验室第2周星期一~三算法设计，编程实现实验室星期四~五检查程序，答辩实验室。
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有5个进程要运行在一个单核处理器上，每个进程有不同的运行时间和优先级。
进程信息如下：进程A：运行时间10ms，优先级4进程B：运行时间8ms，优先级3进程C：运行时间6ms，优先级2进程D：运行时间4ms，优先级1进程E：运行时间2ms，优先级5实验步骤：1.先来先服务（FCFS）调度算法实验：将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
2.最短作业优先（SJF）调度算法实验：将上述进程按照运行时间的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
3.优先级调度算法实验：将上述进程按照优先级的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
4.时间片轮转（RR）调度算法实验：设置一个时间片大小，将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
实验结果：通过模拟实验，我们可以得到每个进程的运行时间、完成时间和等待时间。
对于FCFS算法，进程的运行顺序是按照先来先服务的原则，因此进程A首先得到处理器资源并完成运行，其它进程依次按照到达顺序得到资源。
因此，对于进程A、B、C、D、E，它们的完成时间分别是10ms、18ms、24ms、28ms和30ms，等待时间分别是0ms、10ms、18ms、24ms和28ms。
对于SJF算法，进程的运行顺序是按照运行时间的大小，即短作业优先。
因此，进程E首先得到处理器资源并完成运行，其它进程依次按照运行时间的大小得到资源。
对于进程E、D、C、B、A，它们的完成时间分别是2ms、6ms、12ms、20ms和30ms，等待时间分别是0ms、2ms、6ms、12ms和20ms。
实验二 进程调度模拟实验
for(i=1;i<Num;i++)
{
k=1;min=0;
if(allin==0)
{
j=0;
while(ArrivalTime[j]<=NowTime && j<Num)
{
j++;
if(j>=Num)
{
allin=1;
}
}
}
else
{
j=Num;
}
j=j-1;
while(k<=j)//从已经到达的进程里找到服务时间最短的进程
cout<<"--------------------------------------------------------------"<<endl;
for(i=0;i<Num;i++)
{
if(ArrivalTime[i]>NowTime)
{
NowTime=ArrivalTime[i];
}
NowTime+=ServiceTime[i];
二实验内容及要求1设计程序模拟先来先服务fcfs作业调度算法短作业优先调度算法sjf高响应比优先调度算法最高优先权调度算法等算法中的两种算法要求比较两种算法的平均周转时间和平均带权周转时间选用cc或java等编程语言中最擅长的一种语言
实验二进程调度模拟实验
一、实验目的
1通过对进程调度算法的设计，加深对进程调度原理的理解，进一步掌握各种调度算法的特征；
cin>>Num;
}
cout<<"-----------------------------------------"<<endl;
模拟调度实验报告(3篇)
第1篇一、实验背景进程调度是操作系统核心功能之一，它负责在多道程序环境下，按照一定的策略对进程进行调度，以确保系统资源的合理分配和高效利用。
为了加深对进程调度算法的理解，本次实验采用模拟的方式，实现了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种算法，并对实验过程进行了详细记录和分析。
二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。
2. 掌握进程控制块（PCB）的设计与实现。
3. 通过模拟实验，验证三种调度算法的执行效果。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 定义进程控制块（PCB）进程控制块是操作系统用于描述和管理进程的实体，它包含了进程的基本信息。
本实验中，PCB包含以下字段：- 进程ID：唯一标识一个进程。
- 到达时间：进程进入就绪队列的时间。
- 需要运行时间：进程完成所需的时间。
- 已运行时间：进程已运行的时间。
- 状态：进程当前的状态（就绪、运行、阻塞、完成）。
2. 实现三种调度算法（1）先来先服务（FCFS）算法FCFS算法按照进程到达就绪队列的顺序进行调度，先到先服务。
具体实现如下：- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，依次执行进程，直到进程完成或被阻塞。
（2）时间片轮转（RR）算法RR算法将CPU时间划分为时间片，每个进程运行一个时间片后，让出CPU，等待下一个时间片。
具体实现如下：- 设置一个时间片大小。
- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，每个进程执行一个时间片，如果进程未完成，则将其加入就绪队列队尾。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
进程调度模拟程序实验实验报告
实验三、进程调度模拟程序实验一、实验目的用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验内容和要求设计一个有 N个进程并发执行的进程调度模拟程序。
用Ｃ＋＋模拟基于时间片的轮转算法、静态优先算法、动态优先算法、多级反馈队列调度算法。
三、实验方法、步骤及结果测试1.原理分析及流程图(1). 每个进程有一个进程控制块（PCB）表示。
进程控制块包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
(2). 进程的优先数及需要的运行时间可以事先人为地指定，进程的运行时间以时间片为单位进行计算。
(3). 每个进程的状态可以是就绪 r（ready）、运行R（Running）、或完成F（Finished）三种状态之一。
(4). 就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
(5). 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待调度。
(6). 每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB，以便进行检查。
(7). 重复以上过程，直到所要进程都完成为止。
2.主要程序段及其解释：动态优先调度：#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 24struct jcb{char name[10];int reqtime;int runtime;int startime;int fintime;int prio;char status;};typedef struct jcb JCB;void input(JCB job[],int *pnum){int num;int i;printf("process 数：");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个process:\n",i+1);printf("输入proc名：");scanf("%s",job[i].name);printf("Priority:");scanf("%d",&job[i].prio);printf("要求服务时间:");scanf("%d",&job[i].reqtime);job[i].status='r';job[i].runtime=0;}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;if (n==0){printf("the queue is null!!\n");return;}printf("\tname\tprio\trqtime\truntime\tstatus");for(i=0;i<n;i++){printf("\nN %d",i+1);printf("\t&s",jcbp[i].name);printf("\t&d",jcbp[i].prio);printf("\t&d",jcbp[i].reqtime);printf("\t&d",jcbp[i].runtime);printf("\t&c",jcbp[i].status);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++)for(i=0;i<n-j;i++)if(btjcb[i].prio<btjcb[i+1].prio){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}main(){JCB jobarrived[MAX],jobfinished[MAX];int numarr, numfin;int systime=0;int i,j,n;JCB jcbrunning;input(jobarrived,&numarr);numfin=0;systime=0;btsort (jobarrived,numarr);printf("经按priority排序后,read queue是\n");jcbprintf(jobarrived,numarr);do{btsort(jobarrived,numarr);printf("\n\n\t\t现在系统时间%d:\n\n",systime);printf("ready queue 有\n");jcbprintf(jobarrived,numarr);jcbrunning=jobarrived[0];numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jcbrunning.status='R';jcbrunning.startime=systime;printf("\n\n\t\t处于运行态的作业名%s\n",);systime++;jcbrunning.runtime++;if (jcbrunning.runtime==jcbrunning.reqtime){jobfinished[numfin]=jcbrunning;jobfinished[numfin].status='F';numfin++;}else{jcbrunning.prio--;jcbrunning.status='r';jobarrived[numarr]=jcbrunning;numarr++;}printf("\n\n\t\t系统时间：%d已经完成的有\n\n",systime);jcbprintf(jobfinished,numfin);getchar();getchar();}while((numarr!=0));printf("\nCompleted!! ByeBye!!");getchar();getchar();}2、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1); printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t运行时间");for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].reqtime); }}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d\n",job[i].name,job[i].reqtime,job[i].ru ntime);}}void main(){JCB jobarrived[MAX];int numarr,i;JCB jcbrunning;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后，就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");while(numarr>0){jcbrunning=jobarrived[0];jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");if(jcbrunning.reqtime>0){for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jobarrived[numarr-1]=jcbrunning;}else{numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int firsttime;int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序数目:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);printf("优先级:");scanf("%d",&jcb[i].firsttime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1);printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].firsttime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t优先级\t运行时间"); for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].firsttime); printf(" %d",jcbp[i].reqtime);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称优先级运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d %d\n",job[i].name,job[i].firstti me,job[i].reqtime,job[i].runtime);}}void main(){JCBjobarrived1[MAX],jobarrived2[MAX],jobarrived3[MAX],jobarrived[MAX]; int numarr1,numarr2,numarr3,numarr,i;JCB jcbrunning;numarr2=0;numarr1=0;numarr3=0;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后，就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}for(i=0;i<numarr;i++){jobarrived3[i]=jobarrived[i];numarr3++;}printf("\n.............就绪队列3是..........\n");jcbprintf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");jcbprintf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");jcbprintf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();while(numarr3>0){jcbrunning=jobarrived3[0];if(jcbrunning.firsttime==3){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1; jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");}jobarrived3[0]=jcbrunning;}if(jobarrived3[0].reqtime>0){jobarrived2[numarr2]=jobarrived3[0];numarr2++;}numarr3--;for(i=0;i<numarr3;i++){jobarrived3[i]=jobarrived3[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr2>0){jcbrunning=jobarrived2[0];if(jcbrunning.firsttime==2){if(jcbrunning.reqtime>2){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-2;jcbrunning.runtime=jcbrunning.runtime+2;printf("\n正在执行的进程名称是%s\n",);}else{jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime;jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime;printf("\n正在执行的进程名称是%s\n",); }jobarrived2[0]=jcbrunning;}if(jobarrived2[0].reqtime>0){jobarrived1[numarr1]=jobarrived2[0];numarr1++;}numarr2--;for(i=0;i<numarr2;i++){jobarrived2[i]=jobarrived2[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr1>0){jcbrunning=jobarrived1[0];if(jcbrunning.firsttime==1){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime; jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime; printf("\n正在执行的进程名称是%s\n",); }}numarr1--;for(i=0;i<numarr1;i++){jobarrived1[i]=jobarrived1[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3.运行结果及分析四、 实验总结这次的实验是我们这门课第一次以个人为单位来完成的实验，然后这次实验用了三个星期去完成，虽然每次上机课老师都会先讲，可是我还是不太懂，到自己做的时候又不会，都是照样画葫芦。
模拟进程调度-实验
模拟进程调度
1、进程控制块
进制控制块如下，进程状态有ready，run，finish三种，每个进程的初始状态均为ready，结束后为finish。
2、初始化时为每个进程确定“优先级”和“要求运行时间”，且按照优先级从高到低排序。
3、进程的执行
采用高优先级调度，优先级可变。
同等优先级的进程，剩余运行时间少的优先，同等优先级、同等剩余运行时间的进程，累计运行时间少的进程优先。
每次调度队首的进程运行
每次运行一个时间片，模拟时采用运行一次就立即切换
运行时的操作为：优先级-1；剩余运行时间-1
当剩余时间为0时，该进程退出队列
直至所有进程都运行完毕
4、期待结果
5、实现方法和部分代码
（1）Process类(一个Process对象表示一个进程，包含进程各项属性),Process 类提供比较方法compareTo()，用于将集合中的Process对象自动排序，排序标准为：进程按照优先级从高到低排序，如果优先级相同，按照剩余时间从小到大排序，
如果剩余时间也相同，按照累计执行时间从小到大排序。
操作系统 进程调度模拟实验
实验一进程调度实验◆实验名称：进程调度实验◆仪器、设备：计算机◆参考资料：操作系统实验指导书◆实验目的：设计一个有N个进程并行的进程调度程序◆实验内容：进程调度算法：采用最高优先级优先的调度算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
进程名、优先级、需要运行时间通过键盘输入。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，否则将进程的优先级减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所有进程都完成为止。
调度算法的流程图如下:◆实验原理、数据（程序）记录：进程调度源程序如下：#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;void sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ {p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/ {first=first->link;second=second->link;}}if(insert==0) first->link=p;}}void input() /* 建立进程控制块函数*/{int i,num;//clrscr(); /*清屏*/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->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n qname \t state \t super \t ndtime \t runtime \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数*/{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{printf("\n 进程[%s] 已完成.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}void 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';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}◆实验结果及分析通过实验，实现了采用最高优先级优先的调度算法进行进程调度的模拟。
进程调度模拟实验
进程调度模拟实验1.实验目的通过对进程调度算法的模拟加深对进程概念和进程调度过程的理解。
2.实验内容用C语言、Pascal语言或其他开发工具实现对N（N=5）个进程的调度模拟，要求至少采用两种不同的调度算法（如简单轮转法Round Robin和优先权高者优先算法Highest Priority First），分别进行模拟调度。
每个用来标识进程的进程控制块PCB用结构（记录）来描述，根据需要，它包括以下字段：进程标识数ID。
进程优先数Priority，并规定优先数越大的进程，其优先权越高。
采用简单轮转法时该字段无用。
进程已经占用的CPU时间CPUTIME（以时间片为单位，下同）。
进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
进程被阻塞的时间BLOCKTIME，表示已经阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
进程状态STATE。
队列指针NEXT，用来将PCB排成队列。
优先数改变的原则（采用简单轮转法时该字段无用）：进程在就绪队列中等待一个时间片，优先数增加1；进程每运行一个时间片，优先数减3。
假设在进行调度前，系统中有5个进程，它们的初始状态可以编程输入（更具有灵活性），也可以初始化为如下内容：ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STA TE0 9 0 3 2 3 READY1 38 0 3 -1 0 READY2 30 0 6 -1 0 READY3 29 0 3 -1 0 READY4 0 0 4 -1 0 READY为了清楚地观察诸进程的调度过程，程序应该将每个时间片内各进程的情况显示出来并暂停，参考格式如下：运行/Running：I就绪队列/Ready Queue：Idi，Idj，…阻塞队列/Block Queue：Idk，Idl，…======================================================================进程号优先数已运行时间需要时间开始阻塞时间阻塞时间状态0 P0 C0 A0 T0 B0 S01 P1 C1 A1 T1 B1 S12 P2 C2 A2 T2 B2 S23 P3 C3 A3 T3 B3 S34 P4 C4 A4 T4 B4 S4======================================================================3.实验分析和思考在实际的进程调度中，还有哪些可行的算法，怎样模拟？在实际的进程调度中，除了按算法选择下一个运行的进程之外，操作系统还应该做哪些工作？为什么对进程的优先数可以按上述原则进行修改？有什么好处？4.实验学时安排：6学时，在调度与死锁内容学习之后进行。
进程调度模拟程序实验实验报告
进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 CPU 资源给各个进程，以提高系统的性能和效率。
本次实验的目的是通过编写和模拟进程调度程序，深入理解不同的进程调度算法的原理和特点，并比较它们在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。
操作系统为 Windows 10。
三、实验原理1、先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 资源。
2、短作业优先（SJF）调度算法短作业优先调度算法优先调度执行时间短的进程。
3、时间片轮转（RR）调度算法时间片轮转调度算法将 CPU 时间划分为固定大小的时间片，每个进程轮流获得一个时间片的 CPU 资源。
四、实验设计1、进程类的设计创建一个进程类，包含进程 ID、到达时间、服务时间、剩余服务时间等属性，以及用于更新剩余服务时间和判断进程是否完成的方法。
2、调度算法实现分别实现先来先服务、短作业优先和时间片轮转三种调度算法。
3、模拟流程（1）初始化进程列表。
（2）按照选定的调度算法进行进程调度。
（3）计算每个进程的等待时间、周转时间等性能指标。
五、实验步骤1、定义进程类｀｀｀pythonclass Process:def ＿_init__(self, pid, arrival_time, service_time)：selfpid ＝ pidselfarrival_time ＝ arrival_timeselfservice_time ＝ service_timeselfremaining_service_time ＝ service_time｀｀｀2、先来先服务调度算法实现｀｀｀pythondef fcfs_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0for process in process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂先来先服务调度算法的平均等待时间：＂，average_waiting_time)print(＂先来先服务调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀3、短作业优先调度算法实现｀｀｀pythondef sjf_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0sorted_process_list ＝ sorted(process_list, key=lambda x: xservice_time) for process in sorted_process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂短作业优先调度算法的平均等待时间：＂，average_waiting_time)print(＂短作业优先调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀4、时间片轮转调度算法实现｀｀｀pythondef rr_scheduling(process_list, time_slice)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0ready_queue ＝while len(process_list) ＞ 0 or len(ready_queue) ＞ 0:for process in process_list:if processarrival_time ＜＝ current_time:ready_queueappend(process)process_listremove(process)if len(ready_queue) ＝＝ 0:current_time ＋＝ 1continueprocess ＝ ready_queuepop(0)if processremaining_service_time ＜＝ time_slice: waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processremaining_service_time turnaround_time ＝ current_time processarrival_time total_turnaround_time ＋＝ turnaround_time processremaining_service_time ＝ 0else:waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ time_sliceprocessremaining_service_time ＝ time_sliceready_queueappend(process)average_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均等待时间：＂， average_waiting_time)print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均周转时间：＂， average_turnaround_time)｀｀｀5、主函数｀｀｀pythonif ＿_name__ ＝＝＂＿_main__"：process_list ＝Process(1, 0, 5)，Process(2, 1, 3)，Process(3, 2, 8)，Process(4, 3, 6)print(＂先来先服务调度算法：＂）fcfs_scheduling(process_list)print(＂短作业优先调度算法：＂）sjf_scheduling(process_list)time_slice ＝ 2print(＂时间片轮转调度算法（时间片大小为"，time_slice, ＂）：＂）rr_scheduling(process_list, time_slice)｀｀｀六、实验结果与分析1、先来先服务调度算法平均等待时间为 575，平均周转时间为 1275。
进程调度实验报告
进程调度实验报告书
Processes Scheduling Demo Report
计算机99本三50 冯志良
○实验目的：
模拟多级反馈队列调度算法。
○程序界面：
○程序说明：
此程序在K6II350，TC2.0环境下通过翻译、运行。
演示了五个优先级队列，时间片分别为8、16、32、64，128。
○程序操作：
如界面所示，所以命令通过键盘输入到Command Box中，或通过快捷键完成。
创建进程：create [life [id]]
说明：ife是生命值(1-999)，id是进程号(0-99)，均为可选，其中进程号为能重复。
例如：create 则创建一个生命值及进程号均为随机的进程
create 88 则创建一个生命值为88，进程号为随机的进程
create 88 20 则创建一个生命值为88，进程号为20的进程
按F1键等于只输入了create
杀进程：kill <id>
说明：id是进程号(0-99)，进程号是必选的。
不能杀正在运行的进程，只能杀在等待的进程。
例如：kill 10 则杀死进程与为10的进程
自动／手动：F2
说明：当为自动时，进程的调度是自动进行的。
当为手动时，只有输入next或按F3键才会运行下一步
退出：quit 或按ESC键
○程序实现(源程序和执行文件均在引文件所在的文件夹中，请以全屏方面运行执行文件) 主程序流程图：
调度模块流程图：。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
1）熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转；2）结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1）本实验要求完成如下任务:2）编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个；3）最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A）, 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为：进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
操作系统进程调度模拟程序实验报告
操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序，以加深对进程调度算法的理解。
二、实验内容1. 实现进程相关的数据结构：进程PCB（Process Control Block）。
2.实现进程的创建、撤销以及调度等操作函数。
3. 实现常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（RR）、优先级调度（Priority）。
4.编写测试程序，验证实现的进程调度算法在不同场景下的表现。
三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构，用于存储和管理进程相关的信息，包括进程状态（就绪、运行、阻塞）、优先级、执行时间等。
2.进程的创建、撤销及调度函数的实现（1）进程创建函数：实现进程的创建，包括为其分配空间、初始化进程PCB等。
可以根据实际需求，设定进程的优先级、执行时间等属性。
（2）进程撤销函数：实现进程的撤销，包括释放其占用的资源、回收其使用的空间等。
（3）进程调度函数：根据不同的调度算法，实现进程的调度。
可以通过设置时间片大小、优先级设定等方式，实现不同调度算法的效果。
3.进程调度算法的设计与实现（1）先来先服务（FCFS）调度算法：按照进程到达的先后顺序，依次进行调度。
（2）最短作业优先（SJF）调度算法：根据进程的执行时间，选择执行时间最短的进程进行调度。
（3）轮转调度（RR）算法：按照时间片的大小进行调度，每个进程在一个时间片内执行，超过时间片后，暂停并进入等待队列，让其他进程执行。
（4）优先级调度（Priority）算法：根据进程的优先级，选择优先级最高的进程进行调度。
4.测试程序编写测试程序，模拟不同的进程到达顺序、执行时间和优先级等场景，验证不同调度算法的表现。
四、实验结果与分析通过测试程序的运行结果，观察不同调度算法的特点和效果。
可以得出以下结论：1.FCFS算法适用于进程到达时间差异较大的场景，保证了先到先服务。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
进程调度模拟实验说明书目录前言 ..................................................................... .......... 错误～未定义书签。
2 摘要 ..................................................................... .......... 错误～未定义书签。
3 正文 ..................................................................... .......... 错误～未定义书签。
4 1. 设计思想 ................................................................ 错误～未定义书签。
42. 算法中用到的主要数据结构(采用类C语言定义)........................53. 相关的各程序伪代码..............................................................6 4. 调试分析...........................................................................9 5. 测试结果..........................................................................11 6( 源程序(带注释)..................................................................... (12)总结 (16)参考文献.....................................................................................17 致谢...........................................................................................18附件1部分源代码 (19)1前言理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块PCB。
理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况进程:进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动进程的状态:运行状态:进程正在处理器上运行就绪状态:一个进程获得了除处理器外的一切所需资源，一旦得到处理器即可运行等待状态:一个进程正在等待某一事件发生而暂时停止运行先进先出调度算法:其基本原则是按照作业到达系统或进程进入就绪对列的先后次序来选择。
对于进程调度来说，一旦一个进程占有了处理器，它就一直运行下去，直到该进程完成其工作或者因等待事件而不能继续运行时才释放出处理器。
优先级调度算法:按照进程的优先级大小来调度。
使高优先级进程或线程得到优先的处理的调度策略称为优先级调度算法。
进程的优先级可以由系统自动地按一定原则赋给它，也可由系统外部来进行安排但在许多采用优先级调度的系统中，通常采用动态优先数策略。
即一个进程的优先级不是固定的，往往是随许多因素的变化而变化。
尤其随作业(进程)的等待时间，已使用的处理器时间或其他系统资源的使用情况而定，以防止低优先级进程或线程长期饥饿现象发生时间片轮转算法:时间片轮转算法主要用于处理器调度。
采用此算法的系统，其进程就绪队列往往按进程到达的时间来排序。
进程调度程序总是选择就绪队列中的第一个进程，也就是说按照先进先出原则调度，但一旦进程占有处理器仅使用一个时间片，在使用完一个时间片后，进程还没有完成其运行，它也必须释放出(被抢占)处理器给下一个就绪的进程。
而被抢占的进程返回到就绪队列的末尾重新排队等候再次运行。
2摘要编写一个进程调度程序，允许多个进程共行的进程调度程序1).进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。
2).每个进程有一个进程控制块( PCB)表示。
进程控制块可以包含如下信息: 进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等.3).进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。
进程的到达时间为输入进程的时间。
4)(进程的运行时间以时间片为单位进行计算。
5).每个进程的状态可以是就绪 W(Wait)、运行R(Run)、或完成F(Finish) 三种状态之一。
.6).就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
7).如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1(即降低一级)，然后把它插入就绪队列等待CPU。
8).每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
关键字:进程、优先级、时间片、需要运行时间3正文1、设计思想设置时间片选择增加进程是结束进程打印进程继续增加结束否优先级排序打印进程进程调度完成真图1.程序设计流程图4定义结构体PCB描述进程的进程控制块，定义数组PCB pcb[Max]存放进程进程调度程序调用face()函数选择所要进行的操作。
输入1则增加进程并调度进程，输入2则打印进程，输入0则任务结束增加进程，调用AddProcess()函数，将输入的进程存放在数组pcb[Max]中打印进程，调用print()函数，在该函数中首先调用sort()函数对进程按优先级和先来先服务排序，然后显示输出排序后的进程进程调度，调用attemper()函数，调度优先级最高的进程分配给CPU使之运行一个时间片进程优先级排序，调用sort()函数，按照先来先服务和优先级排序，使排序完最优先运行的进程存放在pcb[0]中。
进程调度程序选择一个就绪状态的进程，使之在处理器上运行，每个进程的状态信息用数据结构(进程控制块PCB)表示，进程的调度采用最高优先数优先的调度算法和先来先服务调度算法相结合的算法，并且采用动态优先数策略，选择进程占用处理器后该进程仅能使用一个时间片，运行完后优先数减1 2、算法中用到的主要数据结构(采用类C语言定义) 1)进程控制块:描述进程的状态信息，用结构体定义typedef struct process{ char name[10]; //进程名int priority; //优先数Time ReachTime; //到达时间Time NeedTime; //需要运行时间Time UsedTime; //已用时间char state; //进程状态}PCB; //进程控制块进程调度模拟程序进程调入打印进程进程调度选择操作进程优先AddProcessprint() attemper(face() 级排序()函数函数 )函数函数 sort()函数图2.进程调度模拟程序模块图2)sort( )函数:函数用冒泡法排序，首先按到达时间排序，使到达时间最早(即pcb[n].ReachTime最小)的进程被交换到pcb[0]中，再按优先级排序，使具有最高优先级(即pcb[n].priority最大)的进程被交换5到pcb[0]中。
相同优先级的进程只按到达时间排序 3)print( )函数: 打印函数，先调用sort()排序函数对进程进行排序，排序完再打印输出进程4)AddProcess()函数:增加进程函数，输入要添加的进程的进程控制块的信息，并依次存放在数组PCB pcb[Max]中，每加入一个进程后判断是否还要继续增加进程，若是则继续循环的执行操作 5)attemper( )函数:进程调度函数，调度排完序后存放在pcb[0]中的进程，分配给该进程CPU，使之运行一个时间片，然后比较进程的剩余时间(pcb[0].NeedTime-pcb[0].UsedTime)是否小于时间片的大小pTime，若是，则该进程调度完成，进程处于完成状态，若非，则已用时间加上一个时间片，进程处于就绪状态继续等待运行，然后调用print( )函数打印输出当前进程的状态并排序，直至所有进程处于完成状态后结束运行 6)face( )函数:函数打印所能进行的操作以供选择。
输入1则是增加进程后调度进程，输入2则是打印进程，输入0则是任务结束。
7)main( )函数:首先设置时间片的大小pTime，然后调用face()函数选择要进行的操作，choose='1'则增加进程并调度，choose='2'则打印进程，choose='0'则任务结束。
函数间的关系:1)sort( )函数嵌套在print()函数中调用2)调用AddProcess()函数前必须先调用print()函数对进程进行排序并打印3、相关的各模块的伪代码算法1)进程控制块:描述进程的状态信息，用结构体定义typedef struct process{ char name[10]; //进程名int priority; //优先数Time ReachTime; //到达时间Time NeedTime; //需要运行时间Time UsedTime; //已用时间char state; //进程状态}PCB; //进程控制块2)sort()函数主要代码如下:for (i=0;i<n-1;i++) //先按到达时间排序{ for (j=n-2;j>=i;j--){ if (pcb[j+1].ReachTime<pcb[j].ReachTime){temp=pcb[j];pcb[j]=pcb[j+1];pcb[j+1]=temp;6}}}for (i=0;i<n-1;i++) //再按优先级进行排序{ for (j=n-2;j>=i;j--){ if (pcb[j+1].priority>pcb[j].priority){ temp=pcb[j];pcb[j]=pcb[j+1];pcb[j+1]=temp;}}}3)print()函数主要代码如下:sort();printf("\n 进程名优先级到达时间需要时间已用时间进程状态 \n");for (i=0;i<n;i++){printf("%8s%8d%8d%10d%10d%10c\n",pcb[i].name,pcb[i].pri ority,pcb[i].ReachTime,pcb[i].NeedTime,pcb[i].UsedTime,pcb[i]. state);}4)AddProcess()函数主要代码如下:do{printf("\n请输入进程名");scanf("%s",pcb[n].name);printf("请输入进程的优先级");scanf("%d",&pcb[n].priority);printf("请输入进程需要的时间");scanf("%d",&pcb[n].NeedTime);pcb[n].ReachTime=n;pcb[n].UsedTime=0;pcb[n].state='W';n++;printf("还要继续增加进程吗,是(Y),否(N)");do{ch=getchar();} while(ch!='Y'&&ch!='N'&&ch!='y'&&ch!='n'); }while (ch=='Y'||ch=='y');75)attemper( )函数主要代码如下:do{if ((pcb[0].NeedTime-pcb[0].UsedTime)>pTime) { pcb[0].UsedTime+=pTime;//已用时间加时间片pcb[0].priority--;//优先级减一pcb[0].state='W';}else{ pcb[0].UsedTime=pcb[0].NeedTime;//已用时间等于需要时间pcb[0].priority=-1000;//优先级置为零pcb[0].state='F';//完成进程，将状态置为完成}print();}while(pcb[0].state!='F'); 6)face( )函数要代码如下: char choose;printf("\n增加进程并调度进程，请按1");printf("\n打印进程，请按2");printf("\n任务结束, 请按0");printf("\n请选择:");do{choose=getchar();} while(choose!='1'&&choose!='2'&&choose!='0'); return choose;}7)main( )函数主要代码如下:char choose;n=0; //初始化进程数为0printf("设置时间片的大小:");scanf("%d",&pTime);choose=face();do{ if (choose=='1') { AddProcess(); print();attemper();}if (choose=='2') { print();}if (choose=='0') { return;8}choose=face();} while(1);4、调试分析运行程序如图所示:选择1增加进程并调度进程，输入进程名字process1,进程优先级为3，进程需要的时间为43;输入进程名字process2,进程优先级为5，进程需要的时间为35;输入进程名字process3,进程优先级为4，进程需要的时间为23.9再次添加进程process4,优先级为3，进程需要的时间为37. 是否还需要继续添加10经过测试分析可知道进程调度按照最高优先级算法和先来先服务算法调度程序来使用CPU的，就绪进程获得 CPU后都只能运行一个时间片。