实验二 进程调度程序设计
进程调度程序实验报告
一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。
二、实验环境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、设计可用于该实验的进程控制块，进程控制块至少包括进程号、状态和要求服务时间；2、动态或静态创建多个进程；3、模拟操作系统四种进程调度算法中的任意一种。
4、调度所创建的进程并显示调度结果。
（二）实验目标1、加深进程概念的理解；2、掌握进程状态转变；3、掌握进程调度策略。
（三）实验要求1、编写程序完成实验内容；2、在实验报告中画出程序流程图；3、撰写实验报告。
二、实验准备（一）运行环境说明计算机、Windows95/98/Me/2000/XP操作系统（需要能够上网）、Microsoft Visual C++、“记事本”程序。
（二）基础数据设置及说明计算机、Windows95/98/Me/2000/XP操作系统（需要能够上网）、Microsoft Visual C++6.0、“记事本”程序，均能正常运行。
三、实验原理（一）进程概念：1、进程是程序的一次执行。
2、进程是一个程序及其数据在处理机上顺序执行时所发生的活动。
3、进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。
（二）进程状态：进程执行时的间断性决定了进程可能具有多种状态。
事实上，运行中的进程可能具有以下三种基本状态。
1、就绪状态当进程已分配到除CPU以外的所有必要资源后，只要再获得CPU，便可立即执行，进程这时的状态称为就绪状态。
在一个系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列。
2、执行状态进程已获得CPU，其程序正在执行。
在单处理机系统中，只有一个进程处于执行状态；在多处理机系统中，则有多个进程处于执行状态。
3、阻塞状态正在执行的进程由于发生某事件而暂时无法继续执行时，便放弃处理机而处于暂停状态，亦即进程的执行受到阻塞，把这种暂停状态称为阻塞状态，有时也称为等待状态或封锁状态。
致使进程阻塞的典型事件有：请求I/O，申请缓冲空间等。
操作系统实验-进程调度程序设计
课程名称：实验项目：实验地点：专业班级：学生姓名：指导教师：本科实验报告操作系统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 —进程就绪链链尾指针。
操作系统实验二报告-时间片轮转进程调度算法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算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
实验二 进程调度
实验一 进程调度一、 实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
二、 实验要求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）输入：进程流文件（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进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO 算法，优先数调度算法，时间片轮转调度算法产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时间片数？NY YY 结束 N（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<<" "<<pcbs[i].status<<" "<<pcbs[i].time<<" "<<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即可得出以下输出结果：。
实验2-进程调度设计
实验报告院（系）：专业班级：学号:姓名:实验地点:实验日期:一、实验目的及要求进程调度是处理机管理的核心内容。
本实验要求用C 语言编写和调试一个简单的进程调度程序。
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解FIFO 调度算法的具体实现方法。
二、实验环境PC /Windows 系统/Visual C++6.0三、实验内容编写并调试一个模拟的进程调度程序，采用“简单时间片轮转法”调度算法对五个进程进行调度。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已运行时间、进程状态等等。
进程的到达时间及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行 R（Run）两种状态之一。
就绪进程获得 CPU 后都只能运行一个时间片。
用运行时间加 1 来表示。
如果运行一个时间片后，进程的已占用 CPU 时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用 CPU 时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应分配时间片给就绪队列中排在该进程之后的进程，并将它插入就绪队列队尾。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
四、实验步骤1、进程调度算法：采用多级反馈队列调度算法。
其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS 原则排队等待高度。
当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS 原则等待调度执行，以此类推。
2、实验步骤:（1）按先来先服务算法将进程排成就绪队列。
（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。
进程调度算法实验报告
计算机操作系统实验报告实验二进程调度算法一、实验名称：进程调度算法二、实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。
三、问题分析与设计：1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。
当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
FCFS算法比较有利于长作业（进程），2.短作业（进程）优先调度算法短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。
而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。
该算法对长作业不利，完全未考虑作业的紧迫程度。
3.时间片轮转算法在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。
换言之，系统能在给定的时间内响应所有用户的请求。
实验二 进程调度 实验报告
（1）输入进程数、进程名、要求运行时间、已运行时间以及进程状态，初
始状态都为“就绪”，用“R”表示。当一个进程运行结束后，它的状态为“结束”，用“E”表示。
（2）把所有进程按顺序排成循环队列，用指针进行连接。
（3）运行队列中的队首进程，执行一个时间片，同时将该进程的“已运行
时间”+1，同时判断“要求运行时间”和“已运行时间”是否相等，如果相等，则将该进程状态修改为“E”，并退出循环队列，指针指向下一个进程；若不相等，则指针直接指向下一个进程，执行下一个时间片。
3.流程图
五、实验结果和分析（运行结果截图）
问题一
问题二
2.问题二
本题采用的是动态改变响应比的办法。首先根据公式
计算每个进程的响应比即优先数，根据响应比的大小降序排列，响应比大
的进程优先得到服务,每次执行一个时间片。由于本实验是模拟操作系统调
度进程的过程，被选中的进程并不实际的启动运行，而是执行： 要求运行
时间-1、等待时间为0，其它进程等待时间+1。进入下一轮运行时进程重
实验目的如下：
1.利用高级语言模拟进程的时间片轮转调度算法，并熟练掌握。
2.利用高级语言模拟进程的响应比高者优先调度算法，并熟练掌握。
二、实验原理
1.问题一
针对系统的所有进程，首先确定所有进程的要求运行时间（已运行时间初始值为0）；将所有进程按顺序排成循环队列，用指针指出队列连接情况，同时另用一个标志单元记录轮到运行的进程，此时以轮转法进行调度；先将CPU分配给队首进程，并令其执行一个时间片，当它运行完毕后，将CPU分配给就绪队列中新的队首进程，让其执行一个时间片，进程每被调度一次，该进程已运行时间+1，同时，判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间已运行时间，则表示它尚未执行结束，应待到下一轮时再运行，若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”，并退出队列。此时，把该进程的进程控制块中的指针值送到前面一个进程的指针位置，直到所有的进程都成为“结束”状态。
进程的调度实验报告(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文件，如下：。
实验二 进程调度
实验二进程调度实现FPF和RR调度算法实验目的•编写程序，实现FPF和RR算法，模拟进程调度过程，加深对进程调度的理解。
实验内容•实现FPF和RR调度算法。
–数据结构设计（PCB，进程就绪队列）–算法实现与模拟（排序、调度）–输出调度结果，展示调度过程并解释实验要求1.设计进程控制块(PCB)的数据结构–应包含实验必须的数据项，如进程ID、需要的服务时间、进入系统时间、完成时间、周转时间、优先权、进程状态（R-运行，W-等待），以及实验者认为有必要的其他数据项。
2.实现排序算法（将就绪队列中的进程排序）–RR：只需在开始时排序，按FCFS策略将进程依次插入就绪队列。
开始运行后不再需要排序，按RR策略将每一个刚刚运行完一个时间片的进程插入到队尾。
–FPF：每次调度前排序，按计算所得的动态优先权排成有序队列，最高优先权排进程在队首，优先权相同的进程按FCFS策略排队。
实验要求3.实现RR调度过程模拟n每个进程用一个PCB表示，按FCFS策略排成就绪队列，按照固定的周期循环调度。
o选择队首的进程，将其从就绪队列移出，修改其状态为R。
p经过一个时间片，如果正在执行的进程没有执行完，修改其状态为W，插入到就绪队列尾部。
如果执行完毕，计算其周转时间。
q进行下一次调度（去往第d步），直到就绪队列为空。
实验要求4.实现FPF调度过程模拟n每个进程用一个PCB表示。
o计算动态优先权，按优先权高低排入就绪队列，如果相同，则按FCFS排队。
系统开始时调度，每个进程结束时进行调度。
p选择队首的作业，将其从后备队列移出q计算选中作业的周转时间（进程运行过程，在本实验中，无需实现，可认为就绪队列上的进程一但被调度程序选出，就顺利运行结束）r进行下一次调度（去往第d步）实验要求5.实现结果输出–输出进程状态表，展示调度过程•初始进程状态（未调度时）•每次调度后的进程状态6.撰写实验报告–包含实验要求中1~4项内容，要求有设计图（结构图/流程图）和源代码。
实验二 进程调度的设计与实现
院系：计算机学院实验课程：操作系统实验项目：进程调度的设计与实现指导老师：陈红英老师开课时间：2011 ～ 2012年度第 2学期专业：网络工程班级：10级学生：yuth学号：*一、实验项目名称进程调度的设计与实现二、实验目的及要求1、综合应用下列知识点设计并实现操作系统的进程调度：邻接表，布尔数组，非阻塞输入，图形用户界面GUI，进程控制块，进程状态转换，多级反馈队列进程调度算法。
2、加深理解操作系统进程调度的过程。
3、加深理解多级反馈队列进程调度算法。
三、实验主要硬件软件环境32位PC机，VC++6四、实验内容及步骤1、采用一种熟悉的语言，如C、PASCAL 或C++等，编制程序，最好关键代码采用C/C++，界面设计可采用其它自己喜欢的语言。
2、采用多级反馈队列调度算法进行进程调度。
3、每个进程对应一个PCB 。
在PCB 中包括进程标识符pid、进程的状态标识status、进程优先级priority、进程的队列指针next 和表示进程生命周期的数据life（在实际系统中不包括该项）。
4、创建进程时即创建一个PCB，各个进程的pid 都是唯一的，pid 是在1 到100 范围内的一个整数。
可以创建一个下标为 1 到100 的布尔数组，“真”表示下标对应的进程标识号是空闲的，“假”表示下标对应的进程标识号已分配给某个进程。
5、进程状态status 的取值为“就绪ready ”或“运行run ”，刚创建时，状态为“ready ”。
被进程调度程序选中后变为“run ”。
6、进程优先级priority 是0 到49 范围内的一个随机整数。
7、进程生命周期life 是1 到5 范围内的一个随机整数。
8、初始化时，创建一个邻接表，包含50 个就绪队列，各就绪队列的进程优先级priority 分别是0 到49 。
9、为了模拟用户动态提交任务的过程，要求动态创建进程。
进入进程调度循环后，每次按ctrl+f 即动态创建一个进程，然后将该PCB 插入就绪队列中。
操作系统实验报告 进程调度
华中师范大学计算机科学系《操作系统》实验报告实验题目：进程调度学生姓名：日期：2011-12-9实验2进程调度【实验目的】（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、代码：#include<iostream>#include<string>using namespace std;class Process{public:string ProcessName; // 进程名字int Time; // 进程需要时间int leval; // 进程优先级int LeftTime; // 进程运行一段时间后还需要的时间};//////////////////////////////////////////////////////////////////////////////////////////////////void Copy ( Process proc1, Process proc2); // 把proc2赋值给proc1void Sort( Process pr[], int size) ; // 此排序后按优先级从大到小排列void sort1(Process pr[], int size) ; // 此排序后按需要的cpu时间从小到大排列void Fcfs( Process pr[], int num, int Timepice); // 先来先服务算法void TimeTurn( Process process[], int num, int Timepice); // 时间片轮转算法void Priority( Process process[], int num, int Timepice); // 优先级算法//////////////////////////////////////////////////////////////////////////////////////////////////void main(){int TimePice;int num;cout<<" *********创建进程*********\n"<<endl;cout<<" 输入进程个数:";cin>>num;const int Size =30;Process process[Size] ;for( int i=0; i< num; i++){string name;int CpuTime;int Leval;cout<<"\n 输入第"<< i+1<<" 个进程的名字、运行时间和优先级:"<<endl;cin>> name;cin>> CpuTime>> Leval;process[i].ProcessName =name;process[i].Time =CpuTime;process[i].leval =Leval;cout<<endl;}int a;cout<<endl;cout<<" *******输入此进程时间片大小:******: ";cin>>TimePice;cout<<"\n *******选择调度算法：*************\n"<<endl;cout<<"**************************************************************"<<endl; cout<<"* 1: FCFS 2: 时间片轮换3: 优先级调度4: 最短作业优先*"<<endl; cout<<"**************************************************************"<<endl; cin>> a;for ( int k=0;k<num;k++)process[k].LeftTime=process[k].Time ;//对进程剩余时间初始化cout<<" // 说明: 在本程序所列进程信息中，优先级一项是指进程运行后的优先级!! "; cout<<endl; cout<<endl;if(a==1)Fcfs(process,num,TimePice);else if(a==2)TimeTurn( process, num, TimePice);else if(a==3){Sort( process, num);Priority( process , num, TimePice);}else // 最短作业算法，先按时间从小到到排序，再调用Fcfs算法即可{sort1(process,num);Fcfs(process,num,TimePice);}}void Copy ( Process proc1, Process proc2){proc1.leval =proc2.leval ;proc1.ProcessName =proc2.ProcessName ;proc1.Time =proc2.Time ;}void Sort( Process pr[], int size) //以进程优先级高低排序{for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.leval<pr[j-1].leval){pr[j] = pr[j-1];j--;}pr[j] = temp;}for( int d=size-1;d>size/2;d--){Process temp;temp=pr [d];pr [d] = pr [size-d-1];pr [size-d-1]=temp;}}void sort1 ( Process pr[], int size) // 以进程时间从低到高排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.Time < pr[j-1].Time ){pr[j] = pr[j-1];j--;}pr[j] = temp;}}//// 先来先服务算法的实现void Fcfs( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!\n"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}else if(process[num-1].LeftTime<=0){process[num-1].LeftTime=0;cout<<" 进程"<<process[num-1].ProcessName<< " 已经执行完毕!\n"<<endl;num--;}else{cout<<endl;process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<=0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;for(int s=1;s<num;s++){if(process[s].LeftTime<=0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval<<" 等待"<<endl; ;}}cout<<endl;system(" pause");cout<<endl;}}/// 时间片轮转调度算法实现void TimeTurn( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!\n"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}if( process[num-1].LeftTime <=0 ){process[num-1].LeftTime=0;cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! \n"<<endl;num--;}else if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;for(int s=1;s<num;s++){if(process[s].LeftTime<0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}Process temp;temp = process[0];for( int j=0;j<num;j++)process[j] = process[j+1];process[num-1] = temp;}elsesystem(" pause");cout<<endl;system(" pause");cout<<endl;}}/// 优先级调度算法的实现void Priority( Process process[], int num, int Timepice){while( true){if(num==0){cout<< "所有进程都已经执行完毕!\n"<<endl;exit(1);}if(process[0].LeftTime<=0){process[0].LeftTime=0;cout<<" 进程" << process[0].ProcessName <<" 已经执行完毕! \n"<<endl;for( int m=0;m<num;m++)process[m] = process[m+1]; //一个进程执行完毕后从数组中删除num--; // 此时进程数目减少一个}if( num!=1 && process[num-1].LeftTime <=0 ){process[num-1].LeftTime=0;cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! \n"<<endl;num--;}if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;if(process[0].LeftTime<0)process[0].LeftTime=0;process[0].leval =process[0].leval-1;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<" "<<process[0].leval<<" 运行"<<endl;// 输出其他进程for(int s=1;s<num;s++){if(process[s].LeftTime<0)process[s].LeftTime=0;cout<<"进程名字"<<"共需占用CPU时间"<<" 还需要占用时间"<<" 优先级"<<" 状态"<<endl;cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<" "<<process[s].leval ;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}} // elseSort(process, num);cout<<endl;system(" pause");cout<<endl;} // while}【实验小结】本次试验的题目——进程管理。
进程调度模拟程序实验实验报告
进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 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 系统把被唤醒的进程送到就绪队列的队尾。
(完整word版)进程调度模拟程序设计
进程调度模拟程序设计一、实验目的按优先数调度算法或时间片轮转法模拟处理器调度,从而进一步理解处理器调度的原理。
二、实验内容1.设计思路（1）数据结构定义（a)对于不同的调度算法，定义不同的PCB结构体typedef struct PCB_type1 {char name［10］; //进程名char state；//进程状态R—-就绪状态E——结束状态int need_time; //运行需要的CPU时间(需运行的时间片个数）int priority;｝PCB_P; //按优先数调度算法的PCB结构体typedef struct PCB_type2 ｛char name［10]；//进程名int state; //进程状态R-—就绪状态E——结束状态int need_time; //运行需要的CPU时间（需运行的时间片个数）int used_time; //}PCB_T；//按时间片轮转算法的PCB结构体(b）用全局变量choice来指明当前应用的调度算法int choice；(c)为了模拟调度,可以利用STL定义队列deque<PCB_P> q1;queue〈PCB_T〉q2；(2）程序主要模块一共有三个自定义函数,分别是：start_state（) 提示用户选择调度算法，初始化进程信息。
dispatch(）模拟调度(a)对于优先数调度算法，每次调度前对队列里的进程按优先数从大到小排序,然后调度选中队首的进程，将其出队列，并将进程优先数和需要运行时间减1。
如果此进程的需要运行时间不为0，则继续将此进程入队；如果此进程的需要运行时间为0了,则将其状态置为结束状态。
重复上述过程直至队列为空.(b)对于时间片轮转算法，调度选中队首的进程，将其出队列,并将进程已用时间加1。
如果此进程要求运行时间已运行时间，则尚未执行结束，继续将此进程入队；如果此进程的要求运行时间=已运行时间，则已经执行结束，将其状态置为结束状态。
实验二 时间片轮转RR进程调度算法
实验二时间片轮转RR进程调度算法1、需求分析(1) 输入的形式和输入值的范围首先输入进程个数，然后再输入时间片的大小，然后按照到达时间的顺序输入每个进程的名字，然后输入进程到达的时间和服务时间，输入完成，程序显示算法的结果。
(2) 输出的形式程序的输出根据用户输入的时间片的大小到达时间以及服务时间，通过相应的计算输出其各自的完成时间，周转时间，带全周转时间以及平均值，程序输出这些结果。
3) 程序所能达到的功能1）输入进程个数n,时间片的大小t以及每个进程的名字和每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n。
2）时间片轮转法RR调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间。
3）输出：输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
(4) 测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果正确输入的结果错误输入的结果2、概要设计抽象数据类型的定义：int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];主程序的流程以及各程序模块之间的层次(调用)关系：3、详细设计该算法采用队列的方法实现。
先将第一个到达的进程入队，在规定的时间内将其运行，也有可能其服务时间小于实际时间片。
此时判断其他的程序有没有到达，到达就将其入队，没有到达则等待，然后判断此时在队头的进程是否完成执行，如果已经完成执行吗，则将其出对，若还没有完成，则将其调配到队尾，现在打头的进程依旧执行此方法判断，知道所有的进程都出队。
实验二进程调度方案与实现
院系：计算机学院实验课程：操作系统实验工程：进程调度的设计与实现指导老师：陈红英老师开课时间：2018〜2018年度第2学期专业：网络工程班级：10级学生：yuth学号：*一、实验工程名称进程调度的设计与实现二、实验目的及要求1、综合应用下列知识点设计并实现操作系统的进程调度：邻接表，布尔数组，非阻塞输入，图形用户界面GUI，进程控制块，进程状态转换，多级反馈队列进程调度算法。
2、加深理解操作系统进程调度的过程。
3、加深理解多级反馈队列进程调度算法。
三、实验主要硬件软件环境32 位PC 机，VC++6四、实验内容及步骤1、米用一种熟悉的语言，如C、PASCAL或C++等，编制程序，最好关键代码米用C/C++，界面设计可米用其它自己喜欢的语言。
2、采用多级反馈队列调度算法进行进程调度。
3、每个进程对应一个PCB。
在PCB中包括进程标识符pid、进程的状态标识status、进程优先级priority、进程的队列指针next和表示进程生命周期的数据lifev 在实际系统中不包括该项）。
4、创建进程时即创建一个PCB，各个进程的pid都是唯一的，pid是在1到100范围内的一个整数。
可以创建一个下标为1到100的布尔数组，“真”表示下标对应的进程标识号是空闲的，“假”表示下标对应的进程标识号已分配给某个进程。
5、进程状态status的取值为“就绪ready ”或“运行run ”，冈H创建时，状态为“ ready ”。
被进程调度程序选中后变为“ run ”。
6、进程优先级priority是0到49范围内的一个随机整数。
7、进程生命周期life是1到5范围内的一个随机整数。
8初始化时，创建一个邻接表，包含50个就绪队列，各就绪队列的进程优先级priority分别是0到49。
9、为了模拟用户动态提交任务的过程，要求动态创建进程。
进入进程调度循环后，每次按ctrl+f即动态创建一个进程，然后将该PCB插入就绪队列中。
操作系统实验二进程调度
操作系统实验二进程调度摘要：进程调度是操作系统中重要的功能之一，可以决定进程的优先级和执行顺序。
本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。
一、概念介绍进程调度是操作系统中的一项重要功能，用于决定哪个进程能够在处理器上运行。
在操作系统中存在多个进程需要同时运行，而处理器资源有限，因此需要通过进程调度来合理地安排进程的执行顺序，提高系统的效率。
进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。
常见的调度策略包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转、优先级调度等。
二、调度算法介绍1.先来先服务（FCFS）先来先服务（FCFS）是最简单的调度算法，按照进程到达的顺序进行调度，先到达的进程先执行。
FCFS算法不考虑进程的优先级和执行时间，容易导致平均等待时间长。
2.最短作业优先（SJF）最短作业优先（SJF）调度算法按照进程所需的CPU时间进行排序，优先调度所需时间最短的进程。
SJF算法可以减少平均等待时间，但可能会导致长作业等待时间过长。
3.时间片轮转时间片轮转是一种抢占式调度策略，将处理器的使用权分割为若干个时间片，每个进程在一个时间片内运行，如果时间片用完仍未运行完，则将该进程放到队列的末尾，并让下一个进程运行。
时间片轮转算法保证了公平性和响应时间，但可能会导致上下文切换次数过多。
4.优先级调度优先级调度是根据进程的优先级进行调度，优先级高的进程先执行。
优先级可以根据进程类型、实时性等因素确定，不同的操作系统可能有不同的优先级范围和策略。
三、实验步骤1.定义进程结构：定义进程结构体，包含进程ID、进程状态、优先级、执行时间等信息。
2.初始化进程队列：将所有进程按照到达的先后顺序加入到进程队列中。
3.实现调度算法：根据不同的调度算法，实现相应的进程调度算法代码。
可以使用循环遍历进程队列，并根据不同的调度策略决定下一个要执行的进程。
4.执行进程调度：在每个时间片结束后，根据调度算法选取下一个要执行的进程，并更新进程的状态和执行时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二 进程调度程序设计一、目的和要求（一） 目的进程是操作系统最重要的概念之一，进程调度是操作系统的主要内容，本实验要求学生独立地用高级语言编写一个进程调度程序，调度算法可任意选择或自行设计，本实验可使学生加深对进程调度和各种调度算法的理解。
（二） 要求1． 设计一个有几个进程并发执行的进程调度程序，每个进程由一个进程控制块(PCB)表示，进程控制块通常应包括下述信息：进程名，进程优先数，进程需要运行的时间，占用CPU 的时间以及进程的状态等，且可按照调度算法的不同而增删。
2． 调度程序应包含2—3种不同的调度算法，运行时可以任选一种，以利于各种方法的分析和比较。
3． 系统应能显示或打印各进程状态和参数的变化情况，便于观察。
二、实验内容和原理1． 题目 本程序可选用优先数法或简单轮转法对五个进程进行调度。
每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假定起始状态都是就绪状态W 。
为了便于处理，程序中进程的运行时间以时间片为单位计算。
各进程的优先数或轮转时间片数、以及进程需要运行的时间片数，均由伪随机数发生器产生。
进程控制块结构如表2-1所示：表2-1 PCB进程标识符 链指针 优先数/轮转时间片数 占用CPU 时间片数 进程所需时间片数 进程状态进程控制块链结构如图2-1所示：RUN HEAD TAIL…图2-1 进程控制块链结构1 ┇R3 ┇ W5 ┇WW┇2其中：RUN —当前运行进程指针；HEAD —进程就绪链链首指针； TAIL —进程就绪链链尾指针。
2.算法与框图 程序框图如图2-2所示。
图2-2 进程调度框图(1)优先数法。
进程就绪链按优先数大小从大到小排列，链首进程首先投入运行。
每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3。
理由是该进程如果在一个时间片中完成不了，优先级应降低一级。
接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续运行，否则，调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。
(2)简单轮转法。
进程就绪链按各进程进入的先后次序排列，链首进程首先投入运行。
priority是 输入调度算法alog开始alog=priority/round robin?生成并按优先数大小排列进程控制块链 进程时间片数为0？从链首取一个进程投入运行生成并按进入次序 排列进程控制块链 链首进程投入运行时间片到，进程时间片 数减1，优先数减3运行进程退出，排到进程链尾部撤消该进程 链首进程投入运行 时间片到，进程时间片数 减1，占用CPU 时间加1优先数大于链首进程? 进程时间片数为0？撤消该进程 运行进程退出，按优先数插入进程链从链首取一个进程投入运行结束结束进程队列空?进程队列空?是是是否否否否否是 round robin占用处理机时间片到?否是进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相应于优先数法的优先数记录项位置）。
每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
三、系统运行的软硬件环境（硬件配置，软件）笔记本电脑、visualc++6.0四、程序清单#include <stdio.h>#include <stdlib.h>#define furthest 5struct process /*PCB STRUCTURE*/{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;main() /*MAIN PROGRAM*/{ agan: printf("type the algorithm is (1:RR,2:PRIO):");scanf("%d",&algo);if (algo==2){printf("output of priority.\n");init();prisch();}else{if (algo==1){printf("output of round robin.\n");init();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");getch();}print() /*PRINT THE RUNNING PROCESS,WAITING QUEUE AND PCB SEQUENCE LIST*/{int k,p;for (k=1;k<=40;k++)printf("=");printf("\nrunning proc. ");printf("%d",prochain[run].id);printf("\n 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("%5c",prochain[k].state);printf("\n");printf("next ");for (k=1;k<furthest+1;k++)printf("%5d",prochain[k].next);printf("\n");}insert(int q) /*INSERT A PROCESS*/{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;}}insert2() /*PUT A PROCESS ONTO THE TAIL OF THE QUEUE*/ {prochain[tail].next=run;tail=run;prochain[run].next=0;}init() /*CREATE A W AITING QUEUE*/{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();}prisch() /*THE PROCESS WITH PRIO ALGORITHM */{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();}}timesch() /*THE PROCESS WITH RR ALRORITHM */{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[run].priority)&&(head!=0)){prochain[run].state='W';prochain[run].cputime=0;insert2();run=head;prochain[run].state='R';head=prochain[head].next;}}print();}}五、实验结果与分析六、讨论、心得本次实验主要是选用优先数法或简单轮转法对五个进程进行调度，重点在于对两个算法的理解，，简单轮转法是将按进入顺序排列进程。