使用动态优先权的进程调度算法的模拟
- 1 - 实验四 使用动态优先权的进程调度算法的模拟
1、实验目的
通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
2、实验内容
（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个进程，它们的初始状态如下：
ID 0 1 2 3 4
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）为了清楚地观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来，参照的具体格式如下：
RUNNING PROG： i
READY_QUEUE:->id1->id2
BLOCK_QUEUE:->id3->id4
==================================
ID 0 1 2 3 4
PRIORITY P0 P1 P2 P3 P4
CPUTIME C0 C1 C2 C3 C4
ALLTIME A0 A1 A2 A3 A4
STARTBLOCK T0 T1 T2 T3 T4
BLOCKTIME B0 B1 B2 B3 B4
STATE S0 S1 S2 S3 S4
- 2 -
程序代码：
//A.4使用动态优先权的进程调度算法的模拟
//by YanQiwei
#include
#define N 5
void init();
void print();
int getRunning();
void sort();
int run(int time);
enum STATE{Ready,Run,Block,RunOut};
struct PROCESS{
int ID;
int Priority;
int Cputime;
int Alltime;
int Startblock;
int Blocktime;
enum STATE State;
}Process[N];
int READY[N];
int BLOCK[N];
int RUNOUT[N][2];
int main(){
int Time=0;
init();
printf("Time:%d\n",Time);
sort();
print();
while(1){
Time++;
getchar();
printf("Time:%d\n",Time);
if(run(Time))
break;
// sort();
}
//print(Time);
return 0;
}
void init()
{ - 3 - int i;
//printf("Input properties of %d process(PRIORITY,ALLTIME,STARTBLOCK,BLOCKTIME):\n",
// N);
for(i=0;i
READY[i]=-1;
BLOCK[i]=-1;
RUNOUT[i][0]=-1;
RUNOUT[i][1]=-1;
Process[i].ID=i;
Process[i].Cputime=0;
Process[i].State=Ready;
/* printf("Number %d :",i);
scanf("%d,%d,%d,%d",&Process[i].Priority,&Process[i].Alltime,
&Process[i].Startblock,&Process[i].Blocktime);
*/
Process[i].Startblock=-1;Process[i].Blocktime=0;
}
Process[0].Priority=9;Process[0].Alltime=3;Process[0].Startblock=2;Process[0].Blocktime=3;
Process[1].Priority=38;Process[1].Alltime=3;
Process[2].Priority=30;Process[2].Alltime=6;
Process[3].Priority=29;Process[3].Alltime=3;
Process[4].Priority=0;Process[4].Alltime=4;
}
void print()
{
int i;
if(getRunning()>=0)
printf("\tRUNNING PROG: %d\n",getRunning());
printf("\tREADY_QUEUE:");
for(i=0;i
if(READY[i]>=0)
printf("->%d",Process[READY[i]].ID);
else{
break;
}
}
printf("\n\tBLOCK_QUEUE:");
for(i=0;i
if(BLOCK[i]>=0)
printf("->%d",Process[BLOCK[i]].ID);
else{
break;
} - 4 - }
printf("\n=====================================================\n");
printf("ID\t");
for(i=0;i
printf("\t%d",Process[i].ID);
}
printf("\nPRIORITY");
for(i=0;i
printf("\t%d",Process[i].Priority);
}
printf("\nCPUTIME\t");
for(i=0;i
printf("\t%d",Process[i].Cputime);
}
printf("\nALLTIME\t");
for(i=0;i
printf("\t%d",Process[i].Alltime);
}
printf("\nSTARTBLOCK");
for(i=0;i
printf("\t%d",Process[i].Startblock);
}
printf("\nBLOCKTIME");
for(i=0;i
printf("\t%d",Process[i].Blocktime);
}
printf("\nSTATE\t");
for(i=0;i
switch(Process[i].State){
case 0:printf("\tReady");break;
case 1:printf("\tRun");
if(Process[i].Alltime==0)
{
Process[i].State=RunOut;
}
else Process[i].State=Ready;
break;
case 2:printf("\tBlock");break;
case 3:printf("\tRunOut");break;
}
}
printf("\n");
printf("\tRUNOUT LIST:");
for(i=0;i=0)
printf("->%d(%d)",Process[RUNOUT[i][0]].ID,RUNOUT[i][1]);
else{
printf("\n");
break;
}
}
printf("\n");
}
int getRunning()
{
int i;
for(i=0;i
if(Process[i].State==Run)
return i;
}
for(i=0;i
if(Process[i].Startblock==0)
return i;
}
return -1;
}
void sort()
{
int i,j,k;
for(i=0;i
READY[i]=-1;
BLOCK[i]=-1;
}
for(i=0;i
if(Process[i].State==Ready||Process[i].State==Run){
// Process[i].State=Ready;
if(Process[i].Alltime==0)
continue;
for(j=0;j
if(READY[j]<0)
{
READY[j]=i;
break;
}
else if(Process[i].Priority<=Process[READY[j]].Priority)
{ continue; }
else{
for(k=N-1;k>j;--k){
作业调度实验报告
实验项目名称 作业调度
实验目的及要求 一、实验目的：
1、通过模拟作业调度算法的设计加深对作业管理基本原理的理解。
2、深入了解批处理系统如何组织作业、管理作业和调度作业。
3、掌握作业调度算法。
二、实验要求：
1、编写程序完成实验内容；
2、对测试数据进行分析；
3、撰写实验报告。
实验
内容 1、设计可用于该实验的作业控制块；
2、动态或静态创建多个作业；
3、模拟先来先服务调度算法和短作业优先调度算法。
3、调度所创建的作业并显示调度结果（要求至少显示出各作业的到达时间，服务时间，开始时间，完成时间，周转时间和带权周转时间）；
3、比较两种调度算法的优劣。
实验
原理 一、作业
作业(Job)是系统为完成一个用户的计算任务（或一次事物处理）所做的工作总和，它由程序、数据和作业说明书三部分组成，系统根据该说明书来对程序的运行进行控制。在批处理系统中，是以作业为基本单位从外存调入内存的。
二、作业控制块JCB(Job Control Block)
作业控制块ＪＣＢ是记录与该作业有关的各种信息的登记表。为了管理和调度作业，在多道批处理系统中为每个作业设置了一个作业控制块，如同进程控制块是进程在系统中存在的标志一样，它是作业在系统中存在的标志，其中保存了系统对作业进行管理和调度所需的全部信息。在JCB中所包含的内容因系统而异，通常应包含的内容有：作业标识、用户名称、用户帐户、作业类型(CPU 繁忙型、I/O 繁忙型、批量型、终端型)、作业状态、调度信息(优先级、作业已运行时间)、资源需求(预计运行时间、要求内存大小、要求I/O设备的类型和数量等)、进入系统时间、开始处理时间、作业完成时间、作业退出时间、资源使用情况等。
三、作业调度 作业调度的主要功能是根据作业控制块中的信息，审查系统能否满足用户作业的资源需求，以及按照一定的算法，从外存的后备队列中选取某些作业调入内存，并为它们创建进程、分配必要的资源。然后再将新创建的进程插入就绪队列，准备执行。
调度算法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)是指对短作业或短进程优先调度的算法，该算法既可用于作业调度，也可用于进程调度。但其对长作业不利；不能保证紧迫性作业(进程)被及时处理；作业的长短只是被估算出来的。 二、高优先权优先调度算法
第6章进程调度(含答案)
1 第6章 进程调度练习题
一、 单项选择题
1、 在分时操作系统中,进程调度经常采用(C )算法。
A 先来先服务 B最高优先权 C时间片轮转 D随机
2、 （B）优先权是在创建进程时确定的，确定之后在整个进程运行期间不再改变
A 先来先服务 B 静态 C 动态 D 短作业
3、 以优先级为基础的进程调度算法可以保证在任何时候正在运行的进程总是非等待状态下诸进程中优先级最高的进程。上述描述是（ B）
A 正确的 B 错误的
二、 填空题
1、 进程调度方式通常有（非抢占式）和（抢占式）。
2、 所谓进程调度就是从处于（就绪）状态的一些进程中按某种算法选择一个进程，使其占有CPU，使其该进程处于（执行）状态。
3、 进程调度算法采用时间片轮转法，时间片过大，就会使轮转法转化为（FCFS）调度算法。
4、 进程调度负责（处理机）的分配工作。
5、 一种最常用的进程调度算法是把处理机分配给具有最高优先权的进程，而确定优先权的方法概括起来不外乎是基于（静态）特性和（动态）特性两种方法。前者所得到的是（静态）优先权，后者所得到的是（动态）优先权。
6、 在（先来先服务）调度算法中，按照进程进入就绪队列的先后次序来分配处理机。
三、概念的区别与联系
1、 作业调度与进程调度（1998西北大学考研试题）
2、 静态优先数与动态优先数。（1998西北大学考研试题）
四、解析题
1、 假设有一台计算机，它有1M内存，操作系统占有用200K，每个用户进程也占用200K，用户进程等待I/O的时间为80%，若增加1M内存，则CPU的利用率将提高多少？
解：1M内存的情况：1）支持用户进程数：（1024K-200K）/200K=4.12 所以4个用户进程。
2）CPU利用率： 先求CPU空闲（4个用户均处于等待I/O状态）概率P=（80%）4，然后再求CPU利用率1-P
操作系统第三章总复习题
操作系统第三章总复习题
一、单选题
1、进程调度又称低级调度，其主要功能是（ D ）。
A．选择一个作业调入内存 B．选择一个主存中的进程调出到外存
C．选择一个外存中的进程调入到主存 D．将一个就绪的进程投入到运行
2、若进程P 一旦被唤醒就能够投入运行，系统可能为（ B ）。
A．分时系统，进程P 的优先级最高B．抢占调度方式，就绪队列上的所有进程的优先级皆比P 的低
C．就绪队列为空队列 D．抢占调度方式，P 的优先级高于当期运行的进程。
3、一个进程P 被唤醒后,（D ）。
A．P 就占有了CPU。 B．P 的PCB 被移到就绪队列的队首。
C．P 的优先级肯定最高 D．P 的状态变成就绪
4、若当期运行进程（ C）后，系统将会执行进程调度原语。(CPU空闲时，才会执行调度原语)
A 执行了一个转移指令
B 要求增加主存空间，经系统调用银行家算法进行测算认为是安全的。
C 执行了一条I/O 指令要求输入数据。 D 执行程序期间发生了I/O 完成中断。
5、当系统中（ C） 时，系统将不会执行进程调度原语。
A．一个新进程被创建B．当前进程执行了P 操作。
C．在非抢占调度中，进程A 正在运行而进程B 恰好被唤醒。 D．分时系统中时间片用完。
6、在分时系统中，若当期运行的进程连续获得了两个时间片，原因可能是（ B ）。
A 该进程的优先级最高B 就绪队列为空C 该进程最早进入就绪队列D 该进程是一个短进程
7、实时系统中采用的调度算法可以有如下几种：
1、非抢占优先权调度算法 2、立即抢占优先权调度算法 3、时间片轮转调度算法 4、基于时钟中断抢占的优先权调度算法
按实时要求的严格程度由低到高的顺序（ ）。
A 1-3-2-4 B 3-1-4-2 C 3-1-2-4 D 1-3-4-2
8、三种主要类型的OS 中都必须配置的调度（C ）。
A 作业调度B 中级调度C 低级调度D I/O 调度
计算机专业基础综合操作系统(进程管理)模拟试卷1(题后含答案及解析)
计算机专业基础综合操作系统（进程管理）模拟试卷1 (题后含答案及解析)
题型有：1. 单项选择题 2. 综合应用题
单项选择题1-40小题，每小题2分，共80分。下列每题给出的四个选项中，只有一个选项是最符合题目要求的。
1． 进程处于( )等待状态时，它是处于非阻塞状态的。
A．等待从键盘输入数据
B．等待协作进程的一个信号
C．等待操作系统分配CPU时间
D．等待网络数据进入内存
正确答案：C 涉及知识点：操作系统
2． 下列叙述中，错误的是( )。
A．操作系统是用户与计算机之间的接口
B．程序的并发执行，使程序失去了顺序执行时具有的封闭性和可再现性，程序与程序的执行不再一一对应
C．进程从一个状态到另一个状态的转换，都是靠使用不同的原语来实现的
D．在单CPU系统中，任何时刻处于就绪状态的进程有多个，而且只有处于就绪状态的进程经调度程序选中后才可进入运行状态
正确答案：C
解析：从用户的角度看，操作系统是用户使用计算机的桥梁，用户通过操作系统的两类接口来达到操纵计算机的目的。选项A正确。 选项B的叙述也是正确的，因为这正是引入进程概念的原因。 进程从一个状态到另一个状态的转换是一个非常复杂的过程，除了要使用不同的原语外，有时还要借助于硬件触发器才能完成。例如，UNIX系统中，从系统态到用户态的转换要借助硬件触发器。因此，选项C错误。 处于就绪状态的进程已经获得了除CPU之外的所有资源，由于只有一个CPU，任何时刻就只能有一个进程获得CPU，而其他的就只能在就绪状态对应的队列上排队等待调度程序的调度。所以选项D也正确。 知识模块：操作系统
3． 进程调度是从( )选择一个进程投入运行的。
A．就绪队列
B．等待队列
C．作业后备队列
D．提交队列
正确答案：A
解析：处于就绪队列的进程是获得了除处理机以外的所有资源处于准备执行的状态。进程调度就是负责从就绪队列中挑选进程投入运行的。 知识模块：操作系统
操作系统第三章总复习题-答案
操作系统第三章总复习题
一、单选题
1、进程调度又称低级调度，其主要功能是（ D ）。 A．选择一个作业调入内存
B．选择一个主存中的进程调出到外存 C．选择一个外存中的进程调入到主存
D．将一个就绪的进程投入到运行
2、若进程 P 一旦被唤醒就能够投入运行，系统可能为（ D ）。 A．分时系统，进程 P
的优先级最高 B．抢占调度方式，就绪队列上的所有进程的优先级皆比 P 的低
C．就绪队列为空队列
D．抢占调度方式， P 的优先级高于当期运行的进程。
3、一个进程 P 被唤醒后 , （ D ）。
A． P 就占有了 CPU。
B． P 的 PCB 被移到就绪队列的队首。
C． P 的优先级肯定最高
D． P 的状态变成就绪
4、若当期运行进程（ C ）后，系统将会执行进程调度原语。
A 执行了一个转移指令
B 要求增加主存空间，经系统调用银行家算法进行测算认为是安全的。
C 执行了一条 I/O 指令要求输入数据。
D 执行程序期间发生了 I/O 完成中断。
5、当系统中（ C ） 时，系统将不会执行进程调度原语。 A．一个新进程被创建
B．当前进程执行了 P 操作。
C．在非抢占调度中，进程 A 正在运行而进程 B 恰好被唤醒。 D．分时系统中时间片用完。
6、在分时系统中，若当期运行的进程连续获得了两个时间片，原因可能是（ B ）
A 该进程的优先级最高
B 就绪队列为空
C 该进程最早进入就绪队列
D 该进程是一个短进程
7、实时系统中采用的调度算法可以有如下几种： 1、非抢占优先权调度算法
2、立即抢占优先权调度算法
3、时间片轮转调度算法
4、基于时钟中断抢占的优先权调度算法 按实时要求的严格程度由低到高的顺序（ B ）。
A 1-3-2-4 B 3-1-4-2 C 3-1-2-4 D 1-3-4-2
8、三种主要类型的 OS 中都必须配置的调度（ C ）。
A 作业调度 B 中级调度 C 低级调度 D I/O 调度
优先级和时间片轮转调度
实验 优先级和时间片轮转调度
一、实验要求
通过编写程序实现进程高优先权和按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。
二、实验内容
进程调度算法有优先数调度算法，时间片轮转调度算法，分级调度算法。选两种种算法实现。进程调度算法的数据结构主要有：进程函数定义，建立进程函数，进程调度函数。
源程序代码部分：
#include "stdio.h"
#include
#define max 100
#define etime 4
#define pfree 0
#define running 1
#define aready 2
#define blocking 3
typedef struct node
{
char name;
int status;
int pri;
int ptime;
int ax,bx,cx,dx;
int pc;
int psw;
}pcb;
pcb *processarray[max];
static int processnum;
pcb *createprocess(pcb *processarray[]) 组
{
pcb *p,*q;
int a,b,c,d,m,n,r,t;
char ID;
q=NULL;
printf("input the first nine status pcb:");
scanf("\n%c%d%d%d%d%d%d%d%d",&ID,&a,&b,&c,&d,&m,&n,&r,&t);
for(int i=0;i
{
p=(pcb*)malloc(sizeof(pcb));
p->name=ID;
p->ax=a;
p->bx=b; p->cx=c;
p->dx=d;
p->pc=m;
模拟题
一、填空题练习
1．进程控制块 是进程存在的惟一标志。
2、利用程序级接口调用操作系统内部的功能模块，称为系统调用。
3、进程的 并发性 是指多个进程在同一时间间隔内同时发生。
4．操作系统的基本功能是 管理计算机资源 和 担任人机接口。
5、进程运行中，外部事件得不到满足，进程由 运行 状转换为 阻塞（等待）状态。
6、操作系统3级调度中的高级调度是指 作业调度。
7、产生死锁的原因有资源竞争和 进程推进顺序不当 。
8、把一个程序在某个数据集合上的一次执行称为一个进程。
9、进程运用行时，CPU花费大部分时间用于内外存交换信息，这种现象称
为 对换。
11、一次只允许一个进程使用的资源称为临界资源，对其进行访问的那段程序代码称为
临界区。
12、在实时操作系统中，响应一个新任务的时间必须在被控对象规定的时间内。
13、操作系统是覆盖在裸机之上的第 一 层软件，与硬件关系更加密切。
14、操作系统的主要管理功能有：存储器管理、作业管理、设备管理、文件管理和进程管理 。
15、一个批处理型作业，从进入系统并驻留在外存的后备队列上开始，至作业完成，可能要经历三级调度。高级调度为 作业 调度，低级调度为 进程 调度。
16三级调度是指作业调度、进程调度和对换。
17、不能被多个进程同时使用的资源称为 临界资源 。
18一次只允许一个进程使用的资源称为临界资源。
19、从结构上看，每个进程都是由PCB块和程序部分以及数据集合三部分所组成的。
20．作业调度是从外存的后备作业队列中选择一个或一批作业调入内存，为它们创建进程，并将这些进程送入就绪 队列。
21．分页式存储管理中，页表是用来指出作业的 逻辑页号 与 物理块号
的对应关系。
22、进程的三个基本状态有：阻塞态、就绪态和执行态。
23、在Linux系统中，显示当前系统中的进程情况，使用 ps 命令；显示文件内容，使用 cat 命令。
使用动态优先权的进程调度算法的模拟实验
使用动态优先权的进程调度算法的模拟实验
动态优先权调度算法是一种根据进程动态表现调整优先权的进程调度算法。它不仅考虑了进程的优先级，还将进程的实际执行情况作为调度依据。下面将介绍一个模拟实验，以更好地理解这种调度算法。
实验背景：
假设有五个待执行的进程，它们的ID和初始优先权分别为P1（3）、P2（5）、P3（2）、P4（1）、P5（4）。这五个进程的优先权在调度过程中会根据实际情况进行动态调整。
实验过程：
1.初始化：在实验开始之前，首先需要对进程的初始状态进行初始化。每个进程有两个属性：优先级和已运行时间。优先级用于决定进程的调度优先级，已运行时间用于记录进程已经运行了多长时间。设置一个全局时间片，表示每个时间单元中运行的时间。
2.进程调度：根据进程的优先权，选取最高优先权的进程进行调度。从P1到P5，进程的优先权逐渐减小。
-选择进程：比如初始时最高优先权的进程为P2
-进程执行：进程P2被调度后开始执行，运行一个时间片。每运行一个时间片，该进程的已运行时间加一，重新计算进程的优先权。
-优先权调整：根据已运行时间的加一，重新计算进程的优先权。优先权的计算公式可以根据实际需要进行调整，比如可以设为：新的优先权=原优先权+（已运行时间/其中一常量）。 -进程阻塞：如果进程运行的时间超过了一个时间片，则该进程被阻塞，进入就绪队列等待下一次轮转调度，其他进程继续执行。
3.调度进程更新：进程在执行和阻塞的过程中，它们的优先权会发生变化。在每一轮调度后，需要更新进程的优先权，重新确定每个进程的调度顺序。
4.实验结果：重复进行步骤2和步骤3，直到所有进程都完成执行。记录每次调度过程中的结果，包括进程的执行顺序、时刻和优先权的变化。
实验分析：
通过模拟实验，可以得出以下一些结论：
1.动态优先权调度算法能够根据实际情况调整进程的优先权，更好地适应不同进程的需求，增强了调度的灵活性。
2.在实验中，进程运行时间越长，优先权越低。这使得系统可以更多地照顾那些等待时间较长的进程，避免了进程长时间等待的情况。
进程调度算法总结
进程调度算法总结
所谓进程，简单来说是计算机中的各种任务，那么计算机如何分配系统资源以供这些任务使⽤呢？此篇博客⽬的就是为⼤家
整理⼀下⼏种常见进程调度算法。
进度调度就是按照⼀定的策略，动态地把处理机分配给处于就绪队列的进程，使之执⾏。
常见的进程调度算法：
1、先来先服务和短作业（进程）优先调度算法
2、⾼优先权优先调度算法
3、基于时间⽚的轮转调度算法
下⾯细说：
1、先来先服务和短作业优先调度算法
1.1、先来先服务调度算法
这种调度算法由字⾯意思理解很直观，所谓先来先服务，就是谁先来先服务谁。结合进程，先来先服务调度算法就是对于
优先到达就绪队列的进程采取优先服务的策略，直到该进程运⾏结束或发⽣某事件导致阻塞才放弃处理机。这种调度算法是
⼀种最简单的调度算法，适⽤于作业和进程。当⽤于作业时，先进⼊后备队列的作业先运⾏。
1.2、短作业（进程）优先调度算法
短作业（进程）优先调度算法，是对短作业或短进程进⾏得调度算法。何为短？就是估计运⾏时间短。该算法从后备队列
或就绪队列选择估计运⾏时间较短的作业或进程，将他们调⼊内存运⾏，直到该进程运⾏结束或发⽣某事件导致阻塞才放弃
处理机重新进⾏调度。
2、⾼优先权优先调度算法
2.1、优先权调度算法
上述所说的两种调度算法，过于简单，当系统中有紧急作业或进程，且不满⾜先进队列或运⾏时间短时，这些作业或进程
将很难得到资源。那么对于这些作业或进程，⼜该怎么办呢？因此，⼜有了优先权调度算法，所谓优先权调度算法，顾名思
义就是谁的优先权⾼，谁就西安得到资源得以运⾏。进⼀步将算法分为以下两种：
2.1.1、⾮抢占式优先权算法
在这种⽅式下，系统⼀旦把处理机分配给就绪队列中优先权最⾼的进程后，该进程便⼀直执⾏下去，直⾄完成；或因发⽣
某事件使该进程放弃处理机时，系统⽅可再将处理机重新分配给另⼀优先权最⾼的进程。这种调度算法主要⽤于批处理系统
中；也可⽤于某些对实时性要求不严的实时系统中。
2.1.2、抢占式优先权算法