操作系统优先级调度算法实验报告

先来先服务,时间片调度,优先级调度算法实验报告实验报告1. 引言进程调度是操作系统中非常重要的一部分，它决定了进程在CPU上执行的顺序和时间长度。

在本次实验中，我们通过实现先来先服务调度算法、时间片调度算法和优先级调度算法，并对其性能进行比较，来深入了解各种调度算法的工作原理及优缺点。

2. 先来先服务调度算法先来先服务调度算法按照进程到达的先后顺序进行调度。

当一个进程到达时，如果CPU空闲，则将其分配给CPU进行执行；如果CPU 正在执行其他进程，则该进程将等待直到CPU空闲。

优点是简单易实现，适用于长作业。

缺点是可能出现饥饿现象，即低优先级的进程可能会一直等待高优先级进程的执行。

3. 时间片调度算法时间片调度算法将CPU的执行时间划分为固定长度的时间片，每个进程在一个时间片内执行，当时间片用完后，系统将切换到下一个进程执行。

该算法确保每个进程都有公平的执行时间，避免了饥饿现象。

然而，对于CPU利用率较高的情况下，可能会导致进程频繁地切换，增加了上下文切换的开销。

4. 优先级调度算法优先级调度算法根据进程的优先级来进行调度，优先级较高的进程将具有更高的执行优先级。

当多个进程同时到达CPU时，系统将选择优先级最高的进程先执行。

该算法可以分为静态优先级调度和动态优先级调度两种方式。

优点是可以根据进程的重要性灵活调整执行顺序。

缺点是可能导致优先级低的进程长时间等待，造成饥饿现象。

5. 实验结果与分析我们通过模拟多个进程的到达和执行过程，在不同的场景下比较了先来先服务调度算法、时间片调度算法和优先级调度算法的性能。

实验结果显示，在长作业的情况下，先来先服务调度算法表现较好；在要求公平性的场景下，时间片调度算法比较适合；而对于需要根据优先级来调度的场景，优先级调度算法可以更好地满足需求。

6. 结论不同的进程调度算法在不同的场景下有各自的优劣。

先来先服务调度算法简单易实现，适用于长作业；时间片调度算法保证了公平性，适用于要求公平的场景；而优先级调度算法则可以根据进程的重要性进行调度。

操作系统调度算法实验报告摘要：本篇实验报告旨在研究和分析不同的操作系统调度算法对系统性能的影响。

通过实验，我们对先来先服务调度算法、短作业优先调度算法和时间片轮转调度算法进行了比较和评估。

实验结果表明，不同的调度算法对系统响应时间、吞吐量和公平性等方面都有不同的影响。

一、引言操作系统的调度算法是管理计算机资源的关键部分之一。

调度算法的好坏直接影响着系统的性能和用户体验。

本实验旨在通过模拟不同的调度算法，评估其对系统的影响，以便选择最适合特定环境的调度算法。

二、实验方法本实验使用了一个模拟的操作系统调度器，通过调度器模拟不同的进程到达和执行过程。

我们选择了三种常见的调度算法进行比较和评估。

1. 先来先服务（First-Come, First-Served）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度。

当一个进程到达后，它将占用处理器直到该进程执行完毕。

我们记录了每个进程的到达时间、执行时间和完成时间，并计算了系统的平均等待时间和平均周转时间。

2. 短作业优先（Shortest Job First）调度算法短作业优先调度算法按照进程执行时间的长短进行调度。

当一个进程到达后，系统会选择执行剩余执行时间最短的进程。

我们同样记录了每个进程的到达时间、执行时间和完成时间，并计算了系统的平均等待时间和平均周转时间。

3. 时间片轮转（Round Robin）调度算法时间片轮转调度算法将处理器时间分成若干个时间片，每个进程只能占用一个时间片。

当一个进程用完一个时间片后，它排到队列的末尾等待下一个时间片。

我们选择了不同的时间片长度，并观察了系统的响应时间和吞吐量。

三、实验结果与分析我们通过多组实验数据对不同的调度算法进行了评估。

以下是实验结果的分析：1. 先来先服务调度算法根据实验数据，我们发现先来先服务调度算法对长作业具有较高的等待时间和周转时间。

这是因为当一个长作业到达后，其他短作业需要等待该作业执行完毕才能获得处理器资源。

操作系统调度算法实验报告
本实验旨在研究不同操作系统调度算法在实际应用中的表现和影响。

我们选择了三种常见的调度算法进行对比分析，分别是先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。

1. 实验准备
在开始实验之前，我们首先搭建了一个简单的模拟环境，包括一个CPU和多个进程。

每个进程具有不同的执行时间，以便模拟不同情况
下的调度效果。

2. 先来先服务（FCFS）
先来先服务是最简单的调度算法之一，即根据进程到达的顺序依次
执行。

实验结果显示，FCFS算法适用于处理大量长作业，但当出现短
作业时会导致平均等待时间较长。

3. 最短作业优先（SJF）
最短作业优先算法会优先执行执行时间最短的进程，以减少平均等
待时间。

在我们的实验中，SJF算法表现出色，尤其在短作业较多的情
况下，能够显著提高系统的响应速度。

4. 时间片轮转（RR）
时间片轮转算法将CPU时间分配给每个进程，每个进程执行一个
时间片后轮转到下一个进程。

然而，RR算法可能导致上下文切换频繁，
影响系统效率。

在实验中，我们发现RR算法在处理多任务时效果较好，但在处理长时间任务时表现一般。

5. 实验总结
通过对三种调度算法的实验比较，我们可以看出不同算法在不同情
况下有着不同的优势和劣势。

在实际应用中，需要根据具体情况选择
合适的调度算法，以提高系统的性能和效率。

希望本实验能为操作系
统调度算法的研究提供一定的参考价值。

实验五调度一、基本信息二、实验内容在设计一个按优先级进行调度的算法（1（2的进程（3）调度时，总是选择优先级最高的执行，并采用动态调度：每运行一次优先级减1，估计运行时间减1（4）进程运行一次后，若剩余的运行时间不为0，且优先级低于就绪队列中的进程，则状态变为ready，并选择一个进程使用CPU；若剩余的运行时间为0，则状态变为完成（5）如就绪队列不空，则重复（3）（4）直到所有进程都结束三、实验目的通过实验，巩固和加深对进程调度的理解，以及各种调度算法的基本实现思想。

四、设计思路和流程图(1)用一个结构体构造进程块，记录进程的各个属性，优先级和估计运行时间随机产生(2)创建一个进程块链表，每个节点表示一个进程块。

用head指针表示链表头部，用curPCB表示当前CPU调度的进程块(3)遍历链表，找到优先级最高的进程“运行”(4)重复调度进直到就绪队列中没有进程时，程序运行结束五、主要数据结构及其说明#include <cstdio>#include <random>#include <time.h>struct PCB{int id;int priority;//数值越大，优先级越高PCB* nextPCB;//指向就绪队列中下一个进程的PCB首址int probTime;//估计运行时间int state;//0： ready， 1： running， 2：finished};void main(){srand((unsigned)time(0));struct PCB *temp = new struct PCB;const int cnt = 3;struct PCB *head = temp;for(int i=0; i<cnt; ++i){temp->id = i;temp->priority = rand() % 10 + 1;temp->probTime = rand() % 10 + 1;temp->state = 0;temp->nextPCB = (i == (cnt-1))?0:new struct PCB;temp = temp->nextPCB;}int max = 0;//最高优先级struct PCB *curPCB;//正在执行的进程int countOfPro = cnt;//记录当前剩余进程数while(countOfPro != 0){for(struct PCB *p = head; p != 0; p = p->nextPCB) {if(p->state != 2 && p->priority > max){max = p->priority;curPCB = p;}}curPCB->priority--;curPCB->probTime--;if(curPCB->probTime <= 0){curPCB->state = 2;countOfPro--;}max = -99999;//打印运行后的进程属性内容printf("current proccess is %d ",curPCB->id);printf("priority is %d ", curPCB->priority);printf("rest time is %d\n", curPCB->probTime);}system("pause");return;}六、程序运行时的初值和运行结果七、实验体会此次实验模拟了系统进程调度，进一步学习了进程调度的机制，加深了对调度的理解。

操作系统最高响应比优先调度算法实验报告一、实验目的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五、实验总结通过本次实验，我们了解了最高响应比优先调度算法的原理和实现过程。

该调度算法能够有效提高作业的响应速度和用户体验，但在实际应用中也存在一些问题，比如容易出现饥饿现象，即一些低响应比的作业可能一直得不到调度。

在选择调度算法时，需要根据实际情况和需求来进行权衡和选择，最高响应比优先调度算法适用于对响应时间要求较高的场景，但在其他场景下可能不适用。

一、实验目的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. 分别采用五种调度算法对作业队列进行调度，并记录每个进程的执行情况。

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. 引言本次实验旨在研究和比较先来先服务（FCFS）、时间片调度（RR）和优先级调度（Priority Scheduling）三种常见的进程调度算法。

进程调度是操作系统中的重要概念之一，合理的进程调度算法可以提高系统效率，优化资源利用。

2. 先来先服务算法•先来先服务算法是一种简单的调度算法，按照进程到达的顺序进行调度。

•优点：简单易实现，适用于长作业。

•缺点：容易造成短作业等待时间过长，无法满足实时性要求。

3. 时间片调度算法•时间片调度算法将CPU时间划分为一段一段的时间片，每个进程在一个时间片内执行。

•若进程未完成，会被放入就绪队列的末尾，等待下一个时间片。

•优点：公平，适用于短作业，能满足实时性要求。

•缺点：时间片过长，会导致长作业等待时间过长。

4. 优先级调度算法•优先级调度算法根据进程的优先级来确定调度顺序，拥有最高优先级的进程先执行。

•静态优先级可在创建进程时确定，动态优先级可根据进程执行情况进行调整。

•优点：适用于实时任务和长作业，可根据需求调整优先级。

•缺点：可能导致低优先级任务等待时间过长，存在优先级反转问题。

5. 实验结果与分析通过对三种调度算法的实验测试，得出以下结论：•FCFS算法在长作业的情况下表现较好，但对于短作业不友好，容易造成长时间等待；•RR算法适用于短作业，能保证公平性，但时间片过长可能导致长作业等待时间过长；•优先级调度算法较为灵活，能满足实时性要求，但可能导致低优先级任务长时间等待。

综上所述，不同的调度算法适用于不同的场景，根据需求选择合适的算法可提高系统效率。

6. 总结本次实验对先来先服务、时间片调度和优先级调度算法进行了研究和比较。

通过对三种算法的分析，我们可以根据任务特点和需求选择合适的调度算法，以提高系统的效率和资源利用率。

同时，在实际应用中也需要考虑进程的实时性要求，避免长时间等待等问题的出现。

操作系统基于优先级的进程调度实验报告计算机与信息技术学院综合性实验报告一、实验目的：通过优先级调度算法的模拟，加深进程概念和进程调度过程的理解。

二、实验仪器或设备：微型计算机、Linux操作系统、dev C++三、总体设计：1、设计原理及方案：1)在Linux下用C语言编程模拟优先级程调度算法。

为了清楚地观察每个进程的调度过程，程序将每个时间片内的进程情况显示出来。

2)进程控制块是进程存在的唯一标志，因此，在模拟算法中每一个进程用一个进程控制块PCB来代表，PCB用一结构体表示。

3)进程在运行过程中其状态将在就绪、执行、完成几种状态之间转换，同时进程可能处于不同的队列中，如就绪队列。

在优先级调度算法中，选择单向队列，入队既是将进程控制块插入队尾，出队既是按优先级重新排列的队，删除队头元素。

4）为了便于处理，程序中的某进程运行时间以时间片为单位计算。

各进程的优先级认为输入，运行所需时间随机产生。

5）优先权调度算法采用动态优先权，进程每运行一个时间片，优先数减1；进程在就绪队列等待一个时间单位，优先数加1。

6）对于遇到优先权一致的情况，采用FCFS策略解决。

7）由于是模拟进程调度，所以，对被选中的进程并不实际启动运行，而是修改进程控制块的相关信息来模拟进程的一次运行。

2、分别用两种调度算法对伍个进程进行调度。

每个进程可有三种状态；执行状态（R）、就绪状态（W,包括等待状态）和完成状态（F，并假定初始状态为就绪状态。

（1）进程控制块结构如下：name——进程标示符prio——进程优先数cputime——进程累计占用CPU的时间片数needtime——进程到完成还需要的时间片数state——进程状态next——链指针（2）进程的就绪态和等待态均为链表结构，共有四个指针如下：run——当前运行进程指针ready——就绪队列头指针tall——就绪队列尾指针finish——完成队列头指针2、程序流程图：四、按照流程图编写代码view plaincopy to clipboardprint? /* 优先级调度算法#include#include#includetypedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state;/*进程的状态，W——就绪态，R——执行态，F——完成态*/int count; /*记录执行的次数*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in);//创建优先级队列规定优先数越小优先级越高void PrioCreate(); /*优先级输入函数*/void Priority(); /*按照优先级调度*/int main(void){ printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("优先级调度算法： \n");PrioCreate();Priority();Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{ run = ready;if(ready!=NULL){ run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{ PCB *p;p = ready;printf("进程名\t优先级\tcpu时间\t需要时间\t进程状态\t计数器\n"); while(p!=NULL){printf("%s\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio, p->cputime,p->need time,p->state,p->count);p = p->next;}while(p!=NULL){printf("%s\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio, p->cputime,p->need time,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio, p->cputime,p->need time,p->state,p->count);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 InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/fst = ready;if(ready == NULL){ in->next = ready;ready = in;}else{while(fst->next != NULL){ fst = fst->next; }in ->next = fst ->next;fst ->next = in;}}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));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->count = 0;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);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/ }}显示结果：请输入进程个数：3优先级调度算法：输入进程名字和进程所需时间：a 2b 1c 5进程名优先级 cpu时间需要时间进程状态计数器a 48 0 2 W 0c 45 0 5 W 0b 49 0 1 R 0进程名优先级 cpu时间需要时间进程状态计数器c 45 0 5 W 0b 46 1 0 F 1a 48 0 2 R 0………进程名优先级 cpu时间需要时间进程状态计数器b 46 1 0 F 1a 42 2 0 F 2c 33 4 1 R 4进程名优先级 cpu时间需要时间进程状态计数器b 46 1 0 F 1a 42 2 0 F 2c 30 5 0 F 5五、结果分析与总结:这次实验使我加深对处理机进程调度机制的理解，对进程的概念有了更深一层次的认识。