动态优先权算法模拟-操作系统课程设计
使用动态优先权的进程调度算法的模拟实验
使用动态优先权的进程调度算法的模拟实验动态优先权调度算法是一种根据进程动态表现调整优先权的进程调度算法。
它不仅考虑了进程的优先级，还将进程的实际执行情况作为调度依据。
下面将介绍一个模拟实验，以更好地理解这种调度算法。
实验背景：假设有五个待执行的进程，它们的ID和初始优先权分别为P1（3）、P2（5）、P3（2）、P4（1）、P5（4）。
这五个进程的优先权在调度过程中会根据实际情况进行动态调整。
实验过程：1.初始化：在实验开始之前，首先需要对进程的初始状态进行初始化。
每个进程有两个属性：优先级和已运行时间。
优先级用于决定进程的调度优先级，已运行时间用于记录进程已经运行了多长时间。
设置一个全局时间片，表示每个时间单元中运行的时间。
2.进程调度：根据进程的优先权，选取最高优先权的进程进行调度。
从P1到P5，进程的优先权逐渐减小。
-选择进程：比如初始时最高优先权的进程为P2-进程执行：进程P2被调度后开始执行，运行一个时间片。
每运行一个时间片，该进程的已运行时间加一，重新计算进程的优先权。
-优先权调整：根据已运行时间的加一，重新计算进程的优先权。
优先权的计算公式可以根据实际需要进行调整，比如可以设为：新的优先权=原优先权+（已运行时间/其中一常量）。
-进程阻塞：如果进程运行的时间超过了一个时间片，则该进程被阻塞，进入就绪队列等待下一次轮转调度，其他进程继续执行。
3.调度进程更新：进程在执行和阻塞的过程中，它们的优先权会发生变化。
在每一轮调度后，需要更新进程的优先权，重新确定每个进程的调度顺序。
4.实验结果：重复进行步骤2和步骤3，直到所有进程都完成执行。
记录每次调度过程中的结果，包括进程的执行顺序、时刻和优先权的变化。
实验分析：通过模拟实验，可以得出以下一些结论：1.动态优先权调度算法能够根据实际情况调整进程的优先权，更好地适应不同进程的需求，增强了调度的灵活性。
2.在实验中，进程运行时间越长，优先权越低。
动态优先权的进程调度算法模拟
动态优先权的进程调度算法模拟华北科技学院计算机系综合性实验实验报告课程名称计算机操作系统实验学期 2010 至 2011 学年第 2 学期学生所在系部基础部年级 2008级专业班级信息与计算科学学生姓名范玉文学号200809014212 任课教师杜杏菁实验成绩计算机系制华北科技学院计算机系综合性实验报告《操作系统》课程综合性实验报告开课实验室:第六实验室 2011年 6 月 15日进程调度算法程序设计实验题目一、实验目的通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。
二、设备与环境1. 硬件设备:PC机一台2. 软件环境:安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java 等编程语言环境。
三、实验内容(1)用C语言(或其它语言，如Java)实现对N个进程采用某种进程调度算法(如动态优先权调度)的调度。
(2)每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段: , 进程标识数ID。
, 进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
, 进程已占用CPU时间CPUTIME。
, 进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
, 进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
, 进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
, 进程状态STATE。
, 队列指针NEXT，用来将PCB排成队列。
(3)优先数改变的原则:, 进程在就绪队列中呆一个时间片，优先数增加1。
, 进程每运行一个时间片，优先数减3。
(4)为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
使用动态优先权的进程调度算法的模拟
使用动态优先权的进程调度算法的模拟动态优先权（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资源，而优先级低的进程无法得到执行，造成资源浪费。
其次，该算法没有考虑进程的等待时间和执行时间，容易导致饥饿现象的发生，即一些进程无法得到执行。
五、实验总结通过本实验，我们了解了动态优先权调度算法的工作原理和模拟方法。
使用动态优先权的进程调度算法的模拟实验
使用动态优先权的进程调度算法的模拟实验进程调度算法是操作系统中对进程进行调度的一种策略，动态优先权调度算法是其中一种常用的调度算法。
下面将对动态优先权调度算法进行模拟实验，并对实验结果进行分析。
首先，我们定义进程的属性包括进程编号、到达时间、服务时间、优先权和完成时间等。
动态优先权调度算法的基本思想是根据进程的优先权决定下一个被调度的进程，优先权越高，被调度的机会越大。
实验过程如下：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.通过实验模拟，对进程调度算法的性能进行评估。
实验背景：动态优先权的进程调度算法是基于进程优先级的调度算法。
每个进程被赋予一个初始优先级，随着时间的推移，根据进程的行为和状态，动态地调整进程的优先级。
实验实施步骤：1.定义进程的数据结构，包括进程ID、进程优先级、进程状态等信息；2.创建多个进程，并初始化前述的进程数据结构；3.模拟进程的执行过程，按照一定的规则和时间片来调度执行进程；4.根据进程的行为和状态，动态地调整进程的优先级；5.模拟多轮进程调度，记录进程的执行情况和性能指标；6.结果分析和实验总结。
实验具体实施：1.定义进程的数据结构：进程的数据结构可以使用类或者结构体来定义，包括进程ID（PID）、进程优先级（priority）、进程状态（state）等字段。
进程状态可以包括"就绪"、"运行"和"完成"等状态。
2.创建多个进程：创建多个进程，并为每个进程初始化进程数据结构，包括PID、priority和state等字段。
可以使用数组、链表或队列等数据结构来管理多个进程的信息。
3.模拟进程的执行过程：在模拟的过程中，将进程按照一定的规则和时间片来调度执行。
可以采用循环方式，循环执行每个进程的一小段代码，模拟进程在CPU上的执行过程。
4.动态地调整进程的优先级：根据进程的行为和状态，动态地调整进程的优先级。
例如，当进程执行完成后，将其优先级降低；当进程等待很长时间后，在没有获得CPU资源的情况下，将其优先级提高。
使用动态优先权的进程调度算法的模拟
PRIORITY 9 38 30 29 0
CPUTIME 0 0 0 0 0
ALLTIME 3 3 6 3 4
STARTBLOCK 2 -1 -1 -1 -1
BLOCKTIME 3 0 0 0 0
STATE ready ready ready ready ready
（5）为了清楚的观察各进程的调度过程，程序应将每个时间片内的情况显示出来，参照的具体格式如下：
if(i==0) //如果创建的是第一个结点
{
head=temp1;
head->next=NULL;
continue;
}
if(head->priority < temp1->priority) //如果创建结点中所保存的数比头结点所保存的数要大，则直
接把该结点插入到头结点之前
{
temp1->next=head;
进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
进程已占用的CPU时间CPUTIME。
进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，将进入阻塞状态。
int startblock; //进程的阻塞时间
int blocktime; //进程被阻塞的时间
char state[10]; //进程状态
struct node *next; //队列指针
}PCB;
PCB *CreatQueue(int num) //创建一个就绪队列
{
int i; //i为循环计数器
基于动态优先权调度算法的模拟
计算机学院设计性实验报告一、实验目的通过动态优先权调度算法和时间片轮转调度算法的模拟加深进程概念和进程调度过程的理解。
二、实验仪器或设备一台笔记本电脑或者是一台台式机三、总体设计（设计原理、设计方案及流程等）本实验的目的就是用在Linux下用C语言编程模拟N个进程采用高优先权优先（要求采用动态优先权）进程调度算法。
已知时间片轮转算法，可以根据时间片轮转的思路加以修改就行了。
时间轮转调度算法与动态优先权的区别就是时间片轮转是在FIFO进程调度的基础上，队列中的进程按照进入的顺序，每个进程每次都执行一个时间片；如果运行完就把该进程释放掉，如果在一个时间片内未结束就插到队列尾部。
而动态优先权进程调度算法就是按照优先权的大小运行进程，如果一个时间片内未运行完，则将优先权数减3后再插入到队列中（不是队尾而是队列中的适当位置，该位置前面的节点的优先级数大于该节点的优先级数，后面的节点的count值小于该节点的count值）。
四、实验要求：(1)在Linux下用C语言编程模拟N个进程采用高优先权优先（要求采用动态优先权）进程调度算法。
为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程情况显示出来；(2)进程控制块是进程存在的唯一标志，因此，在模拟算法中每一个进程用一个进程控制块PCB来代表，PCB用一结构体表示。
包括以下字段：●进程标识数id，或者进程的名称name；●进程优先数priority，并规定优先数越大的进程，其优先权越高；●进程需要运行的CPU时间ntime；●进程的运行时间rtime；●进程状态state；●队列指针next，用来将PCB排成队列。
(3)进程在运行过程中其状态将在就绪、执行、阻塞（可选）、完成几种状态之间转换，同时进程可能处于不同的队列中，如就绪队列、阻塞队列（可选）。
在两种调度算法中，考虑分别可以选择什么样的队列及如何实现进程的入队、出队操作；(4)为了便于处理，优先权调度每次也仅让进程执行一个时间片，若在一个时间片内未运行结束，调整进程优先级将其插入就绪队列，进行新一轮调度；(5)优先数改变原则：●进程每运行若一个时间单位，优先数减3；●进程在就绪队列中呆一个时间片，优先数增加1。
使用动态优先权的进程调度算法的模拟
3实验结果
(1)流程图
操作系统实验报告
%操作系统实验报告
(2)程序源代码
include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
int id;〃进程标识数
int priority;〃进程优先数，优先数越大优先级越高
(
int i;//i为循环计数器
PCB *head, *templ, *temp2, *temp3;//head为就绪队列的头指针，tempi为创建进程结点的指针，
temp2、temp3分别为比较结点的前驱结点和比较结点for(i=0; i<num; i++)〃根据进程的个数创建结点并按从大到小的顺序进行排序
if(i==0)〃如果创建的是第一个结点
{
head=templ;
head->next=NULL;
continue;
}
if(head->priority < templ->priority)〃如果创建结点中所保存的数比头结点所保存的数要大，则直
接把该结点插入到头结点之前
(
templ->next=head; head=templ;
te m p=temp->next;
)
while(alltime > 0)
(
if(head!=NULL)
{
run=head;〃把就绪队列中的第一个进程取出来执行
head=head->next;〃就绪队列的头指针指向下一个结点
动态高优先权优先
《操作系统》课程实验报告实验名称：动态高优先权优先调度班级：****************学号：*************姓名：**************指导老师：***************成绩：一、实验目的：1.测试数据可以随即输入或从文件中读入。
2.必须要考虑到作业的到达时间3.最终能够计算每一个作业的周转时间。
二、实验内容：模拟实现动态高优先权优先（若数值越大优先权越高，每运行一个时间单位优先权-n，若数值越小优先权越高，没运行一个时间单位优先权+n），具体如下：设置作业体：作业名，作业的到达时间，服务时间，初始优先权，作业状态（W ——等待,R——运行,F——完成），作业间的链接指针作业初始化：由用户输入作业名、服务时间、初始优先权进行初始化，同时，初始化作业的状态为W。
显示函数：在作业调度前、调度中和调度后进行显示。
排序函数：对就绪状态的作业按照优先权排序。
优先权相同时进入等待队列时间早的作业在前。
注意考虑到达时间调度函数：每次从等待队列队首调度优先权最高的作业执行，状态变化。
并在执行一个时间单位后优先权变化，服务时间变化，状态变化。
当服务时间为0时，状态变为F。
删除函数：撤销状态为F的作业。
三、实验代码#include<stdio.h>#include<string.h>#include<stdlib.h>typedefstruct PCB2{char name[10];//进程名int runtime;//要求运行时间intfrist;//定义优先数char zhuangtai; //定义状态，R为就绪，F为完成};struct PCB2 PCBcontrol[4];//定义进程控制块数组void youxian()//构造优先函数{inti,n;printf("请输入进程的个数:\n");scanf("%d",&n);printf("请输入进程的名字、优先权、运行时间\n");printf("\n");for(i=0;i<n;i++){printf("请输入第%d个进程的信息:\n",i+1);scanf("%s%d%d",&PCBcontrol[i].name,&PCBcontrol[i].frist,&PCBcontrol[i].ru ntime);PCBcontrol[i].zhuangtai='R';//进程初始状态均为就绪getchar();//等待回车进入下一次运行}}intmax_frist_process()//确定最大优先级进程子程序{int max=-10;//max为最大优先数，初始化为-10inti,key;for(i=0;i<5;i++){if(PCBcontrol[i].zhuangtai=='r')//r表示正在运行return -1;//返回-1elseif(max<PCBcontrol[i].frist&&PCBcontrol[i].zhuangtai=='R')//从就绪进程中选取优先数最大的进程{max=PCBcontrol[i].frist;//max存放每次循环中的最大优先数key=i;//将进程号赋给key}}if(PCBcontrol[key].zhuangtai=='F')//具有最大优先数的进程若已运行完毕return -1;//则返回-1elsereturn key;//将key作为返回值返回}void show()//显示函数{int i;printf("\n进程名优先级运行时间当前状态\n");printf("*****************************************\n");for(i=0;i<5;i++)//依次显示每个进程的名、优先数、要求运行时间和状态{printf(" %s\t %d\t %d\t %s\t\n",&PCBcontrol[i].name,PCBcontrol[i].frist, PCBcontrol[i].runtime,&PCBcontrol[i].zhuangtai);}printf("\n请按回车键进行查看");}void run()//进程运行子程序{inti,j;int t=0;//t为运行次数for(j=0;j<5;j++){t+=PCBcontrol[j].runtime;}//运行次数即为各个进程运行时间之和printf("\n进程没运行前，当前的状态是:\n");show(); //调用show()子程序显示运行前PCB的情况getchar();//等待回车进入下一次运行for(j=0;j<t;j++){while(max_frist_process()!=-1)//具有最大优先数的进程没有运行完，让其运行{PCBcontrol[max_frist_process()].zhuangtai='r';//将其状态置为r，表示其正在运行}for(i=0;i<5;i++){if(PCBcontrol[i].zhuangtai=='r'){PCBcontrol[i].frist-=1;//将当前运行进程的优先数减1PCBcontrol[i].runtime--;//要求运行时间减1{if(PCBcontrol[i].runtime==0)PCBcontrol[i].zhuangtai='F';//运行完则将该进程状态置为结束elsePCBcontrol[i].zhuangtai='R';//未运行完将其状态置为就绪}show();//显示每次运行后各PCB的情况getchar();//等待回车进入下一次运行}}}}void main(){int N;int number;char Tishikuang;//提示框do{printf(" ★*********★********★*******★******★********★*********★************★\n");printf("*************嵌入式软件14-01班****51********杨霖***************************\n");printf(" ** 输入1—高优先权优先服务法*\n");printf(" ** 输入0—退出该程序*\n");printf("********************************************************************* **\n");printf("\n注:请根据自己的需求选择相应的操作数：\n");scanf("%d",&number);/*提示输入字母，用switch语句存入到case中，最后增加提示框是否继续*/switch(number){case 0:break;case 1:printf("\n您选择的是“优先服务项目”，本程序可提供5个进程的调度。
操作系统实验——动态优先级进程调度实验报告
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. 程序流程图6. 程序清单#include<iostream>#include<string>using namespace std;#define LEN 5 // 进程最大数量typedef enum STATE// 进程状态{READY, // 就绪BLOCK, // 阻塞END// 完成}STATE;// 定义进程控制块typedef struct PCB {int id; // 进程标识符int priority; // 进程优先级int cputime; // 已占用的CPU时间int alltime; // 还需占用的CPU时间int startblock; // 阻塞时间int blocktime; // 被阻塞时间STATE state; // 进程状态}PCB;// 定义队列typedef struct queue {int size; // 队列中进程的数量PCB *data[LEN]; // 进程的指针}Queue;PCB ps[LEN]; // 进程数组PCB *cp; // 当前正在运行的进程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.data[j + 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 = -1;}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 <<"\nRUNNING PROG: ";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 <<"\nPRIORITY\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";}else if (ps[i].state == BLOCK) {cout <<"BLOCK"<<"\t";}else if (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(&rQueue, cp); // 将当前进程放入就绪队列cp = pop(&rQueue); // 就绪队列队首进程成为当前进程}if (cp->alltime == 0) { // 如果当前进程运行结束cp->state = END; // 改变进程状态cp = pop(&rQueue); // 从就绪队列取出新的当前进程}cp->priority -= 3; // 修改当前进程的优先级// startblock为0，标志着当前进程要进入阻塞状态if (cp->startblock == 0 && cp->blocktime > 0) {cp->state = BLOCK; // 修改当前进程的状态push(&bQueue, cp); // 将当前进程加入阻塞队列cp = pop(&rQueue); // 从就绪队列取出新的当前进程}else if (cp->startblock > 0) { // 当前进程的startblock为正数时cp->startblock--; // 运行一次减一个时间片}cp->cputime++; // 当前进程占用CPU时间片+1if(cp->alltime > 0){ // 当前进程还需运行的时间片-1cp->alltime--;if (cp->alltime == 0) { // 减到0时，修改进程状态cp->state = END;}}for (int i = 0; i < rQueue.size; i++) { // 每运行一个时间片rQueue.data[i]->priority++; // 就绪队列中的进程优先级+1 }for (int i = 0; i < bQueue.size; i++) { // 每运行一个时间片if (bQueue.data[i]->blocktime > 0) { // 阻塞队列中的进程blocktime-1 bQueue.data[i]->blocktime--;}}// 当阻塞队列队首进程blocktime为0时if (bQueue.size > 0 && bQueue.data[0]->blocktime == 0) {bQueue.data[0]->state = READY; // 修改进程状态push(&rQueue, pop(&bQueue)); // 将阻塞队列首进程取出，放入就绪队列}// 每运行一个时间片，就绪队列排一次序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. 实验过程记录程序开始执行，当前进程是优先级最高的1号进程，1号进程的优先级减3、cputime++、alltime--。
动态优先权算法模拟-操作系统课程设计
计算机与通信工程学院操作系统课程设计设计题目动态优先权算法模拟专业名称计算机科学与技术班级学号学生姓名指导教师设计时间课程设计任务书专业：计算机科学与技术学号：学生姓名（签名）：设计题目：动态优先权算法模拟一、设计实验条件综合楼808二、设计任务及要求模拟单处理机环境下的进程调度模型，调度采用基于动态优先权的调度算法。
三、设计报告的内容1.设计题目与设计任务设计题目：动态优先权算法模拟设计任务：模拟单处理机环境下的进程调度模型，调度采用基于动态优先权的调度算法。
2.前言（绪论）在操作系统中调度算法的实质是一种资源的分配，因而调度算法是指“根据系统资源分配策略所规定的资源分配算法”。
对于不同的操作系统和系统目标，通常采用不同的调度算法。
为了照顾紧迫作业，使之在进入系统后便获得优先处理，引入了最高优先权先调度算法。
在作为进程调度算法时，该算法是把处理机分配给就绪队列优先权最高的进程。
这可以分为抢占式优先权算法和非抢占式优先权算法。
对于最高优先权优先调度算法，其关键在于：它是使用静态优先权还是动态优先权，以及如何确定进程的优先权。
本次课程设计所实现的算法就是动态优先权算法的抢占式优先权调度算法和非抢占式动态优先权算法。
动态优先权拥有其特有的灵活优点，同时，若所有的进程都具有相同的优先权初值，则显然是最先进入就绪队列的进程，将因其动态优先权变得高而优先获得处理机，此即FCFS算法。
若所有的就绪进程具有各不相同优先权初值，那么，对于优先权初值低的进程，在等待了足够长的时间后，其优先权便可能升为最高，从而获得处理机。
当采用抢占式优先权调度算法时，如果规定当前进程的优先权以一定速率下降，则可防止一个长作业长期垄断处理机。
这里，我们采用高响应比来决定每个进程的优先权。
3.设计主体（各部分设计内容、分析、结论等）【设计内容】动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。
动态优先权进程调度算法实验报告
《动态优先权进程调度算法》实验报告题目:动态优先权进程调度算法的模拟实现专业：班级：学号：姓名：日期：一﹑实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
二﹑实验内容与基本要求编制模拟动态优先权算法的程序，并给出的例子验证所编写的程序的正确性。
（1）用C语言实现对N个进程采用动态优先权算法的调度。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：✧进程标识数ID。
✧进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
✧进程已占用CPU时间CPUTIME。
✧进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
✧进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
✧进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
✧进程状态STATE。
✧队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：✧进程在就绪队列中呆一个时间片，优先数增加1。
✧进程每运行一个时间片，优先数减3。
（4）假设在调度前，系统中有5个进程，它们得初始状态如下：为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
格式如下：RUNNING PROG：iREADY_QUEUE：->id1->id2BLOCK_QUEUE：->id3->id4==========================================================ID 0 1 2 3 4PRIORITY P0 P1 P2 P3 P4CPUTIME C0 C1 C3 C4 C5ALLTIME A0 A1 A2 A3 A4STARTBLOCK T0 T1 T2 T3 T4BLOCKTIME B0 B1 B2 B3 B4STATE S0 S1 S2 S3 S4三、实验报告内容1、动态优先权算法原理动态优先权是指，在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。
操作系统课程设计进程调度模拟设计--先来先服务,优先
操作系统课程设计进程调度模拟设计--先来先服务,优先学号：课程设计课程名字系统软件开发实训A题目进程调度模拟设计——先来先服务、优先级法学院计算机科学与技术学院专业计算机科学与技术专业班级姓名指导教师李玉强2014 年01 月13 日课程设计任务书学生姓名：专业班级：指导教师：李玉强工作单位：计算机科学与技术学院题目: 进程调度模拟设计——先来先服务、优先级法初始条件：1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟进程调度，能够处理以下的情形：⑴能够选择不同的调度算法（要求中给出的调度算法）；⑵能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；⑶根据选择的调度算法显示进程调度队列；⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2．设计报告内容应说明：⑴课程设计目的与功能；⑵需求分析，数据结构或模块说明(功能与框图)；⑶源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结。
时间安排：设计安排3周：查阅、分析资料 1天系统软件的分析与建模 4天系统软件的设计 5天系统软件的实现 3天撰写文档 1天课程设计验收答辩 1天设计验收安排：设计周的第三周的指定时间到实验室进行上机验收。
设计报告书收取时间：课程设计验收答辩完结时。
（注意事项：严禁抄袭，一旦发现，抄与被抄的一律按0分记）指导教师签名： 2013 年 12 月 10日系主任（或责任教师）签名： 2013 年 12 月 10日课程设计报告书1.需求分析1.1设计目的(1)阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
(2)掌握一种计算机高级语言的使用。
要求完成的主要任务: （包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1.2程序流程图1.3设计要求(1)能够选择不同的调度算法（要求中给出的调度算法）；(2)能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等； (3)根据选择的调度算法显示进程调度队列；(4)根据选择的调度算法计算平均周转时间和平均带权周转时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实用标准文档东北大学分校计算机与通信工程学院操作系统课程设计设计题目动态优先权算法模拟专业名称计算机科学与技术班级学号学生指导教师设计时间课程设计任务书专业：计算机科学与技术学号：学生（签名）：设计题目：动态优先权算法模拟一、设计实验条件综合楼808二、设计任务及要求模拟单处理机环境下的进程调度模型，调度采用基于动态优先权的调度算法。
三、设计报告的容1.设计题目与设计任务设计题目：动态优先权算法模拟设计任务：模拟单处理机环境下的进程调度模型，调度采用基于动态优先权的调度算法。
2.前言（绪论）在操作系统中调度算法的实质是一种资源的分配，因而调度算法是指“根据系统资源分配策略所规定的资源分配算法”。
对于不同的操作系统和系统目标，通常采用不同的调度算法。
为了照顾紧迫作业，使之在进入系统后便获得优先处理，引入了最高优先权先调度算法。
在作为进程调度算法时，该算法是把处理机分配给就绪队列优先权最高的进程。
这可以分为抢占式优先权算法和非抢占式优先权算法。
对于最高优先权优先调度算法，其关键在于：它是使用静态优先权还是动态优先权，以及如何确定进程的优先权。
本次课程设计所实现的算法就是动态优先权算法的抢占式优先权调度算法和非抢占式动态优先权算法。
动态优先权拥有其特有的灵活优点，同时，若所有的进程都具有相同的优先权初值，则显然是最先进入就绪队列的进程，将因其动态优先权变得高而优先获得处理机，此即FCFS算法。
若所有的就绪进程具有各不相同优先权初值，那么，对于优先权初值低的进程，在等待了足够长的时间后，其优先权便可能升为最高，从而获得处理机。
当采用抢占式优先权调度算法时，如果规定当前进程的优先权以一定速率下降，则可防止一个长作业长期垄断处理机。
这里，我们采用高响应比来决定每个进程的优先权。
3.设计主体（各部分设计容、分析、结论等）【设计容】动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。
非抢占式优先权调度算法。
在这种方式下，系统一旦把处理机分配给就绪队列中优先权最高的进程后，该进程便一直执行下去，直至完成；或因发生某事件使该进程放弃处理机时，系统方可再将处理机重新分配给另一优先权最高的进程。
抢占式优先权算法。
系统同样把处理机分配给优先权最高的进程，使之执行。
但在其执行期间，只要又出现了另一个优先权更高的进程，进程调度程序就立即停止当前进程的执行，重新将进程分配给优先权最高的进程。
在批处理系统中，段作业优先算法是一种比较好的算法，其主要不足之处，是长作业的运行得不到保证。
如果我们为每个作业引入动态优先权，并使作业优先级随着等待时间的增加而以一定速率提高，则可以解决这个问题。
优先权的变化规律可描述为：优先权=（等待时间+要求服务时间）/要求服务时间对优先权计算完毕之后，要能够通过正确的调度函数，完成相应进程的每个变量的更新，其中等待时间加一，运行进程的CPU时间减一，如果这时候运行的进程结束，则改变其状态并记录完成时间。
【算法分析】模拟动态优先权算法，在主函数中选择采用抢占式进程调度算法还是非抢占式进程调度算法，进而调用对应的函数完成模拟。
设置进程结构体，struct PROCESS{int id; //进程iddouble response_rate; //优先权int cputime; //要求服务时间int waittime; //等待时间int endtime; //进程完成时间，未完成时标记-1 int STATE; //进程当前状态};记录完成的进程id，使用数组pro_list[10]功能函数display() 打印各进程当前状态init() 初始化进程状态change() 抢占式调度算法进程状态更新no_change() 非抢占式调度算法进程状态更新函数调用顺序如图1：图1 函数调用顺序图采用高响应比作为进程调度的优先权，其特点如下：（1）如果作业的等待时间相同，则要求服务时间愈短，其优先权愈高，因而该算法有利于短作业；（2）当服务时间相同时，作业的优先权决定于其等待时间，等待时间愈长，其优先权愈高，因而它实现的是先来先服务。
（3）对于长作业，作业的优先级可以随等待时间的增加而提高，当其等待时间足够长时，其优先级便可以升到很高，从而也可以获得处理机。
【代码实现】#include<iostream>#include<cstring>#include<stdio.h>#include<cstdlib>using namespace std;#define num 6#define RUN 1#define READY 0#define RUNOUT -1int time=0;struct PROCESS{int id;double response_rate;int cputime;int waittime;int endtime;int STATE;}pro[10];int pro_list[10],q=0;void display(){cout<<"Time:"<<time<<endl;cout<<"========================================== ="<<endl;cout<<"ID\t\t0\t1\t2\t3\t4\t5"<<endl;cout<<"respone_rate\t";for(int i=0;i<num;i++){cout<<pro[i].response_rate<<'\t';}cout<<endl;cout<<"cputime\t\t";for(int i=0;i<num;i++){cout<<pro[i].cputime<<'\t';}cout<<endl;cout<<"waittime\t";for(int i=0;i<num;i++){cout<<pro[i].waittime<<'\t'; }cout<<endl;cout<<"endtime\t\t";for(int i=0;i<num;i++){cout<<pro[i].endtime<<'\t'; }cout<<endl;cout<<"STATE\t\t";for(int i=0;i<num;i++){if(pro[i].STATE==RUN)cout<<"RUN\t";else if(pro[i].STATE==READY) cout<<"READY\t";else cout<<"RUNOUT\t";}cout<<endl;cout<<"the end process<end time>: ";for(int i=0;i<q;i++){cout<<"->"<<pro_list[i]<<'<'<<pro[pro_list[i]].endtime<<'>';}cout<<endl;cout<<"========================================== ="<<endl;}void init(){for(int i=0;i<num;i++){pro[i].id=i;pro[i].response_rate=1;pro[i].waittime=0;pro[i].endtime=-1;pro[i].STATE=0;}pro[0].cputime=5;pro[1].cputime=3;pro[2].cputime=1;pro[3].cputime=2;pro[4].cputime=4;pro[5].cputime=6;}void change(){double runflag=0;int runprocess=0;for(int i=0;i<num;i++){if(pro[i].STATE!=RUNOUT){pro[i].response_rate=1.0*(pro[i].waittime+pro[i].cputime)/pro[i].cputime;if(pro[i].response_rate>runflag){runflag=pro[i].response_rate;runprocess=i;}}}for(int i=0;i<num;i++){if(pro[i].STATE==RUN){pro[i].STATE=READY;pro[i].waittime=-1;}}pro[runprocess].cputime--; pro[runprocess].waittime=-1; pro[runprocess].STATE=RUN; for(int i=0;i<num;i++){if(pro[i].STATE==RUNOUT){continue;}pro[i].waittime++;if(pro[i].cputime==0){pro[i].endtime=time;pro[i].STATE=RUNOUT;pro[i].response_rate=0;pro_list[q++]=i;}}}void no_change(){int runprocess=0,flag=0;double runflag=0;for(int i=0;i<num;i++){if(pro[i].STATE==RUNOUT){continue;}pro[i].response_rate=1.0*(pro[i].waittime+pro[i].cputime)/pro[i].cputime;if(pro[i].response_rate>runflag){runflag=pro[i].response_rate;runprocess=i;}}for(int i=0;i<num;i++){if(pro[i].STATE==RUNOUT){continue;}if(pro[i].STATE==RUN){flag=1;pro[i].cputime--;pro[i].waittime=-1;for(int j=0;j<num;j++){if(pro[j].STATE==RUNOUT){continue;}pro[j].waittime++;}if(pro[i].cputime==0){pro[i].STATE=RUNOUT;pro[i].endtime=time;pro[i].response_rate=0;pro_list[q++]=i;}break;}}if(!flag){pro[runprocess].cputime--;pro[runprocess].waittime=-1;pro[runprocess].STATE=RUN;for(int j=0;j<num;j++){if(pro[j].STATE==RUNOUT){continue;}pro[j].waittime++;}if(pro[runprocess].cputime==0){pro[runprocess].STATE=RUNOUT;pro[runprocess].endtime=time;pro[runprocess].response_rate=0;pro_list[q++]=runprocess;}}}int main(){int flag=0,type;cout<<"selecet type£¨1.preemptive scheduling 2.non-preemptive scheduling£©£º";cin>>type;init();while(1){flag=0;display();for(int i=0;i<num;i++){if(pro[i].STATE!=RUNOUT){flag=1;break;}}if(!flag) break;time++;if(type==1){change();}elseno_change();cout<<endl;getchar();}cout<<endl<<endl;cout<<"All processes have runed out!!"<<endl; }【结果截图】抢占式优先权调度算法非抢占式优先调度算法4.结束语本次课程设计是由小组合作完成，大家一同讨论算法的可行性、实现流程、结构安排等，一起讨论交流使得大家对这个算法了解得更加深刻，从各个不同的角度对它有了不同的认识，也发现了很多自己思考的死角，学到算法的同时也体会到团队合作的重要性，培养了我们团队合作的意识和能力。