实验一：进程调度实验报告书
进程调度程序实验报告
一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。
二、实验环境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分析：先来先服务调度算法简单直观，但对于短作业可能会造成较长的等待时间，导致平均等待时间和平均周转时间较长。
操作系统进程调度实验报告
《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号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算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
进程的调度实验报告(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个进程的“优先数”和“要求运行时间”，也有显示或打印语句，能显示或打印每次被选中进程的进程名、运行一次后队列的变化，以及结束进程的进程名。
实验一进程调度实验报告书
淮海工学院计算机工程学院实验报告书课程名：《操作系统原理A》题目：进程调度班级：软件132学号：2013122907姓名：孙莹莹操作系统原理实验——进程调度实验报告一、目的与要求1）进程是操作系统最重要的概念之一，进程调度是操作系统内核的重要功能，本实验要求用C 语言编写一个进程调度模拟程序，使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
2）按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）3）于2015年4月18日以前提交本次实验报告（含电子和纸质报告，由学习委员以班为单位统一打包提交）。
二、实验内容或题目1）设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2）模拟调度程序可任选两种调度算法之一实现（有能力的同学可同时实现两个调度算法）。
3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
4）本次实验内容（项目）的详细说明以及要求请参见实验指导书。
三、实验步骤与源程序（1）流程图（2）实验步骤1）PCB的结构：优先级算法中，设PCB的结构如下图所示，其中各数据项的含义如下：Id：进程标识符号，取值1—5。
Priority：优先级，随机产生，范围1—5。
Used：目前已占用的CPU时间数，初值为0；当该进程被调用执行时，每执行一个时间片，Used加1。
Need：进程尚需的CPU时间数，初值表示该进程需要运行的总时间，取值范围为5—10。
并随机产生，每运行一个时间片need减1；need为0则进程结束。
Status：进程状态R（运行），W（就绪），F（完成）；初始时都处于就绪状态。
Next：指向就绪队列中下一个进程的PCB的指针。
2）初始状态及就绪队列组织：5个进程初始都处于就绪状态，进程标识1—5，used初值都为0。
各进程的优先级随机产生，范围1—5。
处于就绪状态的进程，用队列加以组织，队列按优先级由高到低依次排列，队首指针设为head，队尾指针为tail。
操作系统(进程调度)实验报告
操作系统原理（进程调度）实验报告实验一：动态优先权一．实验目的：（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; }
实验一：进程调度实验报告书
实验一：进程调度实验报告书淮海工学院计算机科学系实验报告书课程名:《操作系统原理》题目: 进程调度班级: 网络091学号: 110912133姓名: 钟学圣评语:成绩: 指导教师:批阅时间: 年月日《操作系统原理》实验报告 - 1 -操作系统原理实验——进程调度实验报告一、目的与要求1)进程是操作系统最重要的概念之一，进程调度是操作系统内核的重要功能，本实验要求用C语言编写一个进程调度模拟程序，使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序，提交程序清单及及相关2实验数据与运行结果)3)于2011年10月22日以前提交本次实验报告(含电子和纸质报告，由学习委员以班为单位统一打包提交)。
2 实验内容或题目1)设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。
3)程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。
3 实验步骤与源程序(1) 编写进程控制块数据结构typedef struct node{char name[10];/*进程名*/int prio; /*进程优先级*/int round; /*循环轮转法进程每次轮转的时间片*/int cputime; /*进程累计消耗的CUP时间*/int needtime; /*进程到完成还需要的CUP时间*/int count; /*循环轮转法一个是时间片内进程运行时间*/char state; /*进程的状态:'R':运行,'W':等待,'F':结束*/struct node *next;/*指向下一个进程的链指针*/}PCB;(2)在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中void prior_init(char chose)/*进程优先级法初始化将进程按优先级插入到就绪队列里*/{PCB *p;int i,time1;char na[10];ready=NULL;finish=NULL;run=NULL;《操作系统原理》实验报告 - 2 -printf("\t\t进程优先级算法模拟全过程\n\n");printf("输入进程的个数 N:\n");scanf("%d",&N); for(i=0;i<N;i++)(3)进程优先级法初始化将进程按优先级插入到就绪队列里void prior_init(char chose)/*进程优先级法初始化将进程按优先级插入到就绪队列里*/ {PCB *p;int i,time1;char na[10];ready=NULL;finish=NULL;run=NULL;printf("\t\t进程优先级算法模拟全过程\n\n");printf("输入进程的个数 N:\n");scanf("%d",&N); for(i=0;i<N;i++)(4)进程优先级算法总函数void priority(char chose)//进程优先级算法总函数 { int i=1;while(run!=NULL){run->cputime+=1;run->needtime-=1;run->prio-=1;if(run->needtime==0){run->next=finish;finish=run;run->state='F';run->prio=0;run=NULL;firstin(); }else{if((ready!=NULL)&&(run->prio<ready->prio)) {run->state='W';insert_prio(run);run=NULL;firstin();}《操作系统原理》实验报告 - 3 -}详细代码:#include <stdio.h>#include <stdlib.h>#include <string.h>#include <windows.h>#include <time.h>/*进程控制块数据结构*/typedef struct node{char name[10];/*进程名*/int prio; /*进程优先级*/int round; /*循环轮转法进程每次轮转的时间片*/ int cputime; /*进程累计消耗的CUP时间*/int needtime; /*进程到完成还需要的CUP时间*/int count; /*循环轮转法一个是时间片内进程运行时间*/ char state; /*进程的状态:'R':运行,'W':等待,'F':结束*/ struct node *next;/*指向下一个进程的链指针*/ }PCB;PCB *finish,*ready,*tail,*run;/*指向三个队列的队首的指针，finish为完成队列头指针，ready为就绪队列头指针，tail为就绪队列的队尾指针，run为当前运行进程头指针*/int N;/*定义进程的数目*/void firstin(void); //调度就绪队列的第一个进程投入运行; voidprint1(char a); //打印表头行信息void print2(char chose,PCB *p); //打印每一行的状态信息 voidprint(char chose); //打印每执行一次算法后所有的进程的状态信息 void insert_prio(PCB *q); //在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中;void prior_init(char chose); //进程优先级法初始化将进程按优先级插入到就绪队列里void priority(char chose); //进程优先级算法总函数 void insert_rr(PCB *q); //在轮转法中，将执行了一个时间片单位(为2)，但尚未完成的进程的PCB，插到就绪队列的队尾;void roundrun_init(char chose); //循环轮转法初始化将就绪队列保存为FIFO队列void roundrun(char chose); //循环轮转法总算法void main()//主函数{char chose=' ';《操作系统原理》实验报告 - 4 -while((chose!='e')&&(chose!='E')){fflush(stdin);system("cls");printf("\t\t\t两种进程调度算法的模拟\n\n");printf("\tP.进程优先级算法模拟\n\n"); printf("\tR.循环轮转算法模拟\n\n"); printf("\tE.推出程序\n\n");printf("\t请输入你的选择:");scanf("%c",&chose);if((chose!='e')&&(chose!='E')){system("cls");if((chose=='P')||(chose=='p')){prior_init(chose);priority(chose);system("cls");}else if((chose=='r')||(chose=='R')) {roundrun_init(chose);roundrun(chose);system("cls");}}}printf("\n\t\t谢谢使用～～～\n");}void firstin(void)//调度就绪队列的第一个进程投入运行; { if(ready!=NULL){run=ready;ready=ready->next;run->state='R';run->next=NULL;}else《操作系统原理》实验报告 - 5 -{run=NULL;}}void print1(char a)//打印表头行信息{if(toupper(a)=='P'){printf("name cputime needtime priority state \n");}else{printf("name cputime needtime count round state \n"); }}void print2(char chose,PCB *p)//打印每一行的状态信息 {if(toupper(chose)=='P') {printf("%s\t%d\t%d\t%d\t %c\n",p->name,p->cputime,p->needtime,p->prio,p->state);}else{printf("%s\t%d\t%d\t%d\t%d\t%c\n",p->name,p->cputime,p->needtime,p->count,p->round,p->state);}}void print(char chose)//打印每执行一次算法后所有的进程的状态信息{PCB *p;print1(chose);if(run!=NULL){print2(chose,run);}p=ready;while(p!=NULL){print2(chose,p);p=p->next;}《操作系统原理》实验报告 - 6 -p=finish;while(p!=NULL){print2(chose,p);p=p->next;}}void insert_prio(PCB *q)/*在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中;*/ {PCB *p,*s,*r; /*p,r用来控制就绪队列滚动，S指向插入的队列*/s=q;p=ready;r=p;if(s->prio>ready->prio)// 要插入的进程的优先级大于ready的优先级{s->next=ready;ready=s;}else//要插入的进程的优先级不大于ready的优先级 {while(p){if(p->prio>=s->prio) {r=p;p=p->next;}elsebreak;} //找到要插入的位置s->next=p;r->next=s;}}void prior_init(char chose)/*进程优先级法初始化将进程按优先级插入到就绪队列里*/ {PCB *p;int i,time1;char na[10];ready=NULL;《操作系统原理》实验报告 - 7 -finish=NULL;run=NULL;printf("\t\t进程优先级算法模拟全过程\n\n"); printf("输入进程的个数 N:\n");scanf("%d",&N); for(i=0;i<N;i++){p=(PCB*)malloc(sizeof(PCB));printf("输入第%d个进程名\n",i+1); scanf("%s",na);printf("完成进程需要的时间片数\n"); scanf("%d",&time1); strcpy(p->name,na); p->cputime=0;p->needtime=time1; p->state='W';srand((unsigned)time(NULL));//用当前时间，设置种子int ss=1+rand()%6; p->prio=ss;//设置进程优先值初值if(ready==NULL){ready=p;ready->next=NULL; }else{insert_prio(p); }printf("当前就绪队列的进程的信息\n"); print(chose);}printf("%d个进程已按优先级从高到低进到就绪队列中\n",N);printf("按回车键开始模拟优先级算法.....\n");fflush(stdin);getchar();firstin();}void priority(char chose)//进程优先级算法总函数 {int i=1;while(run!=NULL){run->cputime+=1;《操作系统原理》实验报告 - 8 -run->needtime-=1;run->prio-=1;if(run->needtime==0) {run->next=finish;finish=run;run->state='F';run->prio=0;run=NULL;firstin(); }else{if((ready!=NULL)&&(run->prio<ready->prio)) {run->state='W';insert_prio(run);run=NULL;firstin();}}printf("第%d次执行优先级算法\n",i++);print(chose);if(run){printf("按回车键继续下一次优先级算法.....\n");}elseprintf("优先级算法模拟过程结束～～\n");fflush(stdin);getchar();}}void insert_rr(PCB *q)//在轮转法中，将执行了一个时间片单位(为2)，//但尚未完成的进程的PCB，插到就绪队列的队尾; {tail->next=q;tail=q;q->next=NULL;}void roundrun_init(char chose)/*循环轮转法初始化将就绪队列保存为FIFO队列*/《操作系统原理》实验报告 - 9 -{PCB *p;int i,time1;char na[10];ready=NULL;finish=NULL;run=NULL;printf("\t\t循环轮转算法模拟全过程\n\n");printf("输入进程的个数 N:\n");scanf("%d",&N); for(i=0;i<N;i++){p=(PCB*)malloc(sizeof(PCB));printf("输入第%d个进程名\n",i+1); scanf("%s",na);printf("完成进程需要的时间片数\n"); scanf("%d",&time1); strcpy(p->name,na); p->cputime=0;p->needtime=time1; p->count=0;p->state='W';p->round=2;if(ready!=NULL){insert_rr(p);}else{p->next=ready;ready=p;tail=p;}printf("当前就绪队列的进程的信息\n"); print(chose); }printf("%d个进程已按FIFO进到就绪队列中\n",N); printf("按回车键开始模循环轮转算法.....\n");fflush(stdin);getchar();run=ready;ready=ready->next; run->state='R';}void roundrun(char chose)//循环轮转法总算法《操作系统原理》实验报告 - 10 -{int i=1;while(run!=NULL){run->cputime+=1;run->needtime-=1; run->count+=1;if(run->needtime==0) {run->next=finish;finish=run;run->state='F';run->prio=0;run=NULL;if(ready!=NULL){firstin();}}else{if(run->count==run->round){run->count=0;if(ready!=NULL){run->state='W';insert_rr(run);firstin();}}}printf("第%d次执行循环轮转算法\n",i++);print(chose);if(run){printf("按回车键继续下一次循环轮转算法.....\n"); }elseprintf("循环轮转算法模拟过程结束～～\n"); fflush(stdin);getchar();}}《操作系统原理》实验报告 - 11 -4 测试数据与实验结果(可以抓图粘贴)一、使用优先级实现进程调度1. 输入以下数据，并且随机产生1—5优先级2.按回车开始模拟优先级算法《操作系统原理》实验报告 - 12 - 3.运行结果二、时间片轮转算法1. 输入以下数据2. 开始模拟运行《操作系统原理》实验报告 - 13 - 3. 运行结束5 结果分析与实验体会经检查，所运行结果正确。
进程调度实验报告
操作系统实验 报告实验项目： 进程调度学 院： 计算机学院专 业：班 级：学 号：姓 名：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)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。
操作系统进程调度实验报告
实验一进程调度实验专业：XXXXX学号：XXXXX：XXX实验日期：20XX年XX月XX日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法容1. 算法设计思路将每个进程抽象成一个控制块PCB ， PCB 用一个结构体描述。
构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。
还有一个PCB 实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的PCB 展开。
主要用到的技术是STL 中的vector 以维护和保存进程容器、就绪容器、完成容器。
当程序启动时，用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。
进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2. 算法流程图 主程序的框架：();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先.m_WaitQueue .empty ()||.m_ProcessQueue .empt ()();//输入进程信息();();进程调度过程：;3.算法中用到的数据结构struct fcfs{ //先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;}; //定义一个结构体，里面包含的有一个进程相关的信息4.主要的常量变量vector<PCB>m_ProcessQueue;//进程输入队列vector<PCB>m_WaitQueue;//进程就绪队列vector<PCB>m_FinishQueue;//完成队列vector<PCB>::iterator m_iter;//迭代器PCB m_runProcess;//运行中的进程int m_ProcessCount;//进程数float m_RunTime;//运行时间int m_tagIsRun;//是否在运行标志。
操作系统实验之进程调度报告
实验一:进程调度一、实习内容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)。
淮海工学院计算机科学系实验报告书课程名：《操作系统原理A》题目：进程调度班级：软件1学号：201112258姓名：操作系统原理实验——进程调度实验报告一、目的与要求1）进程是操作系统最重要的概念之一，进程调度是操作系统内核的重要功能，本实验要求用C语言编写一个进程调度模拟程序，使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
2）按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）3）于2013年10月22日以前提交本次实验报告（含电子和纸质报告，由学习委员以班为单位统一打包提交）。
2 实验内容或题目1）设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2）模拟调度程序可任选两种调度算法之一实现（有能力的同学可同时实现两个调度算法）。
3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
4）本次实验内容（项目）的详细说明以及要求请参见实验指导书。
3 实验步骤与源程序1.PCB的结构：优先级算法中，设PCB的结构如右图所示，其中各数据项的含义如下：Prior：优先级，随机产生，范围1—5。
Used：目前已占用的CPU时间数，初值为0；当该进程被调用执行时，每执行一个时间片，Used加1。
Need：进程尚需的CPU时间数，初值表示该进程需要运行的总时间，取值范围为5—10。
并随机产生，每运行一个时间片need减1；need为0则进程结束。
Status：进程状态R（运行），J（就绪），F（完成）；初始时都处于就绪状态。
Next：指向就绪队列中下一个进程的PCB的指针。
2.初始状态及就绪队列组织：5个进程初始都处于就绪状态，进程标识1—5，used初值都为0。
各进程的优先级随机产生，范围1—5。
处于就绪状态的进程，用队列加以组织，队列按优先级由高到低依次排列，队首指针设为head，队尾指针设为tail。
3.调度原则以及运行时间的处理：正在执行的进程每执行一个时间片，其优先级减1（允许优先级为负）。
进程调度将在以下情况发生：当正在运行的程序其优先级小于就绪队列队首进程的优先级时。
程序中进程的运行时间以逻辑时间片为单位。
4.流程图:5.源程序:#include <string>#include <iomanip>#include <iostream>#define N 5using namespace std;struct Gzuo{char Id;int Arrtime;int Sevtime;int Fintime;int Runtime;float Wtime;};Gzuo jobline[N];void Menu(){cout<<"┌─────────┐"<<endl;cout<<"│作业调度程序│"<<endl; cout<<"├─────────┤"<<endl; cout<<"│ a.数据输入│"<<endl; cout<<"│ b.FCFS算法│"<<endl; cout<<"│ c.SJF 算法│"<<endl; cout<<"│ d.退出│"<<endl; cout<<"└─────────┘"<<endl; cout<<"请输入操作序号a-d:";}void Input(){for(int b=0;b<N;b++){cout<<"作业编号(0-4):";cin>>jobline[b].Id;cout<<"到达时间(单位为分钟):";cin>>jobline[b].Arrtime;cout<<"服务时间(单位为分钟):";cin>>jobline[b].Sevtime;}void FCFS(){int b,j,i;float t=0;float time1=0.00,time2=0.00;int temp;int TempArr,TempSev;for(b=0;b<N;b++){for(j=0;j<b;j++)if(jobline[b].Arrtime<jobline[j].Arrtime){temp=jobline[j].Id;jobline[j].Id=jobline[b].Id;jobline[b].Id=temp;TempArr=jobline[j].Arrtime;jobline[j].Arrtime=jobline[b].Arrtime;jobline[b].Arrtime=TempArr;TempSev=jobline[j].Sevtime;jobline[j].Sevtime=jobline[b].Sevtime;jobline[b].Sevtime=TempSev;}}cout<<"┌────────┬────┬────┬────┬────┬────┐"<<endl;cout<<"│FCFS运行顺序"<<" "<<"│";for( b=0;b<N;b++){cout<<setw(8)<<jobline[b].Id<<"│";}cout<<endl;jobline[0].Fintime=jobline[0].Sevtime-jobline[0].Arrtime;for(b=1;b<N;b++){jobline[b].Fintime=jobline[b-1].Fintime+jobline[b].Sevtime;cout<<"├────────┼────┼────┼────┼────┼────┤"<<endl;cout<<"│完成时间分别"<<" "<<"│";for(b=0;b<N;b++){cout<<setw(8)<<jobline[b].Fintime<<"│";}cout<<endl;jobline[0].Runtime=jobline[0].Sevtime-jobline[0].Arrtime;for(b=1;b<N;b++){jobline[b].Runtime=jobline[b-1].Fintime+jobline[b].Sevtime-jobline[b].Arrtime;}cout<<"├────────┼────┼────┼────┼────┼────┤"<<endl;cout<<"│周转时间分别"<<" "<<"│";for(b=0;b<N;b++){cout<<setw(8)<<jobline[b].Runtime<<"│";}cout<<endl;for(b=0;b<N;b++){jobline[b].Wtime=(float)jobline[b].Runtime/(float)jobline[b].Sevtime;}cout<<"├────────┼────┼────┼────┼────┼────┤"<<endl;cout<<"│带权周转时间"<<" "<<"│";for(b=0;b<N;b++){cout<<setw(8)<<jobline[b].Wtime<<"│";}cout<<endl;cout<<"├────────┼────┴────┴────┴────┴────┤"<<endl;time1+=jobline[b].Runtime;time2+=jobline[b].Wtime;}cout<<"│平均周转时间│"<<" "<<setw(8)<<time1<<" │"<<endl;cout<<"├────────┼────────────────────────┤"<<endl;cout<<"│平均带权周转时间│"<<" "<<setw(8)<<time2<<" │"<<endl;cout<<"└────────┴────────────────────────┘"<<endl;}void SJF(){int b,j,i;float t=0;float time1=0.00,time2=0.00;int temp;int TempArr,TempSev;for(b=0;b<N;b++){for(j=0;j<b;j++)if(jobline[b].Arrtime<jobline[j].Arrtime){temp=jobline[j].Id;jobline[j].Id=jobline[b].Id;jobline[b].Id=temp;TempArr=jobline[j].Arrtime;jobline[j].Arrtime=jobline[b].Arrtime;jobline[b].Arrtime=TempArr;TempSev=jobline[j].Sevtime;jobline[j].Sevtime=jobline[b].Sevtime;jobline[b].Sevtime=TempSev;}}for(j=1;j<b;j++){int temp;if(jobline[b].Sevtime<jobline[j].Sevtime){temp=jobline[b].Id;jobline[b].Id=jobline[j].Id;jobline[j].Id=temp;temp=jobline[b].Arrtime;jobline[b].Arrtime=jobline[j].Arrtime;jobline[j].Arrtime=temp;temp=jobline[b].Sevtime;jobline[b].Sevtime=jobline[j].Sevtime;jobline[j].Sevtime=temp;}}}cout<<"┌────────┬────┬────┬────┬────┬────┐"<<endl;cout<<"│SJF运行顺序"<<" "<<"│";for( b=0;b<N;b++){cout<<setw(8)<<jobline[b].Id<<"│";}cout<<endl;jobline[0].Fintime=jobline[0].Sevtime-jobline[0].Arrtime;for(b=1;b<N;b++){jobline[b].Fintime=jobline[b-1].Fintime+jobline[b].Sevtime;}cout<<"├────────┼────┼────┼────┼────┼────┤"<<endl;cout<<"│完成时间"<<" "<<"│";for(b=0;b<N;b++){cout<<setw(8)<<jobline[b].Fintime<<"│";}cout<<endl;jobline[0].Runtime=jobline[0].Sevtime-jobline[0].Arrtime;for(b=1;b<N;b++){jobline[b].Runtime=jobline[b-1].Fintime+jobline[b].Sevtime-jobline[b].Arrtime;}cout<<"├────────┼────┼────┼────┼────┼────┤"<<endl;cout<<"│周转时间"<<" "<<"│";for(b=0;b<N;b++){cout<<setw(8)<<jobline[b].Runtime<<"│";}cout<<endl;for(b=0;b<N;b++){jobline[b].Wtime=(float)jobline[b].Runtime/(float)jobline[b].Sevtime;}cout<<"├────────┼────┼────┼────┼────┼────┤"<<endl;cout<<"│带权周转时间"<<" "<<"│";for(b=0;b<N;b++){cout<<setw(8)<<jobline[b].Wtime<<"│";}cout<<endl;for(b=0;b<N;b++){time1+=jobline[b].Runtime;time2+=jobline[b].Wtime;}cout<<"├────────┼────┴────┴────┴────┴────┤"<<endl;cout<<"│平均周转时间│"<<" "<<setw(8)<<time1<<" │"<<endl;cout<<"├────────┼────────────────────────┤"<<endl;cout<<"│平均带权周转时间│"<<" "<<setw(8)<<time2<<" │"<<endl;cout<<"└────────┴────────────────────────┘"<<endl;}void main(){char n;while(1){Menu();cin>>n;switch(n){case 'a':Input();continue;case 'b':FCFS();continue;case 'c':SJF();continue;case 'd':exit(0);default:cout<<"输入错误,请重新输入"<<endl;continue;}}}4 测试数据与实验结果（可以抓图粘贴）5 结果分析与实验体会实验中，我遇到到了一些困难，主要是些概念东西，然后通过查看本以及上网查阅相关知识，自己独立克服了这些困难。