下载文档原格式
实验一进程调度实验一、目的要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、例题：设计一个有 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}。
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有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章 进程调度练习题一、 单项选择题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．操作系统原理中的进程的调度是一个经典的课程，其中有很多实用的调度算法。
例如：先来先去服务算法、最短作业优先算法、最短作业优先时间算法、优先级调度算法、时间片轮转调度算法、多级反馈队列调度算法等。
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章 进程调度练习题一、 单项选择题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进程调度算法模拟引言：进程调度算法是操作系统中非常重要的一部分，它决定了进程如何被安排执行的顺序和时间分配。
进程调度算法的设计对系统的性能和响应时间都有很大的影响。
本实验将会模拟几种常用的进程调度算法，并通过比较它们的性能指标来评估其优劣。
实验目标：1.理解进程调度算法的设计原理和特点；2.掌握几种常见的进程调度算法，并能够使用程序模拟它们；3.对比不同的进程调度算法，分析它们的优缺点和适用场景。
实验内容：本实验将模拟三种常见的进程调度算法：先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）调度算法。
1.先来先服务（FCFS）调度算法：FCFS调度算法是最简单的一种调度算法，按照进程到达的顺序进行调度，先到先执行。
当一个进程执行完成后，才能执行下一个进程。
它适用于执行时间较短的进程，但当执行时间较长的进程到达时，会导致平均等待时间增加。
2.短作业优先（SJF）调度算法：SJF调度算法是根据进程执行时间的长短进行调度的。
当一个进程抵达时，如果它的执行时间比当前正在执行的进程短，那么立即执行它，否则将其放到就绪队列的队尾。
这样做的目的是为了减少平均等待时间。
然而，SJF调度算法存在着无法预测执行时间导致的不公平问题。
3.时间片轮转（RR）调度算法：RR调度算法是为了解决长作业等待时间长的问题而设计的。
它将每个进程分配一个时间片，当一个进程的时间片用完后，将其放到就绪队列的末尾，执行下一个进程。
这样可以确保每个进程都有机会执行，并且减少了长作业的等待时间。
然而，时间片过小可能会导致频繁的切换，降低系统的效率。
实验步骤：1.定义进程类，包含进程名、到达时间、执行时间和优先级等属性；2.创建进程队列，并根据到达时间对进程进行排序；3.分别使用FCFS、SJF和RR算法进行模拟调度，计算平均等待时间和平均周转时间；4.比较三种算法的性能指标，并分析它们的优劣和适用场景。
实验结果与分析：通过模拟实验，我们可以得到每种算法的平均等待时间和平均周转时间。
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}。
