使用动态优先权的进程调度算法的模拟

优先权调度算法的类型
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号进程成为当前进程，开始执行。

操作系统进程调度实验报告一.实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的解．进程调度时进程管理的主要内容之一，通过设计，编制，调试一个简单的进程调度模拟系统，对进程调度，进程运行状态变换加深理解和掌握。

模拟计算机操作系统的进程调度,建立进程控制块PCB,要包含有关进程的描述信息,控制信息以及资源信息.模拟系统根据PCB感知进程的存在和通过PCB中所包含的各项变量的变化,掌握进程所处的状态以达到控制进程活动的目的.要实现进程的状态及其转换,进程的创建与撤消,进程的阻塞与唤醒.用P,V原语操作实现进程互斥.二.实验要求建立进程控制块PCB,用PCB实现进程在运行过程中的一切状态,未创建、就绪、运行、等待、退出.以完成资源的共享,实现进程的同步与互斥.程序要求用p,v操作实现进程互斥.三.实验平台Windows XP 下的Microsoft vitual c++平台四.所用语言Microsoft Visual C++语言五.机器要求Microsoft Windows XP Professional版本 2002Service Pack256MB内存SVGA(800×600分辨率，256色或更高级的显示卡鼠标或其他相容设备六.系统分析设计建立四个进程,模拟模拟批处理多道操作系统的进程调度,进程调度算法,采用最高优先数优先的调度算法.每个进程有一个进程控制块（ PCB）表示。

进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪 W（Wait）、运行R （Run）、或完成F（Finish）三种状态之一。

就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

华北电力大学实验报告实验名称动态优先权进程调度算法模拟课程名称计算机操作系统专业班级：学生姓名：学号：成绩：指导教师：实验日期：一﹑实验目的：通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

二﹑实验内容：（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）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。

（5）分析程序运行的结果，谈一下自己的认识。

三、设计思路和方法通过VC++程序模拟动态优先权程序调度算法，主要思路和方法就是，通过结构体模拟计算机的控制模组，构造一个PCB结构体即进程控制块结构体，用来记录当前进程的的相关状态信息，包括进程标识符、处理机状态、进程调度信息、进程控制信息。

并通过C++语言模拟计算机的相关调度算法，对构建的PCB进程进行模拟调度和运行，从而实现用计算机对进程的调度过程进行过程仿真。

四、数据结构和算法数据结构：1.包含PCB信息的结构体2.包含进程信息的顺序表结构算法：优先权=(等待时间+要求服务时间)/要求服务时间R p=(等待时间+要求服务时间)/要求服务时间=相应时间/要求服务时间系统将所有就绪队列按优先级高低排成一个队列，每次调度时，将CPU分配给优先级最高的进程，并令其执行一个时间片，而后中断，寻找并运行下一个优先级最高的进程。

第四章线程4.1举两个多线程程序设计的例子来说明多线程不比单线程方案提高性能答：1）任何形式的顺序程序对线程来说都不是一个好的形式。

例如一个计算个人报酬的程序。

2）另外一个例子是一个“空壳”程序，如C-shell和korn shell。

这种程序必须密切检测其本身的工作空间。

如打开的文件、环境变量和当前工作目录。

4.2描述一下线程库采取行动进行用户级线程上下文切换的过程答：用户线程之间的上下文切换和内核线程之间的相互转换是非常相似的。

但它依赖于线程库和怎样把用户线程指给内核程序。

一般来说，用户线程之间的上下文切换涉及到用一个用户程序的轻量级进程（LWP）和用另外一个线程来代替。

这种行为通常涉及到寄存器的节约和释放。

4.3在哪些情况下使用多内核线程的多线程方案比单处理器系统的单个线程方案提供更好的性能。

答：当一个内核线程的页面发生错误时，另外的内核线程会用一种有效的方法被转换成使用交错时间。

另一方面，当页面发生错误时，一个单一线程进程将不能够发挥有效性能。

因此，在一个程序可能有频繁的页面错误或不得不等待其他系统的事件的情况下，多线程方案会有比单处理器系统更好的性能。

4.4以下程序中的哪些组成部分在多线程程序中是被线程共享的？a.寄存值b.堆内存c.全局变量d.栈内存答：一个线程程序的线程共享堆内存和全局变量，但每个线程都有属于自己的一组寄存值和栈内存。

4．5一个采用多用户线程的多线程方案在多进程系统中能够取得比在单处理器系统中更好的性能吗？答：一个包括多用户线程的多线程系统无法在多处理系统上同时使用不同的处理器。

操作系统只能看到一个单一的进程且不会调度在不同处理器上的不同进程的线程。

因此，多处理器系统执行多个用户线程是没有性能优势的。

4.6就如4.5.2章节描述的那样，Linux没有区分进程和线程的能力。

且Linux线程都是用相同的方法：允许一个任务与一组传递给clone()系统调用的标志的进程或线程。

操作系统中常用的进程调度算法1、先来先服务调度算法先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。

当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。

在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

2、短作业(进程)优先调度算法短作业(进程)优先调度算法，是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。

而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。

3、时间片轮转法在早期的时间片轮转法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

时间片的大小从几ms到几百ms。

当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。

换言之，系统能在给定的时间内响应所有用户的请求。

4、多级反馈队列调度算法前面介绍的各种用作进程调度的算法都有一定的局限性。

如短进程优先的调度算法，仅照顾了短进程而忽略了长进程，而且如果并未指明进程的长度，则短进程优先和基于进程长度的抢占式调度算法都将无法使用。

而多级反馈队列调度算法则不必事先知道各种进程所需的执行时间，而且还可以满足各种类型进程的需要，因而它是目前被公认的一种较好的进程调度算法。

[整理]操作系统的三⼤调度机制及算法⽬录操作系统的三⼤调度机制，分别是「进程调度/页⾯置换/磁盘调度算法」。

进程调度算法进程调度算法也称 CPU 调度算法，毕竟进程是由 CPU 调度的。

当 CPU 空闲时，操作系统就选择内存中的某个「就绪状态」的进程，并给其分配 CPU。

什么时候会发⽣ CPU 调度呢？通常有以下情况：1. 当进程从运⾏状态转到等待状态；2. 当进程从运⾏状态转到就绪状态；3. 当进程从等待状态转到就绪状态；4. 当进程从运⾏状态转到终⽌状态；其中发⽣在 1 和 4 两种情况下的调度称为「⾮抢占式调度」，2 和 3 两种情况下发⽣的调度称为「抢占式调度」。

⾮抢占式的意思就是，当进程正在运⾏时，它就会⼀直运⾏，直到该进程完成或发⽣某个事件⽽被阻塞时，才会把 CPU 让给其他进程。

⽽抢占式调度，顾名思义就是进程正在运⾏的时，可以被打断，使其把 CPU 让给其他进程。

那抢占的原则⼀般有三种，分别是：时间⽚原则、优先权原则、短作业优先原则。

你可能会好奇为什么第 3 种情况也会发⽣ CPU 调度呢？假设有⼀个进程是处于等待状态的，但是它的优先级⽐较⾼，如果该进程等待的事件发⽣了，它就会转到就绪状态，⼀旦它转到就绪状态，如果我们的调度算法是以优先级来进⾏调度的，那么它就会⽴马抢占正在运⾏的进程，所以这个时候就会发⽣ CPU 调度。

那第 2 种状态通常是时间⽚到的情况，因为时间⽚到了就会发⽣中断，于是就会抢占正在运⾏的进程，从⽽占⽤ CPU。

调度算法影响的是等待时间（进程在就绪队列中等待调度的时间总和），⽽不能影响进程真在使⽤ CPU 的时间和 I/O 时间。

接下来，说说常见的调度算法：1. 先来先服务调度算法2. 最短作业优先调度算法3. ⾼响应⽐优先调度算法4. 时间⽚轮转调度算法5. 最⾼优先级调度算法6. 多级反馈队列调度算法先来先服务调度算法最简单的⼀个调度算法，就是⾮抢占式的先来先服务（First Come First Severd, FCFS）算法了。

计算机操作系统模拟试题与答案解析(总10页)本页仅作为文档封面，使用时可以删除This document is for reference only-rar21year.March张顺全计算机操作系统模拟试题（二）张顺全一、选择题（红色数字、符号是答案。

笔67－16）1. 在分时系统中，导致创建进程的典型事件是A2；在批处理系统中导致创建进程的典型事件是B2；由系统专门为运行中的应用进程创建新进程的事件是C4。

（汤’165题5、汤’204）A：⑴用户注册⑵用户登录⑶用户记账⑷用户通信B：⑴作业录入⑵作业调度⑶进程调度⑷中级调度C：⑴分配资源⑵进程通信⑶共享资源⑷提供服务2. 从下面对临界资源的论述中，选出一条正确的论述，并在其前面打“√”。

（汤’165题6）⑴临界区是指进程中用于实现进程互斥的那段代码⑵临界区是指进程中用于实现进程同步的那段代码⑶临界区是指进程中用于实现进程通信的那段代码⑷临界区是指进程中用于访问共享资源的那段代码√⑸临界区是指进程中访问临界资源那段代码3. 在生产者－消费者问题中，应设置互斥信号量Mutex、资源信号量full和empty。

它们的初始值应分别是A2、B1和C5。

（汤’165题9）A、B、C：⑴ 0 ⑵ 1 ⑶－1 ⑷－n ⑸ +n4. 从下面预防死锁的论述中，选出一条正确的论述，并在其前面打“√”。

（汤’166题16、汤’204、汤六122－4）⑴由于产生死锁的基本原因是系统资源不足，因而预防死锁的有效方法，是根据系统规模，配置足够的系统资源⑵由于产生死锁的另一基本原因是进程推进顺序不当，因而预防死锁的有效方法，是使进程的推进顺序合法⑶因为只要系统不进入不安全状态，便不会产生死锁，故预防死锁的有效方法，是防止系统进入不安全状态√⑷可以通过破坏产生死锁的四个必要条件之一或其中几个的方法，来预防发生死锁5. 根据作业说明书中的信息对作业进行控制，称此种作业为A4；用终端键盘命令直接控制作业运行的作业称为B1。

1. 调度类型高级调度——作业调度批处理系统中使用，周期较长。

低级调度——进程调度是最基本的一种调度，在三种类型的OS中都必须配置。

进程调度可采用非抢占或抢占两种方式。

其中抢占方式允许调度程序根据某种原则，例时间片原则、优先权原则、短进程优先原则等去停止某个正在执行的进程，将已分配给该进程的处理机，重新分配给另一进程。

进程调度的运行频率最高，故算法不能太复杂。

中级调度——引入中级调度的目的是为了提高内存的利用率和系统吞吐量。

中级调度实际上是存储器管理中的对换功能。

2. 调度队列模型3. 选择调度方式和算法的准则周转时间（批处理）面向用户响应时间（分时）的准则截止时间的保证（实时）优先权准则面向系统系统吞吐量高（批处理）的准则处理机利用率好各类资源的平衡利用周转时间——指作业提交系统开始，到作业完成为止的时间间隔。

带权周转时间——作业的周转时间与系统为它提供的实际服务时间之比。

W=T/TS响应时间——从用户通过键盘提交一个请求开始，直至系统首次产生响应为止的时间。

截止时间——某任务必须开始执行的最迟时间，或必须完成的最迟时间。

吞吐量——单位时间内所完成的作业数。

4. 调度算法（作业调度、进程调度）先来先服务调度算法（FCFS）按进入后备（或就绪）队列的先后选择目标作业（或进程）。

有利于长作业（进程），不利于短作业（进程）。

最短作业优先调度算法SJ（P）F从后备（或就绪）队列中选择估计运行时间最短的作业（或进程）tn+1=a tn+(1-a) tn tn为实际值，tn为预测值SJF有效地降低作业的平均等待时间，提高了系统的吞吐量。

对长作业（或进程）不利，可能死等，且未考虑作业的紧迫程度。

时间片轮转调度算法（进程调度）系统将所有的就绪进程按先来先服务原则，排成一个队列，每次调度时把CPU分配给队首进程，令其执行一个时间片。

就绪队列中所有进程，在一个给定的时间内，均能获得一个时间片的处理机执行时间。

T=nq优先权调度算法适用于作业调度和进程调度。