下载文档原格式
进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中的重要组成部分，它决定了进程在CPU上的执行顺序。
合理的进程调度算法能够提高系统的性能和效率，使得多个进程能够公平地共享CPU资源。
本实验旨在通过实际操作和数据分析，探究不同的进程调度算法对系统性能的影响。
二、实验方法1. 实验环境本次实验使用了一台配置较高的计算机作为实验环境，操作系统为Windows 10。
实验中使用了C语言编写的模拟进程调度程序。
2. 实验步骤（1）编写模拟进程调度程序，实现常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（Priority）。
（2）设计一组测试用例，包括不同执行时间的进程和不同优先级的进程。
（3）运行模拟进程调度程序，记录每个进程的等待时间、周转时间和响应时间。
（4）根据实验结果分析不同进程调度算法的性能差异。
三、实验结果与分析1. 先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，即先到达的进程先执行。
实验结果显示，该算法对于执行时间较短的进程表现良好，但对于执行时间较长的进程则存在明显的不公平性。
长作业的等待时间较长，导致整体执行效率较低。
2. 最短作业优先（SJF）调度算法最短作业优先调度算法按照进程执行时间的长度进行调度，即执行时间最短的进程先执行。
实验结果显示，该算法能够最大程度地减少平均等待时间和周转时间，提高系统的执行效率。
然而，该算法对于执行时间较长的进程存在饥饿问题，即长作业可能一直等待短作业的执行，导致长作业的等待时间过长。
3. 时间片轮转（RR）调度算法时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片，每个进程按照轮流执行的方式进行调度。
实验结果显示，该算法能够保证每个进程都能够获得一定的执行时间，提高了系统的公平性。
然而，对于执行时间较长的进程而言，由于需要等待其他进程的轮转，其执行效率相对较低。
操作系统实验报告实验二时间片轮转进程调度算法学号：班级：姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的时间片轮转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算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
时间片轮转调度算法实验时间片轮转调度算法是一种基于时间片轮转的进程调度算法，它按照轮转的方式，将每个进程分配一个时间片，如果该进程在时间片结束前未完成其任务，则该进程将被挂起，然后下一个进程继续执行。
下面将从实验过程、结果分析和算法优缺点三个方面回答该问题。
实验过程：本次实验使用C语言编写程序，模拟了一个简单的时间片轮转调度算法。
实验环境为Windows 10操作系统，使用了Dev-C++ 5.11编译器。
实验流程如下：1.首先定义了一个进程的结构体，其中包括了进程的名称、进程需要执行的时间片以及已经执行的时间片。
2.定义一个队列来存储进程，为了方便起见，队列采用了循环存储结构。
3.在主函数中，首先输入需要执行的进程数和一个时间片长度，接着依次输入每个进程的名称和需要执行的时间。
程序会根据输入的信息初始化进程，并将进程加入队列。
4.最后，程序开始模拟调度器的调度过程。
每次从队列中取出一个进程，将其执行时间减去一个时间片。
如果执行时间为0，则代表该进程已经完成任务，将其移出队列。
如果执行时间大于0，则将该进程重新加入队列尾部，然后下一个进程开始执行。
结果分析：在进行实验的过程中，我们发现时间片轮转调度算法可以很好地实现多进程的调度。
通过不断地轮转时间片，每个进程都有机会被执行。
此外，该算法具有良好的响应时间和公平性，能够确保每个进程都能够在一定时间内执行一定的任务，从而提高了系统的利用率和效率。
算法优缺点：时间片轮转调度算法具有以下几个优点：1. 公平性：每个进程都能够在一定时间内获得相同的可执行时间。
2. 可控性：时间片长度可以根据需要自行改变。
3. 高效性：可以很好地支持多进程的调度，提高了系统的利用率和效率。
同时，该算法也存在一些缺点：1.时间片的长度可能对进程的执行效率产生影响，长度过长会导致进程轮转过于缓慢，降低了系统的响应速度，长度过短则会增加进程上下文切换的次数。
2. 由于算法本身的局限性，它可能无法解决一些与进程先后顺序等有关的问题，例如死锁或者资源争用等。
用c语言实现时间片轮转调度算法时间片轮转调度算法是一种常见的进程调度算法，其主要思想是将所有就绪进程按顺序排列，每个进程分配一个时间片，当时间片用尽后，进程被送到队列的末尾，然后下一个进程被执行。
本文将介绍如何使用C语言实现时间片轮转调度算法。
首先，我们需要定义进程控制块（PCB），包括进程的ID、状态、优先级和时间片等信息。
可以使用结构体来表示PCB，代码如下：```typedef struct PCB {int pid; // 进程IDint status; // 进程状态（就绪、运行、等待、结束） int priority; // 进程优先级int time_slice; // 时间片} PCB;```接下来，我们需要创建一个就绪队列和一个等待队列来存储所有进程。
可以使用链表来实现队列，代码如下：```typedef struct Node {PCB *pcb; // PCB指针struct Node *next; // 指向下一个节点的指针} Node;// 就绪队列Node *ready_queue = NULL;// 等待队列Node *wait_queue = NULL;```然后，我们需要编写一个函数来创建进程并添加到就绪队列中。
该函数接受进程的ID、优先级和时间片作为参数，并返回一个指向新进程PCB的指针。
代码如下：```PCB *create_process(int pid, int priority, int time_slice) {PCB *pcb = (PCB*)malloc(sizeof(PCB));pcb->pid = pid;pcb->status = 0; // 就绪状态pcb->priority = priority;pcb->time_slice = time_slice;// 将新进程添加到就绪队列末尾Node *p = (Node*)malloc(sizeof(Node));p->pcb = pcb;p->next = NULL;if (ready_queue == NULL) {ready_queue = p;} else {Node *q = ready_queue;while (q->next != NULL) {q = q->next;}q->next = p;}return pcb;}```接下来，我们需要编写一个函数来模拟时间片轮转调度算法。
一、实验目的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算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
第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("无效的调度算法选择。
时间片轮转调度算法实验报告一、引言时间片轮转调度算法是一种常见的操作系统调度算法，它的主要思想是将CPU时间分成若干个时间片，每个进程在一个时间片内执行一定的时间，然后切换到下一个进程执行。
本实验通过使用C语言模拟实现时间片轮转调度算法，并对其进行评估和比较，以便更好地理解该调度算法的性能和特点。
二、实验目的1.理解时间片轮转调度算法的原理和实现方式；2.实现一个简单的时间片轮转调度算法模拟程序；3.比较时间片长度对调度算法性能的影响；4.分析时间片轮转调度算法的优缺点。
三、实验过程1.设计数据结构和算法在开始实验之前，我们首先需要设计数据结构和算法。
在本实验中，我们使用一个队列来表示就绪队列，并使用一个指针来标记当前执行的进程。
2.实现时间片轮转调度算法模拟程序根据设计的数据结构和算法，我们使用C语言编写了一个简单的时间片轮转调度算法模拟程序。
程序首先会要求用户输入进程数量和每个进程的执行时间，然后根据输入的信息，使用时间片轮转调度算法对进程进行调度并统计各个进程的等待时间和周转时间。
3.进行实验和分析我们进行了多组实验，通过改变时间片的长度，观察时间片轮转调度算法的性能。
并对实验结果进行统计和分析，比较不同时间片长度下的平均等待时间和平均周转时间。
四、实验结果和分析在本节，我们将介绍实验的结果和分析。
1.实验结果我们使用不同时间片长度进行了多组实验，得到了如下的结果：时间片长度，平均等待时间，平均周转时间------------，-------------，-------------1，5，152，3，134，2，128，1，112.结果分析通过对实验结果的分析，我们可以得出以下结论：-随着时间片长度的增加，进程的平均等待时间和平均周转时间都呈现下降的趋势。
这是因为时间片越长，每个进程执行的时间就越长，进程切换的次数就越少，从而提高了系统的效率。
-当时间片长度较小时，进程的平均等待时间和平均周转时间较长。
时间片轮转进程调度实验报告实验目的通过实验，掌握时间片轮转调度算法的原理和实现方法，了解进程调度的过程，掌握进程调度的基本要素和调度过程，并能够通过编程实现时间片轮转调度算法。
实验要求1. 理解时间片轮转调度的基本原理；2. 编程实现时间片轮转进程调度算法；3. 运行程序，观察并分析进程的执行情况。
实验设备计算机一台，支持多进程操作系统。
实验原理时间片轮转调度算法是一种基于时间片的进程调度算法，主要应用于多道程序环境下。
它的基本原理是将CPU的运行时间划分为一段段的时间片，在每个时间片结束时，如果进程还未完成，就将该进程挂起，将CPU分配给下一个进程执行。
通过快速切换进程，使得每个进程都能平等地获得CPU时间。
实验过程1. 定义进程控制块（PCB）的数据结构，包括进程的ID、优先级、状态、已执行时间等；2. 定义进程队列的数据结构，使用循环队列实现，用于存储待调度的进程；3. 初始化进程队列，将待调度的进程加入队列中；4. 设置时间片大小；5. 开始执行进程调度算法：a) 从队列中取出一个进程，将其状态设置为运行状态；b) 执行该进程，计算其已执行时间；c) 如果已执行时间小于时间片大小，将进程重新加入队列；d) 如果已执行时间等于时间片大小，将进程的状态设置为挂起，并将其放回队列；6. 重复步骤5，直到队列中所有进程都执行完毕。
实验结果运行该程序，可以观察到进程按照时间片轮转调度算法依次执行，每个进程都能获得一段时间的CPU执行时间，保证了进程执行的公平性。
实验总结通过本次实验，我深入了解了时间片轮转调度算法的原理和实现方法。
时间片轮转调度算法采用了循环队列的数据结构，通过设置时间片大小来控制进程的执行时间。
该算法能够使进程获得公平的CPU时间，并且能够保证每个进程都能得到一定的执行时间。
这在多道程序环境下非常重要，可以避免某个进程长时间占用CPU资源而导致其他进程无法得到执行的情况。
掌握了时间片轮转调度算法的理论和实现方法后，我能够更好地理解进程调度的过程，并能够通过编程实现对进程的调度。
时间片轮转进程调度模拟算法的实现时间片轮转进程调度算法是一种常用的进程调度算法，适用于多任务操作系统。
它采用固定长度的时间片（也称为时间量），将CPU的占用时间划分为多个时间片。
每个进程在每个时间片内被允许执行的时间是固定的，当一个进程的时间片用完时，调度器会切换到下一个进程。
实现时间片轮转进程调度算法，可以使用队列来管理进程的调度。
具体实现如下：1.定义进程和时间片的结构体：进程结构体包含进程的ID、到达时间、服务时间和剩余时间；时间片结构体包含时间片的长度和当前时间。
2.创建就绪队列和完成队列：就绪队列用于管理等待执行的进程，完成队列用于管理已经完成执行的进程。
3.输入待执行进程的信息，包括进程的ID、到达时间和服务时间。
4.将进程按照到达时间的先后顺序加入就绪队列。
5.设置当前时间为0，循环执行以下步骤直到就绪队列为空：-从就绪队列中取出第一个进程。
-如果进程剩余时间小于等于时间片长度，则执行进程的剩余时间，并将进程移动到完成队列。
-如果进程剩余时间大于时间片长度，则执行一个时间片的时间，并将进程重新加入就绪队列。
6.计算各个进程的等待时间和周转时间。
等待时间等于完成时间减去到达时间减去服务时间，周转时间等于等待时间加上服务时间。
7.计算平均等待时间和平均周转时间，分别为所有进程的等待时间和周转时间的总和除以进程数。
8.输出结果，包括进程的ID、到达时间、服务时间、完成时间、等待时间和周转时间。
以下是一个C++实现示例：```cpp#include <iostream>#include <queue>using namespace std;//进程结构体struct Processint id;int arrivalTime;int serviceTime;int remainingTime;};//时间片结构体struct TimeSlotint length;int currentTime;};int maiint n; // 进程数量queue<Process> readyQueue; // 就绪队列queue<Process> finishQueue; // 完成队列//输入进程数量和时间片长度cout << "Enter the number of processes: "; cin >> n;//输入进程信息for (int i = 0; i < n; i++)Process process;cout << "Process ID: ";cin >> process.id;cin >> process.arrivalTime;cin >> process.serviceTime;process.remainingTime = process.serviceTime; readyQueue.push(process);}int currentTime = 0;while (!readyQueue.empty()Process currentProcess = readyQueue.front(;readyQueue.pop(;currentProcess.remainingTime = 0;finishQueue.push(currentProcess);currentTime += currentProcess.remainingTime;} elsereadyQueue.push(currentProcess);}}//计算等待时间和周转时间int totalWaitingTime = 0;int totalTurnaroundTIme = 0;int numProcesses = finishQueue.size(;cout << "Process ID\tArrival Time\tService Time\tFinish Time\tWaiting Time\tTurnaround Time" << endl;while (!finishQueue.empty()Process process = finishQueue.front(;finishQueue.pop(;int waitingTime = currentTime - process.arrivalTime - process.serviceTime;int turnaroundTime = waitingTime + process.serviceTime;cout << process.id << "\t\t" << process.arrivalTime <<"\t\t" << process.serviceTime << "\t\t" << currentTime << "\t\t" << waitingTime << "\t\t" << turnaroundTime << endl;totalWaitingTime += waitingTime;totalTurnaroundTIme += turnaroundTime;}//计算平均等待时间和平均周转时间float avgWaitingTime = (float)totalWaitingTime / numProcesses;float avgTurnaroundTIme = (float)totalTurnaroundTIme / numProcesses;cout << "Average Waiting Time: " << avgWaitingTime << endl;cout << "Average Turnaround Time: " << avgTurnaroundTIme << endl;return 0;```这个示例演示了时间片轮转进程调度算法的实现过程，包括进程的输入、时间片的设置、进程的调度、等待时间和周转时间的计算，以及最后的结果输出。
第1篇一、实验背景进程调度是操作系统核心功能之一，它负责在多道程序环境下，按照一定的策略对进程进行调度，以确保系统资源的合理分配和高效利用。
为了加深对进程调度算法的理解，本次实验采用模拟的方式，实现了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种算法，并对实验过程进行了详细记录和分析。
二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。
2. 掌握进程控制块（PCB）的设计与实现。
3. 通过模拟实验，验证三种调度算法的执行效果。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 定义进程控制块（PCB）进程控制块是操作系统用于描述和管理进程的实体，它包含了进程的基本信息。
本实验中，PCB包含以下字段：- 进程ID：唯一标识一个进程。
- 到达时间：进程进入就绪队列的时间。
- 需要运行时间：进程完成所需的时间。
- 已运行时间：进程已运行的时间。
- 状态：进程当前的状态（就绪、运行、阻塞、完成）。
2. 实现三种调度算法（1）先来先服务（FCFS）算法FCFS算法按照进程到达就绪队列的顺序进行调度，先到先服务。
具体实现如下：- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，依次执行进程，直到进程完成或被阻塞。
（2）时间片轮转（RR）算法RR算法将CPU时间划分为时间片，每个进程运行一个时间片后，让出CPU，等待下一个时间片。
具体实现如下：- 设置一个时间片大小。
- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，每个进程执行一个时间片，如果进程未完成，则将其加入就绪队列队尾。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
郑州轻工业学院实验报告课程名称：操作系统姓名：学号：专业班级：任课教师：黄伟2016 年11 月 2 日实验报告成绩评定表实验报告正文实验二时间片轮转调度算法设计与实现一、实验目的目的：了解并掌握时间片轮转调度算法的理论，熟悉并掌握时间片设置的大小对系统的影响。
任务：模拟实现时间片轮转调度算法。
二、实验内容1．任务描述1）时间片轮转调度算法问题简介时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。
算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。
时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块，定义数据结构，说明进程控制块所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。
实现的过程即运用指针指向某一个进程，判断当前的进程是否是就绪状态“r”，如果是，则为该进程分配一个时间片，同时，已运行时间加一且要求运行的时间减一，如此循环执行，当某一个进程的所需要运行的时间减少至0时，则将该进程的状态设置为“e”。
然后，将指针指向下一个未运行完成的进程，重复判断，直至所有的进程都运行结束。
2）设计任务简介模拟实现时间片轮转调度算法，具体如下：设置进程体：进程名，进程的到达时间，服务时间，，进程状态（W——等待,R——运行,F——完成），进程间的链接指针进程初始化：由用户输入进程名、服务时间进行初始化，同时，初始化进程的状态为W。
显示函数：在进程调度前、调度中和调度后进行显示。
排序函数：对就绪状态的进程按照进入就绪队列的时间排序，新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。
注意考虑到达时间调度函数：每次从就绪队列队首调度优一个进程执行，状态变化。
并在执行一个时间片后化，服务时间变化，状态变化。
当服务时间为0时，状态变为F。
删除函数：撤销状态为F的进行。
2．调度问题的表示方案首先每一个进程用一个进程控制块PCB来代表。
进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 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。
实验一时间片轮转进程调度算法时间片轮转是一种常用的进程调度算法，它的基本思想是将CPU的使用时间分成若干个时间片，每个进程在一个时间片内运行一段时间。
当一个时间片用完后，就将当前进程放入就绪队列的末尾，然后选择就绪队列中的下一个进程来执行。
下面是一个简单的时间片轮转算法的实验：1. 首先，定义一个进程结构体，包括进程ID、执行时间、剩余时间等属性。
```c++struct Process {int id; // 进程IDint executionTime; // 执行时间int remainingTime; // 剩余时间Process(int id, int executionTime) {this->id = id;this->executionTime = executionTime;this->remainingTime = executionTime;}};```2. 定义一个就绪队列，用于存放所有待执行的进程。
```c++queue<Process> readyQueue;```3. 定义一个时间片大小，例如设为1。
```c++int timeSlice = 1;```4. 创建一些进程，并将它们加入就绪队列。
```c++Process p1(1, 5);Process p2(2, 3);Process p3(3, 2);Process p4(4, 4);readyQueue.push(p1);readyQueue.push(p2);readyQueue.push(p3);readyQueue.push(p4);```5. 开始执行进程调度。
```c++while (!readyQueue.empty()) {Process currentProcess = readyQueue.front(); // 获取当前要执行的进程readyQueue.pop(); // 从就绪队列中移除当前进程// 执行当前进程，更新剩余时间if (currentProcess.remainingTime > timeSlice) {currentProcess.remainingTime -= timeSlice;readyQueue.push(currentProcess); // 将剩余时间不为0的进程重新放入就绪队列} else {currentProcess.remainingTime = 0;cout << "进程" << currentProcess.id << "执行完毕。
操作系统实验报告进程调度算法的实现1.实验目的进程是操作系统最重要的概念之一，本实验通过对进程调度模拟程序的运行，学习运用时间片轮转法进行进程调度，加深对进程的基本调度状态以及进程调度算法的理解。
2.算法思想进程调度算法：采用多级反馈队列调度算法。
其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS原则排队等待高度。
当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行，以此类推。
4.算法。
5.程序代码程序的主要代码如下：#include<iostream.h>#include<stdlib.h>#include<time.h>#include<stdio.h>#include<string.h>const int MAXCOMMANDLEN =50;///////////////////////////////////////////////////////////////////////////////////////// PROCESS///////////////////////////////////////////////////////////////////////////////////////class Process{friend class CPU; //友元类protected:static int init_ID; //静态初始IDint ID; //进程IDchar runText[MAXCOMMANDLEN]; //进程指令数组int IP; //进程指令指针，保存进程指令执行到的具体位置bool ISuseSource; //进程是否使用资源（是或者否）bool ISblocked; //进程是否被阻塞（是或者否）int unitTime; //进程被cpu执行单位时间, 默认 1int blockTime; //进程被阻塞时间public:static void RandID(); //静态随机生成进程ID的函数Process(); //进程类的构造函数int getID(); //得到进程IDint getIP(); //获取进程指令指针IPvoid setIP(int); //设置IPvoid Runed(); //进程被执行int getUnittime(); //得到进程的单位执行时间2int getBlcoktime(); //得到进程被阻塞的时间void setBlocktime(int); //设置进程被阻塞的时间void setUnittime(int); //设置进程的单位执行时间char getResult(int); //得到进程被执行的结果char* getRuntext(); //得到进程执行的指令void setBlockstate(bool); //设置进程阻塞状态bool getBlockstate(); //得到进程阻塞状态bool getISusesource(); //得到资源的使用状态void setISusesource(bool); //设置资源的使用状态};int Process::init_ID; //初始化静态变量void Process::RandID() //随机产生一个进程ID{srand((unsigned)time(NULL)); //调用srand随机生成函数init_ID=rand();}Process::Process() //进程的构造函数{ID=init_ID++; //进程ID的初值为静态初始ID的值int commandLen; //命令行长度IP=0;cout<<"Please input the text which process runed by CPU [#command#] :>\\ ";cin>>runText; //输入命令if( (commandLen=strlen(runText) ) > MAXCOMMANDLEN )exit(0); //输入长度超出最大长度时退出，特殊情况处理3runText[commandLen]='#'; //初始指令结束标志 '#' runText[commandLen+1]='\0'; //字符串结束标志ISuseSource=false; //设置资源的使用状态为未使用ISblocked=false; //进程的初始状态-》未被阻塞unitTime=1; //进程被执行的单位时间为1 blockTime=0; //阻塞时间为0}void Process::Runed() //进程被CPU执行{cout<<getResult(IP++); //输出得到的进程执行结果}int Process::getID() //得到进程ID {return ID;}int Process::getIP() //得到进行IP {return IP;}void Process::setIP(int ip) //设置进程IP {IP=ip;}bool Process::getISusesource() //得到资源的使用状态{return ISuseSource;4}void Process::setISusesource(bool s) //设置资源的使用状态{ISuseSource=s;}char* Process::getRuntext() //得到进程执行的指令{return runText;}int Process::getUnittime() //得到进程的单位执行时间{return unitTime;}int Process::getBlcoktime() //得到进程阻塞状态{return blockTime;}void Process::setBlocktime(int BT) //设置进程阻塞时间{blockTime=BT;}void Process::setUnittime(int UT) //设置进程的单位执行时间{unitTime=UT;}5void Process::setBlockstate(bool state) //设置进程阻塞状态{ISblocked=state;}bool Process::getBlockstate() //得到进程阻塞状态{return ISblocked;}char Process::getResult(int k) //得到程序的运行结果{return runText[k];}///////////////////////////////////////////////////////////////////////////////////////// SOURCE///////////////////////////////////////////////////////////////////////////////////////class Source //资源类{protected:int ID; //资源 IDbool state; //资源是否被占用状态int pro_ID; //使用资源的进程id Process *pro; //使用资源的进程指针int time; //进程使用资源的时间6public:Source(int); //资源类构造函数bool getState(); //得到资源被使用状态void setState(bool); //设置资源被使用状态void setTime(int); //设置进程使用资源的时间void setPro(Process *); //设置使用该资源的进程int getID(); //得到资源idint getPorID(); //得到使用资源的进程id void setProID(int); //设置使用资源的进程id void runned(); //资源被cpu调用};Source::Source(int id) //资源类构造函数{ID=id; //资源ID初值为idpro=NULL; //指针赋为空值state=true; //状态为被使用状态}void Source::setProID(int id) //设置使用资源的进程id{pro_ID=id;}void Source::setTime(int t) //设置进程使用资源的时间{time=t;}void Source::setState(bool s) //设置资源使用状态{7state=s;}bool Source::getState() //得到资源使用状态{return state;}void Source::setPro(Process *p) //设置使用该资源的进程{pro=p;}void Source::runned() //资源被CPU调用{if(time>0) //时间充足继续运行输出资源信息并使时间减一{cout<<"( Source :"<<ID<<")";time--;}if(time<=0) //时间用完{pro->setISusesource(false); //资源的使用状态为未使用int ip=pro->getIP(); //得到进程的IPpro->setIP(++ip); //设置到下一个ipSource::setState(true); //设置资源的使用状态为正在使用cout<<endl<<"The process "<<pro->getID()<<" relase the source!"<<endl;pro=NULL; //输出资源被释放指针值赋值为空值}8}//////////////////////////////////////////////////////////// ///////////////////////////// CPU////////////////////////////////////////////////////////////// /////////////////////////typedef struct Block //阻塞队列结构{Process *p_BlockProcess; //被阻塞的进程队列int index; //被阻塞的进程在就绪队列中的位置}Block;class CPU{protected:Process *p_Process; //进程队列Process **pp_Process; //进程就绪队列Block *blockQueue ; //进程阻塞队列Source *p_Source; //资源指针int numOfprocess; //进程数量int numOfblock; //被阻塞的进程数int PC; //程序计数器int allTime; //cpu运行的总时间public :CPU(int); //cpu构造函数void Run(); //cpu运行进程bool _IC(Process&); //虚拟IC,进行进程指令翻译void useSource(Process&); //进程申请资源9void blockProcess(Process&); //阻塞进程void releaseBlockPro(); //释放阻塞进程int getAlltime(); //得到进程运行的总时间void displayPro(); //显示进程的基本信息,id,指令,运行时间等void blockTimeADD(); //阻塞时间加1 };CPU::CPU(int num){p_Source=new Source(379857);//创建一个id号为379857的资源numOfprocess=num; //进程数numOfblock=0; //阻塞数allTime=0; //cpu运行的总时间初始化为0p_Process=new Process[numOfprocess];//进程队列申请空间pp_Process=new Process*[numOfprocess];//进程就绪队列申请空间blockQueue=new Block[numOfprocess]; //阻塞队列申请空间for(int i=0;i<numOfprocess;i++){pp_Process[i]=&p_Process[i]; //用二维数组存放进程指针数组头指针blockQueue->p_BlockProcess=NULL; //阻塞队列的阻塞进程赋值为空blockQueue->index=-1; //阻塞队列的索引值置为1 }}int CPU::getAlltime() //得到进程运行的总时间{return allTime;}10void CPU::displayPro() //显示进程的基本信息{for(int i=0;i<numOfprocess;i++)//循环输出被执行的进程的信息{cout<<"\tProcess ID : "<<p_Process[i].getID()<<endl;cout<<" text of runned :"<<p_Process[i].getRuntext()<<endl;}}void CPU::Run() //cpu运行进程{int numPro=numOfprocess; //记录未被运行的进程个数do{for(int num=0;num < numOfprocess;num++){if(!pp_Process[num]) //就绪队列不空继续执行continue;for(int t=0;t<p_Process[num].getUnittime();t++){PC=p_Process[num].getIP();//得到进程Ipif(_IC(p_Process[num]))//判断进程的状态TURE进入{if(t==0) //时间为0运行完输出进程信息cout<<"the process ["<<p_Process[num].getID()<<"] runed : ";if(!p_Process[num].getISusesource())//如果该进程未被运行过，则调用run运行{p_Process[num].Runed();//}else{p_Source->runned(); //if( p_Source->getState() && numOfblock>0 ){releaseBlockPro();////如果进程运行过，现在但未运行，说明为阻塞。
Java实现进程调度算法（⼆）RR（时间⽚轮转）⼀、概述 因为这次os作业对⽤户在控制台的输⼊输出有要求，所以我花了挺多的代码来完善控制台的显⽰。
也因为我这次要实现多个类似算法，所以将⼀些共性单独提取出来作为⼀个类。
如果只想要和算法有关的核⼼代码，看RR类的calc()即可。
实现思路：每运⾏⼀个进程，则将所有进程的remainServiceTime减去⼀个时间⽚的长度。
⼆、运⾏结果 1. 测试数据： 2. 运⾏结果：三、流程图四、实现代码 1. RR类（主类）只有calc()中涉及了算法，init()和printResult()只有简单的输⼊输出操作。
1package xqy.algorithm;23import java.util.*;45import xqy.Util.Tools;6import xqy.been.Process;78/**9 * @author xqy10 * @date 2018年12⽉19⽇19:14:4911*/12public class RR {13private int processNumber;14private ArrayList<Process> processList;15private int timeSlice;1617public RR() {18 init();19 calc();20 Tools.printResult(processList);21 }2223private void init() {24 Scanner sc = new Scanner(System.in);2526 System.out.print("<RR> Please enter the slice time:");27 timeSlice = sc.nextInt();28 System.out.print("<RR> please enter the process num:");29 processNumber = sc.nextInt();3031 processList = new ArrayList<Process>();32for (int i = 0; i < processNumber; i++) {33 processList.add(new Process());34 }3536 System.out.println("<RR> Please enter each process arrival time:");37for (int i = 0; i < processNumber; i++) {38 System.out.print(" Process" + (i + 1) + ":");39 processList.get(i).setArrivalTime(sc.nextInt());40 }4142 System.out.println("<RR> Please enter each process service time:");43for (int i = 0; i < processNumber; i++) {44 System.out.print(" Process" + (i + 1) + ":");45int servicesTime = sc.nextInt();4647 processList.get(i).setServicesTime(servicesTime);48 processList.get(i).setRemainServiceTime(servicesTime);49 }50 }5152private void calc() {53int timeNow = 0;54int processRemain = processNumber;55boolean noProcessRunInThisTurn;56 Process opProcess;5758while (processRemain != 0) {59 noProcessRunInThisTurn = true;6061for (int i = 0; i < processNumber; i++) {62 opProcess = processList.get(i);6364if ((opProcess.getRemainServiceTime() > 0)65 && (timeNow >= opProcess.getArrivalTime())) {66// First time67if (opProcess.getServicesTime() == opProcess68 .getRemainServiceTime()) {69int waitTime = timeNow - opProcess.getArrivalTime();7071 opProcess.setStartTime(timeNow);72 opProcess.setWaitTime(waitTime);73 }7475// Calculating remain service time76int remainServiceTime = opProcess.getRemainServiceTime()77 - timeSlice;78 opProcess.setRemainServiceTime(remainServiceTime);7980// Last time81if (remainServiceTime <= 0) {82int completionTime = timeNow + timeSlice; // The process ends when the current slice is completed. 83int turnAroundTime = completionTime84 - opProcess.getArrivalTime();85double turnAroundTimeWithWeight = 1.0 * turnAroundTime86 / opProcess.getServicesTime();8788 opProcess.setCompletionTime(completionTime);89 opProcess.setTurnAroundTime(turnAroundTime);90 opProcess91 .setTurnAroundTimeWithWeight(turnAroundTimeWithWeight);92 processRemain--;93 }9495 timeNow += timeSlice;96 noProcessRunInThisTurn = false;9798 System.out.println(" #STEP# Process" + (i + 1)99 + " remain service time:"100 + opProcess.getRemainServiceTime()101 + " , timeBefore:" + (timeNow - 1) + ", timeNow:"102 + timeNow103 + ((remainServiceTime <= 0) ? " Finish" : ""));104 } else {105// do noting, because this process has been completed or hasn`t arrived.106 }107 }108109// Means no process could run, because they have arrived.110if ((processRemain > 0) && noProcessRunInThisTurn) {111 timeNow += timeSlice;112 }113 }114 }115 } 2. Process类模拟了进程，对属性进⾏了封装。
时间片轮转算法和优先级调度算法C语言模拟实现时间片轮转算法（Round Robin Scheduling）和优先级调度算法（Priority Scheduling）是操作系统中常用的两种进程调度算法。
下面将分别对这两种算法进行C语言模拟实现，并进行详细解释。
```c#include <stdio.h>#include <stdbool.h>#define MAX_PROC_NUM 10#define TIME_QUANTUM 2typedef struct Processint pid; // 进程ID} Process;void roundRobinScheduling(Process processes[], intnum_processes)for (int i = 0; i < num_processes; i++)} else}}}}int maiProcess processes[MAX_PROC_NUM];int num_processes;printf("Enter the number of processes: "); scanf("%d", &num_processes);for (int i = 0; i < num_processes; i++)printf("Process %d: ", i+1);processes[i].pid = i+1;}roundRobinScheduling(processes, num_processes); return 0;```优先级调度算法模拟实现：```c#include <stdio.h>#include <stdbool.h>#define MAX_PROC_NUM 10typedef struct Processint pid; // 进程IDint priority; // 优先级} Process;void priorityScheduling(Process processes[], int num_processes)int highest_priority = 0;int highest_priority_index;highest_priority = -1;for (int i = 0; i < num_processes; i++)highest_priority = processes[i].priority;highest_priority_index = i;}}if (highest_priority == -1)continue;}} else}}int maiProcess processes[MAX_PROC_NUM];int num_processes;printf("Enter the number of processes: ");scanf("%d", &num_processes);for (int i = 0; i < num_processes; i++)printf("Process %d:\n", i+1);printf("Burst Time: ");printf("Priority: ");scanf("%d", &processes[i].priority);processes[i].pid = i+1;}priorityScheduling(processes, num_processes);return 0;```以上是时间片轮转算法和优先级调度算法的C语言模拟实现。
时间片轮转算法及优先级调度算法C语言模拟实现收藏时间片轮转算法是一种常见的CPU调度算法，通过将进程按照到达顺序放置在一个就绪队列中，并且给予每个进程相同的时间片，当进程用完时间片后，将其放到队列的尾部，轮流执行其他进程。
优先级调度算法是根据进程的优先级来决定下一个执行的进程。
下面是使用C语言模拟实现时间片轮转算法和优先级调度算法的代码：```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int remainingTime;} Process;int totalTurnaroundTime = 0;int totalWaitingTime = 0;//初始化每个进程的剩余执行时间for (int i = 0; i < numProcesses; i++)processes[i].remainingTime = processes[i].burstTime;}while (1)int allProcessesFinished = 1; // 标记所有进程是否执行完毕for (int i = 0; i < numProcesses; i++)if (processes[i].remainingTime > 0)allProcessesFinished = 0; // 还有未执行完毕的进程processes[i].remainingTime = 0;} else}printf("%s执行完毕，剩余时间：%d\n", processes[i].name, processes[i].remainingTime);}}if (allProcessesFinished)break; // 所有进程执行完毕，退出循环}}//计算平均周转时间和平均等待时间float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;float averageWaitingTime = (float)totalWaitingTime / numProcesses;printf("平均周转时间：%.2f\n", averageTurnaroundTime);printf("平均等待时间：%.2f\n", averageWaitingTime);int maiint numProcesses;printf("请输入进程数量：");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间和执行时间：", i+1);scanf("%s%d%d", processes[i].name, &processes[i].arrivalTime, &processes[i].burstTime);}printf("请输入时间片大小：");return 0;```优先级调度算法：```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int priority;int waitingTime;int turnaroundTime;} Process;void runPriority(Process* processes, int numProcesses)int totalWaitingTime = 0;int totalTurnaroundTime = 0;//对进程按照到达时间进行排序for (int i = 0; i < numProcesses; i++)for (int j = 0; j < numProcesses-i-1; j++)if (processes[j].arrivalTime > processes[j+1].arrivalTime) Process temp = processes[j];processes[j] = processes[j+1];processes[j+1] = temp;}}}processes[0].waitingTime = 0;//计算每个进程的等待时间和周转时间for (int i = 1; i < numProcesses; i++)processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;totalWaitingTime += processes[i].waitingTime;totalTurnaroundTime += processes[i].turnaroundTime;}//计算平均等待时间和平均周转时间float averageWaitingTime = (float)totalWaitingTime / numProcesses;float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;printf("平均等待时间：%.2f\n", averageWaitingTime);printf("平均周转时间：%.2f\n", averageTurnaroundTime);int maiint numProcesses;printf("请输入进程数量：");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间、执行时间和优先级：", i+1);scanf("%s%d%d%d", processes[i].name,&processes[i].arrivalTime, &processes[i].burstTime,&processes[i].priority);}runPriority(processes, numProcesses);return 0;```通过输入进程的信息，可以计算出使用时间片轮转算法和优先级调度算法的平均等待时间和平均周转时间，从而比较它们的效果。
进程调度实验报告进程调度实验报告一、实验目的本实验旨在通过模拟进程调度算法，加深对操作系统进程调度的理解，掌握进程调度算法的实现方法。
二、实验环境操作系统：Windows 10编程语言：C++开发工具：Visual Studio 2019三、实验内容1. 实现进程调度算法本实验实现了三种进程调度算法：先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）。
其中，FCFS算法按照进程到达的先后顺序进行调度，SJF算法按照进程执行时间的长短进行调度，RR算法则按照时间片轮转的方式进行调度。
2. 模拟进程调度过程本实验模拟了多个进程的调度过程，包括进程的创建、调度、执行和结束。
在模拟过程中，每个进程都有自己的进程ID、到达时间、执行时间和优先级等属性。
通过模拟进程调度过程，可以更好地理解进程调度算法的实现原理。
3. 统计调度结果本实验统计了每种进程调度算法的平均等待时间、平均周转时间和平均带权周转时间。
通过统计调度结果，可以比较不同进程调度算法的优劣，为实际应用提供参考。
四、实验结果1. 进程调度算法的实现本实验实现了三种进程调度算法，分别是FCFS、SJF和RR。
其中，FCFS算法的实现比较简单，只需要按照进程到达的先后顺序进行调度即可。
SJF算法则需要根据进程的执行时间进行排序，然后按照排序后的顺序进行调度。
RR算法则需要设置时间片大小，每个进程执行一个时间片后，将其放入就绪队列的末尾，然后轮到下一个进程执行。
2. 模拟进程调度过程本实验模拟了多个进程的调度过程，包括进程的创建、调度、执行和结束。
在模拟过程中，每个进程都有自己的进程ID、到达时间、执行时间和优先级等属性。
通过模拟进程调度过程，可以更好地理解进程调度算法的实现原理。
3. 统计调度结果本实验统计了每种进程调度算法的平均等待时间、平均周转时间和平均带权周转时间。
通过统计调度结果，可以比较不同进程调度算法的优劣，为实际应用提供参考。
武汉理工大学华夏学院课程设计报告书课程名称：操作系统原理题目：时间片轮转进程调度模拟算法的实现系名：信息工程系专业班级：计算机1132班*名：**学号： *********** ****: ***2015年 6 月 26日武汉理工大学华夏学院信息工程系课程设计任务书课程名称：操作系统原理课程设计指导教师：司晓梅班级名称：计算机1131-2 开课系、教研室：自动化与计算机一、课程设计目的与任务操作系统课程设计是《操作系统原理》课程的后续实践课程，旨在通过一周的实践训练，加深学生对理论课程中操作系统概念，原理和方法的理解，加强学生综合运用操作系统原理、Linux系统、C语言程序设计技术进行实际问题处理的能力，进一步提高学生进行分析问题和解决问题的能力，包含系统分析、系统设计、系统实现和系统测试的能力。
学生将在指导老师的指导下，完成从需求分析，系统设计，编码到测试的全过程。
二、课程设计的内容与基本要求1、课程设计题目时间片轮转进程调度模拟算法的实现2、课程设计内容用c/c++语言实现时间片轮转的进程调度模拟算法。
要求：1．至少要有5个以上进程2．进程被调度占有CPU后，打印出该进程正在运行的相关信息提示:时间片轮转调度算法中，进程调度程序总是选择就绪队列中的第一个进程，也就是说按照先来先服务原则调度，但一旦进程占用处理机则仅使用一个时间片。
在使用完一个时间片后，进程还没有完成其运行，它必须释放出处理机给下一个就绪的进程，而被抢占的进程返回到就绪队列的末尾重新排队等待再次运行。
1）进程运行时，只打印出相关提示信息，同时将它已经运行的时间片加1就可以了。
2）为进程设计出PCB结构。
PCB结构所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息等。
3、设计报告撰写格式要求：1设计题目与要求 2 设计思想3系统结构 4 数据结构的说明和模块的算法流程图5 使用说明书（即用户手册）：内容包含如何登录、退出、读、写等操作说明6 运行结果和结果分析（其中包括实验的检查结果、程序的运行情况）7 自我评价与总结 8 附录：程序清单，注意加注释（包括关键字、方法、变量等），在每个模块前加注释；三、课程设计步骤及时间进度和场地安排本课程设计将安排在第17周, 现代教育技术中心。
具体安排如下：课程设计集中时间安排：四、课程设计考核及评分标准课程设计考核将综合考虑学生的系统设计方案、运行结果、课程设计报告书的质量、态度、考勤、答辩情况等各因素。
具体评分标准如下：（1）设计方案正确，具有可行性、创新性； 30分（2）系统开发效果较好； 20分（3）设计报告规范、课程设计报告质量高、参考文献充分 20分（4）课程设计答辩时，问题回答正确； 20分（5）态度认真、刻苦钻研、遵守纪律； 10分按上述五项分别记分后求和，总分按五级制记载最后成绩。
优秀（100～90分），良好（80～89分），中等（70～79分），及格（60～69分），不及格（0～59分）一、设计题目与要求：进程时间片轮转调度算法。
要求：用C++语言编写程序完成单处理机的进程调度，要求采用时间片轮转调度算法。
实验具体要求包括：首先确定作业控制块的内容和组成方式；然后完成作业调度；最后编写主函数，并对所做工作进行测试。
二、设计思想：在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。
对调度的处理又都可采用不同的调度方式和调度算法。
调度算法是指：根据系统的资源分配策略所规定的资源分配算法。
三、系统结构处理机管理模拟系统由创建进程、运行程序和显示结果三部分组成。
而它们又分别包括输入进程信息、创建结点和插入结点三个步骤。
系统功能说明：创建进程模块在输入进程页面输入要创建的进程数，输入后逐个将进程信息录入插入到就绪队列中，完成进程的创建过程。
运行程序模块：此模块实现时间片轮转调度算法，从就绪队列中取出进程结点，并模拟运行该进程，反复循环，直至进程全部运行结束。
每次运行进程后，将运行信息存入到文件中，实现信息的持久化。
方便信息的记录，系统功能的分析和出错时便于检查错误。
现实结果模块：从文件读入进程运行的结果，在图形界面下操作，提供友好的用户操作方式，方便直观了解进程呢过的调度过程，便于数据的分析和研究。
算法描述：1、在创建进程界面将进程信息录入，将进程控制块进行包装，插入到循环队列中；2、当运行程序时，每次从就绪队列队首取出一个进程，判断是P进程是否到达。
到达则运行该进程；3、若P进程为首次运行，则记录进程开始运行时间；4、运行完P进程后，输入进程运行信息，并将此进程移动至队尾；5、若循环队列长度大于1，则返回执行B，否则结束程序。
四、数据结构的说明和模块的算法流程图typedef struct jcb{char name[N];int prio;int round;int cputime;int needtime;int count;char state;struct node *next;}PCB图1流程图五、使用说明（1）建立一个进程控制块PCB来代表。
PCB包括：进程名、链接指针、到达时间、估计运行时间、剩余时间和进程状态。
进程状态分为就绪（W）、运行（R）和完成（F）。
（2）为每个进程任意确定一个要求运行时间和到达时间。
（3）按照进程到达的先后顺序排成一个循环队列。
再设一个对首指针指向第一个到达进程的首址。
（4）执行处理机调度时，开始选择对首的第一个进程运行。
另外再设一个当前运行进程的指针，指向当前正运行的进程。
（5）执行：a)预计运行时间减1；b)输出当前运行进程的名字。
（6）进程执行一次后，若该进程的剩余运行时间为零，则将该进程的状态置为完成态F，并退出循环队列；若不为空，则将其移至队尾。
继续在运行队首的进程。
（7）若就绪队列不空，则重复上述的（5）和（6）步骤直到所有进程都运行完为止。
在所设计的调度程序中，要求包含显示或打印语句。
以便显示或打印每次选操作系统课程设计中进程的名称及运行一次后队列的变化情况。
六、运行结果1、输入数据图2 输入数据2、运行结果示例（1）数据输入完成后的初始状态，进程标识为x1的进程首先得到调度，运行10个时间单位。
图3运行结果1（2）进程标识为x2的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
图4运行结果2（3）进程标识为x3的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
图5运行结果3（4）进程标识为x4的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
图6运行结果4(5)进程标识为x5的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
图7运行结果5（6）进程标识为x1的进程再次得到调度，从就绪态“W”改为运行态“R”，因进程x1只剩下5个单位时间，所以进程x1只运行5个单位时间。
图8运行结果6（7）进程标识为x2的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
进程x1已运行完，从运行态“R”改为运行结束状态“F”。
图9运行结果7（8）进程标识为x3的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
图10运行结果8（9）进程标识为x4的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
图11运行结果9（10）进程标识为x5的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
图12运行结果10（11）进程标识为x2的进程得到调度，从就绪态“W”改为运行态“R”，运行5个时间单位。
进程x5已运行完，从运行态“R”改为运行结束状态“F”。
图13运行结果11(12）进程标识为x3的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
进程x2已运行完，从运行态“R”改为运行结束状态“F”。
图14运行结果12(13）进程标识为x4的进程得到调度，从就绪态“W”改为运行态“R”，运行10个时间单位。
图15运行结果13(14）进程标识为x3的进程得到调度，从就绪态“W”改为运行态“R”，运行5个时间单位。
进程x4已运行完，从运行态“R”改为运行结束状态“F”。
图16运行结果14（15）所有进程都已运行完，状态都为“F”。
图17运行结果15七、小结在这次实验中,我能够正确分析实验过程和实验结果，思路清晰，能够比较好的理解进程按时间片轮转算法这一调度过程，加深了我对进程时间片轮转调度过程的理解。
但是还有很多不足。
我自己的C++基础差，不能够自己编写这一调度算法的程序，只能通过网络和同学、老师的帮忙得到正确的程序编码；另外一开始输入进程运行需要的时间时，由于输入运行时间的数值较大，导致后面进程繁多，但后来及时改正，走了弯路，也增加了理解。
因此以后要加强自己在C++方面的学习，能够理解源程序；并且要多上机操作，多调试多尝试，争取能理解好了解透。
本次实验题需要详细阅读题目和不断地尝试才能找到简便的过程，能加强学生的上机操作能力。
八、参考源程序#include <stdio.h>#include <stdlib.h>#include <string.h>#include <iostream.h>typedef struct node{char name[10];int prio;int round;int cputime;int needtime;int count;char state;struct node *next;}PCB;PCB *finish,*ready,*tail,*run; //队列指针int N; //进程数void firstin(){run=ready; //就绪队列头指针赋值给运行头指针run->state='R'; //进程状态变为运行态]ready=ready->next; //就绪队列头指针后移到下一进程}//输出标题函数void prt1(char a){if(toupper(a)=='P') //优先级法cout<<" "<<endl;cout<<"进程名占用CPU时间到完成还要的时间轮转时间片状态"<<endl;}//进程PCB输出void prt2(char a,PCB *q){if(toupper(a)=='P') //优先级法的输出cout<<q->name<<" "<<q->cputime<<" "<<q->needtime<<" "<<q->round<<" "<<q->state<<endl;}//输出函数void prt(char algo){PCB *p;prt1(algo); //输出标题if(run!=NULL) //如果运行指针不空prt2(algo,run); //输出当前正在运行的PCBp=ready; //输出就绪队列PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}p=finish; //输出完成队列的PCBwhile(p!=NULL)prt2(algo,p);p=p->next;}getchar(); //按住任意键继续}//时间片轮转的插入算法void insert(PCB *q){PCB *p1,*s,*r;s=q; //待插入的PCB指针p1=ready; //就绪队列头指针r=p1; //*r做pl的前驱指针while(p1!=NULL)if(p1->round<=s->round){r=p1;p1=p1->next;}if(r!=p1){r->next=s;s->next=p1;}else{s->next=p1; //否则插入在就绪队列的头ready=s;}//优先级创建初void create(char alg){PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;cout<<"输入进程名及其需要运行的时间："<<endl; for(i=1;i<=N;i++){p=new PCB;cin>>na;cin>>time;strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';p->round=0;if(ready!=NULL)insert(p);else{p->next=ready;ready=p;}cout<<"输入进程名及其需要运行的时间："<<endl; }prt(alg);run=ready;ready=ready->next;run->state='R';}void timeslicecycle(char alg){while(run!=NULL){run->cputime=run->cputime+10;run->needtime=run->needtime-10;run->round=run->round+10;if(run->needtime<=0){run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)firstin();}else{run->state='W';insert(run);firstin();}prt(alg);}}//主函数void main(){char algo='P'; //算法标记cout<<"输入进程的个数："; cin>>N; //输入进程数create(algo); //创建进程timeslicecycle(algo); //优先级法调度} //main()。
