实验一、进程调度实验报告
进程调度实验【实验报告】
实验一进程调度实验专业：信息管理与信息系统学号：2014******姓名：陈*实验日期：2016年11月11日一、实验目的通过本实验，采用动态优先权优先的调度算法编写和调试一个简单的进程调度程序，加深理解了有关进程控制块、进程队列的概念，并体会了优先权调度算法的具体实施办法。
二、实验要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．三、实验方法内容1.算法设计思路（流程图）开始输入所有进程到一个链表中是否所有进程都已完成结束Yi = 1,m = 0在就绪队列中找到优先级最高的进程，用P1表示，state 设为R用P2指向链表第一个节点P2所指进程state = F ？NP2所指进程state = R ？NPriority – 2，CPUTime + 1，AllTime –1，YAllTime = 0？YNState 设为F ，m = 1CPUTime % StartBlock = 0 ？state 设为B ，m = 1YNP2所指进程state = B ？BolckTime - 1BlockTime = 0?State 设为 W YYN P2所指进程state = W ？NPriority + 1YNP2指向下一个节点P2已指向链表末尾？NYM = 1 ？i <= 2 ?i + 1YNNYNY2.算法中用到的数据结构（1）首先定义一个结构体，用以保存一个进程的各种信息，最后一个指针便于将所有进程形成一个链表typedef struct pcb{int id;int arriveTime; //到达时间int priority;int cpuTime;int allTime;int startBlock;int blockTime;char state;struct pcb *next;}PCB;（2）接着建立一个链表存储所有进程，以结构体PCB为节点（头节点为空节点，从第二个节点开始存储数据）。
进程调度程序实验报告
一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。
二、实验环境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调度算法简单，但可能导致长作业等待时间过长。
实验一、进程调度实验报告
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一，其目的是合理地分配 CPU 资源给各个进程，以提高系统的整体性能和资源利用率。
通过本次实验，我们旨在深入理解进程调度的原理和算法，掌握进程状态的转换，观察不同调度策略对系统性能的影响，并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验原理1、进程状态进程在其生命周期中会经历不同的状态，包括就绪态、运行态和阻塞态。
就绪态表示进程已经准备好执行，只等待 CPU 分配；运行态表示进程正在 CPU 上执行；阻塞态表示进程由于等待某个事件（如 I/O操作完成）而暂时无法执行。
2、调度算法常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。
先来先服务算法按照进程到达的先后顺序进行调度。
短作业优先算法优先调度执行时间短的进程。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片执行。
四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体，包含进程 ID、到达时间、执行时间、剩余时间等信息。
实现进程的创建、插入、删除等操作。
实现不同的调度算法。
2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。
分别采用先来先服务、短作业优先和时间片轮转算法进行调度。
记录每个算法下的平均周转时间、平均等待时间等性能指标。
五、实验步骤1、进程结构体的定义｀｀｀c+＋struct Process ｛int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;｝；｀｀｀2、进程创建函数｀｀｀c+＋void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) ｛processesnumProcessespid ＝ pid;processesnumProcessesarrivalTime ＝ arrivalTime;processesnumProcessesexecutionTime ＝ executionTime;processesnumProcessesremainingTime ＝ executionTime;numProcesses+＋；｝｀｀｀3、先来先服务调度算法实现｀｀｀c+＋void fcfsScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （currentTime ＜ processesiarrivalTime) ｛currentTime ＝ processesiarrivalTime;｝processesistartTime ＝ currentTime;currentTime ＋＝ processesiexecutionTime;processesifinishTime ＝ currentTime;processesiwaitingTime ＝ processesistartTime processesiarrivalTime;processesiturnaroundTime ＝ processesifinishTime processesiarrivalTime;｝｝｀｀｀4、短作业优先调度算法实现｀｀｀c+＋void sjfScheduling(Process processes, int numProcesses) ｛int currentTime ＝ 0;int minExecutionTime, selectedProcess;bool found;while （true) ｛found ＝ false;minExecutionTime ＝ INT_MAX;selectedProcess ＝－1;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛if （processesiarrivalTime ＜＝ currentTime ＆＆processesiremainingTime ＜ minExecutionTime ＆＆processesiremainingTime ＞ 0) ｛found ＝ true;minExecutionTime ＝ processesiremainingTime;selectedProcess ＝ i;｝｝if （！found) ｛break;｝processesselectedProcessstartTime ＝ currentTime;currentTime ＋＝ processesselectedProcessremainingTime;processesselectedProcessfinishTime ＝ currentTime;processesselectedProcesswaitingTime ＝processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime ＝processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime ＝ 0;｝｝｀｀｀5、时间片轮转调度算法实现｀｀｀c+＋void rrScheduling(Process processes, int numProcesses, int timeSlice) ｛int currentTime ＝ 0;Queue<int> readyQueue;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛readyQueueenqueue(i)；｝while （！readyQueueisEmpty(））｛int currentProcess ＝ readyQueuedequeue(）；if （processescurrentProcessarrivalTime ＞ currentTime) ｛currentTime ＝ processescurrentProcessarrivalTime;｝if （processescurrentProcessremainingTime ＜＝ timeSlice) ｛currentTime ＋＝ processescurrentProcessremainingTime;processescurrentProcessfinishTime ＝ currentTime;processescurrentProcesswaitingTime ＝processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime ＝processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime ＝ 0;｝ else ｛currentTime ＋＝ timeSlice;processescurrentProcessremainingTime ＝ timeSlice;readyQueueenqueue(currentProcess)；｝｝｝｀｀｀6、性能指标计算函数｀｀｀c+＋void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) ｛double totalWaitingTime ＝ 0, totalTurnaroundTime ＝ 0;for （int i ＝ 0; i ＜ numProcesses; i+＋）｛totalWaitingTime ＋＝ processesiwaitingTime;totalTurnaroundTime ＋＝ processesiturnaroundTime;｝averageWaitingTime ＝ totalWaitingTime ／ numProcesses; averageTurnaroundTime ＝ totalTurnaroundTime ／ numProcesses;｝｀｀｀7、主函数｀｀｀c+＋int main(）｛Process processes100;int numProcesses ＝ 0;／／创建进程createProcess(processes, numProcesses, 1, 0, 5)；createProcess(processes, numProcesses, 2, 1, 3)；createProcess(processes, numProcesses, 3, 2, 4)；createProcess(processes, numProcesses, 4, 3, 2)；／／先来先服务调度fcfsScheduling(processes, numProcesses)；double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime)；cout ＜＜＂先来先服务调度的平均等待时间：＂＜＜fcfsAverageWaitingTime ＜＜ endl;cout ＜＜＂先来先服务调度的平均周转时间：＂＜＜fcfsAverageTurnaroundTime ＜＜ endl;／／短作业优先调度sjfScheduling(processes, numProcesses)；double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime)；cout ＜＜＂短作业优先调度的平均等待时间：＂＜＜sjfAverageWaitingTime ＜＜ endl;cout ＜＜＂短作业优先调度的平均周转时间：＂＜＜sjfAverageTurnaroundTime ＜＜ endl;／／时间片轮转调度（时间片为 2）rrScheduling(processes, numProcesses, 2)；double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime)；cout ＜＜＂时间片轮转调度（时间片为 2）的平均等待时间：＂＜＜ rrAverageWaitingTime ＜＜ endl;cout ＜＜＂时间片轮转调度（时间片为 2）的平均周转时间：＂＜＜ rrAverageTurnaroundTime ＜＜ endl;return 0;｝｀｀｀六、实验结果与分析1、先来先服务调度平均等待时间：40平均周转时间：85分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。
操作系统原理 实验一：进程调度实验报告书-模板
计算机科学系实验报告书课程名：《操作系统原理》题目：进程调度班级：学号：姓名：操作系统原理实验——进程调度实验报告一、目的与要求1）进程是操作系统最重要的概念之一，进程调度是操作系统内核的重要功能，本实验要求用C 语言编写一个进程调度模拟程序，使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
2）按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）3）于2012年10月22日以前提交本次实验报告（含电子和纸质报告，由学习委员以班为单位统一打包提交）。
2 实验内容或题目1）设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2）模拟调度程序可任选两种调度算法之一实现（有能力的同学可同时实现两个调度算法）。
3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
4）本次实验内容（项目）的详细说明以及要求请参见实验指导书。
3 实验步骤与源程序实验步骤：1、理解本实验中关于两种调度算法的说明。
2、根据调度算法的说明，画出相应的程序流程图。
3、按照程序流程图，用C语言编程并实现。
源程序：#include <stdlib.h>/*进程调度优先权法*/#include <stdio.h>#include <time.h>#define null 0struct PCB{int id;int prior;int used;int need;int run;char status;struct PCB * next;};main(){struct PCB *head,*rear,*temp,*run,*small,*p,*q;int i,j,t;printf("优先权进程调度算法\n\n 5个初始进程详细信息如下：\n\n");printf("\t进程号\t优先级\tused\tneed\t状态\t下一PCB\n\n");head=null;rear=null;for(i=1;i<=5;i++) { //动态生成含5个元素的队列temp=malloc(sizeof(struct PCB)); //动态分配一个PCB temp->id=i;temp->prior=rand()%5;temp->status='W';temp->next=null;if (head==null){head=temp;rear=head;}else{rear->next=temp;rear=temp;}}temp=head;while(temp!=null){printf("\t%d\t%d\t%c\t%d\n",temp->id,temp->prior,temp->status,temp->next);temp=temp->next;}getchar(); //让程序停下来，可以查看结果。
进程调度操作系统实验报告
进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。
二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一，它负责决定哪个进程在何时获得 CPU 资源进行执行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 执行。
这种算法简单直观，但可能导致短作业等待时间过长。
短作业优先算法优先调度执行时间短的进程，能有效减少平均等待时间，但可能导致长作业饥饿。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片进行执行。
如果进程在时间片内未完成，则被放回就绪队列等待下一轮调度。
优先级调度根据进程的优先级来决定调度顺序，优先级高的进程先获得 CPU 资源。
四、实验步骤1、设计进程结构体定义进程的标识号（PID）、到达时间、服务时间、剩余时间、优先级等属性。
2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中取出第一个进程进行调度执行，直到其完成。
3、实现短作业优先算法计算每个进程的剩余服务时间。
将进程按照剩余服务时间从小到大排序，放入就绪队列。
从就绪队列中取出剩余服务时间最短的进程进行调度执行。
4、实现时间片轮转算法设定时间片大小。
将进程放入就绪队列，按照先来先服务的原则依次分配时间片执行。
进程在时间片内未完成的，放回就绪队列末尾。
5、实现优先级调度算法为每个进程设置优先级。
将进程按照优先级从高到低排序，放入就绪队列。
从就绪队列中取出优先级最高的进程进行调度执行。
6、计算平均周转时间和平均带权周转时间周转时间＝完成时间到达时间带权周转时间＝周转时间／服务时间平均周转时间＝总周转时间／进程数平均带权周转时间＝总带权周转时间／进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。
操作系统进程调度实验报告
《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号2015年10月21日实验一进程调度1.实验目的：通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。
2.实验内容：用C语言实现对N个进程采用某种进程调度算法先来先服务调度、短作业优先调度的调度。
3.设计实现：要求给出设计源码，设计源码要有详细注释，#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/int atime; /*到达时间*/int stime; /*服务时间*/int ftime; /*完成时间*/int rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("根据到达时间重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++)if(a[i].atime>a[i+1].atime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %d %d |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void fcfs(struct program a[],int n){int i;int time=0;for(i=0;i<n;i++){time=time+a[i].stime;a[i].ftime=a[0].atime+time;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=(float)a[i].rtime/a[i].stime;}printf("\nFCFS算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %d %.2d %.2d %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******先来先服务算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);fcfs(pro,m);getchar();}#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/float atime; /*到达时间*/float stime; /*服务时间*/float ftime; /*完成时间*/float rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("重新排序：\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=1;i<n-1-j;i++)if(a[i].stime>a[i+1].stime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %f %f |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void SJF(struct program a[],int n){int i;a[0].ftime=a[0].atime+a[0].stime;a[0].rtime=a[0].ftime-a[0].atime;a[0].qrtime=a[0].rtime/a[0].stime;for(i=1;i<n;i++){a[i].ftime=a[i-1].ftime+a[i].stime;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=a[i].rtime/a[i].stime;}printf("\nSJF算法：\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %.2f %.2f %.2f %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******短作业优先算法****** \n");printf("请输入进程的数目：\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名，到达时间，服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);SJF(pro,m); getchar(); }4.实验结果5.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。
实验进程调度的实验报告
一、实验目的1. 加深对进程概念和进程调度算法的理解。
2. 掌握进程调度算法的基本原理和实现方法。
3. 培养编程能力和系统分析能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块（PCB）3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一，负责将CPU分配给就绪队列中的进程。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转（RR）等。
1. 先来先服务（FCFS）算法：按照进程到达就绪队列的顺序进行调度。
2. 短作业优先（SJF）算法：优先调度运行时间最短的进程。
3. 优先级调度算法：根据进程的优先级进行调度，优先级高的进程优先执行。
4. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行，时间片结束后进行调度。
五、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、运行时间、优先级、状态等信息。
2. 创建进程队列，用于存储就绪队列、等待队列和完成队列。
3. 实现进程调度算法：a. FCFS算法：按照进程到达就绪队列的顺序进行调度。
b. SJF算法：优先调度运行时间最短的进程。
c. 优先级调度算法：根据进程的优先级进行调度。
d. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行。
4. 模拟进程调度过程：a. 初始化进程队列，将进程添加到就绪队列。
b. 循环执行调度算法，将CPU分配给就绪队列中的进程。
c. 更新进程状态，统计进程执行时间、等待时间等指标。
d. 当进程完成时，将其移至完成队列。
六、实验结果与分析1. FCFS算法：按照进程到达就绪队列的顺序进行调度，简单易实现，但可能导致短作业等待时间过长。
2. SJF算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述：进程调度是操作系统中一个重要的组成部分，它负责决定在多个进程同时运行时，每个进程分配到的CPU时间片以及切换进程的时机。
合理的进程调度算法能够提高系统的性能和资源利用率，因此对进程调度的研究和优化具有重要意义。
1. 背景介绍进程调度是操作系统中的一个关键任务，它负责管理和控制多个进程的执行顺序，以实现对CPU的合理分配。
在多道程序设计环境下，进程调度的作用尤为重要。
进程调度算法的好坏直接影响着系统的性能和响应速度。
2. 进程调度算法2.1 先来先服务（FCFS）先来先服务是最简单的调度算法之一，它按照进程到达的先后顺序进行调度，即先到达的进程先执行，直到该进程执行完成或者发生I/O操作。
FCFS算法的优点是公平且易于实现，但是它无法适应不同进程的执行时间差异，可能导致长作业效应。
2.2 最短作业优先（SJF）最短作业优先调度算法是根据进程的执行时间长度来进行调度，执行时间越短的进程越优先执行。
SJF算法能够最大程度地减少平均等待时间，但是它需要预先知道进程的执行时间，这在实际应用中往往是不可行的。
2.3 时间片轮转（RR）时间片轮转是一种经典的调度算法，它将CPU的执行时间划分为若干个时间片，每个进程在一个时间片内执行，如果时间片用完还没有执行完，则将该进程放入就绪队列的末尾，继续执行下一个进程。
RR算法能够保证每个进程都能获得公平的CPU时间，但是对于长时间执行的进程，会导致较大的上下文切换开销。
3. 实验设计与结果分析为了评估不同进程调度算法的性能，我们设计了一系列实验。
首先，我们使用不同的进程到达时间和执行时间生成一组测试数据。
然后，分别使用FCFS、SJF和RR算法进行调度，并记录每个进程的等待时间和周转时间。
最后，我们对实验结果进行分析。
实验结果显示，FCFS算法对于执行时间较长的进程会出现较长的平均等待时间，而SJF算法能够有效减少平均等待时间。
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。
二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法：FCFS、RR和DP。
3. 创建一个进程队列，用于存储所有进程。
4. 实现调度函数，根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程，打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
进程调度实验报告[1]
![进程调度实验报告[1]](https://img.taocdn.com/s3/m/5e4b5c1cfc4ffe473368ab21.png)
实验一进程调度一.实验题目:（1）、编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。
2）、编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。
二:实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．三.实验内容:<一>最高优先级优先调度算法1)优先级简介动态优先数是指在进程创建时先确定一个初始优先数，以后在进程运行中随着进程特性的改变不断修改优先数，这样，由于开始优先数很低而得不到CPU的进程，就能因为等待时间的增长而优先数变为最高而得到CPU运行。
例如：在进程获得一次CPU后就将其优先数减少1。
或者，进程等待的时间超过某一时限时增加其优先数的值，等等。
2)详细设计优先权调度算法：1、设定系统中有五个进程，每一个进程用一个进程控制块（ PCB）表示，进程队列采用链表数据结构。
2、进程控制块包含如下信息：进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
3、在每次运行设计的处理调度程序之前，由终端输入五个进程的“优先数”和“要求运行时间”。
4、进程的优先数及需要的运行时间人为地指定.进程的运行时间以时间片为单位进行计算。
5、采用优先权调度算法，将五个进程按给定的优先数从大到小连成就绪队列。
用头指针指出队列首进程，队列采用链表结构。
6、处理机调度总是选队列首进程运行。
采用动态优先数办法，进程每运行一次优先数减“1”，同时将已运行时间加“1”。
7、进程运行一次后，若要求运行时间不等于已运行时间，则再将它加入就绪队列；否则将其状态置为“结束”,且退出就绪队列。
8、“就绪”状态的进程队列不为空，则重复上面6，7步骤，直到所有进程都成为“结束”状态。
9、在设计的程序中有输入语句，输入5个进程的“优先数”和“要求运行时间”，也有显示或打印语句，能显示或打印每次被选中进程的进程名、运行一次后队列的变化，以及结束进程的进程名。
操作系统(进程调度)实验报告
操作系统原理（进程调度）实验报告实验一：动态优先权一．实验目的：（1）.理解进程创建的相关理论；（2）.掌握进程创建方法；（3）.掌握进程相关的数据结构；（4）.了解进程的调度算法；二．实验内容：1、最好采用图形界面；2、可随时增加进程；3、规定道数，设置后备队列和挂起状态。
若内存中进程少于规定道数，可自动从后备队列调度一作业进入。
被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。
4、每次调度后，显示各进程状态。
三．实验步骤1.创建进程PCB。
包括进程ID，优先权，执行时间，占用cpu时间，状态五个部分；struct Process{int id;int priority;int cputime;int alltime;enum STATE state;}process[N];2.初始化进程队列。
进程号用ID表示，优先权随机设定，状态均置为ready；void Init(){srand((unsigned)time(NULL));for(int i=0;i<N;i++){process[i].id = Rseq[i] = i;process[i].priority = rand()%20;process[i].cputime = 0;process[i].alltime = rand()%3+3;process[i].state = ready;TIME += process[i].alltime;}Sort();Print();flag = 1;}3.运行进程。
首轮按优先权大小排列进程执行顺序，优先权最大的最先执行，首轮执行后，运行程序优先权减2，未执行程序优先权加1.第二轮再按优先权顺序排序执行，以此类推，直到所有程序执行完成。
..........附录(源代码)：#include<stdio.h>#include<stdlib.h>#include<time.h>#define N 5enum STATE{ready,run,finish};struct Process{int id;int priority;int cputime;int alltime;enum STATE state;}process[N];int Rseq[N];int flag = 0;int TIME = 0;void Print(){printf("=============================================================\n");printf(" id priority cputime alltime state \n");for(int i=0;i<N;i++){printf(" %d %d %d %d",process[i].id,process[i].priority,process[i].cputime,process[i].alltime);switch(process[i].state){case 0:printf("ready\n");break;case 1:printf("run\n");break;case 2:printf("finish\n");}}printf(" Next Run sequence :");for(int i=0;i<N;i++)if(i != N-1)printf("%d -> ",Rseq[i]);else printf("%d\n",Rseq[i]);printf("=============================================================\n\n"); }void Sort(){int temp;for(int i=0;i<N-1;i++)for(int j=i+1;j<N;j++)if(process[Rseq[i]].priority <= process[Rseq[j]].priority){temp = Rseq[i];Rseq[i] = Rseq[j];Rseq[j] = temp;}}void Init(){srand((unsigned)time(NULL));for(int i=0;i<N;i++){process[i].id = Rseq[i] = i;process[i].priority = rand()%20;process[i].cputime = 0;process[i].alltime = rand()%3+3;process[i].state = ready;TIME += process[i].alltime;}Sort();Print();flag = 1;}void Run(){for(int i=0;i<=TIME;i++){printf(" run process:%d\n",Rseq[0]);for(int j=0;j<N;j++){if(process[j].state == run) process[j].state = ready;}for(int j=0;j<N;j++){if(process[Rseq[j]].alltime == 0){process[Rseq[j]].priority = 0;process[Rseq[j]].state = finish;}else if(j == 0 && process[Rseq[j]].alltime != 0){process[Rseq[j]].priority -= 2;process[Rseq[j]].cputime++;process[Rseq[j]].alltime--;process[Rseq[j]].state = run ;}else process[Rseq[j]].priority++;}Sort();Print();}}main(){Init();Run();}实验二：循环首次适应法（一）需求分析该算法是首次适应算法的变种。
进程调度实验报告
if(q!=NULL)
{
copy(&q->PCB,&x.PCB);
q->next=NULL;
Q->tail->next=q;
Q->tail=q;
return true;
}
else
return false;
}
LinkQueueNode *deleteq(LinkQueue *Q)//出队
{
int flag;
getchar();
}
printf("******各进程的信息******\n\n");
printf("进程的名字进程的状态进程执行的时间\n");
printf("\n");
display(rq);
display(bq);
}
int QueueState(LinkQueue Q)//判断队列是否为空
{
p->PCB.state=2;
printf("***进程状态为%d\n",p->PCB.state);
p->PCB.cpu_time--;
if(p->PCB.cpu_time>0)
{
p->PCB.state=1;
enterq(&rq,*p);
}
else
free(p);
}
count++;
if(count==counter)
进程调度实验报告答案(3篇)
第1篇一、实验目的通过本次实验，加深对操作系统进程调度过程的理解，掌握三种基本调度算法（先来先服务（FCFS）、时间片轮转、动态优先级调度）的原理和实现方法，并能够通过编程模拟进程调度过程，分析不同调度算法的性能特点。
二、实验环境1. 操作系统：Linux/Windows2. 编程语言：C/C++3. 开发环境：Visual Studio、Code::Blocks等三、实验内容1. 实现三种基本调度算法：FCFS、时间片轮转、动态优先级调度。
2. 编写代码模拟进程调度过程，包括进程创建、进程调度、进程运行、进程结束等环节。
3. 每次调度后，打印当前运行的进程、就绪队列以及所有进程的PCB信息。
4. 编写实验报告，描述数据结构、算法流程，展示实验结果，并总结心得。
四、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、已用时间、优先数、进程状态等信息。
2. 实现进程调度函数，根据所选调度算法进行进程调度。
3. 编写主函数，初始化进程信息，选择调度算法，并模拟进程调度过程。
4. 每次调度后，打印当前运行的进程、就绪队列以及所有进程的PCB信息。
5. 编写实验报告，描述数据结构、算法流程，展示实验结果，并总结心得。
五、实验结果与分析1. FCFS调度算法实验结果：按照进程到达时间依次调度，每个进程结束后，调度下一个进程。
分析：FCFS调度算法简单，易于实现，但可能会导致进程的响应时间较长，特别是当有大量进程到达时，后到达的进程可能会长时间等待。
2. 时间片轮转调度算法实验结果：每个进程完成一个时间片后，放弃处理机，转到就绪队列队尾。
分析：时间片轮转调度算法能够保证每个进程都能得到一定的运行时间，但可能会出现进程饥饿现象，即某些进程长时间得不到运行。
3. 动态优先级调度算法实验结果：每个进程完成一个时间片后，优先级减1，插入到就绪队列相关位置。
分析：动态优先级调度算法能够根据进程的运行情况动态调整优先级，使得优先级高的进程能够得到更多的运行时间，从而提高系统的响应速度。
进程调度算法实验报告
实验报告实验一：进程调度算法一、实验目的1．利用高级语言实现三种不同及进程调度算法：短作业优先算法、时间片轮转调度算法和优先级调度算法。
2．通过实验理解有关进程控制块，进程队列等的概念。
二、实验原理各调度算法思想：1.先来先服务算法(FCFS)：按照进程进入就绪队列的先后次序来分配CPU，一旦一个进程占有CPU，就一直运行下去，知道该进程完成工作，才释放CPU。
2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列，进程调度程序总是选择队列中的第一个进程执行，且仅能执行一个时间片，在使用完一个时间片后，即使进程并未完成其运行，也必须将CPU交给下一个进程；如果一个时间片未使用完就完成了该进程，则剩下的时间分配给下一个进程。
3.优先权调度算法；在创建进程时就确定优先权，确定之后在整个程序运行期间不再改变，根据优先级排列，系统会把CPU分配给优先权最高的进程。
三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义：PCB块结构体类型struct PCB{int name;int arrivetime; //到达时间int servicetime; //服务时间//int starttime[max]; //开始时间int finishtime; //完成/结束时间int turntime; //周转时间int average_turntime; //带权周转时间int sign; //标志进程是否完成int remain_time; //剩余时间int priority; //优先级}pcb[max];主程序的流程以及各程序模块之间的层次(调用)关系：主程序中从键盘得到进程的数量，创建PCB，调用layout（）函数显示选择界面。
Layout（）函数中选择相应的算法并调用相关函数如：FCFS()、time_segment();、Priority()，这三个函数分别实现先来先服务算法，时间片轮转算法和优先级算法，最后分别打印。
进程调度 实验报告
一、实验目的 多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那
个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度 问题，加深对进程调度的理解。 二、实验内容 1．优先权法、轮转法
简化假设 1）进程为计算型的（无 I/O） 2）进程状态：ready、running、finish 3）进程需要的 CPU 时间以时间片为单位确定 2．算法描述 1） 优先权法——动态优先权
/*******************优先权调度算法所需函数 *****************************************************/ struct process1*creatlist1(int n) {
srand((int)time(0)); struct process1 *first =new process1; first ->next=NULL; for (int i=0;i<n;i++) {
struct process1 *s; s =new process1; s->pcb =i; s-> privilege=random(20)+5; s->cpu=random(20)+1; insert1(first,s ); } return first; } void insert1(struct process1 *first,struct process1 *s) //插入节点 { struct process1 *p=search(first,s); s->next=p->next; p->next=s; //return; }
调度算法实验报告总结(3篇)
第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程，加深对进程调度算法的理解。
实验中，我们重点研究了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种常见的调度算法。
通过编写C语言程序模拟这些算法的运行，我们能够直观地观察到不同调度策略对进程调度效果的影响。
二、实验内容1. 数据结构设计在实验中，我们定义了进程控制块（PCB）作为进程的抽象表示。
PCB包含以下信息：- 进程编号- 到达时间- 运行时间- 优先级- 状态（就绪、运行、阻塞、完成）为了方便调度，我们使用链表来存储就绪队列，以便于按照不同的调度策略进行操作。
2. 算法实现与模拟（1）先来先服务（FCFS）调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。
在模拟过程中，我们首先将所有进程按照到达时间排序，然后依次将它们从就绪队列中取出并分配CPU资源。
（2）时间片轮转（RR）调度算法RR算法将CPU时间划分为固定的时间片，并按照进程到达就绪队列的顺序轮流分配CPU资源。
当一个进程的时间片用完时，它将被放入就绪队列的末尾，等待下一次调度。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度。
在模拟过程中，我们为每个进程分配一个优先级，并按照优先级从高到低的顺序进行调度。
3. 输出调度结果在模拟结束后，我们输出每个进程的调度结果，包括：- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时，我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。
三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现，但可能会导致进程的响应时间较长，尤其是在存在大量短作业的情况下。
此外，FCFS算法可能导致某些进程长时间得不到调度，造成饥饿现象。
2. 时间片轮转（RR）调度算法RR算法能够有效地降低进程的响应时间，并提高系统的吞吐量。
然而，RR算法在进程数量较多时，可能会导致调度开销较大。
进程调度实验报告
操作系统实验 报告实验项目： 进程调度学 院： 计算机学院专 业：班 级：学 号：姓 名：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．模拟批处理多道操作系统的进程调度；2．模拟实现同步机构避免并发进程执行时可能与时间相关的错误；二、实习目的进程调度时进程管理的主要内容之一，通过设计，编制，调试一个简单的进程调度模拟系统，对进程调度，进程运行状态变换及PV操作加深理解和掌握。
三、实习题目采用剥夺式优先算法，对三个进程进行模拟调度模拟PV操作同步机构，用PV操作解决进程进入临界区的问题。
【提示】（1）对三个进程进行模拟调度，对各进程的优先数静态设置，P1,P2,P3三个进程的优先数为1，2，3，并指定P1的优先数最高，P3的优先数最低，每个进程都处于执行态“e”，就绪态“r”，等待态“w”三种状态之一，并假定初始态为“r”。
（2）每一个进程用一个PCB表，PCB表的内容根据具体情况设置，该系统在运行过程中能显示或打印各进程和参数的变化情况，以便观察各进程的调度。
（3）在完成必要的初始化后，便进入进程调度程序，首先由P1进入执行，当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时，转进程调度。
（4）在进入临界区前后，调PV操作。
（5）如果被唤醒的进程优先数高于现有执行的进程，则剥夺现行进程的执行权。
（6）当三个进程都处于等待状态时，本模拟系统退出执行。
四、示例1.数据结构：（1）进程控制块PCBstruct{int id;char status;int priority;int waiter1;}（2）信号量struct{int value;int waiter2;}sem[2]（3）现场保护栈stackchar stack[11][4]每个进程都有一个大小为10个字的现场保护栈，用来保护被中断时的断点地址等信息。
（4）全局变量int i;用以模拟一个通用寄存器char addr;用以模拟程序计数器int m1,m2;为系统设置的公用数据被三个进程共享使用。
五、程序框图：六、程序说明：本程序是用C语言编写，模拟三个进程的运行情况，过程在运行中要调用P操作申请信号量，如果该过程得到其申请的信号量，就继续运行，否则P操作阻塞该申请过程的运行，并将过程置为所申请信号量的等待者，如果已有其它过程在等待同一信号量则将该申请过程排在所有等待进程之后。
进程调度实验报告范文
进程调度实验报告范文i快鬲紳狡犬爹整芦SHAAN某IUNIVERSITYOFSCIENCE&TECHNOLOG￥操作系统实验报告实验1进程调度算法报告日期：2022-6-10姓名:学号:班级:任课教师:实验1进程调度算法一、实验内容按优先数调度算法实现处理器调度。
二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
三、实验原理设计一个按优先数调度算法实现处理器调度的程序。
假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：进程名指针要求运行时间优先数状态其中，进程名一一作为进程的标识，假设五个进程的进程名分别为Pi，P2,P3,P4,P5。
指针一一按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”要求运行时间一一假设进程需要运行的单位时间数。
优先数一一赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪”状态和“结束”状态。
五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
为了调度方便，把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程，用指针指出队列的连接情况。
例：队首标志K2KiPiK2P2K3P3K4P4K5P5K4K5K3K12312415342RRRRRPCB1PCB2PCB3PCB4PCB5处理器调度总是选队首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行,而是执行：优先数-1要求运行时间-1来模拟进程的一次运行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一、进程调度实验报告广东技术师范学院实验报告学院：计算机科学学院专业：计算机科学与技术（师范）班级：成绩：姓名：学号：组别：组员：实验地点：实验日期：指导教师签名：实验名称：实验一、进程调度实验一、实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解二、实验类别综合性实验。
综合高级语言编程、进程调度模型、进程调度算法及数据结构等多方面的知识三、实验内容和步骤1．编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。
“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。
动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。
例如：在进程获得一次CPU后就将其优先数减少1。
或者，进程等待的时间超过某一时限时增加其优先数的值，等等该题根据老师给的代码用Visual C++运行，结果以及分析如下：预习情况操作情况考勤情况数据处理情况结果分析：根据上述输入的三个进程的信息可以得到：优先级最高的是进程cc 最先调度进程cc的状态为运行态，需要执行的时间为10当前就绪队列状态为：进程aa先级比较高，处于就绪队列前面，而进程bb先级是三者中最低的，所以处于就绪队列的最后。
而此时这两个进程的状态都为就绪态。
结果分析：当进程cc了一个时间片之后而它已占用CPU时间已达到所需要的运行时间，则将它的优先级减1之后，再将三个进程按优先级的大小排列，从中选择优先级大的进程进入运行状态，则该次进入运行态的是进程aa按照这种方式一直运行下去：直到:结果分析：当进程bb的CPU占用时间等于它需要的执行时间时，进程bb度完成。
则这时进程调度中还有两个进程：进程aa进程cc结果分析：当调度进程中只剩下进程aa程cc这时根据进程优先级的大小，进程aa入运行态。
当进程aa调度时，进程调度程序中直剩下进程cc这时进程cc进入运行态，而当前就绪队列将为空。
直到：结果分析：当进程i的CPU占用时间等于所需要的执行时间时，进程cc调度完成，则这时进程调度中已经没有需要调度的进程了，则整个进程调度完成。
2、编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。
轮转法可以是简单轮转法、可变时间片轮转法，或多队列轮转法。
简单轮转法的基本思想是：所有就绪进程按 FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。
如果运行进程用完它的时间片后还为完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。
直至所有的进程运行完毕。
将老师给的源程序修改成简单的时间片轮转法流程图如下：进程完就绪队列首进时间片到，运行进程已占用把运行进程插入开始 初始化PCB,输所有各进程按FCFS 原则时间片轮转法 #include<stdio.h> #include<stdlib.h> #include<conio.h>#define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0#define TIME 2//时间片长度 /////////////typedef struct pcb{ //////进程管理块char name[10];///////进程名字char state; ///////进程状态int queue; //////进程所在的队列int ntime; /////进程需要运行的时间int rtime; //////进程已经运行的时间int etime; ////进程在本队列可运行的时间片struct pcb *link;}PCB;PCB *ready = NULL, *pinsert = NULL, *pfend = NULL,*p =NULL; /*就绪队列，进程插入位置的变量*/int geti() //使用户仅能输入整数{char ch;int i = 0;fflush(stdin);ch = getchar();while(ch == '\n'){printf("\tf输入不能为空..请重新输入\n");fflush(stdin);ch = getchar();}while(ch != '\n'){if(ch > '9' || ch < '0'){printf("\t输入有误!!输入只能为正整数，请重新输入...\n");fflush(stdin);i = 0;ch = getchar();}else{i = i*10 + (ch - '0');ch = getchar();}}return i;}void findpos()///////更新状态量{PCB *ps = pfend;if(!ps || !ps -> link || (ps-> link->queue - ps->queue) > 1) pinsert = ps;else{while (ps->link && ps ->link->queue != (pfend ->queue +2)) ps = ps->link;pinsert = ps;}}void insert()//////插入进程{if(!ready ){ready = p;pfend = p;pinsert = p;}else if(ready ->queue == 1) //////第一队列存在{ p->link = pfend->link;pfend->link = p;pfend = p;findpos();}Else{p->link = ready;ready = p;findpos();}}void input()/*建立进程控制块函数*/ {int i,num;printf("\n请输入进程的个数："); num = geti();for(i=0; i < num; i++){printf("\n进程号No.%d:\n",i+1);p=getpch(PCB);printf("\n输入进程名:");scanf("%s",p->name);printf("\n输入进程运行时间:");p ->ntime = geti();printf("\n");p->rtime=0;p->state='w';p->queue =1;p->etime = TIME;p->link=NULL;insert();/*调用insert函数*/}}void disp(PCB *pr)/*建立进程现实函数，用于显示当前进程*/{printf("\nname\t state\t queue\t ntime\t rtime\t在队列可停留时间\t \n");printf("|%s\t",pr->name);printf(" |%c\t",pr->state);printf(" |%d\t",pr->queue);printf(" |%d\t",pr->ntime);printf(" |%d\t",pr->rtime);printf(" |%d\t",pr->etime);printf("\n");}void check()/*建立进程查看函数*/{PCB *pr;printf("\n ****当前正在运行的进程是:%s",ready->name);/*显示当前运行的进程*/disp(ready);pr= ready ->link;printf("\n****当前就绪队列状态为:\n");/*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}void sort()//调整进程队列{if(!ready->link ||ready->queue < ready->link->queue) return;p = ready ->link;ready ->link = pinsert ->link;pinsert ->link = ready;pinsert = ready;ready = p;if (ready && ready -> queue == pinsert ->queue){findpos();}}void addnew()//添加新的进程{if(ready ->queue != 1){(ready -> queue)++;ready->etime *= 2;ready -> state='w';sort();/*调用sort函数*/input();}else{input();}}void destroy()/*建立进程撤销函数(进程运行结束，撤销进程)*/ {printf("\n进程[%s]已完成.\n",ready->name);p = ready;ready = ready->link;free(p);if (ready && ready -> queue == pinsert ->queue)findpos();}void running()/*建立进程就绪函数(进程运行时间到，置就绪状态)*/ {(ready -> rtime)++;ready ->etime --;if(ready->rtime == ready->ntime){destroy();return;}else if(ready ->etime == 0){int time = 2;(ready -> queue)++;for(int i = 2; i != ready->queue; ++i)time *= 2;ready->etime = time;ready -> state='w';sort();/*调用sort函数*/}}void main(){char ch;input();while(ready != NULL){printf("\nThe execute name:%s\n",ready ->name);ready ->state = 'R';check();running();printf("\n按i键添加新进程....按其他任意键继续运行...");fflush(stdin);ch = getchar();if (ch == 'i'|| ch=='I')addnew();}printf("\n\n 进程已经完成\n");getchar();}运行结果如下：根据题意输入五个进程按任意键继续四、实验问题及原因(1)本次试验，思路设计不难在这个多级反馈的实验中，我采取了用一条实际上的链表队列来模拟多个逻辑上的队列，通过维护几个链表的状态信息来找到每个进程运行完后应该插入的地方，还有一个标志位Fend用来表明新插入的队列的位置。