优先级调度算法实验报告
先来先服务,时间片调度,优先级调度算法实验报告
![先来先服务,时间片调度,优先级调度算法实验报告](https://img.taocdn.com/s3/m/2111885f1fd9ad51f01dc281e53a580216fc5031.png)
先来先服务,时间片调度,优先级调度算法实验报告实验报告1. 引言进程调度是操作系统中非常重要的一部分,它决定了进程在CPU上执行的顺序和时间长度。
在本次实验中,我们通过实现先来先服务调度算法、时间片调度算法和优先级调度算法,并对其性能进行比较,来深入了解各种调度算法的工作原理及优缺点。
2. 先来先服务调度算法先来先服务调度算法按照进程到达的先后顺序进行调度。
当一个进程到达时,如果CPU空闲,则将其分配给CPU进行执行;如果CPU 正在执行其他进程,则该进程将等待直到CPU空闲。
优点是简单易实现,适用于长作业。
缺点是可能出现饥饿现象,即低优先级的进程可能会一直等待高优先级进程的执行。
3. 时间片调度算法时间片调度算法将CPU的执行时间划分为固定长度的时间片,每个进程在一个时间片内执行,当时间片用完后,系统将切换到下一个进程执行。
该算法确保每个进程都有公平的执行时间,避免了饥饿现象。
然而,对于CPU利用率较高的情况下,可能会导致进程频繁地切换,增加了上下文切换的开销。
4. 优先级调度算法优先级调度算法根据进程的优先级来进行调度,优先级较高的进程将具有更高的执行优先级。
当多个进程同时到达CPU时,系统将选择优先级最高的进程先执行。
该算法可以分为静态优先级调度和动态优先级调度两种方式。
优点是可以根据进程的重要性灵活调整执行顺序。
缺点是可能导致优先级低的进程长时间等待,造成饥饿现象。
5. 实验结果与分析我们通过模拟多个进程的到达和执行过程,在不同的场景下比较了先来先服务调度算法、时间片调度算法和优先级调度算法的性能。
实验结果显示,在长作业的情况下,先来先服务调度算法表现较好;在要求公平性的场景下,时间片调度算法比较适合;而对于需要根据优先级来调度的场景,优先级调度算法可以更好地满足需求。
6. 结论不同的进程调度算法在不同的场景下有各自的优劣。
先来先服务调度算法简单易实现,适用于长作业;时间片调度算法保证了公平性,适用于要求公平的场景;而优先级调度算法则可以根据进程的重要性进行调度。
操作系统实验报告——调度算法
![操作系统实验报告——调度算法](https://img.taocdn.com/s3/m/6b1af10d842458fb770bf78a6529647d26283440.png)
操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法,通过编写代码模拟不同的调度算法,了解它们的特点和应用场景。
2. 实验环境本次实验使用的操作系统环境为Linux,并采用C语言进行编码。
3. 实验内容3.1 调度算法1:先来先服务(FCFS)FCFS调度算法是一种简单且常见的调度算法。
该算法按照进程到达的先后顺序进行调度。
在本实验中,我们使用C语言编写代码模拟FCFS算法的调度过程,并记录每个进程的等待时间、周转时间和响应时间。
3.2 调度算法2:最短作业优先(SJF)SJF调度算法是一种非抢占式的调度算法,根据进程的执行时间来选择下一个要执行的进程。
在本实验中,我们使用C语言编写代码模拟SJF算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。
3.3 调度算法3:轮转调度(Round Robin)Round Robin调度算法是一种经典的时间片轮转算法,每个进程在给定的时间片内依次执行一定数量的时间。
如果进程的执行时间超过时间片,进程将被暂时挂起,等待下一次轮转。
在本实验中,我们使用C语言编写代码模拟Round Robin算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。
4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析,可以得出以下结论:- FCFS算法适用于任务到达的先后顺序不重要的场景,但对于执行时间较长的进程可能会导致下一个进程需要等待较久。
- SJF算法适用于任务的执行时间差异较大的场景,能够提高整体执行效率。
- Round Robin算法适用于时间片相对较小的情况,能够公平地为每个进程提供执行时间。
5. 实验总结本次实验通过模拟不同调度算法的实际执行过程,深入了解了各种调度算法的原理、特点和适用场景。
通过对实验结果的分析,我们可以更好地选择合适的调度算法来满足实际应用的需求。
在后续的学习中,我们将进一步探索更多操作系统相关的实验和算法。
操作系统优先调度算法实验报告
![操作系统优先调度算法实验报告](https://img.taocdn.com/s3/m/38fb8385e53a580216fcfeee.png)
scanf("%d",&a);
printf("\nPlease input the process name,arrive time and run time:\nFor example: 1 2 1\n");
for(i=0;i<a;i++)
注意:
实验报告将记入实验成绩;
每次实验开始时,交上一次的实验报告,否则将扣除此次实验成绩。
********************************************
name arrive run rest state
3 4 3 1 running
********************************************
name arrive run rest state
为考虑进程所需时间小于时间片大小的情况,如:进程运行完一次时间片时间中断后,但下一个进程的提交时间要迟很多,这时候就会浪费很多时间等待,这是该程序还需改进的地方。
另外,本实验中的RR算法的时间片大小固定,所以实际是属于基本轮转法,还有种是时间片长短是变化的,即改进轮转法。在基本轮转法中,时间片大小的设置是关键。时间片设得太短会导致过多的进程切换,降低了CPU效率;而设得太长又可能引起对短的交互请求的响应变差。据悉,通常,时间片的长度为几十毫秒到几百毫秒,而将时间片设为100毫秒通常是一个比较合理的折衷。
5.实验环境:实验用的软硬件环境(配置)。
6.实验方案设计(思路、步骤和方法等):这是实验报告极其重要的内容。概括整个实验过程。
先来先服务调度和最短作业优先调度算法实验报告
![先来先服务调度和最短作业优先调度算法实验报告](https://img.taocdn.com/s3/m/4870d1fec67da26925c52cc58bd63186bceb92a8.png)
先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法,以深入理解和掌握这两种调度算法的原理和实现方法。
二、实验方法和原理1.先来先服务调度算法(FCFS)2.最短作业优先调度算法(SJF)最短作业优先调度算法是根据作业所需的运行时间进行调度的。
当一个作业到达并获得CPU后,系统会选择剩余运行时间最短的作业进行处理,这样可以最大化地提高系统的吞吐量。
三、实验过程与结果1.先来先服务调度算法的实现我们先定义一个作业类Job,其中包含作业名称、到达时间和运行时间等属性。
首先根据到达时间对作业队列进行排序,然后按照顺序执行作业,记录每个作业的开始时间、结束时间和周转时间等指标。
下面是先来先服务调度算法的代码实现部分:```pythonclass Job: = namedef fcfs_scheduler(jobs):for job in sorted_jobs:#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业fcfs_scheduler(jobs)#输出结果for job in jobs:```运行以上代码,会得到作业的开始时间、结束时间和周转时间等信息。
2.最短作业优先调度算法的实现最短作业优先调度算法需要知道每个作业的运行时间,而这个信息在实际情况中是未知的。
因此,我们可以先按到达时间对作业队列进行排序,然后在每个时间片中选择剩余运行时间最短的作业进行执行。
下面是最短作业优先调度算法的代码实现部分:```pythondef sjf_scheduler(jobs):while True:if not remaining_jobs:break#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业sjf_scheduler(jobs)#输出结果for job in jobs:```运行以上代码,会得到相应的作业调度结果。
进程的调度实验报告(3篇)
![进程的调度实验报告(3篇)](https://img.taocdn.com/s3/m/3d52daba7e192279168884868762caaedd33bafc.png)
第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("无效的调度算法选择。
操作系统优先级调度算法实验报告
![操作系统优先级调度算法实验报告](https://img.taocdn.com/s3/m/910ffc6559fb770bf78a6529647d27284b7337d3.png)
操作系统优先级调度算法实验报告一、引言在操作系统中,进程调度是指将进程从就绪队列中选取一个最优的进程分配给CPU执行的过程。
优先级调度算法是一种常用的调度算法,根据进程的优先级来确定执行顺序。
本次实验旨在通过实例验证优先级调度算法的正确性和性能。
二、实验内容本次实验主要包括以下几个步骤:1.设计一个简单的操作系统,包括进程控制块(PCB)、就绪队列、等待队列等基本数据结构。
2.设计并实现优先级调度算法,包括进程创建、进程调度和进程结束等功能。
3.设计测试用例,并根据测试结果分析算法的正确性和性能。
三、实验设计1.数据结构设计(1)进程控制块(PCB):用于描述进程的属性和状态,包括进程ID、优先级、状态等信息。
(2)就绪队列:存放已经创建且处于就绪状态的进程。
(3)等待队列:存放因等待资源而暂停运行的进程。
2.优先级调度算法设计(1)进程创建:根据用户输入的优先级创建进程,并将进程添加到就绪队列中。
(2)进程调度:根据进程的优先级从就绪队列中选取一个进程,将其从就绪队列中移除,并将其状态设为运行。
(3)进程结束:当一个进程运行完成或被中断时,将其从就绪队列或等待队列中移除。
四、实验过程1.初始化操作系统,包括创建就绪队列和等待队列等数据结构。
2.设计测试用例,包括优先级相同和不同的进程。
3.执行测试用例,观察进程的执行顺序和调度性能。
4.根据测试结果分析算法的正确性和性能,包括是否按照优先级从高到低进行调度,以及调度过程中的上下文切换次数等指标。
五、实验结果与分析经过多次测试,实验结果如下:1.优先级相同的进程可以按照先来先服务的原则进行调度,无需进行优先级调度,因为它们具有相同的优先级。
2.优先级不同的进程可以按照优先级从高到低的顺序进行调度,优先级高的进程先执行,优先级低的进程后执行。
3.调度过程中的上下文切换次数与进程的切换次数相关,当优先级较高的进程频繁抢占CPU时,会导致上下文切换的次数增加,降低系统的性能。
操作系统最高响应比优先调度算法实验报告
![操作系统最高响应比优先调度算法实验报告](https://img.taocdn.com/s3/m/5f21fe834128915f804d2b160b4e767f5acf800c.png)
操作系统最高响应比优先调度算法实验报告一、实验目的1.了解操作系统中调度算法的概念和特点;2.掌握最高响应比优先调度算法的原理和实现;3.通过实验验证最高响应比优先调度算法在不同场景下的性能表现。
二、实验原理最高响应比优先调度算法是一种比较常见的作业调度算法,主要用于提高作业的响应速度和用户体验。
该算法的原则是根据作业的响应比来决定作业的调度顺序,响应比越高,优先级越高。
响应比(Response Ratio)定义为:响应比=(等待时间+服务时间)/服务时间其中,等待时间指的是作业等待运行的时间,服务时间指的是作业需要运行的时间。
在最高响应比优先调度算法中,每次从就绪队列中选择响应比最高的作业进行调度,直到所有作业都完成。
三、实验过程1.设计实验场景,包括作业数、服务时间和到达时间等参数;2.实现最高响应比优先调度算法的调度程序;3.根据参数设置,将作业按照到达时间的先后顺序放入就绪队列;4.按照最高响应比优先调度算法的原则,选择响应比最高的作业进行调度;5.更新作业的等待时间和响应比,并记录作业的调度顺序;6.统计作业的平均等待时间和平均响应时间,并输出结果。
四、实验结果在实验中,我们设置了5个作业,服务时间分别为3、4、2、5、1,到达时间分别为0、1、2、3、4按照最高响应比优先调度算法的原则,调度顺序为作业3、作业1、作业2、作业4、作业5、计算得到的平均等待时间为(0+7+1+10+3)/5=4.2,平均响应时间为(3+7+3+14+1)/5=5.6五、实验总结通过本次实验,我们了解了最高响应比优先调度算法的原理和实现过程。
该调度算法能够有效提高作业的响应速度和用户体验,但在实际应用中也存在一些问题,比如容易出现饥饿现象,即一些低响应比的作业可能一直得不到调度。
在选择调度算法时,需要根据实际情况和需求来进行权衡和选择,最高响应比优先调度算法适用于对响应时间要求较高的场景,但在其他场景下可能不适用。
调度算法的实验报告
![调度算法的实验报告](https://img.taocdn.com/s3/m/f888651d26284b73f242336c1eb91a37f0113250.png)
一、实验目的1. 理解操作系统调度算法的基本原理和概念。
2. 掌握几种常见调度算法的原理和实现方法。
3. 分析不同调度算法的性能特点,为实际应用提供参考。
二、实验内容本次实验主要涉及以下几种调度算法:先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)、最高响应比优先(HRRN)和时间片轮转(Round Robin)。
1. 先来先服务(FCFS)调度算法FCFS调度算法按照进程到达就绪队列的顺序进行调度,先到达的进程先执行。
该算法简单易实现,但可能导致长作业等待时间过长,从而降低系统吞吐量。
2. 最短作业优先(SJF)调度算法SJF调度算法优先选择执行时间最短的进程进行调度。
该算法可以最大程度地减少平均等待时间和平均周转时间,但可能导致长作业等待时间过长。
3. 优先级调度(Priority Scheduling)算法优先级调度算法为每个进程设置一个优先级,优先选择优先级高的进程进行调度。
该算法可以满足高优先级作业的需求,但可能导致低优先级作业长时间等待。
4. 最高响应比优先(HRRN)调度算法HRRN调度算法为每个进程设置一个响应比,优先选择响应比高的进程进行调度。
响应比是作业的等待时间与作业所需时间的比值。
该算法综合考虑了作业的等待时间和所需时间,是一种较为公平的调度算法。
5. 时间片轮转(Round Robin)调度算法时间片轮转调度算法将CPU时间划分为固定的时间片,按照进程到达就绪队列的顺序,每次只允许一个进程运行一个时间片。
如果进程在一个时间片内无法完成,则将其放入就绪队列的末尾,等待下一次调度。
该算法可以平衡各个进程的执行时间,但可能导致进程响应时间较长。
三、实验步骤1. 编写一个进程调度程序,实现上述五种调度算法。
2. 生成一个包含多个进程的作业队列,每个进程具有到达时间、所需运行时间和优先级等信息。
3. 分别采用五种调度算法对作业队列进行调度,并记录每个进程的执行情况。
实验的4优先级调度算法设计的实验的
![实验的4优先级调度算法设计的实验的](https://img.taocdn.com/s3/m/d7a59afd0508763231121243.png)
实验4 优先级调度算法设计实验1.实验目的在操作系统的调度算法中,优先级调度算法是一种常用的调度算法。
采用优先级调度算法要求每个进程都有一个优先级与其关联,具有最高优先级的进程会分配到CPU,具有相同优先级的进程按FCFS(First Come First Served)顺序调度。
本次实验要求在Linux操作系统上用C语言编写和调试一个基于优先级优先运行算法的进程调度程序。
2.实验内容1)优先级简介动态优先数是指在进程创建时先确定一个初始优先数,以后在进程运行中随着进程特性的改变不断修改优先数,这样,由于开始优先数很低而得不到CPU的进程,就能因为等待时间的增长而优先数变为最高而得到CPU运行。
例如:在进程获得一次CPU后就将其优先数减少1,或者进程等待的时间超过某一时限时增加其优先数的值,等等。
2)详细设计优先权调度算法:1.设定系统中有五个进程,每一个进程用一个进程控制块(PCB)表示,进程队列采用链表数据结构。
进程控制块包含如下信息:进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
在每次运行设计的处理调度程序之前,由终端输入五个进程的“优先数”和“要求运行时间”。
进程的优先数及需要的运行时间人为地指定,进程的运行时间以时间片为单位进行计算。
2.采用优先权调度算法,将五个进程按给定的优先数从大到小连成就绪队列。
用头指针指出队列首进程,队列采用链表结构。
处理机调度总是选队列首进程运行。
采用动态优先数办法,进程每运行一次优先数减“1”,同时将已运行时间加“1”。
进程运行一次后,若要求运行时间不等于已运行时间,则再将它加入就绪队列;否则将其状态置为“结束”,且退出就绪队列。
“就绪”状态的进程队列不为空,则重复上面6,7步骤,直到所有进程都成为“结束”状态。
3.在设计的程序中有输入语句,输入5个进程的“优先数”和“要求运行时间”,也有显示或打印语句,能显示或打印每次被选中进程的进程名、运行一次后队列的变化,以及结束进程的进程名。
操作系统实验——动态优先级进程调度实验报告
![操作系统实验——动态优先级进程调度实验报告](https://img.taocdn.com/s3/m/f811e72d00f69e3143323968011ca300a6c3f623.png)
1.实验名称:动态优先权调度过程中就绪队列的模拟2.实验要求:采用动态优先权的进程调度算法,用C语言编程模拟调度过程中每个时间片内的就绪队列。
3.实验内容:(1)每个进程控制块PCB用结构描述,包括以下字段:*进程标识符id*进程优先数priority,并规定优先数越大的进程,其优先权越高。
*进程已占用的CPU时间cputime*进程还需占用的CPU时间alltime,当进程运行完毕时,aiitime变为0*进程的阻塞时间startblock,当进程再运行startblock个时间片后,进程将进入阻塞状态*进程被阻塞的时间blocktime,已阻塞的进程再等待blocktime个时间片后,将转换成就绪状态*进程状态state*队列指针next,将PCB排成队列。
2)调度前,系统中有五个进程,它们的初始状态如下:3)进程在就绪队列呆一个时间片,优先数增加1。
4)进程每运行一个时间片,优先数减3。
5)按下面格式显示每个时间片内就绪队列的情况:READY_QUEUE:->id1->id24.任务分析进程控制块用结构体来表示,包含它的各项属性。
建立两个队列:一个就绪队列,一个阻塞队列。
创建一个进程控制块表示当前正在运行的进程。
程序开始运行时,所有进程都在就绪队列中。
当startblock减少到0时,进程进入阻塞队列。
在阻塞队列中的进程,当blocktime减少到0时,转入就绪队列。
在就绪队列中的进程,如果优先级比当前正在执行的进程高,就可以取代当前进程获取时间片。
当前进程如果运行完毕,就绪队列中优先级最高的进程就可以成为新当前进程。
5.程序流程图#include〈iostream〉#include〈string〉usingnamespace std;#define LEN5typedefenum STATE{READYBLOCKEND}STATE;//定义进程控制块typedefstruct PCB{int id;int priority;int cputime;int alltime;int startblock;int blocktime;STATE state;}PCB;//定义队列typedefstruct queue{int si ze;PCB*data[LEN];}Queue;PCB ps[LEN];PCB*cp; //进程最大数量//进程状态//就绪//阻塞//完成//进程标识符//进程优先级//已占用的CPU时间//还需占用的CPu时间//阻塞时间//被阻塞时间//进程状态//队列中进程的数量//进程的指针//进程数组//当前正在运行的进程6.程序清单Queue rQueue,bQueue;//就绪队列和阻塞队列//就绪队列按优先级降序排序(使用了冒泡排序法)void rQueueSort(){ PCB*temp;for(int i=0;i<rQueue.size-1;i++){for(int j=0;j<rQueue.size-1-i;j++){if(rQueue.data[j]-〉priority<rQueue.data[j+1]-〉priority){temp=rQueue.data[j];rQueue.data[j]=rQueue.data[j+1];}}rQueue.dataj+1]=temp;}}//初始化void init(){//给进程赋值for(int i=0;i<LEN;i++){ps[i].id=i;ps[i].state=READY;ps[i].cputime=0;ps[i].alltime=3;ps[i].blocktime=0;ps[i].startblock=T;}ps[0].priority=9;ps[1].priority=38;ps[2].priority=30;ps[3].priority=29;ps[4].priority=0;ps[2].alltime=6;ps[4].alltime=4;ps[0].startblock=2;ps[0].blocktime=3;cp=NULL;//当前进程赋空bQueue.size=0;//阻塞队列没有进程for(int i=0;i<LEN;i++){bQueue.data[i]=NULL;rQueue.data[i]=&ps[i];}rQueue.size=5;//所有进程全部进入就绪队列rQueueSort();//对就绪队列排序}//打印void print(){cout〈〈"\nRUNNINGPROG:";if(cp!=NULL){cout〈〈cp->id;}cout<<"\nREADY_QUEUE:";for(int i=0;i<rQueue.size;i++){cout〈〈"-〉"〈〈rQueue.data[i]-〉id; }cout<<"\nBLOCK_QUEUE:";for(int i=0;i<bQueue.size;i++){cout〈〈"-〉"〈〈bQueue.data[i]-〉id; }cout〈〈"\n"<<endl;cout<<"ID\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].id<<"\t";}cout<<"\nPRI0RITY\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].priority〈〈"\t";}cout<<"\nCPUTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].cputime〈〈"\t";}cout<<"\nALLTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].alltime〈〈"\t";}cout<<"\nSTARTBLOCK\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].startblock<<"\t";}cout<<"\nBLOCKTIME\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].blocktime<<"\t";}cout<<"\nSTATE\t\t";for(int i=0;i<LEN;i++){if(ps[i].state==READY){cout<<"READY"<<"\t";}elseif(ps[i].state==BLOCK){cout<<"BLOCK"<<"\t";}elseif(ps[i].state==END){cout〈〈"END"<<"\t";}}cout〈〈endl;}//出队,返回进程指针PCB*pop(Queue*q){PCB*temp;if(q-〉size>0){temp=q-〉data[0];//取出队首进程for(int i=0;i<q-〉size-1;i++){q-〉data[i]=q-〉data[i+1];//其他进程依次向前移动}q->size__;return temp;//返回队首进程}return NULL;}//入队void push(Queue*q,PCB*p){if(q_>size<LEN){q_>data[q_〉size]=p;//将入队的进程放在队尾q_>size++;}return;}//运行进程void run(){if(rQueue.size〉0||bQueue.size〉0){if(cp==NULL){//程序一开始运行时,从就绪队列取出首进程cp=pop(&rQueue);}//当前进程没有结束,但优先级比就绪队列首进程低if(cp_〉alltime〉0&&cp_>priority<rQueue.data[0]_〉priority){}push(&r Queue,c//改变进程状态//从就绪队列取出新的当前进程//修改当前进程的状态 //将当前进程加入阻塞队列 //从就绪队列取出新的当前进程{//当前进程的startblock 为正数时//运行一次减一个时间片//减到0时,修改进程状态//每运行一个时间片//就绪队列中的进程优先级+1//每运行一个时间片//阻塞队列中的进程blocktime-1//将当前进程放入就绪队列 //就绪队列队首进程成为当前进程if (cp-〉alltime==0){cp->state =END ;cp=pop(&rQueue); }//如果当前进程运行结束//startblock 为0,标志着当前进程要进入阻塞状态if (cp —>startblock==0&&cp —>blocktime>0){cp —>state=BLOCK ; push(&bQueue,cp); cp=pop(&rQueue); }elseif (cp —>startblock>0)cp —>st artblock 一; }cp —>alltime ——;if (cp —>alltime==0){cp —>state=END ;for (int i=0;i<rQueue.size;i++){rQueue.data[i]-〉priority++; }for (int i=0;i<bQueue.size;i++){if (bQueue.data[i]-〉blocktime>0){bQueue.data[i]-〉blocktime--; }//当阻塞队列队首进程blocktime 为0时if (bQueue.size 〉0&&bQueue.data[0]-〉blocktime==0){bQueue.data[0]-〉state=READY ;//修改进程状态push(&rQueue,pop(&bQueue));//将阻塞队列首进程取出,放入就绪队列cp —〉priority-=3;//修改当前进程的优先级cp —>cputime++; //当前进程占用CPU 时间片+1 if (cp —>alltime>0){//当前进程还需运行的时间片-1}//每运行一个时间片,就绪队列排一次序rQueueSort();} }//主函数int main(){init();//初始化 print();//打印进程信息 while (1){_sleep(1000);if (rQueue.size==0&&bQueue.size==0){//当两个队列都为空时,结束程序cp-〉state=END ;break ; }run();//运行进程 print();//打印进程信息 }return 0; }7.实验过程记录m 匚:\WINDQWS\system32\cmd.exe程序开始执行,当前进程是优先级最高的1号进程,1号进程的优先级减3、cputime++、执行几次之后,1号进程执行完毕而且优先级也不是最高的了,所以优先级为33的2号进程成为当前进程,开始执行。
先来先服务,时间片调度,优先级调度算法实验报告
![先来先服务,时间片调度,优先级调度算法实验报告](https://img.taocdn.com/s3/m/3f5e0526c4da50e2524de518964bcf84b9d52d11.png)
先来先服务,时间片调度,优先级调度算法实验报告先来先服务、时间片调度、优先级调度算法实验报告1. 引言本次实验旨在研究和比较先来先服务(FCFS)、时间片调度(RR)和优先级调度(Priority Scheduling)三种常见的进程调度算法。
进程调度是操作系统中的重要概念之一,合理的进程调度算法可以提高系统效率,优化资源利用。
2. 先来先服务算法•先来先服务算法是一种简单的调度算法,按照进程到达的顺序进行调度。
•优点:简单易实现,适用于长作业。
•缺点:容易造成短作业等待时间过长,无法满足实时性要求。
3. 时间片调度算法•时间片调度算法将CPU时间划分为一段一段的时间片,每个进程在一个时间片内执行。
•若进程未完成,会被放入就绪队列的末尾,等待下一个时间片。
•优点:公平,适用于短作业,能满足实时性要求。
•缺点:时间片过长,会导致长作业等待时间过长。
4. 优先级调度算法•优先级调度算法根据进程的优先级来确定调度顺序,拥有最高优先级的进程先执行。
•静态优先级可在创建进程时确定,动态优先级可根据进程执行情况进行调整。
•优点:适用于实时任务和长作业,可根据需求调整优先级。
•缺点:可能导致低优先级任务等待时间过长,存在优先级反转问题。
5. 实验结果与分析通过对三种调度算法的实验测试,得出以下结论:•FCFS算法在长作业的情况下表现较好,但对于短作业不友好,容易造成长时间等待;•RR算法适用于短作业,能保证公平性,但时间片过长可能导致长作业等待时间过长;•优先级调度算法较为灵活,能满足实时性要求,但可能导致低优先级任务长时间等待。
综上所述,不同的调度算法适用于不同的场景,根据需求选择合适的算法可提高系统效率。
6. 总结本次实验对先来先服务、时间片调度和优先级调度算法进行了研究和比较。
通过对三种算法的分析,我们可以根据任务特点和需求选择合适的调度算法,以提高系统的效率和资源利用率。
同时,在实际应用中也需要考虑进程的实时性要求,避免长时间等待等问题的出现。
抢占式优先级调度算法实验报告
![抢占式优先级调度算法实验报告](https://img.taocdn.com/s3/m/78dd6f10a4e9856a561252d380eb6294dc882248.png)
抢占式优先级调度算法实验报告一、实验目的1.了解抢占式优先级调度算法的基本原理和实现方法。
2.掌握抢占式优先级调度算法的实现过程。
3.通过实验,加深对操作系统调度算法的理解。
二、实验环境1.操作系统:Windows 102.编程语言:C++三、实验内容1.设计一个简单的抢占式优先级调度算法。
2.编写程序,模拟该算法的实现过程。
3.通过实验,观察和分析该算法的优缺点。
四、实验步骤1.设计抢占式优先级调度算法。
抢占式优先级调度算法是一种基于优先级的调度算法,它的基本思想是将进程按照优先级从高到低排序,然后按照优先级高低依次执行。
如果有更高优先级的进程到来,则当前进程会被抢占,让出CPU资源给更高优先级的进程执行。
2.编写程序,模拟该算法的实现过程。
程序的主要流程如下:(1)定义进程结构体,包括进程ID、进程优先级、进程状态等信息。
(2)定义进程队列,包括就绪队列和阻塞队列。
(3)初始化进程队列,将所有进程按照优先级从高到低排序,放入就绪队列中。
(4)循环执行以下操作:a.从就绪队列中取出优先级最高的进程,执行该进程。
b.如果有更高优先级的进程到来,则将当前进程放回就绪队列中,将新到来的进程放入就绪队列中。
c.如果当前进程执行完毕,则将其从就绪队列中移除。
d.如果当前进程被阻塞,则将其从就绪队列中移除,放入阻塞队列中。
e.如果阻塞队列中有进程被唤醒,则将其放回就绪队列中。
3.观察和分析该算法的优缺点。
优点:(1)能够充分利用CPU资源,提高系统的响应速度。
(2)能够保证高优先级进程的及时响应,提高系统的实时性。
缺点:(1)可能会出现“饥饿”现象,即低优先级进程无法得到执行。
(2)可能会出现“优先级反转”现象,即低优先级进程占用了高优先级进程所需的资源,导致高优先级进程无法得到及时响应。
五、实验结果经过实验,我们发现抢占式优先级调度算法能够有效地提高系统的响应速度和实时性,但也存在一些缺点,需要根据具体情况进行优化。
实验报告:模拟时间片轮转和优先级调度算法
![实验报告:模拟时间片轮转和优先级调度算法](https://img.taocdn.com/s3/m/8972a756cc175527072208e5.png)
1.实验内容(时间片轮转和优先级调度算法)(1)用C/C++/JA V A等语言来实现对N个进程采用优先权调度和时间片轮转调度。
(2)每个用来标识进程的进程控制块PCB用结构来描述,可能需要包括以下字段:⏹进程标识数ID。
⏹进程优先数PRIORITY,并规定优先数越小的进程,其优先权越高。
⏹进程已占用的CPU时间CPUTIME。
(初始都为0)⏹进程总的需要运行的时间ALLTIME。
⏹进程剩余运行时间remainTime, 当进程运行完毕时,remainTime变为0。
⏹进程的结束时间finishTime, 当进程结束时,“系统”的时间,计算周转时间用⏹进程状态STATE。
(就绪,运行,结束,根据需要决定是否使用)(3)输出:为观察进程调度是否正确,应输出进程的“执行”过程。
但是注意,我们是模拟进程执行,所以进程并不会真正“执行”,只是输出进程执行的先后顺序,和进程执行,结束的时间点。
对于时间片轮转,应该每个时间片输出一次----------------------------------------------------------Id pri cpuTime allTime0 4 3 41 32 60 4 3 4对于优先权调度,每次调度输出一次,进行的结束时间,依次输出调度进程的信息最后输出进程的周转时间,带权周转时间和系统平均周转时间等(4)实验数据:作业执行时间优先数----------------------1 10 32 6 13 2 44 4 55 8 2如果使用时间片调度算法,请自行设定时间片(如1,2等),并比较不同时间片下的周转时间等(5)实验设计:实验的小数据量使用数组或链表都可以,但考虑到真实的应用经常要删除和添加PCB,应该使用链表,如果涉及动态的插入删除,并且需要随时找最大/最小,也可以考虑用树/堆等其他数据结构(如C++中的优先级队列)。
(6)提高要求:给每个进程增加“到达”时间,重新计算优先级调度的各个结果,并验证结果是否正确2.实验目的通过模拟进程调度算法加深对进程调度的理解3.实验原理(1)周转时间:●概念:作业提交到操作系统开始到作业完成的时间包括四个部分:1、从外存中后备队列等待作业调度(高级调度)的时间2、进程在就绪队列等待进程调度(低级调度)的时间3、进程在cpu执行的时间4、进程等待IO操作完成的时间●计算:1、周转时间= 作业完成时间- 作业提交时间2、平均周转时间= 各作业周转时间之和/ 作业数3、带权周转时间= 作业周转时间/ 作业实际运行时间4、平均带权周转时间= 各作业带权周转时间之和/ 作业数(2)等待时间:1、进程/作业处于等待处理机状态时间之和2、对于进程:进程建立后等待被服务的时间之和3、对于作业:除了进程建立后的等待还包括作业在外存后备队列中等待的时间4、相应时间:用户提交请求到首次产生相应所用的时间(3)时间片轮转:●思想:公平、轮流为每个进程服务、每个进程在一定时间内得到相应●规则:按照到达就绪队列的顺序,轮流让各个进程执行一个时间片。
优先级实验报告
![优先级实验报告](https://img.taocdn.com/s3/m/9a81e777bc64783e0912a21614791711cc7979d3.png)
一、实验目的1. 了解优先级在操作系统中的重要性。
2. 掌握如何设置和调整任务的优先级。
3. 分析不同优先级对系统性能的影响。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3. 实验工具:多线程、多进程三、实验原理优先级是操作系统调度进程时考虑的一个重要因素。
操作系统根据进程的优先级来决定进程的执行顺序。
高优先级的进程会优先获得CPU时间,从而提高系统的响应速度。
在本实验中,我们将通过Python实现一个简单的优先级调度系统,模拟不同优先级对系统性能的影响。
四、实验步骤1. 创建一个进程池,用于执行多个任务。
2. 设置不同任务的优先级,并提交到进程池中。
3. 调用进程池的执行方法,观察不同优先级任务的执行顺序。
4. 记录并分析不同优先级任务执行时间。
五、实验代码```pythonimport threadingimport time# 定义任务函数def task(name, priority):print(f"开始执行任务:{name}")time.sleep(2) # 模拟任务执行时间print(f"任务:{name} 完成")# 创建一个优先级队列class PriorityQueue:def __init__(self):self.queue = []def enqueue(self, name, priority):self.queue.append((name, priority))def dequeue(self):if self.queue:name, priority = self.queue[0]self.queue.pop(0)return name, priorityreturn None# 创建进程池def process_pool(priority_queue):while True:task_name, priority = priority_queue.dequeue()if task_name is None:breakt = threading.Thread(target=task, args=(task_name, priority)) t.start()# 主函数def main():priority_queue = PriorityQueue()# 添加任务到优先级队列priority_queue.enqueue("任务1", 1)priority_queue.enqueue("任务2", 2)priority_queue.enqueue("任务3", 3)priority_queue.enqueue("任务4", 4)priority_queue.enqueue("任务5", 5)# 启动进程池process_pool(priority_queue)if __name__ == "__main__":main()```六、实验结果与分析1. 在实验中,我们设置了5个任务,它们的优先级从1到5依次递增。
最高优先数优先调度算法实验总结(共10篇)
![最高优先数优先调度算法实验总结(共10篇)](https://img.taocdn.com/s3/m/0d995b9082d049649b6648d7c1c708a1284a0acf.png)
最高优先数优先调度算法实验总结(共10篇):优先调度算法实验短作业优先调度算法sjf 算法c 高响应比优先调度算法篇一:优先级调度算法实验报告优先级调度算法实验报告院系:****************学院班级:***********姓名:***学号:************一、实验题目:优先级调度算法二、实验目的进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序,以便加深理解有关进程控制快、进程队列等概念,并体会和了解优先级算法的具体实施办法。
三、实验内容1.设计进程控制块PCB的结构,通常应包括如下信息:进程名、进程优先数(或轮转时间片数)、进程已占用的CPU 时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写优先级调度算法程序3.按要求输出结果。
四、实验要求每个进程可有三种状态;执行状态(RUN)、就绪状态(READY,包括等待状态)和完成状态(FINISH),并假定初始状态为就绪状态。
(一)进程控制块结构如下:NAME——进程标示符PRIO/ROUND——进程优先数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注:1.为了便于处理,程序中进程的的运行时间以时间片为单位进行计算;2.各进程的优先数或,以及进程运行时间片数的初值,均由用户在程序运行时给定。
(二)进程的就绪态和等待态均为链表结构,共有四个指针如下:RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针五、实验结果:六、实验总结:首先这次实验的难度不小,它必须在熟悉掌握数据结构的链表和队列的前提下才能完成,这次实验中用了三个队列,就绪队列,执行队列和完成队列,就绪队列中的优先级数是有序插入的,当进行进程调度的时候,需要先把就绪队列的队首节点(优先级数最大的节点)移入执行队列中,当执行进程结束后,判断该进程是否已经完成,如果已经完成则移入完成队列,如果没有完成,重新有序插入就绪队列中,这就是这次实验算法的思想。
优先级作业调度系统实验报告
![优先级作业调度系统实验报告](https://img.taocdn.com/s3/m/0b38b45867ec102de2bd89d7.png)
优先级作业调度系统实验报告一、实验内容分析:实验目的:Windows、Linux等操作系统都支持同时运行多个作业,但作业的执行顺序却因调度算法的不同而不同。
通常,操作系统都采用优先级作业调度,即操作系统根据作业的长短来设置优先级大小,优先级高的作业先执行,优先级低的作业后执行。
作业调度的详细情况如下描述:一个作业Ji的长度为ti =(si,ei),si 为作业运行的开始时间(进入时间),ei 为作业运行的结束时间(离开时间),ti则为完成作业Ji所需要的执行时间(单位:秒)。
作业调度的基本任务是从作业队列中选取一个来执行,如果没有作业则执行空操作操作。
而优先级作业调度,是指每次选取优先级最高的作业来调度,优先级可以用优先数(每个作业一个优先数pi)来表示,优先数越小,优先级越高。
作业Ji 进入系统时,即si 时刻,系统给该作业指定其初始优先数pi = ti,从而使越短的作业优先级越高。
该优先数在作业等待调度执行的过程中会不断减小,调整公式为:pi = pi - wi,其中wi 为作业Ji的等待时间:wi = 当前时间-si。
一旦作业被调度,该作业就一直执行,不能被抢占,只有当前执行的作业完成时,才产生下一轮调度。
所以需要在每次调度前动态调整各作业的优先数。
在每次调度的时候,如果出现相同优先级的作业,则按照先进先出(FIFO: First In First Out)的原则进行调度。
实验要求:1. 要求自己编程实现堆结构及其相关功能,从而实现优先级队列,不允许使用标准模板类的堆函数和优先级队列;测试时,各种情况都需要测试,并附上测试截图;2. 要求采用类的设计思路,不允许出现类以外的函数定义,但允许友元函数。
主函数中只能出现类的成员函数的调用,不允许出现对其它函数的调用。
3. 要求采用多文件方式:.h文件存储类的声明,.cpp文件存储类的实现,主函数main存储在另外一个单独的cpp文件中。
如果采用类模板,则类的声明和实现都放在.h文件中。
调度算法实验报告总结(3篇)
![调度算法实验报告总结(3篇)](https://img.taocdn.com/s3/m/7a8d8227326c1eb91a37f111f18583d048640f32.png)
第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程,加深对进程调度算法的理解。
实验中,我们重点研究了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种常见的调度算法。
通过编写C语言程序模拟这些算法的运行,我们能够直观地观察到不同调度策略对进程调度效果的影响。
二、实验内容1. 数据结构设计在实验中,我们定义了进程控制块(PCB)作为进程的抽象表示。
PCB包含以下信息:- 进程编号- 到达时间- 运行时间- 优先级- 状态(就绪、运行、阻塞、完成)为了方便调度,我们使用链表来存储就绪队列,以便于按照不同的调度策略进行操作。
2. 算法实现与模拟(1)先来先服务(FCFS)调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。
在模拟过程中,我们首先将所有进程按照到达时间排序,然后依次将它们从就绪队列中取出并分配CPU资源。
(2)时间片轮转(RR)调度算法RR算法将CPU时间划分为固定的时间片,并按照进程到达就绪队列的顺序轮流分配CPU资源。
当一个进程的时间片用完时,它将被放入就绪队列的末尾,等待下一次调度。
(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度。
在模拟过程中,我们为每个进程分配一个优先级,并按照优先级从高到低的顺序进行调度。
3. 输出调度结果在模拟结束后,我们输出每个进程的调度结果,包括:- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时,我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。
三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现,但可能会导致进程的响应时间较长,尤其是在存在大量短作业的情况下。
此外,FCFS算法可能导致某些进程长时间得不到调度,造成饥饿现象。
2. 时间片轮转(RR)调度算法RR算法能够有效地降低进程的响应时间,并提高系统的吞吐量。
然而,RR算法在进程数量较多时,可能会导致调度开销较大。
抢占式优先级调度算法实验报告
![抢占式优先级调度算法实验报告](https://img.taocdn.com/s3/m/e16d0d19443610661ed9ad51f01dc281e53a56d7.png)
抢占式优先级调度算法实验报告
抢占式优先级调度算法实验报告
实验目的
本次实验的主要目的是通过实际操作和观察结果,理解和掌握抢占式优先级调度算法的特点和使用方法,并且进一步熟悉操作系统相关概念和技术。
实验过程
实验环境和工具
本次实验环境为Windows操作系统及Visual Studio Code开发工具,使用C语言编写代码,在Ubuntu虚拟机上进行编译和执行测试。
实验步骤
1.了解抢占式优先级调度算法的基本概念和原理。
2.编写代码,实现抢占式优先级调度算法。
3.在Ubuntu虚拟机上编译和执行测试,观察结果并记录。
实验结果
经过多次测试,抢占式优先级调度算法表现出了以下特点: - 高优先级任务总是能够先执行。
- 如果新的高优先级任务进入队列,则会立即抢占正在执行的低优先级任务。
- 低优先级任务会被一直延后,直到没有高优先级任务需要执行为止。
实验感悟
通过本次实验,我更加深入地理解了抢占式优先级调度算法的运行机制和特点,同时也锻炼了自己的编程能力和问题解决能力。
在今后的学习和工作中,我会继续努力学习和尝试新的技术,不断提升自己的实践能力和创新能力。
实验总结
本次实验是一次很好的学习机会,让我对抢占式优先级调度算法有了更深入的理解和掌握。
同时,也让我意识到实践是掌握知识的最好途径,只有通过不断地实践和尝试,才能真正地掌握知识和技能。
在今后的学习和工作中,我将继续坚持自己的学习和实践,不断地提高自己的技能和能力。
希望自己能够成为一名优秀的技术人才,为社会和人民做出更多的贡献。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
优先级调度算法实验报告院系:****************学院班级:***********姓名:***学号:************一、实验题目:优先级调度算法二、实验目的进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序,以便加深理解有关进程控制快、进程队列等概念,并体会和了解优先级算法的具体实施办法。
三、实验内容1.设计进程控制块PCB的结构,通常应包括如下信息:进程名、进程优先数(或轮转时间片数)、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写优先级调度算法程序3.按要求输出结果。
四、实验要求每个进程可有三种状态;执行状态(RUN)、就绪状态(READY,包括等待状态)和完成状态(FINISH),并假定初始状态为就绪状态。
(一)进程控制块结构如下:NAME——进程标示符PRIO/ROUND——进程优先数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注:1.为了便于处理,程序中进程的的运行时间以时间片为单位进行计算;2.各进程的优先数或,以及进程运行时间片数的初值,均由用户在程序运行时给定。
(二)进程的就绪态和等待态均为链表结构,共有四个指针如下:RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针五、实验结果:六、实验总结:首先这次实验的难度不小,它必须在熟悉掌握数据结构的链表和队列的前提下才能完成,这次实验中用了三个队列,就绪队列,执行队列和完成队列,就绪队列中的优先级数是有序插入的,当进行进程调度的时候,需要先把就绪队列的队首节点(优先级数最大的节点)移入执行队列中,当执行进程结束后,判断该进程是否已经完成,如果已经完成则移入完成队列,如果没有完成,重新有序插入就绪队列中,这就是这次实验算法的思想。
附录(算法代码):#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*///int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态,W--就绪态,R--执行态,F--完成态*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列,就绪队列,执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列,规定优先数越小,优先级越高*/ void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*///void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*///void RoundRun(); /*时间片轮转调度*/void main(){printf("优先数调度算法\n");printf("请输入要创建的进程数目:");scanf("%d",&num);PrioCreate();Priority();Output();}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\t优先级\t需要时间\t进程状态\n");while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\n",p->name,p->prio,p->needtime,p->state);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\n",p->name,p->prio,p->needtime,p->state);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t\t%c\t\n",p->name,p->prio,p->needtime,p->state);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列,规定优先数越小,优先级越低*/ {PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空,则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大,则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾,则其优先级数最小,将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/{PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;int i;printf("输入进程名字,进程所需时间和优先级数:\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));getchar();scanf("%d",&(tmp->prio));// tmp ->cputime = 0;tmp ->state ='W';//tmp ->prio = 20 - tmp->needtime; /*设置其优先级,需要的时间越多,优先级越低*/InsertPrio(tmp); /*按照优先级从高到低,插入到就绪队列*/}}void Priority() /*按照优先级调度,每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时,则调度进程如执行队列执行*/ {Output(); /*输出每次调度过程中各个节点的状态*/while(flag){run->prio -= 3; /*优先级减去三*///run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/if(run->needtime == 0)/*如果进程执行完毕,将进程状态置为F,将其插入到完成队列*/{run ->state = 'F';// run->count++; /*进程执行的次数加一*/InsertFinish(run);flag = 0;}else /*将进程状态置为W,入就绪队列*/{run->state = 'W';//run->count++; /*进程执行的次数加一*///InsertTime(run);//再次插入就绪队列尾部InsertPrio(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/ }。