进程调度算法模拟带答案版.pdf
进程调度算法模拟带答案版.pptx
int i=0,j; int number_schedul,temp_counter; /*正在被调度执行的进程编号和已经调度完成的进程个数*/ float run_time; /*借助该局部变量可以帮助找到执行时间 run_time 最短进程*/ run_time=tasks[i].run_time; j=1; /*从到达时间最早且相同的进程中查找第一个被调度的进程*/ while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
调用 短作 业（进 程）调 度程
序
调用 响应 比高 者优 先调 度程 序
输出调度结果
2．数据输入算法
输入进程或作业个数 对每一个进程或作业
输入进程或作业名
输入进程或作业号 输入进程或作业到达时间 输入进程或作业运行时间 输入进程或作业优先级
3．数据输出算法
学海无 涯
对每个作业执行
输出进程（或作业）号、 进程（或作业）名、 到达时间、 开始运行时间、 运行结束时间、 优先级、 运行次序、 周转时间、 带权周转时间 计算并输出平均周转时间、带权周 转时间
{ max_priority=tasks[j].priority; i=j; } j++; } /*对第一个被调度的进程求相应的参数*/ number_schedul=i; tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time; tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].r un_time; tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; tasks[number_schedul].order=1; temp_counter=1;
操作系统进程调度模拟(全三分合集)
实验一进程调度实验一、目的要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、例题：设计一个有 N个进程共行的进程调度程序进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
调度算法的流程图如下图所示。
三．实验题：1、编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。
“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。
静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。
动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。
例如：在进程获得一次CPU后就将其优先数减少1。
或者，进程等待的时间超过某一时限时增加其优先数的值，等等。
2、编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。
轮转法可以是简单轮转法、可变时间片轮转法，或多队列轮转法。
操作系统-进程调度模拟算法(附源码)
进程调度模拟算法课程名称：计算机操作系统班级：信1501-2实验者姓名：李琛实验日期：2018年5月1日评分：教师签名：一、实验目的进程调度是处理机管理的核心内容。
本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验要求1.设计进程控制块 PCB 的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的 CPU 时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。
三、实验过程分别用两种调度算法对伍个进程进行调度。
每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。
（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数 2）CPUTIME——进程累计占用 CPU 的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。
（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减 1，CPU 时间片数加 1，进程还需要的时间片数减 1。
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加 2，进程还需要的时间片数减 2，并退出 CPU，排到就绪队列尾，等待下一次调度。
进程调度算法模拟
操作系统实验报告姓名：班级：学号：指导教师：实验一进程调度算法模拟，用动态优先数及时间片轮转法实现进程调度一．实验内容：设计一个简单的进程调度算法，模拟OS中的进程调度过程二．实验要求：①进程数不少于5个；②进程调度算法任选；最好选用动态优先数法，每运行一个时间片优先数减3③用C++（或C）语言编程；④程序运行时显示进程调度过程。
三．实验步骤：①设计PCB及其数据结构：struct pcb{ /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;} *ready=NULL,*p;typedef struct pcb PCB;②设计进程就绪队列及数据结构；三个应用队列：PCB *ready=NULL,*run=NULL,*finish=NULL;③设计进程调度算法，并画出程序流程图；④设计输入数据和输出格式；结构格式：当前正运行的进程：0当前就绪队列：2，1，3，4⑤编程上机，验证结果。
源程序代码如下：#include<stdio.h>void main(){int a[4][5]={{0,1,2,3,4},{9,38,30,29,0},{0,0,0,0,0},{3,3,6,3,4}};int a1[5],a0[5],a2[5],num;printf("当前系统中有5个进程，其初始状态如下：\n\n");for(int i=0;i<4;i++){if(i==0)printf("ID ");if(i==1)printf("PRIORITY ");if(i==2)printf("CPUTIME ");if(i==3)printf("ALLTIME ");for(int j=0;j<5;j++){printf("%5d ",a[i][j]);}printf("\n");}printf("STATE ready ready ready ready ready");for(;;){for(i=0;i<5;i++){a0[i]=a[1][i];}for(i=0;i<5;i++){for(int j=0;j<5-1;j++){if(a0[j]<=a0[j+1]){num=a0[j];a0[j]=a0[j+1];a0[j+1]=num;}}}//a0数组为排列好的优先极for(int j=0;j<5;j++){a2[j]=a[1][j];}for(i=0;i<5;i++){for(int j=0;j<5;j++){if(a0[i]==a2[j]){a1[i]=j;a2[j]=-10;break;}}}a[1][a1[0]]-=3;a[2][a1[0]]+=1;a[3][a1[0]]-=1;printf("\n");if(a[3][a1[0]]<=0){a[1][a1[0]]=-3;}int ji=0;for(i=0;i<5;i++){ji+=a[3][i];}printf("\n当前运行程序为：%d\n当前就绪队列：",a1[0]);for(i=1;i<5;i++){if(a[1][a1[i]]>=0)printf("%d ",a1[i]);}if(ji<=0)break;printf("\n\n程序正在运行中...");}printf("\n\n当前程序已全部运行完毕\n");}实验结果：四．实验总结：（1）本次试验后对优先数调度算法和时间片轮转调度算法实现的过程，有了很清楚的认识、理解。
操作系统进程调度练习及答案
1 假设一个系统中有5个进程，它们的到达时间和服务时间如下表所示，忽略I/O以及其他开销，若分别按先来先服务（FCFS）、非抢占式及抢占式的短进程优先（SPF）、高响应比优先、时间片轮转、多级反馈队列和立即抢占式多级反馈队列七种调度算法，请给出各进程的完成时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。
答：
2 在银行家算法中，若出现下列资源分配情况：
请问：
（1）此状态是否安全？
（2）若进程P2提出请求Request(1,2,2,2)后，系统能否将资源分配给它？
答：（1）安全，因为存在安全序列{P0,P3,P4,P1,P2}（2）系统能分配资源，分析如下。
① Request(1,2,2,2) <= Need2(2,3,5,6);
② Request(1,2,2,2) <= Available2(1,3,5,4)改成
Available2(1,6,2,2)；
③系统先假定可为P2分配资源，并修改Available2，Allocation2和Need2向量，
由此形成的资源变化情况如下图所示：
④再利用安全性算法检查此时系统是否安全。
如下图
由此进行的安全性检查得知，可以找到一个安全序列{P2,P0,P1,P3,P4}。
操作系统进程调度练习及答案
1 假设一个系统中有5个进程，它们的到达时间和服务时间如下表所示，忽略I/O以及其他开销，若分别按先来先服务（FCFS）、非抢占式及抢占式的短进程优先（SPF）、高响应比优先、时间片轮转、多级反馈队列和立即抢占式多级反馈队列七种调度算法，请给出各进程的完成时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。
答：
2 在银行家算法中，若出现下列资源分配情况：
请问：
（1）此状态是否安全？
（2）若进程P2提出请求Request(1,2,2,2)后，系统能否将资源分配给它？
答：（1）安全，因为存在安全序列{P0,P3,P4,P1,P2} （2）系统能分配资源，分析如下。
① Request(1,2,2,2) <= Need2(2,3,5,6);
② Request(1,2,2,2) <= Available2(1,3,5,4)改成
Available2(1,6,2,2)；
③系统先假定可为P2分配资源，并修改Available2，Allocation2和Need2向量，
由此形成的资源变化情况如下图所示：
④再利用安全性算法检查此时系统是否安全。
如下图
由此进行的安全性检查得知，可以找到一个安全序列{P2,P0,P1,P3,P4}。
操作系统---进程调度算法的模拟
void blockQueueUpdate()
///查看阻塞队列中的进程信息
void blockQueueWalk()
⑤模拟动态优先权进程调度函数定义：
///初始化进程PCB数据，返回PCB头指针
PCB * initData()
///模拟CPU执行1个时间片的操作
if(cpuProcess->allTime == 0){ ///若当前执行进程还需CPU时间片为0
cpuProcess->state = Finish; ///设置当前进程状态为终止
free(cpuProcess); ///释放该进程的PCB内存空间
cpuBusy = 0; ///CPU状态设置为空闲
进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
（5）分析程序运行的结果，谈一下自己的认识。
四、实验结果及分析
（1）实验关键代码
①模拟PCB数据结构定义：
///枚举进程的状态：新建、就绪、执行、阻塞、终止
⑪第11个时间片后：
⑫第12个时间片后：
⑬第13个时间片后：
⑭第14个时间片后：
⑮第15个时间片后：
⑯第16个时间片后：
⑰第17个时间片后：
⑱第18个时间片后：
⑲第19个时间片后：
⑳第20个时间片后：
（3）实验结果分析
①调度算法开始之前进程PCB信息为：
②调度算法结束之后进程PCB信息为：
③调度算法分析：
}///end if
///更新就绪队列和阻塞队列中的进程信息
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有5个进程要运行在一个单核处理器上，每个进程有不同的运行时间和优先级。
进程信息如下：进程A：运行时间10ms，优先级4进程B：运行时间8ms，优先级3进程C：运行时间6ms，优先级2进程D：运行时间4ms，优先级1进程E：运行时间2ms，优先级5实验步骤：1.先来先服务（FCFS）调度算法实验：将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
2.最短作业优先（SJF）调度算法实验：将上述进程按照运行时间的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
3.优先级调度算法实验：将上述进程按照优先级的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
4.时间片轮转（RR）调度算法实验：设置一个时间片大小，将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。
实验结果：通过模拟实验，我们可以得到每个进程的运行时间、完成时间和等待时间。
对于FCFS算法，进程的运行顺序是按照先来先服务的原则，因此进程A首先得到处理器资源并完成运行，其它进程依次按照到达顺序得到资源。
因此，对于进程A、B、C、D、E，它们的完成时间分别是10ms、18ms、24ms、28ms和30ms，等待时间分别是0ms、10ms、18ms、24ms和28ms。
对于SJF算法，进程的运行顺序是按照运行时间的大小，即短作业优先。
因此，进程E首先得到处理器资源并完成运行，其它进程依次按照运行时间的大小得到资源。
对于进程E、D、C、B、A，它们的完成时间分别是2ms、6ms、12ms、20ms和30ms，等待时间分别是0ms、2ms、6ms、12ms和20ms。
进程调度算法模拟(链表模拟)
实验一 进程调度算法模拟，1．内容：设计一个简单的进程调度算法，模拟OS 中的进程调度过程；2．要求：① 进程数不少于5个；② 进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3； ③ 用C 语言编程；④ 程序运行时显示进程调度过程。
3．步骤：① 设计PCB 及其数据结构：进程标识数：ID进程优先数：PRIORITY （优先数越大，优先级越高）进程已占用时间片：CPUTIME ，每得到一次调度，值加1；进程还需占用时间片：ALLTIME ，每得到一次调度，该值减1，一旦运行完毕，ALLTIME 为0）进程队列指针：NEXT ，用来将PCB 排成队列进程状态：STATE （一般为就绪，可以不用）② 设计进程就绪队列及数据结构；③ 设计进程调度算法，并画出程序流程图；④ 设计输入数据和输出格式；结构格式：当前正运行的进程：0当前就绪队列：2，1，3，4⑤ 编程上机，验证结果。
4．提示：假设调度前，系统中有5个进程，其初始状态如下：ID 0 1 2 3 4PRIORITY 9 38 30 29 0 可否考虑用数组或链表去实现 CPUTIME 0 0 0 0 0 ALLTIME 3 2 6 3 4 STA TE ready Ready ready ready ready ① 以时间片为单位调度运行；② 每次调度ALLTIME 不为0，且PRIORITY 最大的进程运行一个时间片；③ 上述进程运行后其优先数减3，再修改其CPUTIME 和ALLTIME ，重复②，③ ④ 直到所有进程的ALLTIME 均变为0。
5．书写实验报告① 实验题目；② 程序中所用数据结构及说明；③ 清单程序及描述；④ 执行结果。
#include<iostream.h>#include<stdlib.h>#include<malloc.h>#include<windows.h>#include<stdio.h>#define MINSIZE 5typedef enum STATE{ready,running,stop,}STA TE; //进程状态typedef struct PCB{int pid;int priority;// 进程优先级int cputime;int alltime;STA TE state;struct PCB *prev;struct PCB *next;}PCB; //进程控制模块typedef PCB Node; //结点void init_process(Node *&head) //进程初始化{head= (PCB *)malloc(sizeof(PCB));head->next = head;head->prev = head;}void push(Node *head,Node *pnode) //将进程结点插入到双向循环链表中{if(head == NULL||pnode == NULL)return;Node * p = head->next;while(p!=head && pnode->priority < p->priority){p= p->next;}pnode->next=p->prev->next;pnode->prev=p->prev;p->prev->next=pnode;p->prev = pnode;}void show_process(Node *head) //对进程的模拟显示输出{if(head==NULL)return;Node *p = head->next;cout<<"当前的就绪队列有："<<endl;cout<<"****************************进程调度表**************************"<<endl;while(p != head){cout<<endl;cout<<"进程号为"<<p->pid<<" ";cout<<"优先级为"<<p->priority<<" ";cout<<"剩余ALLTIME为"<<p->alltime<<" ";cout<<"运行时间cputime为"<<p->cputime<<" ";cout<<endl;cout<<endl;p = p->next;}cout<<"****************************************************************"<<e ndl;}Node * pop_front(Node *head) //将优先级高的进程结点调进处理机处理{if(head==NULL||head->next == head)return NULL;Node * p = head->next;p->prev->next = p->next;p->next->prev = p->prev;return p;}PCB * create_process(int id,int priority,int cputime,int alltime,STATE state){PCB *p = (PCB *)malloc(sizeof(PCB));p->pid = id;p->cputime = cputime;p->alltime = alltime;p->priority = priority;p->state = state;p->next = NULL;p->prev = NULL;return p;}void destroy_head(Node *head) //释放空间{if(head==NULL)return;free(head);}void destroy(Node *pnode){if(pnode == NULL)return;Node *p = pnode;p->prev->next=p->next;p->next->prev=p->prev;cout<<"进程"<<p->pid<<"已经销毁！"<<endl;free(p);}void process_running(Node *head) //优先级判断{if(head == NULL||head->next == head)return;Node *p = NULL;while(head->next!=head){p = head->next;p = pop_front(head);p->cputime += 1;p->alltime -= 1;p->priority -= 3;p->state = running;cout<<endl;cout<<"当前正在执行的进程为:"<<p->pid<<endl;if(p->priority<=0){p->priority =0;}cout<<endl;cout<<"进程号为"<<p->pid<<" ";cout<<"优先级为"<<p->priority<<" ";cout<<"剩余ALLTIME为"<<p->alltime<<" ";cout<<"运行时间cputime为"<<p->cputime<<" ";cout<<endl;cout<<endl;cout<<endl;cout<<endl;if(p->alltime<=0){p->state = stop;destroy(p);p = NULL;}if(p!=NULL){p->state = ready;push(head,p);}show_process(head);char c = getchar();}destroy_head(head);}int main(){PCB * head=NULL;init_process(head);PCB *p =NULL;int PRIORITY = 1;int CPUTIME = 0;int ALLTIME = 0;STA TE state = ready;int count = 0;int num = 0;cout<<"请输入当前运行的进程数，至少5个"<<endl;cin>>num;for(int i = 0;i<num;++i){count+=1;cout<<"请输入第"<<count<<"个进程的优先级和总运行时间ALLTIME"<<endl;cin>>PRIORITY>>ALLTIME;p=create_process(count,PRIORITY,CPUTIME,ALLTIME,state);push(head,p);}show_process(head);process_running(head);return 0;}。
实验一 进程调度模拟算法
实验一进程调度模拟算法
进程调度模拟算法是操作系统中的重要概念，它是指操作系统如何安排进程的执行顺序，以达到最优的系统性能。
常见的进程调度算法包括先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。
下面将分别介绍这些算法的原理和特点。
1. 先来先服务（FCFS）
先来先服务是最简单的进程调度算法，它按照进程到达的先后顺序进行调度，即先到达的进程先执行。
这种算法的优点是实现简单，适用于长作业，但是它存在一个致命的缺陷，即无法处理短作业的情况，因为长作业可能会占用大量的CPU 时间，导致短作业等待时间过长。
2. 短作业优先（SJF）
短作业优先是一种非抢占式的调度算法，它按照进程的执行时间长短进行调度，即执行时间短的进程先执行。
这种算法的优点是可以减少平均等待时间，但是它存在一个问题，即可能会导致长作业一直等待，因为短作业总是可以插队执行。
3. 时间片轮转（RR）
时间片轮转是一种抢占式的调度算法，它将CPU时间划分为若干个时间片，每个进程在一个时间片内执行一定的时间，然后被挂起，让其他进程执行，直到所有进程都执行完毕。
这种算法的优点是可以保证所有进程都能得到执行，但是它存在一个问题，即时间片的长度会影响系统性能，如果时间片太短，会增加上下文切换的开销，如果时间片太长，会导致长作业等待时间过长。
实验一介绍了三种常见的进程调度算法，它们各有优缺点，需要根据具体的应用场景选择合适的算法。
第6章进程调度(含答案)
第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-P1-P =1-（80%）4 = 1-0.84=59%增加1M 内存的情况：1）支持用户进程数：（2*1024K-200K ）/200K=9.24 所以9个用户进程。
进程调度算法模拟2
《计算机操作系统原理》课外上机实验报告题目名称进程调度算法模拟院系班级完成时间指导老师本次实验成绩组长联系电话邮件地址组长（姓名、学号）主要任务成员（姓名、学号）主要任务主要原理及参考的资料（包括实验内容及条件）主要原理：1．操作系统原理中的进程的调度是一个经典的课程，其中有很多实用的调度算法。
例如：先来先去服务算法、最短作业优先算法、最短作业优先时间算法、优先级调度算法、时间片轮转调度算法、多级反馈队列调度算法等。
2．C#面向对象程序设计及.NET Framework 3.5平台提供了优质、高效、便捷的Windows窗体应用程序设计平台。
我们使用Visual Studio2010编程软件可以使用窗体应用程序清晰、真实的表现出来。
参考资料：1．《操作系统教程（第四版）》孙钟秀主编费翔林骆斌编著高等教育出版社 2008年4月2．《C#面向对象程序设计》郑宇军编著人民邮电出版社 2009年6月3．《C#入门经典（第四版）》（美）Karli Watson Christian Nagel 等著齐立波翻译清华大学出版社 2008年12月实验内容及条件：1．设计有 n 个进程的并发程序，其中每个进程控制块 PCB 至少包含：进程名（ID），进程优先数（Priority），进程状态标志（State），进程进入 CPU 的时间（In），程序需要运行的时间（Alltime）、队列指针等信息。
2．用随机数的方法动态产生进程 PCB 中的优先级和运行时间。
3. 调度算法（1）静态优先级的立即抢占式调度算法，进一步将静态优先级调度改为动态优先级调度，优先级高低自己设定。
（2）时间片轮转调度算法，进程占用 CPU 的时间片由每个进程的优先数计算获得。
(约定：每个优先数对应 10 分钟，进行完一次调度优先数减 1。
4．要求运行结果能够显示各进程被调度的序列及每个进程获得 CPU 的调度时间、计算周转时间以及 CPU 利用率等信息。
第6章进程调度(含答案)
第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-P1-P =1-（80%）4 = 1-0.84=59%增加1M 内存的情况：1）支持用户进程数：（2*1024K-200K ）/200K=9.24 所以9个用户进程。
进程调度算法模拟
实验一进程调度算法模拟1.实验内容设计一个简单的进程调度算法，模拟OS中的进程调度过程；2.实验要求①进程数不少于5个；②进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3；③用C语言编程；④程序运行时显示进程调度过程。
3.程序中所用数据结构及说明struct pcb { /* 定义进程控制块PCB */char id[10]; // 进程号char state; // 进程状态int priority;// 进程优先级数，数字越大，优先级越高int alltime; // 进程还需占用时间片int cputime; // 进程已占用时间片struct pcb* next; //进程队列指针}*ready=NULL,*p;4.程序清单#include<stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char id[10]; // 进程号char state; // 进程状态int priority;// 进程优先级数，数字越大，优先级越高int alltime; // 进程还需占用时间片int cputime; // 进程已占用时间片struct pcb* next; //进程队列指针}*ready=NULL,*p;typedef struct pcb PCB;void sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->priority)>(ready->priority))) /*优先级最大者,插入队首*/{p->next=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->next;while(second!=NULL){if((p->priority)>(second->priority)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->next=second;first->next=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{first=first->next;second=second->next;}}if(insert==0) first->next=p;}}void input() /* 建立进程控制块函数*/{int i,num;system("cls"); /*清屏*/printf("\n 请输入进程数: ");scanf("%d",&num);for(i=1;i<=num;i++){printf("\n 进程号%d:\n",i);p=getpch(PCB);printf("\n 输入进程名ID:");scanf("%s",p->id);printf("\n 输入进程优先数PRIORITY:");scanf("%d",&p->priority);printf("\n 输入进程运行时间ALLTIME:");scanf("%d",&p->alltime);printf("\n");p->cputime=0;p->state='W';p->next=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0;PCB* pr=ready;while(pr!=NULL){l++;pr=pr->next;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n 进程名\t 状态\t 优先数\t 需要运行时间\t 已经运行时间\n");printf(" %s\t",pr->id);printf(" %c\t",pr->state);printf(" %d\t",pr->priority);printf(" %d\t\t",pr->alltime);printf(" %d\t",pr->cputime);printf("\n");}void check() /* 建立进程查看函数*/{PCB* pr;printf("\n 当前正在运行的进程是:\n"); /*显示当前运行进程*/disp(p);pr=ready;printf("\n 当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL)disp(pr);pr=pr->next;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{printf("\n 进程[%s] 已完成.\n",p->id);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态)*/ {(p->cputime)++;if(p->cputime==p->alltime)destroy(); /* 调用destroy函数*/else{(p->priority)--;p->state='W';sort(); /*调用sort函数*/}}void main() /*主函数*/{int len,h=0; //n为运行次数char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n");printf("-----------------------------------------------------");printf("\n 现在是第%d次运行：\n",h);p=ready;ready=p->next;p->next=NULL;p->state='R';check();running();printf("\n 按任意键继续......\n");printf("\n\n 进程已经完成.\n"); }5.运行结果。
实验06进程调度算法模拟
实验06进程调度算法模拟引言：进程调度算法是操作系统中非常重要的一部分，它决定了进程如何被安排执行的顺序和时间分配。
进程调度算法的设计对系统的性能和响应时间都有很大的影响。
本实验将会模拟几种常用的进程调度算法，并通过比较它们的性能指标来评估其优劣。
实验目标：1.理解进程调度算法的设计原理和特点；2.掌握几种常见的进程调度算法，并能够使用程序模拟它们；3.对比不同的进程调度算法，分析它们的优缺点和适用场景。
实验内容：本实验将模拟三种常见的进程调度算法：先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）调度算法。
1.先来先服务（FCFS）调度算法：FCFS调度算法是最简单的一种调度算法，按照进程到达的顺序进行调度，先到先执行。
当一个进程执行完成后，才能执行下一个进程。
它适用于执行时间较短的进程，但当执行时间较长的进程到达时，会导致平均等待时间增加。
2.短作业优先（SJF）调度算法：SJF调度算法是根据进程执行时间的长短进行调度的。
当一个进程抵达时，如果它的执行时间比当前正在执行的进程短，那么立即执行它，否则将其放到就绪队列的队尾。
这样做的目的是为了减少平均等待时间。
然而，SJF调度算法存在着无法预测执行时间导致的不公平问题。
3.时间片轮转（RR）调度算法：RR调度算法是为了解决长作业等待时间长的问题而设计的。
它将每个进程分配一个时间片，当一个进程的时间片用完后，将其放到就绪队列的末尾，执行下一个进程。
这样可以确保每个进程都有机会执行，并且减少了长作业的等待时间。
然而，时间片过小可能会导致频繁的切换，降低系统的效率。
实验步骤：1.定义进程类，包含进程名、到达时间、执行时间和优先级等属性；2.创建进程队列，并根据到达时间对进程进行排序；3.分别使用FCFS、SJF和RR算法进行模拟调度，计算平均等待时间和平均周转时间；4.比较三种算法的性能指标，并分析它们的优劣和适用场景。
实验结果与分析：通过模拟实验，我们可以得到每种算法的平均等待时间和平均周转时间。
(完整word版)进程调度习题
12.假设一个系统中有5个进程，它们到达的实践依次为0、2、4、6、8，服务时间依次为3、6、4、5、2，忽略I/O以及其他时间开销，若分别按响应比高者优先、时间片轮转（时间片为1）、先来先服务、非抢占短进程优先、抢占短进程优先调度算法调度CPU，请给出进程的调度顺序，计算各进程的平均周转时间和平均带权周转时间。
【解】（1）响应比高者优先调度算法平均周转时间=（3+7+9+14+7）/5 = 40/5 = 8平均带权周转时间=(1+1.17+2.25+2.8+3.5)/5=10.72/5=2.144（2）时间片轮转（时间片为1）调度算法平均带权周转时间=(1+2.67+2.75+2.8+4)/5=13.22/5=2.644进程调度顺序：P1、P2、P3、P4、P5平均周转时间=（3+7+9+12+12）/5 = 41/5 = 8.2平均带权周转时间=(1+1.17+2.25+2.4+6)/5=12.82/5=2.564（4）非抢占短进程优先调度算法平均周转时间=（3+7+11+14+3）/5 = 38/5 = 7.6平均带权周转时间=(1+1.17+2.75+2.8+1.5)/5=9.22/5=1.844（5）抢占短进程优先调度算法平均周转时间=（3+18+9+9+2）/5 = 41/5 = 8.2平均带权周转时间=(1+3+2.25+1.8+1)/5=9.05/5=1.81补充：有5个待运行的进程A、B、C、D、E，各自估计运行时间为9、6、3、5、x，试问哪种运行次序可以使平均响应时间最短？【解】使平均响应时间最短的调度算法是短进程优先。
因进程E的时间待定，所以调度次序与x 的大小有关。
（1）当x<3时的运行次序为：E、C、D、B、A（2）当3<=x<5时的运行次序为：C、E、D、B、A（3）当5<=x<6时的运行次序为：C、D、E、B、A（4）当6<=x<9时的运行次序为：C、D、B、E、A（5）当x>=9时的运行次序为：C、D、B、A 、E一个有两个作业管理进程的批处理系统，作业调度采用最高响应比优先的算法，进程调度采用基于优先数（优先数大者优先）的算法，有以下作业序列。
操作系统进程调度练习及答案
操作系统进程调度练习及答
案(总5页)
本页仅作为文档封面，使用时可以删除
This document is for reference only-rar21year.March
1 假设一个系统中有5个进程，它们的到达时间和服务时间如下表所示，忽略I/O以及其他开销，若分别按先来先服务（FCFS）、非抢占式及抢占式的短进程优先（SPF）、高响应比优先、时间片轮转、多级反馈队列和立即抢占式多级反馈队列七种调度算法，请给出各进程的完成时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。
答：
2 在银行家算法中，若出现下列资源分配情况：
请问：
（1）此状态是否安全
（2）若进程P2提出请求Request(1,2,2,2)后，系统能否将资源分配给它
答：（1）安全，因为存在安全序列{P0,P3,P4,P1,P2}
（2）系统能分配资源，分析如下。
① Request(1,2,2,2) <= Need2(2,3,5,6);
② Request(1,2,2,2) <= Available2(1,3,5,4)改成Available2(1,6,2,2)；
③系统先假定可为P2分配资源，并修改Available2，Allocation2和Need2向量，
由此形成的资源变化情况如下图所示：
④再利用安全性算法检查此时系统是否安全。
如下图
由此进行的安全性检查得知，可以找到一个安全序列
{P2,P0,P1,P3,P4}。
进程调度作业参考答案
1.下表给出作业1、2、3到达时间和运行时间。
采用短作业优先调度算法和先来先服务调度算法，试问平均周转时间各为多少是否还有更好的调度策略存在（时间单位：小时，以十进制进行计算。
解：存在更好的调度算法，如采用剥夺式短作业优先调度算法2.假设有四个作业,它们提交、运行时间如下表所示。
若采用响应比高者优先调度算法，试问平均周转时间和带权周转时间为多少 （时间单位：小时，以十进制进行计算。
）解：第一个作业完成时间为，此时其它作业的响应比计算如下：R2=+/=R3=+/=16R4=+10-9)/=根据响应比高者优先调度原则，应先运行作业3，作业3完成时间为,此时作业2和作业4的响应比计算如下：R2=+根据响应比高者优先调度原则，应先运行作业2，作业2完成时间为,最后运行作业4，作业4完成时间为。
4.在单CPU和两台输入/输出设备(I1,I2)的多道程序设计环境下,同时投入三个作业Job1、 Job2、 Job3运行。
这三个作业对CPU和输入/输出设备的使用顺序和时间如下所示：Job1: I2(30ms);CPU(10ms);I1(30ms);CPU(10ms);I2(20ms|)Job2: I1(20ms);CPU(20ms); I2(40ms|)Job3: CPU(30ms);I1(20ms);CPU(10ms);I1(10ms|)假定CPU 、 I1、I2都能并行工作， Job1优先级最高， Job2次之， Job3优先级最低，优先级高的作业可以抢占优先级低的作业的CPU但不抢占I1和I2。
试求：（1）三个作业投入到完成分别需要的时间。
（2）从投入到完成的CPU利用率。
（3）I/O设备利用率解：（1）(2)cpu利用率：（60+10+10）/110=%(3) i1设备利用率：（20+30+20+10）/110=%i2设备利用率：（30+40+20）/110=%。
进程与作业调度—答案电子版
作业与进程调度练习1．有一个两道的批处理操作系统，作业调度采用最短作业优先的调度算法，进程调度采用基于优先数的抢占式调度算法，有如下的作业序列（其中优先数值越小优先级越高）： 作业 进入时间 估计运行时间 优先数 Job1 10:00 40分钟 5 Job2 10:20 30分钟 3 Job3 10:30 50分钟 4 Job4 10:50 20分钟 6答：基于优先数的抢占式调度算法JOB1JOB2JOB3JOB410:1010:2010:5011:1012:0012:20CPU 上工作时间示意图2．某系统采用不能移动已在内存中作业的可变分区方式管理内存，现有供用户使用的内存空间100K ，系统配有4台磁带机，有一批作业如下： 作业 进入系统时间 估计运行时间 内存需求 磁带机需求 Job1 10:00 25分钟 15K 2台 Job2 10:20 30分钟 60K 1台 Job3 10:30 10分钟 50K 3台 Job4 10:35 20分钟 10K 2台 Job5 10:40 15分钟 30K 2台 该系统采用多道程序设计技术，对磁带机采用静态分配策略，忽略设备工作时间和系统进行调度所花的时间，请分别写出采用“先来先服务调度算法”和“最短作业优先算法”选中作业执行的次序以及作业平均周转时间。
参考答案：先来先服务的调度算法中的资源变化：10:00Tape:2运行：1（2）就绪：0输入#：空10:20Tape:1运行：1（2）就绪：2（1）输入#：空10:25Tape:3运行：2（1）就绪：空输入#：空10:30Tape:3运行：2（1）就绪：空输入#：310:35Tape:1运行：2（1）就绪：4(2)输入#：310:40Tape:1运行：2（1）就绪：4(2)输入#：3,510:55Tape:0运行：4(2)就绪：5(2)输入#：311:15Tape:2运行：5(2)就绪：空输入#：311:30Tape:1运行：3(3)就绪：空输入#：空先来先服务调度算法的资源变化情况示意图说明：红色区域为被占用的CPU资源蓝色区域为空闲的CPU资源JOB1JOB2JOB3JOB410:0010:2510:5511:1511：3011:45CPU 上工作时间示意图JOB5。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
学海无涯
max_priority=0; for(j=0;j<counter;j++) { if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
printf("对进程按短作业优先调度。\n\n"); sjf();
poutput(); break; case 4:
printf("对进程按响应比高优先调度。\n\n"); hrrn();
poutput(); break; } } int fcfs() /*非抢占式先来先服务，该程序段默认进程已经按到达先后顺序排成了队列，如果考虑输 入为乱序，还需要根据 come_time 对进程进行排队，形成一个先来后到的队列。*/ { float time_temp=0; int i; int number_schedul; time_temp=tasks[0].come_time;
5. 实验环境（硬件环境、软件环境）：
（1） 硬件环境：Intel Pentium III 以上 CPU，128MB 以上内存，2GB 以上硬盘。 （2） 软件环境：linux 操作系统 gcc 编译器或 windows 操作系统 vc++集成开发环境。
6. 实验内容
设定一组作业或进程，给定相关参数，对这组进程或作业按调度算法实施调度，输出调度次 序，并计算平均周转时间和带权平均周转时间。使用的调度算法有：
{ if (tasks[j].run_time<tasks[i].run_time) { run_time=tasks[j].run_time; i=j; } j++;
} /*对第一个被调度的进程求相应的参数*/ number_schedul=i; tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time;
if (tasks[j].priority>tasks[i].priority) { max_priority=tasks[j].priority; i=j; }
j++; } /*对第一个被调度的进程求相应的参数*/ number_schedul=i; tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time; tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].r un_time; tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; tasks[number_schedul].order=1; temp_counter=1;
调用输出程序输出结果
先来先服务调度算法
学海无涯
5．优先级调度算法
系统中有未运行的作业
把运行次序填入数组相应位置； 分别计算出该作业进入输入井时 间、开始运行时间、运行结束时 间、周转时间、带权周转时间， 并填入数组相应位置。
调用数据输Leabharlann 程序输出结果优先级调度算法
在数组中找第一个未运行的作业
未找到
找到
学海无涯
实验二 进程管理
2.5 作业（进程）调度算法模拟
1．实验目的与要求
本实验的目的是通过作业或进程调度算法模拟设计，进一步加深对作业或进程调度算法的理 解，通过计算平均周转时间和带权平均周转时间，进一步加深对算法的评价方法的理解。
2. 实验类型：验证型
3. 实验学时：4
4. 实验原理和知识点
（1） 掌握作业或进程调度算法。 （2） 平均周转时间和带权平均周转时间计算。
pinput(); printf("请选择调度算法（0~4）:\n"); printf("1.先来先服务\n"); printf("2.优先级调度\n"); printf(" 3.短作业优先\n");
printf(" 4.响应比高优先\n"); printf(" 0.退出\n"); scanf("%d",&option);
3．数据输出算法
学海无涯
对每个作业执行
输出进程（或作业）号、 进程（或作业）名、 到达时间、 开始运行时间、 运行结束时间、 优先级、 运行次序、 周转时间、 带权周转时间 计算并输出平均周转时间、带权周 转时间 平均
4．先来先服务调度算法描述
系统中有未运行的作业
在未运行的作业中选择一个提 交时间最早的作业 把运行次序填入数组相应位置； 分别计算出该作业进入输入井时 间、开始运行时间、运行结束时 间、周转时间、带权周转时间， 并填入数组相应位置。
学海无涯
for(i=0;i<counter;i++) {
tasks[i].run_begin_time=time_temp; tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time; tasks[i].run_flag=1; time_temp=tasks[i].run_end_time; number_schedul=i; tasks[number_schedul].order=i+1; } return 0; } /*非抢占式优先级调度，默认 tasks[0]是最早到达的进程，进程已按到达先后顺序排成了队列。*/ int ps() { float temp_time=0; int i=0,j; int number_schedul,temp_counter; /*正在被调度执行的进程编号和已经调度完成的进程个数*/ int max_priority; max_priority=tasks[i].priority; j=1; /* 从从到达时间最早且相同的进程中遍历，查找第一个被调度的进程*/ while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))/*寻找到达时间相同优先级最高的 进程。*/ {
int fcfs(); int ps();
/*先来先服务*/ /*优先级调度*/
int sjf();
/*短作业优先*/
int hrrn();
/*响应比高优先*/
int pinput(); /*进程参数输入*/
int poutput(); /*调度结果输出*/
学海无涯
void main() { int option;
/*到达时间*/ /*开始运行时间*/
float run_time;
/*运行时间*/
float run_end_time; /*运行结束时间*/
int priority;
/*优先级*/
int order;
/*运行次序*/
int run_flag;
/*调度标志*/
}tasks[MAX]; int counter; /*实际进程个数*/
选择运行时间最短作业的算法
学海无涯
7．响应比高优先调度算法
系统中有未运行的作业
在未运行的作业中选择一个响应比最 高的作业运行 （响应比相同按先来先服务进行选择）
把运行次序填入数组相应位置； 分别计算出该作业进入输入井时 间、开始运行时间、运行结束时 间、周转时间、带权周转时间， 并填入数组相应位置。
int sjf() /*非抢占式短作业优先，默认 tasks[0]是最早到达的进程，进程已按到达先后顺序排成了队 列。*/ { float temp_time=0;
int i=0,j; int number_schedul,temp_counter; /*正在被调度执行的进程编号和已经调度完成的进程个数*/ float run_time; /*借助该局部变量可以帮助找到执行时间 run_time 最短进程*/ run_time=tasks[i].run_time; j=1; /*从到达时间最早且相同的进程中查找第一个被调度的进程*/ while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
if (tasks[j].priority>max_priority) { max_priority=tasks[j].priority; number_schedul=j; }
}
/*对找到的下一个被调度的进程求相应的参数*/ tasks[number_schedul].run_begin_time=temp_time; tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].r un_time; tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; temp_counter++; tasks[number_schedul].order=temp_counter; } return 0; }
Pmin该作业的优先数 （当前最小的） k该作业的在数组中的下标
有未运行的作业