操作系统实验-进程调度程序设计
进程调度程序实验报告
一、实验目的通过本次实验，加深对进程调度原理和算法的理解，掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序，实现不同调度算法的模拟，并通过实验验证算法的性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法：1. 先来先服务（FCFS）2. 最短作业优先（SJF）3. 时间片轮转（RR）四、实验步骤1. 定义进程类（Process）：```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类（Scheduler）：```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序：```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果：");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果：");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果（时间片为2）：");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验，我们可以观察到以下结果：1. FCFS调度算法简单，但可能导致长作业等待时间过长。
操作系统实验二报告-时间片轮转进程调度算法1
操作系统实验报告实验二时间片轮转进程调度算法学号：班级：姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的时间片轮转RR 调度过程。
假设有n 个进程分别在T1, … ,Tn 时刻到达系统, 它们需要的服务时间分别为S1, … ,Sn 。
分别利用不同的时间片大小q, 采用时间片轮转RR 进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n 个进程的平均周转时间和平均带权周转时间。
程序要求如下:1）进程个数n ；每个进程的到达时间T 1, … ,T n 和服务时间S 1, … ,S n ；输入时间片大小q 。
2）要求时间片轮转法RR 调度进程运行, 计算每个进程的周转时间, 带权周转时间, 并且计算所有进程的平均周转时间, 带权平均周转时间；3）输出: 要求模拟整个调度过程, 输出每个时刻的进程运行状态, 如“时刻3: 进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间, 带权周转时间, 所有进程的平均周转时间, 带权平均周转时间。
实现提示:用C++语言实现提示:1）程序中进程调度时间变量描述如下:int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];➢2）进程调度的实现过程如下:➢变量初始化；➢接收用户输入n, T1, … ,Tn, S1, … ,Sn；时间片大小q；➢按照时间片轮转RR算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
进程调度操作系统实验报告
进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。
二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一，它负责决定哪个进程在何时获得 CPU 资源进行执行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 执行。
这种算法简单直观，但可能导致短作业等待时间过长。
短作业优先算法优先调度执行时间短的进程，能有效减少平均等待时间，但可能导致长作业饥饿。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片进行执行。
如果进程在时间片内未完成，则被放回就绪队列等待下一轮调度。
优先级调度根据进程的优先级来决定调度顺序，优先级高的进程先获得 CPU 资源。
四、实验步骤1、设计进程结构体定义进程的标识号（PID）、到达时间、服务时间、剩余时间、优先级等属性。
2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中取出第一个进程进行调度执行，直到其完成。
3、实现短作业优先算法计算每个进程的剩余服务时间。
将进程按照剩余服务时间从小到大排序，放入就绪队列。
从就绪队列中取出剩余服务时间最短的进程进行调度执行。
4、实现时间片轮转算法设定时间片大小。
将进程放入就绪队列，按照先来先服务的原则依次分配时间片执行。
进程在时间片内未完成的，放回就绪队列末尾。
5、实现优先级调度算法为每个进程设置优先级。
将进程按照优先级从高到低排序，放入就绪队列。
从就绪队列中取出优先级最高的进程进行调度执行。
6、计算平均周转时间和平均带权周转时间周转时间＝完成时间到达时间带权周转时间＝周转时间／服务时间平均周转时间＝总周转时间／进程数平均带权周转时间＝总带权周转时间／进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。
操作系统进程调度实验
操作系统进程调度实验操作系统进程调度是操作系统中非常重要的一个功能，它决定了多个进程的执行顺序和调度策略。
进程调度的好坏直接影响着系统的性能和资源利用率。
本实验旨在通过实现一个简单的进程调度模拟，了解不同的调度算法，探讨其优劣和适用场景。
一、实验目的和原理本实验的目标是实现进程调度模拟，并探究不同调度算法的性能和适用场景。
通过实验，我们可以了解以下内容：1.进程调度算法的基本原理和实现方式；2.比较不同调度算法的优劣和特点；3.了解不同调度算法在不同场景下的应用。
二、实验环境和工具本实验使用C语言进行实现，可以选择任何一种编程环境和工具，例如Dev-C++、Visual Studio等。
三、实验过程及方法1.实现一个进程控制块（PCB）的数据结构，用来保存进程的相关信息，包括进程ID、进程状态、优先级等。
2.实现一个进程队列，用来保存就绪队列中的进程。
可以使用数组或链表等数据结构实现。
3. 实现不同调度算法的函数，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和时间片轮转（Round Robin）等。
4.根据实际需求生成一批进程，设置其信息，并根据不同算法进行调度。
5.对比不同算法的运行结果和性能，分析其优劣。
四、实验结果和分析通过实验，我们可以得到每个算法的平均等待时间、平均周转时间和吞吐量等性能指标。
根据这些指标，我们可以对不同算法进行评价和分析。
1.先来先服务（FCFS）算法FCFS算法是最简单的调度算法，按照进程到达的顺序进行调度。
它的主要优点是实现简单、公平性好。
然而，FCFS算法有明显的缺点，会导致长作业等待时间过长，产生"饥饿"现象。
2.最短作业优先（SJF）算法SJF算法是按照进程的执行时间长短进行调度的算法。
它能够最大限度地减少平均等待时间和周转时间，但是需要提前知道所有进程的执行时间，这在实际中是很难做到的。
操作系统课程设计进程调度
静态最高优先数调度算法的流程图如下：
开始
创建PCB
将PCB挂入就绪队 列中，优先级高的
放在队首
是 就绪队列空
否 从队首取下最高优
先级进程运行
结束
进程运行完成，撤 销
时间片轮转调度算法 就绪进程获得 CPU后都只能运行一个时间片。 如果运行一个时间片后，进程的已占用 CPU时间已达到所
课程实验的目的和意义
培养程序设计的方法和技巧 掌握操作系统的原理和功能
进程调度实验
目的要求
用高级语言编写和调试一个进程调度程序， 以加深对进程的概念及进程调度算法的理解。 （注意：这里只是模拟的进程调度程序，用 一个链表结点模拟一个进程，而不用我们之 前用过的createprocess函数创建进程）
进程调度实验
用三个队列，就绪、运行、完成来表示进程 的不同状态。当新来一个进程时，若采用静 态优先级，则根据优先级插入就绪队列中不 同位置（若队列为空，则直接插入）。若采 用时间片，则直接插入就绪队列队尾。
实验例题
设计一个有 N个进程共行的进程调度程序
链表中每一个结点包括两部分：
（1）用户需要用的实际数据；（ name[10]; int prio; int round; int cputime; int needtime; 需自己输入）
需要的运行时间，则撤消该进程； 如果进程在所分的时间片内没有运行完成，则把它重新插
入就绪队列等待CPU。
时间片轮转调度算法的流程图如下：
开始
创建PCB
将PCB挂入就绪队 列中，先来的放在 队首，后来的放队
尾
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。
二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法：FCFS、RR和DP。
3. 创建一个进程队列，用于存储所有进程。
4. 实现调度函数，根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程，打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
Linux操作系统实验2-进程调度的操作
1.查看并创建用户的计划任务列表crontab文件；
1)查看crontab命令的帮助信息；
在终端下键入info crontab, 进入crontab帮助手册：
2)查看用户的计划任务列表；
查看特定用户的计划任务列表：
在终端下键入crontab -l -u duke 列出duke用户的所有定时任务，如下：
终端提示no crontab for duke，说明用户duke目前没有计划任务。
查看当前用户的计划任务列表：
在终端下键入crontab -l 列出当前用户的所有定时任务，如下：
终端提示no crontab for duke，说明用户duke目前没有计划任务。
2.通过crontab文件对调度进程的计划任务进行编排操作。
1)建立crontab文件；
在终端下键入crontab -e ，提示当前无crontab文件，选择编辑器并新建如下：进入VI编辑器，编辑当前crontab文件，可以看到提供了一些注解作说明。
在crontab中输入0 3 * * 1 ls /etc 并保存，实现在每周一早上三点执行ls /etc 命令。
再次查看crontab文件，可以看到已经保存。
2)使用crontab命令安装crontab文件，安排计划任务；
对于位于/home下的crontab文件，使用crontab <filename>载入crontab计划任务中，如图：
3)查看计划任务表，确认计划任务是否已被安排；
键入crontab -l，查看计划任务安排情况，如图：
4)删除计划任务列表。
在终端下键入crontab -r ，删除当前用户的crontab文件，如下：。
操作系统进程(任务)调度
int turnroundtime;
double weight;
int memory;
struct Task *prev, *next;
} Tasktype;
void inittaskqueue(Tasktype *queue);
Tasktype *createtask(int pid, int state, int priority, int admittime, int runtime, int memory);
#define TASK_EXIT3
#define MAXTASKN1000
#define MAXRUNTIME500
#define MAXTIMEINTERVAL200
#define MAXMEMORY500
#define MAXPRIORITY100
typedef int Boolean;
#endif
FCFS
进程按顺序运行，直到当前进程运行完成，运行下一个进程
pid= 0,prio= 63,admit= 42,run= 359,exit= 401,turn= 359,wei= 1.00, mem=479
pid= 1,prio= 46,admit= 110,run= 206,exit= 607,turn= 497,wei= 2.41, mem=465
unsigned int policy;
int currenttime;
int freetime;
int busytime;
} Cputype;
void initcpu(Cputype *cpu, unsigned policy);
#endif.
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程名称：实验项目：实验地点：专业班级：学生姓名：指导教师：本科实验报告操作系统B进程调度程序设计学号：2011 年11 月目录进程调度程序设计一、实验目的和要求 (1)二、实验内容及原理 (1)三、实验仪器设备 (3)四、操作方法与实验步骤 (3)五、实验数据记录和处理 (3)六、实验结果与分析 (10)七、实验感想 (11)实验二一、实验目的和要求（一） 目的进程调度程序设计进程是操作系统最重要的概念之一，进程调度是操作系统的主要内容，本实验要求 学生独立地用高级语言编写一个进程调度程序，调度算法可任意选择或自行设计，本实验 可使学生加深对进程调度和各种调度算法的理解。
（二） 要求1． 设计一个有几个进程并发执行的进程调度程序，每个进程由一个进程控制块(PCB) 表示，进程控制块通常应包括下述信息：进程名，进程优先数，进程需要运行的时间，占 用 CPU 的时间以及进程的状态等，且可按照调度算法的不同而增删。
2． 调度程序应包含 2—3 种不同的调度算法，运行时可以任选一种，以利于各种方法 的分析和比较。
3． 系统应能显示或打印各进程状态和参数的变化情况，便于观察。
二、实验内容及原理1． 本程序可选用优先数法或简单轮转法对五个进程进行调度。
每个进程处于运行 R(run)、就绪 W(wait)和完成 F(finish)三种状态之一，并假定起始状态都是就绪状态 W 。
为了便于处理，程序中进程的运行时间以时间片为单位计算。
各进程的优先数或轮 转时间片数、以及进程需要运行的时间片数，均由伪随机数发生器产生。
进程控制块结构如表 2-1 所示：表 2-1PCB进程控制块链结构如图 2-1 所示：图 2-1进程控制块链结构其中：RUN —当前运行进程指针；进程标识符 链指针 优先数/轮转时间片数 占用 CPU 时间片数 进程所需时间片数进程状态HEAD —进程就绪链链首指针； TAIL —进程就绪链链尾指针。
2. 算法与框图priority程序框图如图 2-2 所示。
开始alog=priority/round robin?进程时 间片数 为 0？优先数 大于链 首进程?占用处 理机时 间片到?进程时 间片数 为 0？进程队列空?是 结束进程队列空?结束图 2-2进程调度框图(1)优先数法。
进程就绪链按优先数大小从大到小排列，链首进程首先投入运行。
每 过一个时间片，运行进程所需运行的时间片数减 1，说明它已运行了一个时间片，优先数也 减 3。
理由是该进程如果在一个时间片中完成不了，优先级应降低一级。
接着比较现行进程 和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续运行，否则， 调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链，且改变它们对应 的进程状态，直至所有进程都运行完各自的时间片数。
(2)简单轮转法。
进程就绪链按各进程进入的先后次序排列，链首进程首先投入运行。
进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相 输入调度算法 alog从链首取一个进程投入运行时间片到，进程时间片 数减 1，优先数减 3运行进程退出， 排到进程链尾部撤消该进程 生成并按进入次序 排列进程控制块链 链首进程投入运行时间片到，进程时间片数 减 1，占用 CPU 时间加 1撤消该进程 运行进程退出，按 优先数插入进程链从链首取一个 进程投入运行是是 是 否否否否否是 round robin否是生成并按优先数大小 排列进程控制块链 链首进程投入运行应于优先数法的优先数记录项位置）。
每过一个时间片，运行进程占用处理机的时间片数加 1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
三、实验仪器设备微型计算机。
C++6.0编程软件四、操作方法与实验步骤1.编写源程序2.编译运行，查看结果五、实验数据记录和处理优先权调度算法：1．设定系统中有五个进程，每一个进程用一个进程控制块（PCB）表示，进程队列采用链表数据结构。
2.进程控制块包含如下信息：进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
3.在每次运行设计的处理调度程序之前，由终端输入五个进程的“优先数”和“要求运行时间”。
4.进程的优先数及需要的运行时间人为地指定.进程的运行时间以时间片为单位进行计算。
5.采用优先权调度算法，将五个进程按给定的优先数从大到小连成就绪队列。
用头指针指出队列首进程，队列采用链表结构。
6.处理机调度总是选队列首进程运行。
采用动态优先数办法，进程每运行一次优先数减“1”，同时将已运行时间加“1”。
7.进程运行一次后，若要求运行时间不等于已运行时间，则再将它加入就绪队列；否则将其状态置为“结束”,且退出就绪队列。
8.“就绪”状态的进程队列不为空，则重复上面6，7步骤，直到所有进程都成为“结束”状态。
9.在设计的程序中有输入语句，输入5个进程的“优先数”和“要求运行时间”，也有显示或打印语句，能显示或打印每次被选中进程的进程名、运行一次后队列的变化，以及结束进程的进程名。
10、最后，为五个进程任意确定一组“优先数”和“要求运行时间”，运行并调试所设计的程序，显示或打印出逐次被选中进程的进程名及其进程控制块的动态变化过程。
简单时间片轮转法：1.设系统有5个进程，每个进程用一个进程控制块PCB来代表。
2.为每个进程任意确定一个要求运行时间。
3.按照进程输入的先后顺序排成一个队列。
再设一个队首指针指向第一个到达进程的首址。
4.执行处理机调度时，开始选择队首的第一个进程运行。
另外，再设一个当前运行进程的指针，指向当前正在运行的进程。
5.考虑到代码的可重用性, 轮转法调度程序和最高优先级优先调度是调用同一个模快进行输出注:由于轮转法调度程序和最高优先级优先调度是调用同一个模快进行输出,所以在时间轮转法调度算法的进程中,依然显示了随即产生的优先级数.6.进程运行一次后，以后的调度则将当前指针依此下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。
同时还应判断该进程的要求运行时间是否等于已运行时间。
若不等，则等待下一轮的运行，否则将该进程的状态置为完成态C，并退出循环队列。
7.若就绪队列不空，则重复上述的（5）和（6）步骤直到所有的进程都运行完为止。
8.在所设计的调度程序中,包含显示或打印语句。
显示或打印每次选中的进程的名称及运行一次后队列的变化情况。
源程序：#include<stdio.h>#include<math.h>#include<stdlib.h>#define furthest5struct process{int id;int priority;int cputime;int alltime;char state;int next;}prochain[furthest-1];int procnum;int rand();int algo;int run,head,tail,j;void main(){agan:printf("type the algorithm is (1:RR,2:PRIO):");scanf("%d",&algo);if(algo==2){printf("output of priority.\n");extern void init();extern void prisch();}else{if(algo==1){printf("output of round robin.\n");extern void init();extern void timesch();}else{printf("try again,please\n");goto agan;}}for (j=1;j<=40;j++){printf("=");}printf("\n\n");for(j=1;j<=40;j++){printf("=");}printf("\n\n");printf("system finished\n");}void print(){int k,p;for(k=1;k<=40;k++)printf("=");printf("\nrunning proc.");printf("waiting queue.");printf("\n %d ",prochain[run].id);p=head;while(p!=0){printf("%5d",p);p=prochain[p].next;}printf("\n");for(k=1;k<=40;k++){printf("=");}printf("\n");printf("id ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].id);printf("\n");printf("priority ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].priority);printf("\n");printf("cputime ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].cputime);printf("\n");printf("alltime ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].alltime);printf("\n");printf("state ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].state);printf("\n");printf("next ");for(k=1;k<furthest+1;k++)printf("%5d",prochain[k].next);printf("\n");}void insert(int q){int p,s;p=head;s=prochain[head].next;while((prochain[q].priority<prochain[s].priority)&&(s!=0)) {p=s;s=prochain[s].next;}prochain[p].next=q;prochain[q].next=s;}void insert2(){prochain[tail].next=run;tail=run;prochain[run].next=0;}void init(){int i;head=0;if(algo==2){for(i=1;i<furthest+1;i++){prochain[i].id=i;prochain[i].priority=(rand()+11)%41;prochain[i].cputime=0;prochain[i].alltime=(rand()+1)%7;prochain[i].state='W';prochain[i].next=0;if((prochain[i].priority<prochain[head].priority)&&(head!=0)) insert(prochain[i].id);else{prochain[i].next=head;head=prochain[i].id;}}}else{for(i=1;i<furthest+1;i++){prochain[i].id=i;prochain[i].priority=(rand()+1)%3+1;prochain[i].cputime=0;prochain[i].alltime=(rand()+1)%7;prochain[i].state='W';prochain[i].next=(i+1)%(furthest+1);}head=1;tail=furthest;prochain[furthest].next =0;}run=head;prochain[run].state='R';head=prochain[head].next;prochain[run].next=0;print();}void prisch(){while(run!=0){prochain[run].cputime+=1;prochain[run].priority-=3;prochain[run].alltime-=1;if(prochain[run].alltime==0){prochain[run].state='F';prochain[run].next=0;if(head!=0){run=head;prochain[run].state='R';head=prochain[head].next;}else{prochain[0].id=prochain[run].id;run=0;}}else{if((prochain[run].priority<prochain[head].priority)&&(head!=0)) {prochain[run].state='W';insert(run);run=head;prochain[run].state='R';head=prochain[head].next;}}print();}}void timesch(){while(run!=0){prochain[run].alltime-=1;prochain[run].cputime+=1;if(prochain[run].alltime==0){prochain[run].state='F';prochain[run].next=0;if(head!=0){run=head;prochain[run].state='R';head=prochain[head].next;}else{prochain[0].id=prochain[run].id;run=0;}}else{if((prochain[run].cputime<prochain[head].priority)&&(head!=0)) {prochain[run].state='W';prochain[run].cputime=0;insert2();run=head;prochain[run].state='R';head=prochain[head].next;}}print();}}六、实验结果与分析（1）输入1的结果为：（2）输入2的结果为：七、实验感想这个实验老师给了实验程序的主题框架，但是在完善程序和程序运行时也遇到了不少问题，对很多C++的语句语法都忘了好多，导致遇到一些语法错误而发现不了问题。