操作系统实验二进程调度(代码+结果)

五邑大学实验报告操作系统课程2016~2017年度第1学期实验题目：进程调度院系：计算机学院班级： 140801学号： 3114002472姓名：黄凯鑫任课教师：白明成绩评定：实验二题目：进程调度完成日期：2016年12 月11 日1、实验目的（1）设计一个有n个进程工行的进程调度程序。

每个进程由一个进程控制块（PCB）表示。

进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。

（2）调度程序应包含2～3种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。

（3）系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程2、实验内容（1）编制和调试示例给出的进程调度程序，并使其投入运行。

（2）自行设计或改写一个进程调度程序，在相应机器上调试和运行该程序，其功能应该不亚于示例。

（3）直观地评测各种调度算法的性能。

3、算法设计算法：(1) 优先数法。

进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。

每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。

接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。

原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。

(2) 简单轮转法。

进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相当于优先数法的优先数记录项位置）。

每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。

华中师范大学计算机科学系《操作系统》实验报告实验题目：进程调度学生姓名：日期：2011-12-9实验2进程调度进程完成，撤消该进程就绪队列首进程投入运行 时间片到，运行进程已占用CPU 时间+1 运行进程已占用CPU 时间已达到所需的运行时间 把运行进程插入到下一个队列的队尾插入新的进程开始 初始化PCB,输入进程信息 所有队列都为空 各进程按FCFS 原则排队等待调度 【实验目的】（1）通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。

（2）了解Windows2000/XP 中进程（线程）的调度机制。

（3）学习使用Windows2000/XP 中进程（线程）调度算法，掌握相应的与调度有关的Win32 API 函数。

【实验内容】在Windows XP 、Windows 2000等操作系统下，使用的VC 、VB 、java 或C 等编程语言，利用相应的WIN32 API 函数，编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。

【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）1、进程调度算法：采用多级反馈队列调度算法。

其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS 原则排队等待高度。

当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS 原则等待调度执行，以此类推。

2、实验步骤:（1）按先来先服务算法将进程排成就绪队列。

（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。

（3）检查该运行进程是否运行完毕，若运行完毕，则撤消进程，否则，将该进程插入到下一个逻辑队列的队尾。

（4）是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。

（5）重复步骤（2）、（3）、（4），直到就绪队列为空。

操作系统实验报告进程调度操作系统实验报告：进程调度引言操作系统是计算机系统中最核心的软件之一，它负责管理和调度计算机的资源，提供良好的用户体验。

在操作系统中，进程调度是其中一个重要的功能，它决定了进程的执行顺序和时间片分配，对于提高计算机系统的效率和响应能力至关重要。

本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。

一、进程调度的概念进程调度是操作系统中的一个重要组成部分，它负责决定哪个进程可以使用CPU，并为其分配执行时间。

进程调度的目标是提高系统的吞吐量、响应时间和公平性。

在多道程序设计环境下，进程调度需要考虑多个进程之间的竞争和协作，以实现资源的合理利用。

二、进程调度算法1. 先来先服务调度（FCFS）先来先服务调度算法是最简单的进程调度算法之一，它按照进程到达的顺序进行调度，即先到达的进程先执行。

这种算法的优点是公平性高，缺点是无法适应长作业和短作业混合的情况，容易产生"饥饿"现象。

2. 最短作业优先调度（SJF）最短作业优先调度算法是根据进程的执行时间来进行调度的，即执行时间最短的进程先执行。

这种算法的优点是能够最大程度地减少平均等待时间，缺点是无法适应实时系统和长作业的情况。

3. 时间片轮转调度（RR）时间片轮转调度算法是一种抢占式调度算法，它将CPU的执行时间划分为固定大小的时间片，并按照轮转的方式分配给各个进程。

当一个进程的时间片用完后，它将被挂起，等待下一次调度。

这种算法的优点是能够保证每个进程都能够获得一定的执行时间，缺点是无法适应长作业和短作业混合的情况。

4. 优先级调度（Priority Scheduling）优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程先执行。

这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度，缺点是可能会导致低优先级的进程长时间等待。

三、实验结果与分析在实验中，我们使用了不同的进程调度算法，并对其进行了性能测试。

操作系统实验报告实验二时间片轮转进程调度算法学号：班级：姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。

【实验内容】问题描述:设计程序模拟进程的时间片轮转RR 调度过程。

假设有n 个进程分别在T1, … ,Tn 时刻到达系统, 它们需要的服务时间分别为S1, … ,Sn 。

分别利用不同的时间片大小q, 采用时间片轮转RR 进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n 个进程的平均周转时间和平均带权周转时间。

程序要求如下:1）进程个数n ；每个进程的到达时间T 1, … ,T n 和服务时间S 1, … ,S n ；输入时间片大小q 。

2）要求时间片轮转法RR 调度进程运行, 计算每个进程的周转时间, 带权周转时间, 并且计算所有进程的平均周转时间, 带权平均周转时间；3）输出: 要求模拟整个调度过程, 输出每个时刻的进程运行状态, 如“时刻3: 进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间, 带权周转时间, 所有进程的平均周转时间, 带权平均周转时间。

实现提示:用C++语言实现提示:1）程序中进程调度时间变量描述如下:int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];➢2）进程调度的实现过程如下:➢变量初始化；➢接收用户输入n, T1, … ,Tn, S1, … ,Sn；时间片大小q；➢按照时间片轮转RR算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。

实验二进程调度⒈实验内容进程调度模拟实验。

⒉实验目的通过模拟进程调度算法，了解进程调度的过程并比较不同的调度算法的区别。

⒊实验题目设计一段程序来模拟优先级调度算法和时间片轮转算法。

要求可以指定进程的数量、各进程需要CPU的时间和各进程的优先级。

⒋实验提示⑴进程调度算法是指处理机的分配策略。

优先数调度算法是指对每个进程确定一个优先数，进程调度总是让具有最高优先数的进程先使用处理机。

如果进程具有相同的优先数，再按先来先服务的次序分配处理机。

在本实例中采用动态优先数算法。

时间片轮转算法是指就绪进程按就绪的先后次序排成队列，每次总是选择就绪队列中的第一个进程占用处理机，但规定只能使用一个“时间片”。

⑵系统中的进程可以用进程控制块PCB来表示，PCB的结构定义如表5-8所示：表5-8 PCB结构⑶在进程调度时进程会交替的出现在运行、就绪和完成三种状态。

可以定义三个链表来存放三种状态的进程。

当进程运行时就把进程放入到运行链表中；当进程处于就绪状态时就将进程放入到就绪链表中；当进程运行完毕时就将进程放入到完成链表中。

由于同一时刻运行的进程只能有一个，所以运行链表只能有一个结点。

在实例程序中为了使程序更简洁忽略了进程的等待状态，仅运行了优先数调度算法，由于篇幅有限，仅显示部分结果，对于时间片轮转调度算法，请读者自行运行。

⑷主要变量及函数说明如表5-9所示：表5-9 主要变量及函数说明⒌实例代码//进程调度算法proc.c//运行环境Redhad9.0 gcc 4.0#include <stdio.h>#include <string.h>typedef struct pcb //定义PCB结构{char name[20]; /*进程标识符*/int cputime; /*进程占用CPU时间*/int prio; /*进程优先数*/int needtime; /*进程到完成还需要的CPU时间*/struct pcb *next;/*链指针*/}PCB;PCB *RUN,*READY,*RTAIL,*FINSH,*FTAIL;void PRINTLINK(int t)/*输出3个队列*/{PCB *p;printf("CPU运行次数:___%d___\n",t);printf("______________________\n");printf("进程名\t运行状态\t运行次数\t还需要运行次数\n");if(RUN!=NULL){printf("%s\t运行\t%d\t%d\n",RUN->name,RUN->cputime,RUN->needtime);}elseprintf("*运行状态为空\n");p=READY;if(p!=NULL){while(p!=NULL){printf("%s\t就绪\t%d\t%d\n",p->name,p->cputime,p->needtime);p=p->next;}}elseprintf("*就绪队列为空\n");p=FINSH;if (p!=NULL){while(p!=NULL){//printf(" 进程名字为:%s\n",p->name);printf("%s\t完成\t%d\t%d\n",p->name,p->cputime,p->needtime);p=p->next;}}elseprintf("*完成队列为空\n");getchar();}PCB *CPCBLINK()/*建立就绪队列*/{printf("建立就绪队列\n\n");int i,n,nt,pr;PCB *p,*q,*head;n=0;while(1){printf("请输入进程的个数(有效范围1-100)：");scanf("%d",&n);printf("\n");if (n>=1&&n<=100)break;elseprintf("输入有误。

实验二进程调度1．目的和要求通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。

2．实验内容阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。

编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。

假设初始状态为：有n个进程处于就绪状态，有m个进程处于阻塞状态。

采用轮转法进程调度算法进行调度(调度过程中，假设处于执行状态的进程不会阻塞)，且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。

程序要求如下：1）输出系统中进程的调度次序；2）计算CPU利用率。

3．实验环境Windows操作系统、VC++6.0C语言4设计思想：（1）程序中进程可用PCB表示，其类型描述如下：struct PCB_type{int pid ; //进程名int state ; //进程状态2——表示“执行”状态1——表示“就绪”状态0——表示“阻塞”状态int cpu_time ; //运行需要的CPU时间（需运行的时间片个数）}用PCB来模拟进程；（2）设置两个队列，将处于“就绪”状态的进程PCB挂在队列ready中；将处于“阻塞”状态的进程PCB挂在队列blocked中。

队列类型描述如下：struct QueueNode{struct PCB_type PCB;Struct QueueNode *next;}并设全程量：struct QueueNode *ready_head=NULL,//ready队列队首指针*ready_tail=NULL , //ready队列队尾指针*blocked_head=NULL,//blocked队列队首指针*blocked_tail=NULL; //blocked队列队尾指针（3）设计子程序：start_state();读入假设的数据，设置系统初始状态，即初始化就绪队列和阻塞队列。

实验二–单处理器系统的进程调度
简介
在操作系统中，进程调度是非常重要的一项工作。

进程调度负责将CPU分配
给各个进程，使得每个进程都能够有机会占用CPU资源。

在单处理器系统中，CPU只有一个，因此进程调度是非常重要的。

本次实验将会探究单处理器系统的进程调度，了解各种进程调度算法的实现和
比较，利用模拟操作系统的实验平台进行实验。

实验目的
1.了解进程调度的基本概念和实现方法；
2.学习多种进程调度算法，并比较其优缺点；
3.熟悉模拟操作系统的实验环境，学习如何将算法实现到具体的系统中。

实验内容
进程调度的基本概念
进程调度是指将CPU资源分配给各个进程的过程。

在单处理器系统中，当有
多个进程需要使用CPU时，操作系统需要进行进程调度，使得每个进程都能够得
到CPU资源。

在进程调度中，需要考虑各个进程的优先级、进程的状态和进程的等待时间等
因素。

根据不同的调度算法，可以根据这些因素来确定哪个进程应该先占用CPU。

进程调度算法比较
常见的进程调度算法包括：
1.先来先服务算法（FCFS）
2.短作业优先算法（SJF）
3.优先级调度算法
4.时间片轮转算法（RR）
下面将对这些算法进行比较和介绍。

先来先服务算法（FCFS）
先来先服务算法是最简单的一种进程调度算法。

该算法将按照进程的到达时间
的先后顺序进行调度，先到达的进程先得到CPU资源。

这种算法的优点是实现简单，适用于短作业和计算密集型进程。

缺点是无法充分利用CPU资源，导致长作业需要等待较长时间才能被调度，容易产生。

进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。

二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一，它负责决定哪个进程在何时获得 CPU 资源进行执行。

常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。

先来先服务算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 执行。

这种算法简单直观，但可能导致短作业等待时间过长。

短作业优先算法优先调度执行时间短的进程，能有效减少平均等待时间，但可能导致长作业饥饿。

时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片进行执行。

如果进程在时间片内未完成，则被放回就绪队列等待下一轮调度。

优先级调度根据进程的优先级来决定调度顺序，优先级高的进程先获得 CPU 资源。

四、实验步骤1、设计进程结构体定义进程的标识号（PID）、到达时间、服务时间、剩余时间、优先级等属性。

2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。

从就绪队列中取出第一个进程进行调度执行，直到其完成。

3、实现短作业优先算法计算每个进程的剩余服务时间。

将进程按照剩余服务时间从小到大排序，放入就绪队列。

从就绪队列中取出剩余服务时间最短的进程进行调度执行。

4、实现时间片轮转算法设定时间片大小。

将进程放入就绪队列，按照先来先服务的原则依次分配时间片执行。

进程在时间片内未完成的，放回就绪队列末尾。

5、实现优先级调度算法为每个进程设置优先级。

将进程按照优先级从高到低排序，放入就绪队列。

从就绪队列中取出优先级最高的进程进行调度执行。

6、计算平均周转时间和平均带权周转时间周转时间＝完成时间到达时间带权周转时间＝周转时间／服务时间平均周转时间＝总周转时间／进程数平均带权周转时间＝总带权周转时间／进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。

计算机操作系统实验报告实验二进程调度算法一、实验名称：进程调度算法二、实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。

三、问题分析与设计：1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。

当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。

在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

FCFS算法比较有利于长作业（进程），2.短作业（进程）优先调度算法短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。

而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。

SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。

该算法对长作业不利，完全未考虑作业的紧迫程度。

3.时间片轮转算法在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。

换言之，系统能在给定的时间内响应所有用户的请求。

第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("无效的调度算法选择。

进程调度算法实验报告Newly compiled on November 23, 2020操作系统实验报告（二）实验题目：进程调度算法实验环境：C++实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较各种算法的性能优劣。

实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。

设计分析：程序流程图：1.2.短进程优先算法3.时间片轮转调度算法实验代码：1.先来先服务算法#include <>#define n 20typedef struct{int id; d;cin>>f[i].runtime;}for(i=0;i<amount;i++) time>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<<"之前结束。

"<<endl;f[i+1].atime=f[i].atime+f[i].runtime;}}2.短进程优先算法#include<>#define n 5#define num 5#define max 65535typedef struct pro{ int PRO_ID;int arrive_time;int sum_time;int flag;}Pro;um_time>s[j+1].sum_time){temp=s[j];s[j]=s[j+1];s[j+1]=temp;lastX=0;}}if(lastX==1) break;}return s[0];}void SPF(int p){if(n>0)int i,j,k,l,tc=0;Pro seq[n];Pro temp_seq[n];printf("短进程优先调度算法SPF\n");printf("请依次输入5个进程的进程号、到达时间和执行时间\n");printf("成员变量用逗号隔开；进程间用回车隔开\n");for(i=0;i<n;i++){scanf("%d,%d,%d",&seq[i].PRO_ID,&seq[i].arrive_time,&seq[i].sum_time);}printf("调度顺序是：\n");rrive_time;}tc=bubble(temp);lag=-1;}for(i=0;i<n;i++){for(j=0;j<n;j++){if(seq[j].flag!=1&&seq[j].arrive_time<=tc){seq[j].flag=0;}}for(j=0;j<n;j++){temp_seq[j]=seq[j];if(seq[j].flag!=0){temp_seq[j].sum_time=max;}}l=bubble(temp_seq).PRO_ID;for(j=0;j<n;j++){if(l==seq[j].PRO_ID){k=j;}}tc=tc+bubble(temp_seq).sum_time;seq[k].flag=1;printf("%d",l);}printf("\n");}}void main(){SPF(n);}3.时间片轮转调度算法头文件#include<iostream>#include<>#include<>#include<>#include<>#define MaxNum 100typedef struct pcb 行时间小于0，删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%,带权周转时间=%\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);head->front=p1->next;free(p1);}行时间大于0，向后找位置插入else{printf(" %c\n",p1->state);p2=p1->next;while(p2->next && p2->arrivetime != t){p2=p2->next;}用找位置往后插入，队首不变，不做操作位置往后插入if(p2->arrivetime != t){PCB *p3=p1,*p4;while(p3->next && p3->arrivetime<t){p4=p3;p3=p3->next;}if(p3->arrivetime>t){if(p4!=p1) 行时间小于0，删除队首if(p1->runtime<=0){p1->state='C';printf(" %c\n",p1->state);p1->FinishTime=t;p1->WeightTime=p1->FinishTime-p1->arrivetime;p1->WeightWholeTime=p1->WeightTime/p1->wholetime;SumWT+=p1->WeightTime;SumWWT+=p1->WeightWholeTime;printf("时刻%2d进程%s运行结束,进程%s周转时间=%,带权周转时间=%\n",t,p1->Name,p1->Name,p1->WeightTime,p1->WeightWholeTime);行时间大于0，直接插在队尾else{printf(" %c\n",p1->state);//若原队列只有一个进程，不必往队尾插if(!p1->next)head->front=p1;//若原队列有多个进程else{head->front=p1->next;head->rear->next=p1;head->rear=p1;p1->next=NULL;}}//时刻变化，队列为空时不做时刻变化if(empty(head))return;else{if(head->front->runtime<q)t=t+head->front->runtime;elset=t+q;}}/*******第二种情况结束*********/}}主程序#include<iostream>#include<>#include<>#include<>#include<>#include ""void main(){queue *head;int q;head=init();head=creat(head);printf("\n您输入的时间片轮转进程队列为:\n");print(head);printf("\n请输入时间片轮转调度的时间片为:");scanf("%d",&q);//时间片轮转调度RR(head,q);AverageWT=SumWT/N;AverageWWT=SumWWT/N;printf("平均周转时间=%,平均带权周转时间=%",AverageWT,AverageWWT);}运行结果：先来先服务：短进程：时间片轮：心得体会：这次的实验与上次的实验相比，在很多方面都有更多的难度，所以我们参考了别人很多的程序然后稍作了修改。

实验二 进程调度一、 实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。

二、 实验要求1． 设计进程调度算法，进程数不定2． 包含几种调度算法，并加以实现3． 输出进程的调度过程——进程的状态、链表等。

三、 参考例1．题目——优先权法、轮转法简化假设1） 进程为计算型的（无I/O ）2） 进程状态：ready 、running 、finish3） 进程需要的CPU 时间以时间片为单位确定2．算法描述1） 优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。

2） 轮转法四、 实验流程图 开始 键盘输入进程数n ，和调度方法的选择 优先权法？ 轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？结束 N YY注意：1．产生的各种随机数的取值范围加以限制，如所需的CPU 时间限制在1~20之间。

2．进程数n 不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法6．若有可能请在图形方式下，将PCB 的调度用图形成动画显示。

五．实验过程：要求：读懂下面给出的程序，然后将其改写成由用户选择调度方式，例如：1、 FIFO2、 优先权调度3、 时间片轮转4、 退出对于每一种调度算法，由用户确定进程数，数据可以从文件读取，也可由用户手动输入。

（1）输入：进程流文件（1.txt ），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1 产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时间片数？NY YY 结束 N进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO算法，优先数调度算法，时间片轮转调度算法（2）程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time;}pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" \t"<<pcbs[i].status<<" \t"<<pcbs[i].time<<" \t"<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0;pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){pcbs[j].wait_time+=pcbs[i].time;}}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl; }//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){number++; j=i;}}if(number==1){queue[total]=j;total++;pcbs[j].finished=1;}if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){total--;}cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl;}//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){FIFO();init();privilege();init();timer();}}（3）运行结果：输入进程流文件名1.txt即可得出以下输出结果：。

学生实验报告姓名：年级专业班级学号成绩
【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意
1.三种进程调度算法的执行结果如下。

(1)FCFS算法
(2)高优先权优先调度算法
(3)时间片轮转调度算法
2.以上三个程序能较好地实现进程的三种调度算法。

(1)用数组元素的顺序输入输出能实现进程的FCFS算法。

(2)用优先权的变化规律描述和冒泡法排序能模拟实现优先权调度算法。

(3)通过数组的运算和利用中间数组能实现时间片轮转调度算法。

3. 虽然以上三个程序能较直观的体现进程基本的三种调度算法，但还是存在一些不足。

(1)如在高优先权调度算中，当同时出现多个进程优先权相同的情况时，程序可能对这些不能选择正确的执行顺序。

改进的方法为添加一个判断，当多个进程的优先权相同时，按FCFS算法执行。

即在程序中表现为按数组元素下标的增大顺序排序。

(2)在时间片轮转算法中，不能一次性的输出进程的调度程度，而要通过多次的输入时间片。

改进的方法为把时间片设置为全局变量，在每次循环时都执行一次。

指导教师签名：
20 年月日
【备注。

操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。

进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。

本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。

一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。

二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。

三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。

FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。

这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。

2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。

一个进程通常包含进程ID、到达时间、执行时间等信息。

我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。

具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。

然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。

4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。

可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。

通过比较不同调度算法的指标，可以得出不同算法的优缺点。

四、实验步骤1. 定义进程的数据结构，包括进程ID、到达时间和执行时间等信息。

操作系统实验二进程调度摘要：进程调度是操作系统中重要的功能之一，可以决定进程的优先级和执行顺序。

本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。

一、概念介绍进程调度是操作系统中的一项重要功能，用于决定哪个进程能够在处理器上运行。

在操作系统中存在多个进程需要同时运行，而处理器资源有限，因此需要通过进程调度来合理地安排进程的执行顺序，提高系统的效率。

进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。

常见的调度策略包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转、优先级调度等。

二、调度算法介绍1.先来先服务（FCFS）先来先服务（FCFS）是最简单的调度算法，按照进程到达的顺序进行调度，先到达的进程先执行。

FCFS算法不考虑进程的优先级和执行时间，容易导致平均等待时间长。

2.最短作业优先（SJF）最短作业优先（SJF）调度算法按照进程所需的CPU时间进行排序，优先调度所需时间最短的进程。

SJF算法可以减少平均等待时间，但可能会导致长作业等待时间过长。

3.时间片轮转时间片轮转是一种抢占式调度策略，将处理器的使用权分割为若干个时间片，每个进程在一个时间片内运行，如果时间片用完仍未运行完，则将该进程放到队列的末尾，并让下一个进程运行。

时间片轮转算法保证了公平性和响应时间，但可能会导致上下文切换次数过多。

4.优先级调度优先级调度是根据进程的优先级进行调度，优先级高的进程先执行。

优先级可以根据进程类型、实时性等因素确定，不同的操作系统可能有不同的优先级范围和策略。

三、实验步骤1.定义进程结构：定义进程结构体，包含进程ID、进程状态、优先级、执行时间等信息。

2.初始化进程队列：将所有进程按照到达的先后顺序加入到进程队列中。

3.实现调度算法：根据不同的调度算法，实现相应的进程调度算法代码。

可以使用循环遍历进程队列，并根据不同的调度策略决定下一个要执行的进程。

4.执行进程调度：在每个时间片结束后，根据调度算法选取下一个要执行的进程，并更新进程的状态和执行时间。