操作系统实验-进程调度程序设计说课讲解
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。
其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。
在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。
2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。
3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。
实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。
因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。
同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言操作系统是计算机系统中最核心的软件之一，它负责管理和调度计算机的资源，提供良好的用户体验。
在操作系统中，进程调度是其中一个重要的功能，它决定了进程的执行顺序和时间片分配，对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分，它负责决定哪个进程可以使用CPU，并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下，进程调度需要考虑多个进程之间的竞争和协作，以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度（FCFS）先来先服务调度算法是最简单的进程调度算法之一，它按照进程到达的顺序进行调度，即先到达的进程先执行。
这种算法的优点是公平性高，缺点是无法适应长作业和短作业混合的情况，容易产生"饥饿"现象。
2. 最短作业优先调度（SJF）最短作业优先调度算法是根据进程的执行时间来进行调度的，即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间，缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度（RR）时间片轮转调度算法是一种抢占式调度算法，它将CPU的执行时间划分为固定大小的时间片，并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后，它将被挂起，等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间，缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度（Priority Scheduling）优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度，缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中，我们使用了不同的进程调度算法，并对其进行了性能测试。
进程调度操作系统实验报告
进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。
二、实验环境操作系统：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算法是按照进程的执行时间长短进行调度的算法。
它能够最大限度地减少平均等待时间和周转时间，但是需要提前知道所有进程的执行时间，这在实际中是很难做到的。
《操作系统》上机实验报告—进程调度
《操作系统》上机实验报告实验算法主体内容及#include<stdio.h>#include<dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5 // 共有5 个进程#define P_TIME 50 //作为优先数计算时所用的值enum state{ready,execute,block, finish};//进程的状态，使用枚举struct pcb{char name[4]; // 进程名称int priority; //进程优先级int cputime; //已经占有cpu运行的时间int needtime; //还需要运行的时间int count; //在时间片轮转法中使用的int round; //在时间片轮转法中使用的state process; //进程的状态pcb *next; //指向下一个进程的pcb};pcb *get_process() //通过输入各进程的值来建立pcb队列，并返回其首元素的指针{pcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"<<endl;while(i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name; cin>>q->needtime; q->cputime=O;q->priority=P_TIME-q->needtime;q->round=0; q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{ t->next=q; t=q; } i++;}return p;}void display(pcb *p) //显示本轮运行后的进程各状态情况{coutvv" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"优先级"vv" "vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";cout<vp_>priority;coutvv"";switch(p->process) //对枚举类型的输出方法{case ready:cout< <"就绪"<<endl;break;case execute:cout< <"执行"<<endl;break;case block:cout<<"阻塞"<<endl;break;case finish:cout<<"完成"<<endl;break;} p=p->next;}}int process_finish(pcb *q) //判断所有的进程是否运行结束{ -int b=1;while(q&&b){b=b&&q->needtime==O; q=q_>next;} return b;}void cpuexe(pcb *q) //优先级调度算法的一次执行{pcb *t;t=q;int i=0;while(q){if (q->process!=finish){q_>process=ready;if(q->needtime==0) q->process=finish;} if(i<q->priority) if(q->process!=finish){ t=q;i=q->priority;} q=q->next;}t->needtime-=1;t_>priority_=3; if(t->needtime==0)t->process=finish; t->cputime+=1;}void priority_cal() //优先级调度算法{pcb *p;P=get_process();〃取得进程队列int cpu=0;while(!process_finish(p)) //若进程并未全部结束，则还需要执行{cpu++;coutvv"运行次数："vvcpuwendl; cpuexe(p);//一次cpu的执行display(p);//显示本次执行结果}}pcb * get_process_round()Jpcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"《endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime; q->cputime=O;q->round=0;q->count=0;q_>process=ready; q->next=NULL; if(i==0){p=q;t=q;}else{} i++; } return p;} t->next=q; t=q；void cpu_round(pcb *q){-q->count++;q->cputime+=2;q->needtime-=2;if(q->needtime<0)q->needtime=0;q->round++;q->process=execute;}pcb *get_next(pcb *k,pcb *head){ -pcb *t;t=k; do{t=t->next;}while (t && t->process==finish);if(t==NULL){} return t; t=head;while (t->next!=k && t->process==finish) {t=t->next;}void set_state(pcb *p){-while(p){if (p->needtime==O){p->process=finish;}if (p->process==execute){p_>process=ready;} p=p_>next;}}void display_round(pcb *p){ -cout«" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"时间片"vv"" vv"次数"vv""vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";coutvvp->round;coutvv"";coutvvp->count;coutvv"";switch(p->process){case ready:coutv v"就绪"vvendl;break;case execute:coutvv'执行"vvendl;break;case finish:coutvv"完成"vvendl;break;}p=p->next;}}void round_cal(){pcb *p;pcb *r;p=get_process();int cpu=0;r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);coutvv"运行次数"vvcpuvvendl;display_round(p);set_state(p);} }-void display_menu(){ -coutvv"进程调度算法操作:"vvendl;coutvv"1 优先数"vvendl;coutvv"2 时间片轮转"vvendl;coutvv"3 退出"vvendl;}void main(){display_menu();int k;printf("请选择:");scanf("%d",&k);switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:break;}} ----------------------------------------------------------------------------------------------------------测试数据:¥间出择1A.时退选r 5642 3込簷运行结果:1优先数S却曰石石<奪--a S 亠 亡疋出尢尤扫 亡、 ^a ^T B a 抄各时 各时 进还进还称进入时|可0 3 0I! IS 运行次数 “称进入时间II态成養成成忧完就完完完&0 94 2R p f c 32 3 4 3 % 扰冋运行次数心 泊称进入吋冋R5 R 5 C4 卜2佳行次数陰态成成成成成状§_f c s ^H Z B6 4 28尸尤32 3 4结果截图与分析2、时间片轮转10 0名称进入时问64 42 运行次数t k 称进入吋间A称进入时间竇鶴躺翻聶s _^->4p 者者者奁廿者_J-^□者者HiH8 数 謝还轎時 0 00 0 0次数0 口2 1 21 2 3 3216 6 42 2 1 20 Q 0D F次数3 E34 4 1 1 e s 02 0 0态成成态成衣成成些兀执完lla兀。
实验进程调度的实验报告
一、实验目的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算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
操作系统课程设计进程调度
静态最高优先数调度算法的流程图如下：
开始
创建PCB
将PCB挂入就绪队 列中，优先级高的
放在队首
是 就绪队列空
否 从队首取下最高优
先级进程运行
结束
进程运行完成，撤 销
时间片轮转调度算法 就绪进程获得 CPU后都只能运行一个时间片。 如果运行一个时间片后，进程的已占用 CPU时间已达到所
课程实验的目的和意义
培养程序设计的方法和技巧 掌握操作系统的原理和功能
进程调度实验
目的要求
用高级语言编写和调试一个进程调度程序， 以加深对进程的概念及进程调度算法的理解。 （注意：这里只是模拟的进程调度程序，用 一个链表结点模拟一个进程，而不用我们之 前用过的createprocess函数创建进程）
进程调度实验
用三个队列，就绪、运行、完成来表示进程 的不同状态。当新来一个进程时，若采用静 态优先级，则根据优先级插入就绪队列中不 同位置（若队列为空，则直接插入）。若采 用时间片，则直接插入就绪队列队尾。
实验例题
设计一个有 N个进程共行的进程调度程序
链表中每一个结点包括两部分：
（1）用户需要用的实际数据；（ name[10]; int prio; int round; int cputime; int needtime; 需自己输入）
需要的运行时间，则撤消该进程； 如果进程在所分的时间片内没有运行完成，则把它重新插
入就绪队列等待CPU。
时间片轮转调度算法的流程图如下：
开始
创建PCB
将PCB挂入就绪队 列中，先来的放在 队首，后来的放队
尾
操作系统课程设计报告进程调度
前言操作系统（Operating System, 简称OS）是管理和控制计算机硬件与软件资源旳计算机程序, 是直接运营在“裸机”上旳最基本旳系统软件, 任何其他软件都必须在操作系统旳支持下才干运营。
操作系统是顾客和计算机旳接口, 同步也是计算机硬件和其他软件旳接口。
操作系统旳功能涉及管理计算机系统旳硬件、软件及数据资源, 控制程序运营, 改善人机界面, 为其他应用软件提供支持, 让计算机系统所有资源最大限度地发挥作用, 提供多种形式旳顾客界面, 使顾客有一种好旳工作环境, 为其他软件旳开发提供必要旳服务和相应旳接口等。
事实上, 顾客是不用接触操作系统旳, 操作系统管理着计算机硬件资源, 同步按照应用程序旳资源祈求, 分派资源, 如: 划分CPU时间, 内存空间旳开辟, 调用打印机等。
操作系统旳重要功能是资源管理, 程序控制和人机交互等。
计算机系统旳资源可分为设备资源和信息资源两大类。
设备资源指旳是构成计算机旳硬件设备, 如中央解决器, 主存储器, 磁盘存储器, 打印机, 磁带存储器, 显示屏, 键盘输入设备和鼠标等。
信息资源指旳是寄存于计算机内旳多种数据, 如系统软件和应用软件等。
操作系统位于底层硬件与顾客之间, 是两者沟通旳桥梁。
顾客可以通过操作系统旳顾客界面, 输入命令。
操作系统则对命令进行解释, 驱动硬件设备, 实现顾客规定。
本次课程设计我们将对上学期所学旳知识进行系统旳应用, 而达到巩固知识旳作用目录1问题概述 (2)2需求分析 (2)3 概要设计 (2)3.1重要功能 (2)3.2 模块功能构造 (3)3.3 软硬件环境 (3)3.4数据构造设计 (3)4 具体设计 (4)4.1“先来先服务（FCFS）调度算法” (4)4.2“短进程调度算法（SPF）” (7)4.3“高响应比优先调度算法” (10)4.4“优先级调度（非抢占式）算法” (13)5 系统测试及调试 (15)5.1测试 (15)5.2调试过程中遇到旳问题 (16)6 心得体会 (17)7 参照文献 (18)8 附录 (19)1问题概述编写一种进程调度程序, 容许多种进程并发执行。
操作系统课程设计报告进程调度算法
操作系统课程设计报告进程调度算法Minix 操作系统实践计算机科学与技术题 目 :姓 名 : 学 号 : 专业 : 指导教师 :实验一1．实验目的通过优先权法和轮转算法的模拟加深对进程概念和进程调度过程的理解，掌握进程状态之间的切换，同时掌握进程调度算法的实现方法和技巧。
2．实验内容1．用C++语言来实现对n 个进程采用优先权优先算法以及轮转算法的进程调度。
2．每个用来标识进程的进程控制块PCB 用结构来描述，包括以下字段：（1）进程标识ID，其中0 为闲逛进程，用户进程的标识数为1，2，3⋯。
（2）进程优先级Priority ，闲逛进程（idle）的优先级为0，用户进程的优先级大于0，且随机产生，标识数越大，优先级越高。
（3）进程占用的CPU时间CPUtime，进程每运行一次，累计值等于4。
（4）进程总共需要运行时间Alltime ，利用随机函数产生。
（5）进程状态，0－就绪态；1－运行态；2－阻塞态。
（6）队列指针next，用来将多个进程控制块PCB 链接为队列。
3．优先数改变的原则（1）进程在就绪队列中每呆一个时间片，优先数增加1。
（2）进程每运行一个时间片，优先数减3。
4．在调度前，系统中拥有的进程数PCB_number 由键盘输入，经初始化后，所有的进程控制块PCB 链接成就绪队列。
5．为了清楚地观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来，3．实验步骤进程调度的思想（1）当系统空闲（就绪队列为空）时，系统运行闲逛进程，否则运行其他进程，发生变迁1（就绪→运行）。
（2）在运行进程（包括闲逛进程）的过程中，可能发生变迁2（运行→阻塞），即将运行进程插入到阻塞队列（闲逛进程不能被阻塞），可能有其他新的进程创建PCB，还可能唤醒阻塞队列中的某些进程PCB，发生变迁3（阻塞→就绪），即从阻塞队列中移出并插入就绪队列中。
（3）时间片运行结束后，若进程累计占用CPU 时间大于等于进程需要运行的时间，则进程执行结束，释放其PCB。
进程调度课程设计
进程调度课程设计一、教学目标本节课的教学目标是让学生掌握进程调度的基本概念、算法和原则，能够运用所学知识分析和解决实际问题。
具体目标如下：1.知识目标：（1）了解进程调度的定义、目的和重要性；（2）掌握进程调度算法，如先来先服务、短作业优先、最高优先级等；（3）理解进程调度原则，如公平性、效率等。
2.技能目标：（1）能够运用进程调度算法分析系统性能；（2）能够根据实际需求设计合适的进程调度策略；（3）能够使用相关工具进行进程调度实验。
3.情感态度价值观目标：（1）培养学生对计算机系统的兴趣和好奇心；（2）培养学生具备解决实际问题的责任感和使命感；（3）培养学生团队协作和自主学习的意识。
二、教学内容本节课的教学内容主要包括以下几个部分：1.进程调度的概念：介绍进程调度的定义、目的和重要性，使学生了解进程调度在操作系统中的地位和作用。
2.进程调度算法：讲解先来先服务、短作业优先、最高优先级等进程调度算法，并通过实例分析各算法的优缺点。
3.进程调度原则：介绍进程调度原则，如公平性、效率等，使学生能够根据实际需求设计合适的进程调度策略。
4.进程调度实验：演示进程调度实验，使学生能够运用所学知识分析和解决实际问题。
三、教学方法为了提高教学效果，本节课将采用以下教学方法：1.讲授法：通过讲解进程调度的基本概念、算法和原则，使学生掌握相关知识。
2.讨论法：学生分组讨论，分享对进程调度算法的理解和观点，培养学生的团队协作能力。
3.案例分析法：分析实际案例，让学生了解进程调度在操作系统中的应用和作用。
4.实验法：安排进程调度实验，让学生动手实践，提高解决实际问题的能力。
四、教学资源为了支持教学内容和教学方法的实施，我们将准备以下教学资源：1.教材：选用权威、实用的教材，如《操作系统原理与实践》等；2.参考书：提供相关领域的参考书籍，如《计算机操作系统》等；3.多媒体资料：制作精美的PPT，生动展示进程调度的相关概念和实例；4.实验设备：配置适当的实验设备，如计算机、网络设备等，为学生提供实践机会。
操作系统实验一进程调度
操作系统实验一进程调度在计算机科学中，操作系统是管理计算机硬件与软件资源的程序，是计算机系统的内核与基石。
而进程调度作为操作系统的核心功能之一，对于系统的性能和资源利用率起着至关重要的作用。
本次操作系统实验一，我们将深入探讨进程调度的原理和实现。
进程，简单来说，是正在运行的程序的实例。
在多道程序环境下，多个进程可能同时竞争计算机系统的资源，如 CPU、内存、I/O 设备等。
进程调度的任务就是从就绪队列中选择一个合适的进程，并将 CPU 分配给它，以实现资源的合理分配和系统的高效运行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达就绪队列的先后顺序进行调度，这种算法简单直观，但可能导致短作业等待时间过长，从而影响系统的整体性能。
短作业优先算法则优先调度运行时间短的进程，能够有效降低平均等待时间，但可能对长作业不利，容易造成“饥饿”现象。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片的 CPU 使用权。
这种算法能够保证每个进程都能得到及时响应，但时间片的大小选择需要权衡系统的开销和响应时间。
优先级调度算法为每个进程赋予一个优先级，优先级高的进程优先获得 CPU 资源。
然而，确定合理的优先级以及避免低优先级进程“饥饿”是该算法需要解决的问题。
在实验中，我们通过模拟实现这些调度算法，来深入理解它们的工作原理和性能特点。
以时间片轮转算法为例，我们首先需要创建一个就绪队列来存放等待调度的进程。
每个进程包含进程 ID、所需运行时间、已运行时间等信息。
在调度过程中，从就绪队列头部取出一个进程，判断其剩余运行时间是否小于等于时间片。
如果是，则该进程运行完毕，从队列中删除；否则，将其已运行时间增加时间片大小，剩余运行时间减少时间片大小，然后将其移到队列尾部，等待下一轮调度。
通过对不同调度算法的模拟实验，我们可以观察到它们在不同场景下的表现。
《计算机操作系统-进程调度》课件解读
进程状态及转换
进程控制
进程控制，就是系统使用一些具有特定功能的程序段来创建、撤消进 程以及完成进程各状态间的转换，从而达到多进程高效率并发执行和 协调、实现资源共享的目的。 1.进程创建 2.进程撤销 3.进程阻塞 4.进程唤醒 5.进程切换：在某一时刻，一运行的进程被迫中断，让出CPU给指定 进程。一般在进行进程上下文切换时，不保留被切换的进程上下文的 正文，但保留进程执行时所使用的寄存器。
并发控制的实施
• • • • 策略：临界资源与临界区 机制：标志、信号量 方法：加锁、P、V原语 实现：互斥和同步
进程互斥（1）
临界资源：一次仅允许一个进程使用的共享资源。每次只准许一个进 程进入临界区，进入后不允许其他进程进入。对于临界资源，多个进 程必须互斥地对它进行访问。 临界区：每个进程中访问临界资源的那段代码。 临界区是由属于不同并发进程的程序段共享公用数据或公用数据变量 而引起的。 间接制约：由共享公有资源而造成的对并发进程执行速度的间接制约 。即把这种由于共享某一公有资源而引起的在临界区内不允许并发进 程交叉执行的现象。
如何监控程序的执行？
用各种数据结构来记录多个进程（PCB） 用状态的变迁来跟踪多个进程 用进程调度来选择控制多个进程 用并发控制来同步、协调多个进程
进程的静态描述
进程=程序+数据+进程控制块PCB
程序描述进程所要完成的功能 数据是对其进行操作的数据结构集，程序在执行时必不可少的工作区 和操作对象。 进程控制块包含了有关进程的描述信息、控制信息以及资源信息，是 进程动态特征的集中反映。
计算机操作系统
——进程调度
摘要
基础：进程调度 策略：进程调度 实现：互斥与同步
- 避免：死锁与饥饿 - 解决：几个经典问题（如生产者-消费者） - 了解：进程通信
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
1）熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转；2）结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1）本实验要求完成如下任务:2）编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个；3）最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A）, 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为：进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
实验三 进程调度实验讲稿
内容一：检查上次进程模拟实验情况；实验三进程调度【实验要求】1、复习进程的状态及其转换；2、深入理解同步与互斥的概念及p、v操作；3、了解进程调度的功能和算法；4、上机前仔细阅读参考程序，并在参考程序的基础上，对程序作相应的修改,修改后进行测试，给出最后的实验数据与测试结果。
【实验目的】进程调度是进程管理的主要内容之一，通过设计编程，调试一个简单的进程调度模拟程序，对进程调度，进程运行状态变换及PV操作加深理解和掌握。
【实验内容】1、模拟批处理多道操作系统的进程调度；采用剥夺式优先算法，对三个进程进行模拟调度2、模拟实现同步机构避免并发进程执行时可能与时间相关的错误；模拟PV操作同步机构，用PV操作解决进程进入临界区的问题。
【需修改的实验内容】这一部分内容要求同学们自己编程完成，并进行调试，给出相应的测试数据和测试结果1、将进程的优先级设为动态的优先数，用设置和计算两种方式实现；设置可以用一个设置函数完成，也可以用随机数；计算给出一个计算公式；2、在不修改优先数的基础上，请同学们将由p1先执行改为p3先执行，并进行测试；测试后与参考程序进行比较；给出比较结果。
3、在修改了优先数之后，请同学们将由p1先执行改为p3先执行，并进行测试；测试后与参考程序进行比较；给出比较结果。
【提示】（1）参考程序对三个进程进行模拟调度，对各进程的优先数静态设置，P1,P2,P3三个进程的优先数为1，2，3，并指定P1的优先数最高，P3的优先数最低，每个进程都处于执行态“e”，就绪态“r”，等待态“w”三种状态之一，并假定初始态为“r”。
（2）每一个进程有一个PCB，PCB的内容根据具体情况设置，这里共设置4个数据域，该系统在运行过程中能显示或打印各进程和参数的变化情况，以便观察各进程的调度；（3）参考程序在完成必要的初始化后，便进入进程调度程序，首先由P1进入执行，当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时，转进程调度。
操作系统实验进程调度程序设计
操作系统实验进程调度程序设计实验目的：1.了解进程调度的原理和实现方式；2.掌握操作系统中进程调度算法的设计和实现方法；3.实现一个简单的进程调度程序，模拟不同的调度算法。
实验内容：在操作系统中，进程调度是一项重要的任务。
它负责决定哪些进程可以运行，以及在什么时间运行。
进程调度的主要目标是提高计算机系统的资源利用率和吞吐量，以及减少用户的响应时间。
本次实验的目标是设计一个简单的进程调度程序，并实现不同的调度算法。
你需要完成以下任务：1. 了解调度算法的基本概念和原理，如先来先服务（FCFS）、最短进程优先（SJF）、优先级调度（Priority Scheduling）、时间片轮转（Round Robin）等；2. 设计一个进程控制块（Process Control Block, PCB），用于存储进程的相关信息，包括进程的标识符、优先级、到达时间、执行时间等；3.实现以上调度算法中的任意一种。
你可以选择自己感兴趣或熟悉的调度算法进行实现。
如果你不确定，可以选择先来先服务（FCFS）算法，这是最简单的调度算法之一；4.编写测试程序，模拟多个进程的到达和执行过程。
你可以根据需要设置不同的进程到达时间和执行时间，并观察不同调度算法下的执行效果。
实验步骤：1.了解调度算法的原理和实现方式。
可以通过查阅相关教材、资料或网络资源来获得更多信息；2. 设计进程控制块（Process Control Block, PCB），其中包括进程的标识符、优先级、到达时间、执行时间等信息；3.根据选择的调度算法，编写相应的调度程序。
你可以选择使用C、C++或其他编程语言来实现；4.编写测试程序，模拟多个进程的到达和执行过程。
可以通过使用随机数生成器来模拟进程到达时间和执行时间；5.运行测试程序，观察不同调度算法下的执行效果。
可以比较各个算法的平均周转时间、平均等待时间等指标，并分析结果；6.根据需要进行调整和优化，再次运行测试程序，并观察结果；7.总结实验过程和结果，撰写实验报告。
实验报告操作系统实验一进程调度.doc
计算机电子信息工程学院实验报告成绩________ 课程名称操作系统指导教师杨秀华实验日期 2011年9月15、22、29,10月12院（系）计算机学院专业班级09计算机应用实验地点 B-4009学生姓名学号实验项目名称实验一模拟设计进程调度一、实验目的和要求用C或C++语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解．二、实验原理进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）状态之一。
就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1（即降低一级）,然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
三、主要仪器设备或材料PC机,C++环境四、实验方法与步骤（可加附页）1、主要数据结构：struct pcb { /* 定义进程控制块PCB */char name[10]; //进程名字char state; //进程状态int super; //进程的优先级int ntime; //进程需要运行的时间int rtime; //进程已经运行的时间struct pcb* link; }2、调度算法的流程图如上图 :五、实验数据记录、处理及结果分析六、讨论、心得计算机电子信息工程学院实验报告（附页）程序参考代码：参考代码：#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb{ /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;void sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/{p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if(insert==0) first->link=p;}}void input() /* 建立进程控制块函数*/{int i,num;printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}Void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n qname \t state \t super \t ndtime \t runtime \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}Void check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}Void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{3 / 4printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}Void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}Void main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}知识改变命运。
操作系统实验二进程调度
操作系统实验二进程调度摘要：进程调度是操作系统中重要的功能之一，可以决定进程的优先级和执行顺序。
本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。
一、概念介绍进程调度是操作系统中的一项重要功能，用于决定哪个进程能够在处理器上运行。
在操作系统中存在多个进程需要同时运行，而处理器资源有限，因此需要通过进程调度来合理地安排进程的执行顺序，提高系统的效率。
进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。
常见的调度策略包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转、优先级调度等。
二、调度算法介绍1.先来先服务（FCFS）先来先服务（FCFS）是最简单的调度算法，按照进程到达的顺序进行调度，先到达的进程先执行。
FCFS算法不考虑进程的优先级和执行时间，容易导致平均等待时间长。
2.最短作业优先（SJF）最短作业优先（SJF）调度算法按照进程所需的CPU时间进行排序，优先调度所需时间最短的进程。
SJF算法可以减少平均等待时间，但可能会导致长作业等待时间过长。
3.时间片轮转时间片轮转是一种抢占式调度策略，将处理器的使用权分割为若干个时间片，每个进程在一个时间片内运行，如果时间片用完仍未运行完，则将该进程放到队列的末尾，并让下一个进程运行。
时间片轮转算法保证了公平性和响应时间，但可能会导致上下文切换次数过多。
4.优先级调度优先级调度是根据进程的优先级进行调度，优先级高的进程先执行。
优先级可以根据进程类型、实时性等因素确定，不同的操作系统可能有不同的优先级范围和策略。
三、实验步骤1.定义进程结构：定义进程结构体，包含进程ID、进程状态、优先级、执行时间等信息。
2.初始化进程队列：将所有进程按照到达的先后顺序加入到进程队列中。
3.实现调度算法：根据不同的调度算法，实现相应的进程调度算法代码。
可以使用循环遍历进程队列，并根据不同的调度策略决定下一个要执行的进程。
4.执行进程调度：在每个时间片结束后，根据调度算法选取下一个要执行的进程，并更新进程的状态和执行时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
本科实验报告课程名称：操作系统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所示：RUN HEAD TAIL图2-1 进程控制块链结构其中：RUN—当前运行进程指针；HEAD—进程就绪链链首指针；TAIL—进程就绪链链尾指针。
2. 算法与框图程序框图如图2-2所示。
图2-2 进程调度框图(1)优先数法。
进程就绪链按优先数大小从大到小排列，链首进程首先投入运行。
每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3。
理由是该进程如果在一个时间片中完成不了，优先级应降低一级。
接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续运行，否则，调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。
(2)简单轮转法。
进程就绪链按各进程进入的先后次序排列，链首进程首先投入运行。
进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相应于优先数法的优先数记录项位置）。
每过一个时间片，运行进程占用处理机的时间片数加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 furthest 5struct 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++的语句语法都忘了好多，导致遇到一些语法错误而发现不了问题。