使用动态优先权的进程调度算法的模拟
优先权调度算法的类型
优先权调度算法的类型
1.非抢占式优先权调度算法：
非抢占式优先权调度算法是指一旦一个进程开始执行，其他进程无法抢占其CPU资源，直到该进程完成或主动释放CPU。
这种类型的优先权调度算法具有简单和易于实现的特点，但容易导致饥饿问题，即一些低优先级的进程可能永远无法执行。
2.抢占式优先权调度算法：
抢占式优先权调度算法允许进程在执行过程中被其他优先级更高的进程抢占CPU资源。
这种类型的优先权调度算法可以有效解决饥饿问题，但实现相对复杂，需要考虑进程状态保存和恢复的问题。
3.静态优先权调度算法：
静态优先权调度算法是在进程创建时就给予每个进程一个优先级，之后不再改变。
这种类型的优先权调度算法适用于优先级相对固定、难以变化的场景。
但是，静态优先权调度算法可能导致低优先级进程无法获得足够的CPU使用时间。
4.动态优先权调度算法：
动态优先权调度算法是根据一定规则和策略不断调整进程的优先级。
这种类型的优先权调度算法可以根据进程的行为和状态来调整优先级，有助于提高系统的性能和公平性。
5.多级队列优先权调度算法：
多级队列优先权调度算法将进程按优先级划分为多个队列，每个队列拥有不同的优先级范围。
进程首先进入最高优先级队列，只有在该队列中
没有可运行的进程时，才会调度下一个优先级较低的队列。
这种类型的优先权调度算法可以根据不同的优先级范围进行调度，提高系统的资源利用率和响应速度。
综上所述，优先权调度算法可以根据是否抢占、是否静态、是否动态以及是否多级队列来进行划分。
不同类型的优先权调度算法在不同的场景下有各自的优势和适用性，选择合适的算法可以提高系统的性能和用户体验。
使用动态优先权的进程调度算法的模拟
使用动态优先权的进程调度算法的模拟动态优先权（Dynamic Priority）调度算法是一种根据进程的行为动态调整其优先级的调度算法。
它是对静态优先权调度算法的一种改进，能够更加灵活和有效地调度进程。
下面我将通过模拟的方式详细介绍动态优先权调度算法。
在动态优先权调度算法中，每个进程都有一个初始优先级，等待时间越长，优先级越高。
当进程开始执行时，系统根据其行为调整它的优先级。
假设有五个进程ReadyQueue={P1, P2, P3, P4, P5}，它们的初始优先级分别为{10, 20, 30, 40, 50}。
每个进程的服务时间分别为{6, 7, 8, 9, 10}。
1.初始化阶段：-进程P1开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-正在运行的时间是指进程执行过程中已经消耗的时间。
2.执行阶段：-进程P1运行6个时间单位后，它已经完成了自己的服务时间。
这时，系统将调度下一个优先级最高的进程P5运行。
-进程P5开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
因为P5执行是第一次运行，所以其正在运行的时间为0。
-进程P5运行10个时间单位后，它也完成了自己的服务时间。
3.更新优先级阶段：-进程P5完成后，进程P2开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P2运行7个时间单位后，它完成了自己的服务时间。
4.重新排序阶段：-进程P3开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P3运行8个时间单位后，它也完成了自己的服务时间。
5.最后的执行阶段：-进程P4开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P4运行9个时间单位后，完成了自己的服务时间。
至此，所有的进程都已经完成了它们的服务时间。
动态优先权调度算法的核心思想是，等待时间越长，优先级越高。
这样做的原因是为了避免饥饿的产生，即一些低优先级的进程因为等待时间太长而无法得到运行。
动态优先权进程调度算法模拟实验报告
动态优先权进程调度算法模拟实验报告动态优先权调度算法是一种动态调度算法，根据进程的优先级来决定下一个要执行的进程。
进程的优先级可以根据其紧迫性、重要性和资源需求等因素来确定。
本实验利用模拟算法来模拟动态优先权调度算法，并通过实例来说明该调度算法的工作原理和优缺点。
一、实验目的通过本实验，我们可以了解动态优先权调度算法的工作原理，掌握如何使用模拟算法来模拟进程的调度过程，进一步了解该调度算法的优缺点。
二、实验环境本实验使用C++编程语言来实现动态优先权调度算法的模拟。
编译器使用Dev-C++。
三、实验步骤1.设计进程控制块（PCB）的数据结构，包括进程优先级、进程标识、进程状态等信息。
2.设计模拟算法来模拟动态优先权调度算法。
具体算法如下：a.初始化就绪队列，将所有的进程按照优先级插入到就绪队列中。
b.选择优先级最高的进程执行，并更新该进程的优先级。
c.执行完毕后更新进程的状态，并将其从就绪队列中删除。
d.如果新的进程到达，将其插入到就绪队列中。
3.实现主函数，模拟进程的创建、调度和执行过程。
4.进行多个实例的测试，观察进程的调度顺序和执行结果。
5.总结实验结果，分析动态优先权调度算法的优缺点。
四、实验结果与分析通过多个实例的测试，我们可以观察到动态优先权调度算法的工作过程和效果。
该算法可以根据进程的优先级来确定下一个要执行的进程，从而可以更好地满足不同进程的需求。
同时，动态优先权调度算法可以确保优先级高的进程能够及时得到执行，提高系统的响应速度。
然而，动态优先权调度算法存在一些缺点。
首先，该算法对进程的优先级要求较高，需要合理设置进程的优先级。
如果优先级设置不合理，可能导致优先级高的进程一直占用CPU资源，而优先级低的进程无法得到执行，造成资源浪费。
其次，该算法没有考虑进程的等待时间和执行时间，容易导致饥饿现象的发生，即一些进程无法得到执行。
五、实验总结通过本实验，我们了解了动态优先权调度算法的工作原理和模拟方法。
操作系统常用调度算法
操作系统常⽤调度算法在操作系统中存在多种调度算法，其中有的调度算法适⽤于作业调度，有的调度算法适⽤于进程调度，有的调度算法两者都适⽤。
下⾯介绍⼏种常⽤的调度算法。
先来先服务(FCFS)调度算法FCFS调度算法是⼀种最简单的调度算法，该调度算法既可以⽤于作业调度也可以⽤于进程调度。
在作业调度中，算法每次从后备作业队列中选择最先进⼊该队列的⼀个或⼏个作业，将它们调⼊内存，分配必要的资源，创建进程并放⼊就绪队列。
在进程调度中，FCFS调度算法每次从就绪队列中选择最先进⼊该队列的进程，将处理机分配给它，使之投⼊运⾏，直到完成或因某种原因⽽阻塞时才释放处理机。
下⾯通过⼀个实例来说明FCFS调度算法的性能。
假设系统中有4个作业，它们的提交时间分别是8、8.4、8.8、9，运⾏时间依次是2、1、0.5、0.2，系统⾤⽤FCFS调度算法，这组作业的平均等待时间、平均周转时间和平均带权周转时间见表2-3。
表2-3 FCFS调度算法的性能作业号提交时间运⾏时间开始时间等待时间完成时间周转时间带权周转时间18280102128.4110 1.611 2.6 2.638.80.511 2.211.5 2.7 5.4490.211.5 2.511.7 2.713.5平均等待时间 t = (0+1.6+2.2+2.5)/4=1.575平均周转时间 T = (2+2.6+2.7+2.7)/4=2.5平均带权周转时间 W = (1+2.6+5.牡13.5)/4=5.625FCFS调度算法属于不可剥夺算法。
从表⾯上看，它对所有作业都是公平的，但若⼀个长作业先到达系统，就会使后⾯许多短作业等待很长时间，因此它不能作为分时系统和实时系统的主要调度策略。
但它常被结合在其他调度策略中使⽤。
例如，在使⽤优先级作为调度策略的系统中，往往对多个具有相同优先级的进程按FCFS原则处理。
FCFS调度算法的特点是算法简单，但效率低；对长作业⽐较有利，但对短作业不利（相对SJF和⾼响应⽐）；有利于CPU繁忙型作业，⽽不利于I/O繁忙型作业。
进程调度
引起进程调度的主要因素有：（1）一个进程运行完毕。
（2）一个正在运行的进程被阻塞。
（3）在抢占式调度中，一个高优先级的进程被创建。
（4）在抢占式调度中，一个高优先级进程由阻塞唤醒。
（5）在轮转式调度中，正垢进程运行完进程调度的概念无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。
另外，系统进程也同样需要使用处理机。
这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
进程有四个基本属性1.多态性从诞生、运行，直至消灭。
2.多个不同的进程可以包括相同的程序3.三种基本状态它们之间可进行转换4.并发性并发执行的进程轮流占用处理器进程的三种基本状态:1.等待态：等待某个事件的完成；2.就绪态：等待系统分配处理器以便运行；3.运行态：占有处理器正在运行。
运行态→等待态往往是由于等待外设，等待主存等资源分配或等待人工干预而引起的。
等待态→就绪态则是等待的条件已满足，只需分配到处理器后就能运行。
运行态→就绪态不是由于自身原因，而是由外界原因使运行状态的进程让出处理器，这时候就变成就绪态。
例如时间片用完，或有更高优先级的进程来抢占处理器等。
就绪态→运行态系统按某种策略选中就绪队列中的一个进程占用处理器，此时就变成了运行态进程调度的分级高级、中级和低级调度作业从提交开始直到完成，往往要经历下述三级调度：高级调度：(High-Level Scheduling)又称为作业调度，它决定把后备作业调入内存运行；低级调度：(Low-Level Scheduling)又称为进程调度，它决定把就绪队列的某进程获得CPU；中级调度：(Intermediate-Level Scheduling)又称为在虚拟存储器中引入，在内、外存对换区进行进程对换。
进程调度的方式进程调度有以下两种基本方式：非剥夺方式分派程序一旦把处理机分配给某进程后便让它一直运行下去，直到进程完成或发生某事件而阻塞时，才把处理机分配给另一个进程。
进程调度模拟设计——时间片轮转、优先级法
学号：课程设计课程名字系统软件开发实训A题目进程调度模拟设计——时间片轮转、优先级法学院专业班级姓名指导教师2014 年01 月17 日课程设计任务书学生姓名：专业班级：指导教师：工作单位：题目: 进程调度模拟设计——时间片轮转、优先级法初始条件：1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟进程调度，能够处理以下的情形：⑴能够选择不同的调度算法（要求中给出的调度算法）；⑵能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；⑶根据选择的调度算法显示进程调度队列；⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2．设计报告内容应说明：⑴课程设计目的与功能；⑵需求分析，数据结构或模块说明(功能与框图)；⑶源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结。
时间安排：设计安排3周：查阅、分析资料 1天系统软件的分析与建模 4天系统软件的设计 5天系统软件的实现 3天撰写文档 1天课程设计验收答辩 1天设计验收安排：设计周的第三周的指定时间到实验室进行上机验收。
设计报告书收取时间：课程设计验收答辩完结时。
（注意事项：严禁抄袭，一旦发现，抄与被抄的一律按0分记）指导教师签名： 2013 年 12 月 10日系主任（或责任教师）签名： 2013 年 12 月 10日进程调度模拟设计——时间片轮转、优先级法1设计目的1.1 阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解，能够使用其中的方法来进行进程调度模拟设计。
1.2 练掌握并运用时间片轮转和优先级法，掌握一种计算机高级语言的使用。
2 设计要求2.1 能够选择不同的调度算法（要求中给出的调度算法）；2.2 能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；2.3 根据选择的调度算法显示进程调度队列；2.4 根据选择的调度算法计算平均周转时间和平均带权周转时间。
使用动态优先权的进程调度算法的模拟实验
使用动态优先权的进程调度算法的模拟实验进程调度算法是操作系统中对进程进行调度的一种策略，动态优先权调度算法是其中一种常用的调度算法。
下面将对动态优先权调度算法进行模拟实验，并对实验结果进行分析。
首先，我们定义进程的属性包括进程编号、到达时间、服务时间、优先权和完成时间等。
动态优先权调度算法的基本思想是根据进程的优先权决定下一个被调度的进程，优先权越高，被调度的机会越大。
实验过程如下：1.创建一个进程队列，用来存放待调度的进程。
2.输入进程的个数，并依次输入每个进程的到达时间、服务时间和优先权。
3.将所有进程按照到达时间进行排序。
4.从排好序的进程队列中选择优先权最高的进程，即优先权最大的进程。
5.通过执行该进程进行模拟，更新进程队列中的进程信息。
6.根据更新后的进程信息，重新选择下一个被调度的进程。
7.重复步骤5和6，直到所有进程执行完毕。
对于每个进程，我们可以记录其等待时间、周转时间和带权周转时间。
等待时间即为该进程在就绪队列中等待的时间，周转时间是指从进程提交到完成的时间，即完成时间减去到达时间，带权周转时间是指每个进程的周转时间除以服务时间，用来评估进程的调度效果。
下面是一个动态优先权调度算法的模拟实验示例：```pythonclass Process:self.id = idself.priority = prioritydef __lt__(self, other):return self.priority < other.prioritydef dynamic_priority_scheduling(processes):queue = []while processes or queue:for process in processes:queue.append(process)processes.remove(process)queue.sort(reverse=True) # 根据进程的优先权进行排序if queue:process = queue.pop(0)for p in queue:if __name__ == '__main__':n = int(input("Enter the number of processes: "))processes = []for i in range(n):priority = int(input("Enter priority for process {}:".format(i+1)))dynamic_priority_scheduling(processes)```以上代码定义了一个Process类来表示进程，并使用动态优先权调度算法对进程进行调度。
操作系统实验——动态优先级进程调度实验报告
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号进程成为当前进程，开始执行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验1使用动态优先权的进程调度算法的模拟1实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
2实验内容（1）实现对N个进程采用动态优先权优先算法的进程调度。
（2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
进程已占用的CPU时间CPUTIME。
进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，将进入阻塞状态。
进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
进程状态STATE。
队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：进程在就绪队列中停留一个时间片，优先数加1。
进程每运行一个时间片，优先数减3。
（4）假设在调度前，系统中有5个进程，它们的初始状态如下：ID 0 1 2 3 4PRIORITY 9 38 30 29 0CPUTIME 0 0 0 0 0ALLTIME 3 3 6 3 4STARTBLOCK 2 -1 -1 -1 -1BLOCKTIME 3 0 0 0 0STATE ready ready ready ready ready（5）为了清楚的观察各进程的调度过程，程序应将每个时间片内的情况显示出来，参照的具体格式如下：RUNNING PROG：iREADY-QUEUE：->id1->id2BLOCK-QUEUE：->id3->id4= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = == = =ID 0 1 2 3 4PRIORITY P0 P1 P2 P3 P4CUPTIME C0 C1 C2 C3 C4ALLTIME A0 A1 A2 A3 A4STARTBLOCK T0 T1 T2 T3 T4BLOCKTIME B0 B1 B2 B3 B4STATE S0 S1 S2 S3 S43实验结果（1）流程图（2）程序源代码#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{int id; //进程标识数int priority; //进程优先数，优先数越大优先级越高int cputime; //进程已占用的CPU时间int alltime; //进程还需占用的CPU时间int startblock; //进程的阻塞时间int blocktime; //进程被阻塞的时间char state[10]; //进程状态struct node *next; //队列指针}PCB;PCB *CreatQueue(int num) //创建一个就绪队列{int i; //i为循环计数器PCB *head, *temp1, *temp2, *temp3; //head为就绪队列的头指针，temp1为创建进程结点的指针，temp2、temp3分别为比较结点的前驱结点和比较结点for(i=0; i<num; i++) //根据进程的个数创建结点并按从大到小的顺序进行排序{temp1=(PCB *)malloc(sizeof(PCB));printf("输入第%d个进程的(id…state)\n",i);scanf("%d%d%d%d%d%d%s",&temp1->id,&temp1->priority,&temp1->cputime,&temp1->alltime,&temp1->startb lock,&temp1->blocktime,temp1->state);if(i==0) //如果创建的是第一个结点{head=temp1;head->next=NULL;continue;}if(head->priority < temp1->priority) //如果创建结点中所保存的数比头结点所保存的数要大，则直接把该结点插入到头结点之前{temp1->next=head;head=temp1;continue;}temp2=head; //temp2为比较结点的直接前驱结点temp3=temp2->next; //temp3为比较的结点while(temp3!=NULL && temp3->priority>=temp1->priority) //实现查找的功能{temp2=temp3;操作系统 实验报告temp2->next=temp1;temp1->next=temp3;}return head;}PCB *InsertQueue(PCB *head,PCB *run) //在就绪队列中插入一个结点{PCB *temp1,*temp2; //temp1和temp2分别为比较结点的前驱和比较结点if(head==NULL) //如果就绪队列为空{head=run;head->next=NULL;}else if(head->priority < run->priority) //如果插入结点中所保存的数比头结点所保存的数要大，则直接把该结点插入到头结点之前{run->next=head;head=run;}else{temp1=head; //temp1为比较结点的直接前驱结点temp2=temp1->next; //temp2为比较的结点while(temp2!=NULL && temp2->priority>=run->priority) //实现查找的功能{temp1=temp2;temp2=temp1->next;}temp1->next=run;run->next=temp2;}return head;}main(){int num; //num为进程的个数int alltime=0; //用来保存所有进程需要占用的CPU时间PCB *head; //head为就绪队列的头指针PCB *run=NULL; //run为执行进程结点的指针PCB *block=NULL; //block为阻塞进程的结点PCB *temp;printf("请输入进程的个数:");scanf("%d",&num);操作系统 实验报告temp=head;while(temp!=NULL){alltime+=temp->alltime;temp=temp->next;}while(alltime > 0){if(head!=NULL){run=head; //把就绪队列中的第一个进程取出来执行head=head->next; //就绪队列的头指针指向下一个结点strcpy(run->state,"run"); //状态改为执行run->next=NULL;/*显示状态*/printf("RUNNING PROG:%d\n",run->id); //显示执行进程printf("READY_QUEUE:"); //显示就绪进程temp=head;while(temp!=NULL){printf("->%d",temp->id);temp=temp->next;}printf("\n");printf("BLOCK_QUEUE:"); //显示阻塞进程if(block!=NULL){printf("%d",block->id);}printf("\n");printf("============================================================================\n");printf("ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE\n");printf("%d%d%d %d%d%d%s\n",run->id,run->priority,run->cputime,run->alltime,run->startblock,run->blocktime,run->state);temp=head;while(temp!=NULL){printf("%d%d%d%d%d%d%s\n",temp->id,temp->priority,temp->cputime,temp->alltime,temp->startblock,temp->blocktime,temp->state);temp=temp->next;}if(block!=NULL){printf("%d%d%d %d%d%d%s",block->id,block->priority,block->cputime,block->alltime,block->startblock,block->blocktime,block->state);操作系统 实验报告printf("============================================================================\n");/*显示状态*//*改变优先数*/run->priority-=3; //执行进程的优先数减3temp=head;while(temp!=NULL) //就绪进程的优先数加1{temp->priority+=1;temp=temp->next;}/*改变优先数*//*改变执行进程的有关参数*/run->cputime+=1; //执行进程的已占用CPU时间加1run->alltime-=1; //还需要的CPU时间减1if(run->alltime!=0){if(run->startblock > 0) //如果该进程会被阻塞{run->startblock-=1; //执行完一个时间片后，开始阻塞的时间减1if(run->startblock==0) //如果阻塞的时间到了{block=run; //执行转阻塞strcpy(block->state,"b"); //状态转阻塞alltime--;printf("\n");continue;}}strcpy(run->state,"r"); //状态转就绪head=InsertQueue(head,run); //执行转就绪run=NULL;}/*改变执行进程的有关参数*/alltime--;}else{/*显示状态*/printf("RUNNING PROG:\n"); //显示执行进程printf("READY_QUEUE:\n"); //显示就绪进程printf("BLOCK_QUEUE:"); //显示阻塞进程if(block!=NULL){printf("%d",block->id);操作系统 实验报告printf("============================================================================\n");printf("ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE\n");if(block!=NULL){printf("%d%d%d%d%d%d%s",block->id,block->priority,block->cputime,block->alltime,block->startblock,block->blocktime,block->state);}printf("\n");printf("============================================================================\n");/*显示状态*/}/*改变阻塞进程的有关参数*/if(block!=NULL) //如果有阻塞进程{block->blocktime-=1; //被阻塞的时间减1if(block->blocktime==0) //如果被阻塞的时间到了{strcpy(block->state,"r"); //状态转就绪head=InsertQueue(head,block); //阻塞转就绪block=NULL;}}/*改变阻塞进程的有关参数*/getchar();}}4思考（1）实际进程调度中，除了按调度算法选择下一个执行的进程外，还需要处理哪些工作？记录系统中所有进程的执行情况，作为进程调度的准备，进程管理模块必须将系统中各个进程的执行特征记录在各个进程的PCB表中。