操作系统实验-进程调度程序设计
进程调度程序实验报告
一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法：1. 先来先服务（FCFS）2. 最短作业优先（SJF）3. 时间片轮转（RR）四、实验步骤1. 定义进程类（Process）：```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类（Scheduler）：```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序：```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果：");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果：");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果（时间片为2）：");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验，我们可以观察到以下结果：1. FCFS调度算法简单，但可能导致长作业等待时间过长。
操作系统实验二报告-时间片轮转进程调度算法1
操作系统实验报告实验二时间片轮转进程调度算法学号：班级：姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的时间片轮转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算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
进程调度操作系统实验报告
进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。
二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一，它负责决定哪个进程在何时获得 CPU 资源进行执行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 执行。
这种算法简单直观，但可能导致短作业等待时间过长。
短作业优先算法优先调度执行时间短的进程，能有效减少平均等待时间，但可能导致长作业饥饿。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片进行执行。
如果进程在时间片内未完成，则被放回就绪队列等待下一轮调度。
优先级调度根据进程的优先级来决定调度顺序，优先级高的进程先获得 CPU 资源。
四、实验步骤1、设计进程结构体定义进程的标识号（PID）、到达时间、服务时间、剩余时间、优先级等属性。
2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中取出第一个进程进行调度执行，直到其完成。
3、实现短作业优先算法计算每个进程的剩余服务时间。
将进程按照剩余服务时间从小到大排序，放入就绪队列。
从就绪队列中取出剩余服务时间最短的进程进行调度执行。
4、实现时间片轮转算法设定时间片大小。
将进程放入就绪队列，按照先来先服务的原则依次分配时间片执行。
进程在时间片内未完成的，放回就绪队列末尾。
5、实现优先级调度算法为每个进程设置优先级。
将进程按照优先级从高到低排序，放入就绪队列。
从就绪队列中取出优先级最高的进程进行调度执行。
6、计算平均周转时间和平均带权周转时间周转时间＝完成时间到达时间带权周转时间＝周转时间／服务时间平均周转时间＝总周转时间／进程数平均带权周转时间＝总带权周转时间／进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。
操作系统进程调度实验
操作系统进程调度实验操作系统进程调度是操作系统中非常重要的一个功能，它决定了多个进程的执行顺序和调度策略。
进程调度的好坏直接影响着系统的性能和资源利用率。
本实验旨在通过实现一个简单的进程调度模拟，了解不同的调度算法，探讨其优劣和适用场景。
一、实验目的和原理本实验的目标是实现进程调度模拟，并探究不同调度算法的性能和适用场景。
通过实验，我们可以了解以下内容：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算法是按照进程的执行时间长短进行调度的算法。
它能够最大限度地减少平均等待时间和周转时间，但是需要提前知道所有进程的执行时间，这在实际中是很难做到的。
操作系统课程设计进程调度
静态最高优先数调度算法的流程图如下：
开始
创建PCB
将PCB挂入就绪队 列中，优先级高的
放在队首
是 就绪队列空
否 从队首取下最高优
先级进程运行
结束
进程运行完成，撤 销
时间片轮转调度算法 就绪进程获得 CPU后都只能运行一个时间片。 如果运行一个时间片后，进程的已占用 CPU时间已达到所
课程实验的目的和意义
培养程序设计的方法和技巧 掌握操作系统的原理和功能
进程调度实验
目的要求
用高级语言编写和调试一个进程调度程序， 以加深对进程的概念及进程调度算法的理解。 （注意：这里只是模拟的进程调度程序，用 一个链表结点模拟一个进程，而不用我们之 前用过的createprocess函数创建进程）
进程调度实验
用三个队列，就绪、运行、完成来表示进程 的不同状态。当新来一个进程时，若采用静 态优先级，则根据优先级插入就绪队列中不 同位置（若队列为空，则直接插入）。若采 用时间片，则直接插入就绪队列队尾。
实验例题
设计一个有 N个进程共行的进程调度程序
链表中每一个结点包括两部分：
（1）用户需要用的实际数据；（ name[10]; int prio; int round; int cputime; int needtime; 需自己输入）
需要的运行时间，则撤消该进程； 如果进程在所分的时间片内没有运行完成，则把它重新插
入就绪队列等待CPU。
时间片轮转调度算法的流程图如下：
开始
创建PCB
将PCB挂入就绪队 列中，先来的放在 队首，后来的放队
尾
进程的调度实验报告(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操作系统实验2-进程调度的操作
1.查看并创建用户的计划任务列表crontab文件；
1)查看crontab命令的帮助信息；
在终端下键入info crontab, 进入crontab帮助手册：
2)查看用户的计划任务列表；
查看特定用户的计划任务列表：
在终端下键入crontab -l -u duke 列出duke用户的所有定时任务，如下：
终端提示no crontab for duke，说明用户duke目前没有计划任务。
查看当前用户的计划任务列表：
在终端下键入crontab -l 列出当前用户的所有定时任务，如下：
终端提示no crontab for duke，说明用户duke目前没有计划任务。
2.通过crontab文件对调度进程的计划任务进行编排操作。
1)建立crontab文件；
在终端下键入crontab -e ，提示当前无crontab文件，选择编辑器并新建如下：进入VI编辑器，编辑当前crontab文件，可以看到提供了一些注解作说明。
在crontab中输入0 3 * * 1 ls /etc 并保存，实现在每周一早上三点执行ls /etc 命令。
再次查看crontab文件，可以看到已经保存。
2)使用crontab命令安装crontab文件，安排计划任务；
对于位于/home下的crontab文件，使用crontab <filename>载入crontab计划任务中，如图：
3)查看计划任务表，确认计划任务是否已被安排；
键入crontab -l，查看计划任务安排情况，如图：
4)删除计划任务列表。
在终端下键入crontab -r ，删除当前用户的crontab文件，如下：。
操作系统进程(任务)调度
int turnroundtime;
double weight;
int memory;
struct Task *prev, *next;
} Tasktype;
void inittaskqueue(Tasktype *queue);
Tasktype *createtask(int pid, int state, int priority, int admittime, int runtime, int memory);
#define TASK_EXIT3
#define MAXTASKN1000
#define MAXRUNTIME500
#define MAXTIMEINTERVAL200
#define MAXMEMORY500
#define MAXPRIORITY100
typedef int Boolean;
#endif
FCFS
进程按顺序运行，直到当前进程运行完成，运行下一个进程
pid= 0,prio= 63,admit= 42,run= 359,exit= 401,turn= 359,wei= 1.00, mem=479
pid= 1,prio= 46,admit= 110,run= 206,exit= 607,turn= 497,wei= 2.41, mem=465
unsigned int policy;
int currenttime;
int freetime;
int busytime;
} Cputype;
void initcpu(Cputype *cpu, unsigned policy);
#endif.
操作系统单处理机系统的进程调度
操作系统单处理机系统的进程调度第一篇：操作系统单处理机系统的进程调度一.实验内容描述1.目的（1）了解Windows内存管理器（2）理解Windows的地址过程2.内容任意给出一个虚拟地址，通过WinDbg观察相关数据并找到其物理地址二.理论分析Windows采用页式虚拟存储管理技术管理内存，页面是硬件级别上的最小保护单位 1.Windows内存管理器Windows的内存管理主要由Windows执行体中的虚存管理程序负责，并由环境子系统负责，并由环境子系统负责与具体API相关的一些用户态特性的实现。
虚存管理程序是Windows中负责内存管理的那些子程序和数据结构的集合内存管理器的主要任务是：地址变换：将一个进程的虚拟地址空间转译为物理内存地址交换：当内存不足时，将内存中的有些内容转移到磁盘上，并且以后还要再次将这些内容读回2.Windows内存管理策略Windows采用页式虚拟存储管理技术管理内存，页面是硬件级别上最小的保护单位。
根据硬件的体系结构不同，页面尺寸被分为两种，大页面和小页面。
X86系统下小页面为4KB，大页面为4MB。
大页面的优点是：当引用同一页面内其他数据时，地址转移的速度会很快。
不过使用大页面通常要较大的内存空间，而且必须用一个单独的保护项来映射，因此可能会造成出现错误而不引发内存访问违例的情况。
通常PC机都为小页面 3.Windows虚拟地址空间布局 x86结构下的布局方式：默认情况下，32位Windows系统中每个用户进程可以占有2GB 的私有地址空间。
操作系统占有另外的2GB 2GB用户的进程地址空间布局如表：2GB的系统地址空间布局如同：3.虚拟地址转译地址转译是指将进程的虚拟地址空间映射到实际物理页面的过程。
x86系统中地址转译过程如图：关键数据结构如下：页目录：每个进程都有一个页目录，它是内存管理器为了映射进程中所有的页表位置而创建的一个页面。
进程也目录的地址被保存在内核进程快KPROCESS中，在x86系统上，它被映射到虚拟地址0xC0300000，当一个进程正在执行时，CPU可以通过寄存器CR3知道该进程页目录的位置。
操作系统实验——动态优先级进程调度实验报告
1.实验名称：动态优先权调度过程中就绪队列的模拟2.实验要求：采用动态优先权的进程调度算法，用C语言编程模拟调度过程中每个时间片内的就绪队列。
3.实验内容：（1）每个进程控制块PCB用结构描述，包括以下字段：*进程标识符id*进程优先数priority,并规定优先数越大的进程，其优先权越高。
*进程已占用的CPU时间cputime*进程还需占用的CPU时间alltime，当进程运行完毕时，aiitime变为0*进程的阻塞时间startblock,当进程再运行startblock个时间片后，进程将进入阻塞状态*进程被阻塞的时间blocktime,已阻塞的进程再等待blocktime个时间片后，将转换成就绪状态*进程状态state*队列指针next,将PCB排成队列。
2）调度前，系统中有五个进程，它们的初始状态如下：3）进程在就绪队列呆一个时间片,优先数增加1。
4）进程每运行一个时间片，优先数减3。
5）按下面格式显示每个时间片内就绪队列的情况：READY_QUEUE:->id1->id24.任务分析进程控制块用结构体来表示，包含它的各项属性。
建立两个队列：一个就绪队列，一个阻塞队列。
创建一个进程控制块表示当前正在运行的进程。
程序开始运行时，所有进程都在就绪队列中。
当startblock减少到0时，进程进入阻塞队列。
在阻塞队列中的进程，当blocktime减少到0时，转入就绪队列。
在就绪队列中的进程，如果优先级比当前正在执行的进程高，就可以取代当前进程获取时间片。
当前进程如果运行完毕，就绪队列中优先级最高的进程就可以成为新当前进程。
5.程序流程图#include〈iostream〉#include〈string〉usingnamespace std;#define LEN5typedefenum STATE{READYBLOCKEND}STATE;//定义进程控制块typedefstruct PCB{int id;int priority;int cputime;int alltime;int startblock;int blocktime;STATE state;}PCB;//定义队列typedefstruct queue{int si ze;PCB*data[LEN];}Queue;PCB ps[LEN];PCB*cp; //进程最大数量//进程状态//就绪//阻塞//完成//进程标识符//进程优先级//已占用的CPU时间//还需占用的CPu时间//阻塞时间//被阻塞时间//进程状态//队列中进程的数量//进程的指针//进程数组//当前正在运行的进程6.程序清单Queue rQueue,bQueue;//就绪队列和阻塞队列//就绪队列按优先级降序排序(使用了冒泡排序法)void rQueueSort(){ PCB*temp;for(int i=0;i<rQueue.size-1;i++){for(int j=0;j<rQueue.size-1-i;j++){if(rQueue.data[j]-〉priority<rQueue.data[j+1]-〉priority){temp=rQueue.data[j];rQueue.data[j]=rQueue.data[j+1];}}rQueue.dataj+1]=temp;}}//初始化void init(){//给进程赋值for(int i=0;i<LEN;i++){ps[i].id=i;ps[i].state=READY;ps[i].cputime=0;ps[i].alltime=3;ps[i].blocktime=0;ps[i].startblock=T;}ps[0].priority=9;ps[1].priority=38;ps[2].priority=30;ps[3].priority=29;ps[4].priority=0;ps[2].alltime=6;ps[4].alltime=4;ps[0].startblock=2;ps[0].blocktime=3;cp=NULL;//当前进程赋空bQueue.size=0;//阻塞队列没有进程for(int i=0;i<LEN;i++){bQueue.data[i]=NULL;rQueue.data[i]=&ps[i];}rQueue.size=5;//所有进程全部进入就绪队列rQueueSort();//对就绪队列排序}//打印void print(){cout〈〈"\nRUNNINGPROG:";if(cp!=NULL){cout〈〈cp->id;}cout<<"\nREADY_QUEUE:";for(int i=0;i<rQueue.size;i++){cout〈〈"-〉"〈〈rQueue.data[i]-〉id; }cout<<"\nBLOCK_QUEUE:";for(int i=0;i<bQueue.size;i++){cout〈〈"-〉"〈〈bQueue.data[i]-〉id; }cout〈〈"\n"<<endl;cout<<"ID\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].id<<"\t";}cout<<"\nPRI0RITY\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].priority〈〈"\t";}cout<<"\nCPUTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].cputime〈〈"\t";}cout<<"\nALLTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].alltime〈〈"\t";}cout<<"\nSTARTBLOCK\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].startblock<<"\t";}cout<<"\nBLOCKTIME\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].blocktime<<"\t";}cout<<"\nSTATE\t\t";for(int i=0;i<LEN;i++){if(ps[i].state==READY){cout<<"READY"<<"\t";}elseif(ps[i].state==BLOCK){cout<<"BLOCK"<<"\t";}elseif(ps[i].state==END){cout〈〈"END"<<"\t";}}cout〈〈endl;}//出队，返回进程指针PCB*pop(Queue*q){PCB*temp;if(q-〉size>0){temp=q-〉data[0];//取出队首进程for(int i=0;i<q-〉size-1;i++){q-〉data[i]=q-〉data[i+1];//其他进程依次向前移动}q->size__;return temp;//返回队首进程}return NULL;}//入队void push(Queue*q,PCB*p){if(q_>size<LEN){q_>data[q_〉size]=p;//将入队的进程放在队尾q_>size++;}return;}//运行进程void run(){if(rQueue.size〉0||bQueue.size〉0){if(cp==NULL){//程序一开始运行时，从就绪队列取出首进程cp=pop(&rQueue);}//当前进程没有结束，但优先级比就绪队列首进程低if(cp_〉alltime〉0&&cp_>priority<rQueue.data[0]_〉priority){}push(&r Queue,c//改变进程状态//从就绪队列取出新的当前进程//修改当前进程的状态 //将当前进程加入阻塞队列 //从就绪队列取出新的当前进程{//当前进程的startblock 为正数时//运行一次减一个时间片//减到0时，修改进程状态//每运行一个时间片//就绪队列中的进程优先级+1//每运行一个时间片//阻塞队列中的进程blocktime-1//将当前进程放入就绪队列 //就绪队列队首进程成为当前进程if (cp-〉alltime==0){cp->state =END ;cp=pop(&rQueue); }//如果当前进程运行结束//startblock 为0,标志着当前进程要进入阻塞状态if (cp —>startblock==0&&cp —>blocktime>0){cp —>state=BLOCK ; push(&bQueue,cp); cp=pop(&rQueue); }elseif (cp —>startblock>0)cp —>st artblock 一; }cp —>alltime ——;if (cp —>alltime==0){cp —>state=END ;for (int i=0;i<rQueue.size;i++){rQueue.data[i]-〉priority++; }for (int i=0;i<bQueue.size;i++){if (bQueue.data[i]-〉blocktime>0){bQueue.data[i]-〉blocktime--; }//当阻塞队列队首进程blocktime 为0时if (bQueue.size 〉0&&bQueue.data[0]-〉blocktime==0){bQueue.data[0]-〉state=READY ;//修改进程状态push(&rQueue,pop(&bQueue));//将阻塞队列首进程取出，放入就绪队列cp —〉priority-=3;//修改当前进程的优先级cp —>cputime++; //当前进程占用CPU 时间片+1 if (cp —>alltime>0){//当前进程还需运行的时间片-1}//每运行一个时间片，就绪队列排一次序rQueueSort();} }//主函数int main(){init();//初始化 print();//打印进程信息 while (1){_sleep(1000);if (rQueue.size==0&&bQueue.size==0){//当两个队列都为空时，结束程序cp-〉state=END ;break ; }run();//运行进程 print();//打印进程信息 }return 0; }7.实验过程记录m 匚:\WINDQWS\system32\cmd.exe程序开始执行，当前进程是优先级最高的1号进程，1号进程的优先级减3、cputime++、执行几次之后，1号进程执行完毕而且优先级也不是最高的了，所以优先级为33的2号进程成为当前进程，开始执行。
操作系统进程调度实验报告
操作系统进程调度实验报告操作系统进程调度实验报告引言：操作系统是计算机系统中的核心软件之一，负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。
进程调度作为操作系统的重要功能之一，负责决定哪个进程可以获得处理器的使用权，以及进程如何在处理器上运行。
本实验旨在通过设计和实现一个简单的进程调度算法，加深对操作系统进程调度原理的理解。
一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程，掌握进程调度算法的实现方法，深入理解不同调度算法的特点和适用场景。
二、实验环境本实验使用C语言进行编程实现，可在Linux或Windows系统下进行。
三、实验内容1. 进程调度算法的选择在本实验中，我们选择了最简单的先来先服务（FCFS）调度算法作为实现对象。
FCFS算法按照进程到达的先后顺序进行调度，即先到先服务。
这种调度算法的优点是简单易实现，但缺点是无法适应不同进程的执行时间差异，可能导致长作业效应。
2. 进程调度的数据结构在实现进程调度算法时，我们需要定义进程的数据结构。
一个进程通常包含进程ID、到达时间、执行时间等信息。
我们可以使用结构体来表示一个进程，例如：```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中，我们需要按照进程到达的先后顺序进行调度。
具体实现时，可以使用一个队列来保存待调度的进程，并按照到达时间的先后顺序将进程入队。
然后，按照队列中的顺序依次执行进程，直到所有进程执行完毕。
4. 实验结果分析通过实现FCFS调度算法，我们可以观察到进程调度的过程和结果。
可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。
通过比较不同调度算法的指标，可以得出不同算法的优缺点。
四、实验步骤1. 定义进程的数据结构，包括进程ID、到达时间和执行时间等信息。
计算机操作系统实验---进程调度
操作系统实验报告--进程调度计科02-8 王长青05年4月17日计算机操作系统实验——进程调度一．实验目的进程调度是处理机管理的核心内容。
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数调度算法的具体实施办法。
二．程序功能本程序使用VC++编译调试，用于实现进程优先数调度的模拟。
主要包含三个模块：1、主界面：用于显示进程调度的过程。
2、数据录入模块：用于获取进程的初始值，其中有三种获取方式，手动输入方式、随即生成方式和从文件中读去数据的方式。
当用户在主窗口中点击“开始”菜单项时即可打开数据录入对话框，用户通过这三种方式之一均可完成数据的录入。
3、进程控制模块：主要实现创建新的进程，就绪队列的管理，完成队列的管理，进程的调度。
三．实验原理（1）本程序采用优先数调度算法对进程进行调度，每个进程可有三个状态，即：就绪状态，运行状态，完成状态。
并假设初始状态为就绪状态。
这三种状态的转换情况如右图：（2）为了便于处理，程序中的某进程运行时间以时间片为单位计算。
各进程的优先数以及进程需运行的时间片数的初始值均由用户给定（通过数据录入模块完成）。
（3）程序通过设置一个定时器来实现时间片的轮转，时间片的大小是1秒，在定时器消息的响应函数中从用户录入的数据中读取一个创建进程，将其加入到就绪队列中，然后进行调度和执行。
在调度函数中，对于遇到优先数一致的情况，采用FIFO策略解决。
（4）在优先数算法中，进程每执行一次，优先数减3，进程还需要运行的时间数减1。
四．详细设计（1）设计进程控制块PCB结构：struct PCB{ int pid; //进程号int pri; //进程优先数int time; //进程所需运行时间int status; // 进程状态 0就绪，1 执行，-1完成};（2）将进程的各种操作封装在类CProMoni中，该类的定义如下：class CProMoni{public:CProMoni();virtual ~CProMoni();void InsertRQ(PCB* p); //将p所指的进程插入到就绪队列中void InsertFQ(PCB* p); //将p所指的进程插入到完成队列中void ProSchedule(); //进程调度函数void ProRun(); //运行函数void Display(CDC* pDC); //以表格形式输出运行过程bool GetFinishFlag();bool OpenLogFile(); //打开日志文件void CloseLogFile(); //关闭日志文件bool WriteLogToFile(); //向日志文件中写入数据private:PCB *m_pRunning; //指向当前运行的进程CPtrList m_readyList; //就绪队列CPtrList m_finishList; //完成队列bool m_finish; //完成标志CString m_LogFileName; //日志文件名CStdioFile m_LogFile; //日志文件public:int m_clock; //时钟序列};（3）主要成员函数的实现：void CProMoni::InsertRQ(PCB* p){ //将p插入到就绪队列中POSITION pre,pos=m_readyList.GetHeadPosition();PCB *q;while(pos!=NULL){pre=pos;q=(PCB*)m_readyList.GetNext(pos);if(q->pri < p->pri){m_readyList.InsertBefore(pre,p);return;}}if(pos==NULL){m_readyList.AddTail(p);}}void CProMoni::ProSchedule(){//进程调度PCB *p;if(m_pRunning==NULL){if(m_readyList.IsEmpty()){m_finish=true;return;}else{p=(PCB*)m_readyList.RemoveHead();m_pRunning=p;}}else{if(!m_readyList.IsEmpty()){p=(PCB*)m_readyList.GetHead();//m_readyList将头节点与当前PCB的权值比较if(p->pri > m_pRunning->pri ){PCB *q=m_pRunning;m_pRunning=(PCB*)m_readyList.RemoveHead();m_pRunning->status=1;q->status=0;InsertRQ(q);}}}}void CProMoni::ProRun(){//运行进程if(!m_finish){if(m_pRunning==NULL){ AfxMessageBox("当前运行的进程不存在!");return;}m_pRunning->pri-=3;m_pRunning->time-=1;{ m_pRunning->time=0;PCB*p=m_pRunning;p->status=-1;InsertFQ(p);m_pRunning=NULL;}}}（4）试图类的主要成员函数：PCB* CProcessView::CreatePCB(){//创建PCBPCB* p=new PCB;p->pid=n+1;p->pri=m_pris[n];p->time=m_times[n];p->status=0;n++;return p;}#include"pritimedlg.h"void CProcessView::OnStart(){ CPriTimeDlg dlg; //定义数据录入对话框dlg.DoModal();if(dlg.m_ok){ m_proTotal=dlg.m_proNum;for(int i=0;i<m_proTotal;i++){ m_pris[i]=dlg.m_pris[i];m_times[i]=dlg.m_times[i];}m_proMoni.OpenLogFile(); //打开日志文件PCB* p=CreatePCB(); //创建新进程m_proMoni.InsertRQ(p); //将新进程插入到就绪队列中m_proMoni.WriteLogToFile(); //写日志文件m_proMoni.ProSchedule(); //进程调度m_start=true; //设置开始标志Invalidate(); //刷新视图m_killTimer=false;SetTimer(1,1000,NULL);//设置定时器}}void CProcessView::OnTimer(UINT nIDEvent){ m_proMoni.m_clock++;m_proMoni.WriteLogToFile();//写日志m_proMoni.ProRun(); //运行进程if(n<m_proTotal){ PCB *p=CreatePCB();//创建新进程m_proMoni.InsertRQ(p);}m_proMoni.ProSchedule();Invalidate();if(m_proMoni.GetFinishFlag()){//若已完成则删除定时器KillTimer(1);m_killTimer=true;AfxMessageBox("演示完毕");}CScrollView::OnTimer(nIDEvent);}五．运行结果（1）数据录入界面：（2）进程调度过程的结果：六、实验总结通过本实验使我对进程的相关概念及进程的优先数调度算法有了更深的理解，使自己在程序设计及编制方面也有了一定的提高。
进程调度模拟程序实验实验报告
进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 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。
实验报告二 进程调度算法
实验报告二——进程调度算法的设计姓名: xxxx 学号: xxxxx班级: xxxx一、实习内容•实现短进程优先调度算法（SPF）•实现时间片轮转调度算法（RR）二、实习目的•通过对进程调度算法的设计, 深入理解进程调度的原理。
进程是程序在一个数据集合上运行的过程, 它是系统进行资源分配和调度的一个独立单位。
进程调度分配处理机, 是控制协调进程对CPU的竞争, 即按一定的调度算法从就绪队列中选中一个进程, 把CPU的使用权交给被选中的进程。
三、实习题目• 1.先来先服务（FCFS）调度算法原理: 每次调度是从就绪队列中, 选择一个最先进入就绪队列的进程, 把处理器分配给该进程, 使之得到执行。
该进程一旦占有了处理器, 它就一直运行下去, 直到该进程完成或因发生事件而阻塞, 才退出处理器。
将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列, 并按照先来先服务的方式进行调度处理, 是一种最普遍和最简单的方法。
它优先考虑在系统中等待时间最长的作业, 而不管要求运行时间的长短。
按照就绪进程进入就绪队列的先后次序进行调度, 简单易实现, 利于长进程, CPU繁忙型作业, 不利于短进程, 排队时间相对过长。
• 2.时间片轮转调度算法RR原理: 时间片轮转法主要用于进程调度。
采用此算法的系统, 其程序就绪队列往往按进程到达的时间来排序。
进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队, 调度程序每次把CPU分配给就绪队列首进程使用一个时间片, 运行完一个时间片释放CPU, 排到就绪队列末尾参加下一轮调度, CPU分配给就绪队列的首进程。
固定时间片轮转法:1 所有就绪进程按FCFS 规则排队。
2 处理机总是分配给就绪队列的队首进程。
3 如果运行的进程用完时间片, 则系统就把该进程送回就绪队列的队尾, 重新排队。
4 因等待某事件而阻塞的进程送到阻塞队列。
5 系统把被唤醒的进程送到就绪队列的队尾。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
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并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
计算机操作系统进程调度实验报告
操作系统实验题：设计一若干并发进程的进程调度程序一、实验目的无论是批处理系统、分时系统还是实时系统，用户进程数一般都大于处理机数，这将导致用户进程互相争夺处理机。
这就要求进程调度程序按一定的策略，动态地把处理及分配给处于就绪队列中的某一进程，以使之执行。
进程调度是处理机管理的核心内容。
本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。
通过本实验可以加深理解有关进程控制块、进程队列的概念。
并体会了优先数和先来先服务调度算法的具体实施办法。
二、实验要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．三、实验内容进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法（将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理）。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
进程调度实验报告
操作系统实验 报告实验项目： 进程调度学 院： 计算机学院专 业：班 级：学 号：姓 名：1. 实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理机数时，就必须依照某种策略来决定哪些进程优先占用处理机。
本实验模拟在单处理机情况下的进程调度，加深了解进程调度的工作。
2. 实验内容设计一个按时间片轮转法实现进程调度的程序。
(1)假定系统有五个进程，每一个进程用一个进程控制块PCB 来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为Q 1，Q 2，Q 3，Q 4，Q 5。
指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数，初始值为“0”。
状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R ”表示。
当一个进程运行结束后，它的状态为“结束”，用“E ”表示。
(2)每次运行所设计的进程调度程序前，为每个进程任意确定它的“要求运行时间”。
(3)把五个进程按顺序排成循环队列，用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如，当前轮到Q 2执行，则有：进程名 指针 要求运行时间 已运行时间 状态标志单元(4)进程调度总是选择标志单元指示的进程运行。
由于本实验是模拟进程调度的功能，所以对被选中的进程并不实际的启动运行，而是执行“已运行时间+1”来模拟进程的一次运行，表示进程已经运行过一个单位的时间。
请注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理机运行，直到出现等待事件或运行满一个时间片。
在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。
(5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。
操作系统进程调度模拟程序实验报告
操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序，以加深对进程调度算法的理解。
二、实验内容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算法适用于进程到达时间差异较大的场景，保证了先到先服务。
实验报告操作系统实验一进程调度.doc
计算机电子信息工程学院实验报告成绩________ 课程名称操作系统指导教师杨秀华实验日期 2011年9月15、22、29,10月12院（系）计算机学院专业班级09计算机应用实验地点 B-4009学生姓名学号实验项目名称实验一模拟设计进程调度一、实验目的和要求用C或C++语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解．二、实验原理进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）状态之一。
就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1（即降低一级）,然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
三、主要仪器设备或材料PC机,C++环境四、实验方法与步骤（可加附页）1、主要数据结构：struct pcb { /* 定义进程控制块PCB */char name[10]; //进程名字char state; //进程状态int super; //进程的优先级int ntime; //进程需要运行的时间int rtime; //进程已经运行的时间struct pcb* link; }2、调度算法的流程图如上图 :五、实验数据记录、处理及结果分析六、讨论、心得计算机电子信息工程学院实验报告（附页）程序参考代码：参考代码：#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;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() /*建立进程撤消函数(进程运行结束,撤消进程)*/{3 / 4printf("\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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程名称：实验项目：实验地点：专业班级：学生姓名：指导教师：本科实验报告操作系统B进程调度程序设计学号：2011 年11 月目录进程调度程序设计一、实验目的和要求 (1)二、实验内容及原理 (1)三、实验仪器设备 (3)四、操作方法与实验步骤 (3)五、实验数据记录和处理 (3)六、实验结果与分析 (10)七、实验感想 (11)实验二一、实验目的和要求（一） 目的进程调度程序设计进程是操作系统最重要的概念之一，进程调度是操作系统的主要内容，本实验要求 学生独立地用高级语言编写一个进程调度程序，调度算法可任意选择或自行设计，本实验 可使学生加深对进程调度和各种调度算法的理解。
（二） 要求1． 设计一个有几个进程并发执行的进程调度程序，每个进程由一个进程控制块(PCB) 表示，进程控制块通常应包括下述信息：进程名，进程优先数，进程需要运行的时间，占 用 CPU 的时间以及进程的状态等，且可按照调度算法的不同而增删。
2． 调度程序应包含 2—3 种不同的调度算法，运行时可以任选一种，以利于各种方法 的分析和比较。
3． 系统应能显示或打印各进程状态和参数的变化情况，便于观察。
二、实验内容及原理1． 本程序可选用优先数法或简单轮转法对五个进程进行调度。
每个进程处于运行 R(run)、就绪 W(wait)和完成 F(finish)三种状态之一，并假定起始状态都是就绪状态 W 。
为了便于处理，程序中进程的运行时间以时间片为单位计算。
各进程的优先数或轮 转时间片数、以及进程需要运行的时间片数，均由伪随机数发生器产生。
进程控制块结构如表 2-1 所示：表 2-1PCB进程控制块链结构如图 2-1 所示：图 2-1进程控制块链结构其中：RUN —当前运行进程指针；进程标识符 链指针 优先数/轮转时间片数 占用 CPU 时间片数 进程所需时间片数进程状态HEAD —进程就绪链链首指针； TAIL —进程就绪链链尾指针。
2. 算法与框图priority程序框图如图 2-2 所示。
开始alog=priority/round robin?进程时 间片数 为 0？优先数 大于链 首进程?占用处 理机时 间片到?进程时 间片数 为 0？进程队列空?是 结束进程队列空?结束图 2-2进程调度框图(1)优先数法。
进程就绪链按优先数大小从大到小排列，链首进程首先投入运行。
每 过一个时间片，运行进程所需运行的时间片数减 1，说明它已运行了一个时间片，优先数也 减 3。
理由是该进程如果在一个时间片中完成不了，优先级应降低一级。
接着比较现行进程 和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续运行，否则， 调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链，且改变它们对应 的进程状态，直至所有进程都运行完各自的时间片数。
(2)简单轮转法。
进程就绪链按各进程进入的先后次序排列，链首进程首先投入运行。
进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相 输入调度算法 alog从链首取一个进程投入运行时间片到，进程时间片 数减 1，优先数减 3运行进程退出， 排到进程链尾部撤消该进程 生成并按进入次序 排列进程控制块链 链首进程投入运行时间片到，进程时间片数 减 1，占用 CPU 时间加 1撤消该进程 运行进程退出，按 优先数插入进程链从链首取一个 进程投入运行是是 是 否否否否否是 round robin否是生成并按优先数大小 排列进程控制块链 链首进程投入运行应于优先数法的优先数记录项位置）。
每过一个时间片，运行进程占用处理机的时间片数加 1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
三、实验仪器设备微型计算机。
C++6.0编程软件四、操作方法与实验步骤1.编写源程序2.编译运行，查看结果五、实验数据记录和处理优先权调度算法：1．设定系统中有五个进程，每一个进程用一个进程控制块（PCB）表示，进程队列采用链表数据结构。
2.进程控制块包含如下信息：进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
3.在每次运行设计的处理调度程序之前，由终端输入五个进程的“优先数”和“要求运行时间”。
4.进程的优先数及需要的运行时间人为地指定.进程的运行时间以时间片为单位进行计算。
5.采用优先权调度算法，将五个进程按给定的优先数从大到小连成就绪队列。
用头指针指出队列首进程，队列采用链表结构。
6.处理机调度总是选队列首进程运行。
采用动态优先数办法，进程每运行一次优先数减“1”，同时将已运行时间加“1”。
7.进程运行一次后，若要求运行时间不等于已运行时间，则再将它加入就绪队列；否则将其状态置为“结束”,且退出就绪队列。
8.“就绪”状态的进程队列不为空，则重复上面6，7步骤，直到所有进程都成为“结束”状态。
9.在设计的程序中有输入语句，输入5个进程的“优先数”和“要求运行时间”，也有显示或打印语句，能显示或打印每次被选中进程的进程名、运行一次后队列的变化，以及结束进程的进程名。
10、最后，为五个进程任意确定一组“优先数”和“要求运行时间”，运行并调试所设计的程序，显示或打印出逐次被选中进程的进程名及其进程控制块的动态变化过程。
简单时间片轮转法：1.设系统有5个进程，每个进程用一个进程控制块PCB来代表。
2.为每个进程任意确定一个要求运行时间。
3.按照进程输入的先后顺序排成一个队列。
再设一个队首指针指向第一个到达进程的首址。
4.执行处理机调度时，开始选择队首的第一个进程运行。
另外，再设一个当前运行进程的指针，指向当前正在运行的进程。
5.考虑到代码的可重用性, 轮转法调度程序和最高优先级优先调度是调用同一个模快进行输出注:由于轮转法调度程序和最高优先级优先调度是调用同一个模快进行输出,所以在时间轮转法调度算法的进程中,依然显示了随即产生的优先级数.6.进程运行一次后，以后的调度则将当前指针依此下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。
同时还应判断该进程的要求运行时间是否等于已运行时间。
若不等，则等待下一轮的运行，否则将该进程的状态置为完成态C，并退出循环队列。
7.若就绪队列不空，则重复上述的（5）和（6）步骤直到所有的进程都运行完为止。
8.在所设计的调度程序中,包含显示或打印语句。
显示或打印每次选中的进程的名称及运行一次后队列的变化情况。
源程序：#include<stdio.h>#include<math.h>#include<stdlib.h>#define furthest5struct process{int id;int priority;int cputime;int alltime;char state;int next;}prochain[furthest-1];int procnum;int rand();int algo;int run,head,tail,j;void main(){agan:printf("type the algorithm is (1:RR,2:PRIO):");scanf("%d",&algo);if(algo==2){printf("output of priority.\n");extern void init();extern void prisch();}else{if(algo==1){printf("output of round robin.\n");extern void init();extern void timesch();}else{printf("try again,please\n");goto agan;}}for (j=1;j<=40;j++){printf("=");}printf("\n\n");for(j=1;j<=40;j++){printf("=");}printf("\n\n");printf("system finished\n");}void print(){int k,p;for(k=1;k<=40;k++)printf("=");printf("\nrunning proc.");printf("waiting queue.");printf("\n %d ",prochain[run].id);p=head;while(p!=0){printf("%5d",p);p=prochain[p].next;}printf("\n");for(k=1;k<=40;k++){printf("=");}printf("\n");printf("id ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].id);printf("\n");printf("priority ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].priority);printf("\n");printf("cputime ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].cputime);printf("\n");printf("alltime ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].alltime);printf("\n");printf("state ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].state);printf("\n");printf("next ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].next);printf("\n");}void insert(int q){int p,s;p=head;s=prochain[head].next;while((prochain[q].priority<prochain[s].priority)&&(s!=0)) {p=s;s=prochain[s].next;}prochain[p].next=q;prochain[q].next=s;}void insert2(){prochain[tail].next=run;tail=run;prochain[run].next=0;}void init(){int i;head=0;if(algo==2){for(i=1;i<furthest+1;i++){prochain[i].id=i;prochain[i].priority=(rand()+11)%41;prochain[i].cputime=0;prochain[i].alltime=(rand()+1)%7;prochain[i].state='W';prochain[i].next=0;if((prochain[i].priority<prochain[head].priority)&&(head!=0)) insert(prochain[i].id);else{prochain[i].next=head;head=prochain[i].id;}}}else{for(i=1;i<furthest+1;i++){prochain[i].id=i;prochain[i].priority=(rand()+1)%3+1;prochain[i].cputime=0;prochain[i].alltime=(rand()+1)%7;prochain[i].state='W';prochain[i].next=(i+1)%(furthest+1);}head=1;tail=furthest;prochain[furthest].next =0;}run=head;prochain[run].state='R';head=prochain[head].next;prochain[run].next=0;print();}void prisch(){while(run!=0){prochain[run].cputime+=1;prochain[run].priority-=3;prochain[run].alltime-=1;if(prochain[run].alltime==0){prochain[run].state='F';prochain[run].next=0;if(head!=0){run=head;prochain[run].state='R';head=prochain[head].next;}else{prochain[0].id=prochain[run].id;run=0;}}else{if((prochain[run].priority<prochain[head].priority)&&(head!=0)) {prochain[run].state='W';insert(run);run=head;prochain[run].state='R';head=prochain[head].next;}}print();}}void timesch(){while(run!=0){prochain[run].alltime-=1;prochain[run].cputime+=1;if(prochain[run].alltime==0){prochain[run].state='F';prochain[run].next=0;if(head!=0){run=head;prochain[run].state='R';head=prochain[head].next;}else{prochain[0].id=prochain[run].id;run=0;}}else{if((prochain[run].cputime<prochain[head].priority)&&(head!=0)) {prochain[run].state='W';prochain[run].cputime=0;insert2();run=head;prochain[run].state='R';head=prochain[head].next;}}print();}}六、实验结果与分析（1）输入1的结果为：（2）输入2的结果为：七、实验感想这个实验老师给了实验程序的主题框架，但是在完善程序和程序运行时也遇到了不少问题，对很多C++的语句语法都忘了好多，导致遇到一些语法错误而发现不了问题。