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

合集下载

《操作系统原理》课程设计任务书

上海电机学院课程设计任务书
指导教师（签名）：宁建红系主任（签名）：
2015 年10 月27 日年月日
指导教师（签名）：宁建红系主任（签名）：
2015 年10 月27 日年月日
指导教师（签名）：宁建红系主任（签名）：
2015 年10 月27 日年月日
上海电机学院课程设计任务书
指导教师（签名）：宁建红系主任（签名）：
2015 年10 月27 日年月日
上海电机学院课程设计任务书
指导教师（签名）：宁建红系主任（签名）：
2015 年10 月27 日年月日
上海电机学院课程设计任务书
指导教师（签名）：宁建红系主任（签名）：
上海电机学院课程设计任务书
指导教师（签名）：宁建红系主任（签名）：
上海电机学院课程设计任务书
指导教师（签名）：宁建红系主任（签名）：
2015 年10 月27 日年月日
上海电机学院课程设计任务书
指导教师（签名）：宁建红系主任（签名）：
2015 年10 月27 日年月日
上海电机学院课程设计任务书
指导教师（签名）：宁建红系主任（签名）：
2015 年10 月27 日年月日[文档可能无法思考全面，请浏览后下载，另外祝您生活愉快，工作顺利，万事如意!]。

进程调度实验报告

2轮转法图三流程图产生n个进程对每个进程用随机数产生进程的轮转时间片数及进程所需的时间片数已占用cpu的时间片数置为0按进程产生的先后次序拉成就绪队列链链首进程投入运行时间片到进程所需时间片数减1已占用cpu时间片数加1输出各进程的运行情况进程所需时间片数0
实验一进程调度实验报告
一、实验目的
多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
{
int num; //进程号
int attime,servtime; //进程到达时间，服务时间
process *next;
};
struct process*creatlist(int); //新建一个链表
void insert(struct process *first,struct process *s); //插入一个节点（尾插法）
process1 *next;
};
/*******************优先权调度算法所需函数声明*****************************************************/
struct process1*creatlist1(); //新建链表（就绪队列）
void insert1(struct process1 *first,struct process1 *s); //增加一个进程或将一个进程查入到队列中
void del1(struct process1 *first,struct process1 *s); //删除（撤销）一个进程
void print1(struct process1 *first); //打印函数

操作系统实验1--进程管理

设计一个有N个进程的进程调度程序一、实验目的通过一个简单的进程调度模拟程序的实现，加深对各种进程调度算法，进程切换的理解。

二、实验内容1、进程调度算法：采用动态最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）。

2、每个进程有一个进程控制块（PCB）表示。

进程控制块可以包含如下信息：●进程名----进程标示数ID；●优先数----Priority，优先数越大优先权越高；●到达时间----进程的到达时间为进程输入的时间；●进程还需要运行时间----AllTime，进程运行完毕AllTime =0；●已用CPU时间----CPUTime；●进程的阻塞时间StartBlock----表示当进程在运行StartBlock个时间片后，进程将进入阻塞状态；●进程的阻塞时间StartTime----表示当进程阻塞StartTime个时间片后，进程将进入就绪状态；●进程状态----State；●队列指针----Next，用来将PCB排成队列。

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

进程的到达时间为进程输入的时间；●进程的运行时间以时间片为单位进行计算；●进程在就绪队列中带一个时间片，优先数加1；●每个进程的状态可以是就绪R（Ready）、运行R（Run）、阻塞B(Block)、或完成F（Finish）四种状态之一；●就绪进程获得CPU后都只能运行一个时间片，用已占用CPU时间加1来表示；●如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减3，然后把它插入就绪队列等待CPU；●每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查；●重复以上过程，直到所要进程都完成为止。

三、实验要求完成实验内容并写出实验报告，报告应具有以下内容：1、实验目的。

实验三模拟进程调度算法

实验三模拟进程调度算法先进先出算法算法总是把处理机分配给最先进入就绪队列的进程,一个进程一旦分得处理机,便一直执行下去,直到该进程完成或阻塞时,才释放处理机。

最高优先权(FPF)优先调度算法该算法总是把处理机分配给就绪队列中具有最高优先权的进程。

常用以下两种方法来确定进程的优先权:轮转法前几种算法主要用于批处理系统中,不能作为分时系统中的主调度算法,在分时系统中,都采用时间片轮转法。

简单轮转法:系统将所有就绪进程按FIFO规则排队,按一定的时间间隔把处理机分配给队列中的进程。

这样,就绪队列中所有进程均可获得一个时间片的处理机而运行。

多级队列方法:将系统中所有进程分成若干类,每类为一级。

多级反馈队列多级反馈队列方式是在系统中设置多个就绪队列,并赋予各队列以不同的优先权。

实验内容①本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。

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

各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。

③在优先数算法中,优先数可以先取值为98,进程每执行一次,优先数减3, CPU时间片数加1,进程还需要的时间片数减1。

在轮转算法中,采用固定时间片(即:每执行一次进程,该进程的执行时间片数为已执行了2个单位),这时, CPU时间片数加2,进程还需要的时间片数减2,并排列到就绪队列的尾上。

④对于遇到优先数一致的情况,采用FIFO策略解决。

实验的示例程序如下:#include<stdio.h>#include <dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5#define P_TIME 50#define clrscr()enum state{ready,execute,block,finish};/* 定义进程控制块PCB */ struct pcb{char name[4];int priority;int cputime;int needtime;int count;int round;state process;pcb * next;};pcb * get_process(); pcb * get_process(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<endl; while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb)); cin>>q->name;cin>>q->needtime;q->cputime=0;q->priority=P_TIME-q->needtime;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}} //whilereturn p;}/*建立进程显示函数*/void display(pcb *p){cout<<"name"<<" "<<"cputime"<<" "<<"needtime"<<" "<<"priority"<<" "<<"state"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->priority;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break; case execute:cout<<"execute"<<endl;break; case block:cout<<"block"<<endl;break; case finish:cout<<"finish"<<endl;break; }p=p->next;}}int process_finish(pcb *q){int bl=1;while(bl&&q){bl=bl&&q->needtime==0;q=q->next;}return bl;}void cpuexe(pcb *q){pcb *t=q;int tp=0;while(q){if (q->process!=finish){q->process=ready;if(q->needtime==0){q->process=finish;}}if(tp<q->priority&&q->process!=finish){ tp=q->priority;t=q;}q=q->next;}if(t->needtime!=0){t->priority-=3;t->needtime--;t->process=execute;t->cputime++;}}//计算优先权void priority_cal(){pcb * p;clrscr();p=get_process();int cpu=0;clrscr();while(!process_finish(p)){cpu++;cout<<"cputime:"<<cpu<<endl;cpuexe(p);display(p);sleep(2);clrscr();}printf("All processes have finished,press any key to exit"); getch();}void display_menu(){cout<<"CHOOSE THE ALGORITHM:"<<endl;cout<<"1 PRIORITY"<<endl;cout<<"2 ROUNDROBIN"<<endl;cout<<"3 EXIT"<<endl;}pcb * get_process_round(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<endl; while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb)); cin>>q->name;cin>>q->needtime;q->cputime=0;q->round=0;q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;} //whilereturn p;}void cpu_round(pcb *q){ q->cputime+=2;q->needtime-=2;if(q->needtime<0) {q->needtime=0;}q->count++;q->round++;q->process=execute;}pcb * get_next(pcb * k,pcb * head){pcb * t;t=k;do{t=t->next;}while (t && t->process==finish);if(t==NULL){t=head;while (t->next!=k && t->process==finish){ t=t->next;}}return t;}//设置进程状态void set_state(pcb *p){while(p){if (p->needtime==0){p->process=finish;}if (p->process==execute){p->process=ready;}p=p->next;}}void display_round(pcb *p){cout<<"NAME"<<" "<<"CPUTIME"<<" "<<"NEEDTIME"<<" "<<"COUNT"<<" "<<"ROUND"<<" "<<"STA TE"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->count;cout<<" ";cout<<p->round;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break; case execute:cout<<"execute"<<endl;break; case finish:cout<<"finish"<<endl;break; }p=p->next;}}void round_cal(){pcb * p;pcb * r;clrscr();p=get_process_round();int cpu=0;clrscr();r=p;while(!process_finish(p)){ cpu+=2;cpu_round(r);r=get_next(r,p);cout<<"cpu "<<cpu<<endl; display_round(p);set_state(p);sleep(5);clrscr();}}void main(){display_menu();int k;scanf("%d",&k);switch(k){case 1:priority_cal();break; case 2:round_cal();break; case 3:break;display_menu();scanf("%d",&k);}}。

进程调度算法的仿真实现

《计算机操作系统原理》课外上机实验报告题目：实验名称：进程调度算法的仿真实现组长主要任务:1.总体数据结构设计；2.进程调度算法过程构架分析；3.优先级算法静态优先级抢占算法；4.动态优先级算法编写；5.算法测试分析；6.使用手册撰写。

组员主要任务:1.总体数据结构设计；2.进程调度算法过程构架分析；3.进程创建算法编写；4.时间片轮转法算法编写5.用户界面编写；6.实验报告撰写。

一、实验目的1.仿真进程并发的调度环境，设计和实现PCB控制块、进程创建、进程切换、进程并发、进程阻塞和进程调度的算法2.掌握进程调度的优先权法、时间片轮转法和多级反馈队列算法的实现3.强化算法设计和数据结构。

二、核心设计思路及实现内容1.利用随机数产生进程，创建PCB类的数组对象；2.建立等待序列将创建好的PCB数组放入等待序列；3.当进程的进入时间小于等于模拟的系统时间时，将该进程从等待序列进入就绪队列，并将就绪队列内的进程按随机生成的优先级进行排序；4.静态优先级算法：优先级高的进程优先的进入；5.动态优先级算法：与静态优先级算法相类似，增加一个优先级减少的算法，优先级高的进程优先的进入；6.时间片算法：根据随机的优先级，确定时间片执行进程，就绪队列队头进入到运行态，在时间片内不能完成的进入就绪队列，时间片未完成的插入到就绪队列队尾，时间片完成的从运行队列中删除。

三、数据结构及操作函数设计1.总体数据结构：class PCB( ) {public PCB(){} //构造函数public PCB(ID){} //重载构造函数public PCB(ID ，Priority ，in ，Alltime ，State){} //重载构造函数 }public partial class 进程调度 {//队列初始化public 进程调度仿真() ; //用户界面private void button_Click(); //按钮动作函数 private void AddListViewItem(); //输出显示窗口 private void staticPriority(); //静态优先级函数 private void ActivePriority(); //动态优先级函数private void TimePiece(); //时间片轮转调度算法函数 }2.模块①PCB 类：进程控制模块的类，类中包含进程名（ID ），优先级（priority ），进入时间（In ），入运行队列占时间从运行队列中删除。

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

使用动态优先权的进程调度算法的模拟动态优先权（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个时间单位后，完成了自己的服务时间。

至此，所有的进程都已经完成了它们的服务时间。

动态优先权调度算法的核心思想是，等待时间越长，优先级越高。

这样做的原因是为了避免饥饿的产生，即一些低优先级的进程因为等待时间太长而无法得到运行。

FPF和RR调度算法

郑州轻工业学院本科实验报告设计题目：实现FPF和RR调度算法学生姓名：李洋系别：计算机与通信工程学院专业：网络运维班级： 13-03 学号： 521507110314 指导教师：吴庆岗2015 年 11 月 18 日一、实验目的编写程序，实现FPF和RR算法，模拟进程调度过程，加深对作业调度的理解。

二、实验内容实现FPF和RR调度算法。

–数据结构设计（PCB，进程就绪队列）–算法实现与模拟（排序、调度）–输出调度结果，展示调度过程并解释三、实验要求1. 设计进程控制块(PCB)的数据结构–应包含实验必须的数据项，如进程ID、需要的服务时间、进入系统时间、完成时间、周转时间、优先权、进程状态（R-运行，W-等待），以及实验者认为有必要的其他数据项。

2. 实现排序算法（将就绪队列中的进程排序）– RR：只需在开始时排序，按FCFS策略将进程依次插入就绪队列。

开始运行后不再需要排序，按RR策略将每一个刚刚运行完一个时间片的进程插入到队尾。

– FPF：每次调度前排序，按计算所得的动态优先权排成有序队列，最高优先权排进程在队首，优先权相同的进程按FCFS策略排队。

3. 实现RR调度过程模拟①每个进程用一个PCB表示，按FCFS策略排成就绪队列，按照固定的周期循环调度。

②选择队首的进程，将其从就绪队列移出，修改其状态为R。

③经过一个时间片，如果正在执行的进程没有执行完，修改其状态为W，插入到就绪队列尾部。

如果执行完毕，计算其周转时间。

④进行下一次调度（去往第②步），直到就绪队列为空。

4. 实现FPF调度过程模拟①每个进程用一个PCB表示。

②计算动态优先权，按优先权高低排入就绪队列，如果相同，则按FCFS排队。

系统开始时调度，每个进程结束时进行调度。

③选择队首的作业，将其从后备队列移出④计算选中作业的周转时间（进程运行过程，在本实验中，无需实现，可认为就绪队列上的进程一但被调度程序选出，就顺利运行结束）⑤进行下一次调度（去往第②步）5.实现结果输出–输出进程状态表，展示调度过程•初始进程状态（未调度时）•每次调度后的进程状态6.撰写实验报告–包含实验要求中1~4项内容，要求有设计图（结构图/流程图）和源代码。

进程调度模拟设计——时间片轮转、优先级法

学号：课程设计课程名字系统软件开发实训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 根据选择的调度算法计算平均周转时间和平均带权周转时间。

调度算法OS

调度算法OS调度算法(OS)2011-04-05 20：59处理机调度的分级高级、中级和低级调度作业从提交开始直到完成，往往要经历下述三级调度：高级调度：(High-Level Scheduling)又称为作业调度，它决定把后备作业调入内存运行；低级调度：(Low-Level Scheduling)又称为进程调度，它决定把就绪队列的某进程获得CPU；中级调度：(Intermediate-Level Scheduling)又称为在虚拟存储器中引入，在内、外存对换区进行进程对换。

1.进程调度算法(处理器管理)A).先来先服务和短作业(进程)优先调度算法B).高优先权优先调度算法C).基于时间片的轮转调度算法2.作业调度算法2)短作业优先法SJF、3)最高响应比优先法HRN、4定时轮转法和优先数法3.移臂(磁盘)调度算法(设备管理根本目的在于有效利用磁盘，保证磁盘的快速访问)1)先来先服务算法；(根据访问者提出访问请求的先后次序来决定执行次序。

)2)最短寻找时间优先调度算法；(从等待的访问者中挑选寻找时间最短的那个请求执行，而不管访问者的先后次序。

)3)电梯4)单向扫描4.页式调度算法(存储器管理)1先进先出调度算法2最近最少调度算法3最近最不常用调度算法/////////////////////////////调度算法是指：根据系统的资源分配策略所规定的资源分配算法。

进程调度算法(处理器管理)一、先来先服务和短作业(进程)优先调度算法1.先来先服务调度算法先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。

FCFS算法比较有利于长作业(进程)，而不利于短作业(进程)。

由此可知，本算法适合于CPU繁忙型作业，而不利于I/O繁忙型的作业(进程)。

2.短作业(进程)优先调度算法短作业(进程)优先调度算法(SJ/PF)是指对短作业或短进程优先调度的算法，该算法既可用于作业调度，也可用于进程调度。

操作系统实验——动态优先级进程调度实验报告

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）用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分配给优先级最高的进程，并令其执行一个时间片，而后中断，寻找并运行下一个优先级最高的进程。

操作系统综合性实验报告-进程调度(含代码)

int count;
// 记录进程执行的次数
struct node *next;
// 队列指针
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; // 和完成队列
定义三个队列，就绪队列，执行队列
int num; void GetFirst(); void Output(); void InsertTime(PCB *in); void InsertFinish(PCB *in); TimeCreate(); void RoundRun(); void main() {
三、实验内容
1. 用 C 语言（或其它语言，如 Java ）编程实现对 N 个进程采用某种进程调度算
法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度
算法）调度执行的模拟。
2. 每个用来标识进程的进程控制块 typedef struct node {
PCB 可用结构来描述，包括以下字段：
一个时间片，当执行完时，有一个计时器发出时钟中断请求，该进程停止，并被送
到就绪队列的末尾，然后再把处理机分配就绪队列的队列进程，同时也让它执行一
个时间片。（ 3 ）、通过亲手实验，对上述写的时间片的工作流程和原理有了更贴切的认识。
另外本次实验遇到了很大的麻烦，其实大部分代码是借鉴网上的，但自己通过修改，来获取自己想要的，在自己的努力和同学的帮助下终于调试正确，很是高兴。
void InsertTime(PCB *in)
// 将进程插入到就绪队列尾部
{ PCB *fst; fst = ready;
if(ready == NULL) {
in->next = ready; ready = in; } else { while(fst->next != NULL) {

实验二FPF和RR调度算法

三、实验要求
1. 设计进程控制块(PCB)的数据结构 – 应包含实验必须的数据项，如进程 ID、需要的服务时间、进入系统时间、完成时间、周转时间、优先权、进程状态（R-运行，W-等待），以及实验者认为有必要的其他数据项。 2. 实现排序算法（将就绪队列中的进程排序） – RR：只需在开始时排序，按 FCFS 策略将进程依次插入就绪队列。开始运行后不再需要排序，按 RR 策略将每一个刚刚运行完一个时间片的进程插入到队尾。 – FPF：每次调度前排序，按计算所得的动态优先权排成有序队列，最高优先权排进程在队首，优先权相同的进程按 FCFS 策略排队。 3. 实现 RR 调度过程模拟
if (ap == NULL) {
pt = psorted->next; psorted = pt; } else
ap->next = pt->next; } ap = pt; pt = pt->next; } if (psorted->next == NULL) break; getchar(); } } struct PCB* SortList(PCB* HL) { struct PCB* SL; SL = (struct PCB*)malloc(sizeof(struct PCB)); SL = NULL;
按回车键进入演示程序
printf(" 法。");
1.演示最高优先数优先算
printf(" 按 1 继续:"); char ch = getchar(); return ch; system("cls"); } void HighPriority() { struct PCB *processes, *pt; //pt 作为临时节点来创建链表，使用 for 语句，限制进程数为 5个

进程的几种状态和调度方法

进程的⼏种状态和调度⽅法进程的七状态模型进程的基本状态：（1）运⾏：已经获得必要的资源占⽤处理机处理机正在执⾏该进程（2）就绪：进程等待分配CPU（3）阻塞：等待某个事件运⾏——>就绪：1，主要是进程占⽤CPU的时间过长，时间⽚⽤完；在采⽤抢先式优先级调度算法的系统中,当有更⾼优先级的进程要运⾏时，该进程就被迫让出CPU，该进程便由执⾏状态转变为就绪状态。

就绪——>运⾏：运⾏的进程的时间⽚⽤完，调度就转到就绪队列中选择合适的进程分配CPU运⾏——>阻塞：正在执⾏的进程因发⽣某等待事件⽽⽆法执⾏，则进程由执⾏状态变为阻塞状态，如发⽣了I/O请求阻塞——>就绪: 进程所等待的事件已经发⽣，就进⼊就绪队列此时进程的五状态模型如下图所⽰：挂起状态挂起状态（挂起态，suspend）：暂时被调到外存等待的进程状态称为挂起状态。

挂起状态由可以进⼀步细分为就绪挂起、阻塞挂起俩种状态。

此时进程的五状态模型成为七状态模型。

如下图所⽰：在执⾏状态的进程通过挂起即可进⼊就绪状态，如图所⽰，就绪状态和阻塞状态都分为活动态和静⽌态。

由活动态向静⽌态转换就是通过挂起实现的。

具有挂起状态的转换图在不少系统中进程只有上述五种状态，但在另⼀些系统中，⼜增加了⼀些新状态，最重要的是挂起状态。

引⼊挂起状态的原因有：(1) 终端⽤户的请求。

当终端⽤户在⾃⼰的程序运⾏期间发现有可疑问题时，希望暂时使⾃⼰的程序静⽌下来。

亦即，使正在执⾏的进程暂停执⾏；若此时⽤户进程正处于就绪状态⽽未执⾏，则该进程暂不接受调度，以便⽤户研究其执⾏情况或对程序进⾏修改。

我们把这种静⽌状态称为挂起状态。

(2) ⽗进程请求。

有时⽗进程希望挂起⾃⼰的某个⼦进程，以便考查和修改该⼦进程，或者协调各⼦进程间的活动。

(3) 负荷调节的需要。

当实时系统中的⼯作负荷较重，已可能影响到对实时任务的控制时，可由系统把⼀些不重要的进程挂起，以保证系统能正常运⾏。

操作系统中常用的进程调度算法

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

进程的调度算法

进程的调度算法调度算法的实质是：根据系统的资源分配策略所规定的资源分配算法。

先介绍⼀下进程调度与作业调度的区别：进程调度是真正让某个就绪状态的进程到处理机上运⾏，⽽作业调度只是使作业具有了竞争处理机的机会。

进程调度（⼜称微观调度、低级调度、短程调度）：是按照某种调度算法从就绪状态的进程中选择⼀个进程到处理机上运⾏。

负责进程调度功能的内核程序称为进程调度程序。

作业调度（⼜称⾼级调度、宏观调度、长程调度）：是按某种调度算法从后备作业队列中选择作业装⼊内存运⾏；另外当该作业执⾏完毕后，还负责回收系统资源。

完成作业调度功能的程序称为作业调度程序。

下⾯介绍⼏种常见的调度算法:先来先服务(FCFS，first come first served)FCFS调度算法是⼀种最简单的调度算法，该调度算法既可以⽤于作业调度也可以⽤于进程调度。

在作业调度中，算法每次从后备作业队列中选择最先进⼊该队列的⼀个或⼏个作业，将它们调⼊内存，分配必要的资源，创建进程并放⼊就绪队列。

在进程调度中，FCFS调度算法每次从就绪队列中选择最先进⼊该队列的进程，将处理机分配给它，使之投⼊运⾏，直到完成或因某种原因⽽阻塞时才释放处理机。

优点：保证了公平性，规则简单缺点:有利于长进程⽽不利于短进程，有利于CPU 繁忙的进程，⽽不利于I/O 繁忙的进程短作业优先(SJF，Shortest Job First)短作业（进程）优先调度算法是指对短作业（进程）优先调度的算法。

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

⽽短进程优先(SPF)调度算法，则是从就绪队列中选择⼀个估计运⾏时间最短的进程，将处理机分配给它，使之⽴即执⾏，直到完成或发⽣某事件⽽阻塞时，才释放处理机。

优点：相⽐FCFS 算法，该算法可改善平均周转时间和平均带权周转时间，缩短进程的等待时间，提⾼系统的吞吐量。

缺点：该算法对长作业不利，SJF调度算法中长作业的周转时间会增加。

进程调度算法实验报告

实验报告实验一：进程调度算法一、实验目的1．利用高级语言实现三种不同及进程调度算法：短作业优先算法、时间片轮转调度算法和优先级调度算法。

2．通过实验理解有关进程控制块，进程队列等的概念。

二、实验原理各调度算法思想：1.先来先服务算法(FCFS)：按照进程进入就绪队列的先后次序来分配CPU，一旦一个进程占有CPU，就一直运行下去，知道该进程完成工作，才释放CPU。

2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列，进程调度程序总是选择队列中的第一个进程执行，且仅能执行一个时间片，在使用完一个时间片后，即使进程并未完成其运行，也必须将CPU交给下一个进程；如果一个时间片未使用完就完成了该进程，则剩下的时间分配给下一个进程。

3.优先权调度算法；在创建进程时就确定优先权，确定之后在整个程序运行期间不再改变，根据优先级排列，系统会把CPU分配给优先权最高的进程。

三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义：PCB块结构体类型struct PCB{int name;int arrivetime; //到达时间int servicetime; //服务时间//int starttime[max]; //开始时间int finishtime; //完成/结束时间int turntime; //周转时间int average_turntime; //带权周转时间int sign; //标志进程是否完成int remain_time; //剩余时间int priority; //优先级}pcb[max];主程序的流程以及各程序模块之间的层次(调用)关系：主程序中从键盘得到进程的数量，创建PCB，调用layout（）函数显示选择界面。

Layout（）函数中选择相应的算法并调用相关函数如：FCFS()、time_segment();、Priority()，这三个函数分别实现先来先服务算法，时间片轮转算法和优先级算法，最后分别打印。

基于动态优先权的进程调度算法的模拟实现

【Key wor ds】dynamic priority schedul ing; proess schedul ing; si mulation
在多道程序环境下, 进程的数目往往多于处理机数目。这就要求系统能按照某种算法, 动态的把处理机分配给就绪队列中的进程, 使之执行。因此, 处理机调度是操作系统设计的中心问题之一。进程调度问题的核心就是采用什么样的算法把处理机分配给进程。进程调度算法也是在任何操作系统中必须配置的一级调度。好的进程调度算法将有效的提高系统中各种资源利用率, 减少处理机的空闲时间, 避免部分作业长期得不到处理机响应等情况的发生。
1 . 动态优先权调度算法介绍动态优先权调度算法, 以就绪队列中各个进程的优先权作为进程调度的依据。各个进程的优先权在创建进程时所赋予, 随着进程的推进或其等待时间的增加而改变。进程的优先权利用某一范围内的整数来表示。有的系统数值越小优先权越高, 如 Uni x 系统, 有的系统则反之。采用该算法时, 每次总是在就绪队列中选择一个优先权最高的进程进行调度, 并将处理机分配给该进程。动态优先权调度算法又分为抢占式和非抢占式两种。本文采用 C 语言对非抢占式动态优先权调度算法进行了设计和实现。 2 . 算法的设计思路 (1 ) 在算法的设计中各项原则。首先规定优先数改变的原则 : ● 进程在就绪队列中呆一个时间片, 优先数增加 1 。 ● 进程每运行一个时间片, 优先数减 3。其次, 算法的数据结构及操作采用数组方式, 将输入的 N个进程的 PCB 信息保存到一个数组中。用 PCB 数组的插入和删除动态地模拟进程调度过程。 (2 ) 系统初始条件。系统中设有 5 个进程, 每个进程产生时间, 优先级各不相同。利用进程控制块 PCB 来描述各个进程。进程控制块 PCB 包括以下字段: ● 进程标识数 ID; ● 进程优先数 PRIORITY, 并规定优先数越大的进程, 其优先权越高; ● 进程已占用的 CPU 时间 CPUTIME; ● 进程还需占用的 CPU 时间 ALLTIME。当进程运行完毕时 , ALLTIME 变为 0 ; ● 进程的阻塞时间 STARTBLOCK, 表示当进程再运行 STARTBLOCK 个时间片后, 进程将进入阻塞状态; ● 进程被阻塞的时间 BLOCKTIME, 表示已阻塞的进程再等待 BLOCKTIME 个时间片后, 进程将转换成就绪状态; ● 进程状态 STATE, 包括三种状态, 就绪态、阻塞态、完成态; CPU 处理进程是从就绪队列中选择当前各进程中优先权最大的进程开始的。由于采用的是非抢占式调度算法, 则当前进程执行完一个时间片之后有以下几种情况 : ① 当前进程结束则退出系统, 否则排到就绪队列尾或根据阻塞时

高优先权优先的进程调度算法模拟

高优先权优先的进程调度算法模拟进程调度算法是操作系统中的一个重要组成部分，其中高（动态）优先权优先调度算法是一种常用的调度算法。

本文将通过模拟该算法的工作原理、实现过程和应用场景等方面，详细介绍高（动态）优先权优先进程调度算法。

一、高（动态）优先权优先进程调度算法的原理及特点：1.原理：高（动态）优先权优先进程调度算法根据进程的优先权值来确定进程执行的顺序，优先权值高的进程先执行。

在这种算法中，每个进程都有一个优先权值，优先权值越大，进程执行的优先级也越高。

2.特点：（1）动态性：高（动态）优先权优先进程调度算法中，进程的优先权值可以根据进程的状态和需求进行动态调整。

例如，用户交互进程或实时进程的优先权值可以较高，而后台进程的优先权值可以较低。

（2）公平性：高（动态）优先权优先进程调度算法能够保证每个进程都有执行的机会，不会出现饥饿现象。

（3）无法避免的问题：由于优先权值的动态调整，高（动态）优先权优先进程调度算法可能导致一些进程饥饿或低优先级进程无法得到执行的情况。

二、高（动态）优先权优先进程调度算法的实现过程：1.初始化：设定每个进程的优先权值，创建就绪队列和堆栈等数据结构，初始化进程的状态和资源。

2. 进程调度：根据进程的优先权值，从就绪队列中选择优先权值最高的进程进行执行。

如果存在多个优先权值相同的进程，可以使用先到先服务（FIFO）或轮转（Round-robin）等调度策略来决定执行顺序。

3.执行进程：将选中的进程从就绪队列中移除，并切换到该进程的上下文，开始执行进程的指令。

4.中断处理或进程阻塞：在进程执行过程中，如果发生中断事件（如I/O请求、信号响应等），则暂停当前进程的执行，并将其状态置为阻塞态，将进程放入阻塞队列中等待事件完成或唤醒信号。

5.进程唤醒或时间片过期：当进程阻塞的事件完成或等待一段时间后，重新将该进程放入就绪队列中，更新其优先权值。

6.进程终止或等待：当进程执行完所有指令或主动请求等待时，将进程从系统中移除，并释放其占用的资源。

操作系统低中高级调度

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优先权调度算法适用于作业调度和进程调度。