动态优先权算法模拟-操作系统课程设计
使用动态优先权的进程调度算法的模拟实验
使用动态优先权的进程调度算法的模拟实验动态优先权调度算法是一种根据进程动态表现调整优先权的进程调度算法。
它不仅考虑了进程的优先级，还将进程的实际执行情况作为调度依据。
下面将介绍一个模拟实验，以更好地理解这种调度算法。
实验背景：假设有五个待执行的进程，它们的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为循环计数器
- 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.结束语本次课程设计是由小组合作完成，大家一同讨论算法的可行性、实现流程、结构安排等，一起讨论交流使得大家对这个算法了解得更加深刻，从各个不同的角度对它有了不同的认识，也发现了很多自己思考的死角，学到算法的同时也体会到团队合作的重要性，培养了我们团队合作的意识和能力。