进程调度算法模拟带答案版.pptx
操作系统-进程调度模拟算法(附源码)
进程调度模拟算法课程名称：计算机操作系统班级：信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）本次试验后对优先数调度算法和时间片轮转调度算法实现的过程，有了很清楚的认识、理解。
操作系统进程调度算法的模拟
操作系统进程调度算法的模拟其次，我们来介绍短作业优先（Shortest Job Next，SJN）算法。
SJN算法按照任务的运行时间来决定运行顺序，即先运行运行时间最短的进程。
该算法能够最大程度地减少平均等待时间，但对于长任务可能导致长时间的等待。
接下来，我们介绍轮转（Round Robin，RR）算法。
RR算法是一种基于时间片的调度算法，将CPU分为若干个时间片，并依次分配给各个进程。
当一个进程的时间片用完后，将其放入队列尾部，继续运行下一个进程。
该算法具有公平性和响应性较高的特点，但对于长时间运行的进程，可能会导致较大的上下文切换开销。
此外，还有最高响应比优先（Highest Response Ratio Next，HRRN）算法。
HRRN算法通过计算等待时间和服务时间的比例来决定运行顺序，即选取响应比最高的进程先执行。
该算法能够尽可能减少平均响应时间，但对于长任务可能存在运行时间过长的问题。
最后，我们介绍最短剩余时间优先（Shortest Remaining Time First，SRTF）算法。
SRTF算法是SJN算法的抢占版本，当有新进程到达时，会比较其剩余运行时间与当前运行进程的时间，如果新进程的剩余时间较短，则立即进行进程切换。
该算法能够最大程度地减少平均等待时间和响应时间，但对于切换开销较大。
针对这几种进程调度算法，我们可以通过编写模拟程序来验证其性能和特点。
首先，我们需要定义进程的数据结构，包括进程ID、到达时间、服务时间等属性。
然后，我们可以编写一个模拟函数来按照不同的算法进行调度，并统计平均等待时间、平均响应时间、吞吐量等指标。
通过对比不同算法在不同场景下的表现，可以评估其优劣。
总结起来，不同的进程调度算法有着各自的优缺点，根据实际需求选择合适的算法能够提高系统的性能和用户体验。
通过模拟和评估这些算法，我们可以更好地理解其原理和适用范围，并为实际系统的设计和优化提供参考。
希望这篇文章能够帮助你更好地理解和应用进程调度算法。
第七讲 进程调度ppt
低级调度
• 进程调度、短程调度。 进程调度、短程调度。 • 主要功能是按照某种原则决定就绪队 列中的哪个进程或内核级线程能获得 处理器, 处理器, 并将处理机出让给它进行工 作。 • 短程调度程序是操作系统最为核心的 部分， 部分，短程调度策略的优劣直接影响 到整个系统的性能。 到整个系统的性能。
进程调度要解决的问题
WHAT：按什么原则分配CPU WHAT：按什么原则分配CPU —进程调度算法 进程调度算法 WHEN：何时分配CPU WHEN：何时分配CPU —进程调度的时机 进程调度的时机 HOW： 如何分配CPU HOW： 如何分配CPU —进程调度过程（进程的切换） 进程调度过程（ 进程调度过程 进程的切换）
平均作业周转时间
• 为了提高系统的性能 ， 要让若干个 为了提高系统的性能， 用户的平均作业周转时间和平均带 权周转时间最小。 权周转时间最小。 平均作业周转时间 T = (Σti) / n
作业带权周转时间和平均作业带权周转时间
• 如果作业 i 的周转时间为 ti ， 所需运行时 如果作业i 的周转时间为t 间为t 则称w 间为tk，则称wi=ti /tk为该作业的带权周 转时间。 转时间。 • ti是等待时间与运行时间之和，故带权周 是等待时间与运行时间之和， 转时间总大于1 转时间总大于1。 平均作业带权周转时间W = (Σwi) / n
28+37+40)/ )/3 T = (28+37+40)/3 = 35
先来先服务算法(3) 先来先服务算法(3)
•若三个作业提交顺序改为作业2、 1、3，平均作业周转时间约为29。 •若三个作业提交顺序改为作业3、 2、1，平均作业周转时间约为18。 FCFS调度算法的平均作业周转时间 与作业提交的顺序有关。
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有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。
操作系统进程调度算法优秀课件
为 CPU 的执行设定一个时间片大小，每个进程 轮询分配时间片，时间片结束后暂停运行加入等 待队列 时间片不能选择太长，否则退化为FCFS
多级反馈队列
不必事先知道进程所需要的执行时间，还可以较 好地满足各种类型进程的需要 多个就绪队列，赋予不同优先级 每个队列采用FCFS，按队列优先级调度
4
开发环境
Contents
1 题目理解 title 2 开发环境 title 3 主要功能 title 4 设计思路 title
1
题目理解
在Linux或Windows环境下编程模拟实现进程调 度，包括：先来先服务，时间片轮转，优先级， 多级反馈队列等进程调度算法。
2
FCFS先来先服务
这是最简单，最基本的算法，就是按照进程到来的时间 顺序，逐个分配 CPU 资源 优点：简单，方便 缺点：效率低，资源利用率低
8
设计思路
• 模块设计： （共同设计部分） M_interface.java——实现了主界面设计和调用三种算法模拟子界面（共用） （个人设计部分） A_interface.java——实现调用子界面 A_process.java——进程类，利用了链表的数据结构 A_fcfs.java——先来先服务算法的实现 A_rr.java——时间片轮转调度算法的实现 A_psa.java——优先级调度算法的实现 A_mfq.java——多级反馈队列调度算法的实现
6
需要运行时间
进程的运行时间以时间片为单位进行计算 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1 来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行 时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未 达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先 数减1（即降低一级），然后把它插入就绪队列等待CPU。
实验一 进程调度模拟算法
实验一进程调度模拟算法
进程调度模拟算法是操作系统中的重要概念，它是指操作系统如何安排进程的执行顺序，以达到最优的系统性能。
常见的进程调度算法包括先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等。
下面将分别介绍这些算法的原理和特点。
1. 先来先服务（FCFS）
先来先服务是最简单的进程调度算法，它按照进程到达的先后顺序进行调度，即先到达的进程先执行。
这种算法的优点是实现简单，适用于长作业，但是它存在一个致命的缺陷，即无法处理短作业的情况，因为长作业可能会占用大量的CPU 时间，导致短作业等待时间过长。
2. 短作业优先（SJF）
短作业优先是一种非抢占式的调度算法，它按照进程的执行时间长短进行调度，即执行时间短的进程先执行。
这种算法的优点是可以减少平均等待时间，但是它存在一个问题，即可能会导致长作业一直等待，因为短作业总是可以插队执行。
3. 时间片轮转（RR）
时间片轮转是一种抢占式的调度算法，它将CPU时间划分为若干个时间片，每个进程在一个时间片内执行一定的时间，然后被挂起，让其他进程执行，直到所有进程都执行完毕。
这种算法的优点是可以保证所有进程都能得到执行，但是它存在一个问题，即时间片的长度会影响系统性能，如果时间片太短，会增加上下文切换的开销，如果时间片太长，会导致长作业等待时间过长。
实验一介绍了三种常见的进程调度算法，它们各有优缺点，需要根据具体的应用场景选择合适的算法。
操作系统进程调度算法模拟
实验一进程调度算法模拟一.实验题目：设计一个简单的进程调度算法，模拟OS中的进程调度过程二．要求：①进程数不少于5个；②进程调度算法任选；可以用动态优先数加时间片轮转法实现进程调度，每运行一个时间片优先数减3；③用C语言编程；④程序运行时显示进程调度过程。
三．程序中所用数据结构及说明:进程控制块结构体：typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片}Block,pcb;就绪进程链表节点：typedef struct node2{pcb data;struct node2 *next;}process;四．清单程序及描述：Procelink.h:typedef struct node1{int ID;//进程标识数int PRIORITY;//进程优先数int CPUTIME;//进程已占用时间片int ALLTIME;//进程还需占用时间片//char STATE;//进程状态//struct node *next;//进程队列指针}Block,pcb;typedef struct node2{pcb data;struct node2 *next;}process;void Initlink(process **PQ){/*如果有内存空间，申请头结点空间并使头指针head指向头结点*/if((*PQ = (process *)malloc(sizeof(process))) == NULL) exit(1);(*PQ)->next = NULL; /*置链尾标记NULL */}int IsEmpty(process *PQ){if(PQ->next == NULL)return 1;else return 0;}void EnInitlink(process *PQ,pcb p){while(PQ->next!=NULL) PQ=PQ->next;process *temp=(process *)malloc(sizeof(Block));temp->data.PRIORITY=p.PRIORITY;temp->data.ID=p.ID;temp->data.CPUTIME=p.CPUTIME;temp->data.ALLTIME=p.ALLTIME;temp->next=PQ->next;PQ->next=temp;}//插入pcb DeInitlink(process *PQ) //选择优先数最小的出列{if(IsEmpty(PQ)){printf("所有进程已运行完!\n");exit(0);//退出}process *temp=(process *)malloc(sizeof(Block));temp = PQ->next;process *te=(process *)malloc(sizeof(Block));process *t=(process *)malloc(sizeof(Block));te= PQ->next;//优先数最小的进程while(temp->next != NULL){if(te->data.PRIORITY<temp->next->data.PRIORITY){te=temp->next;t=temp->next->next;PQ=temp;}temp=temp->next;}PQ->next=PQ->next->next;pcb pp=te->data;// free(temp);// free(t);//free(te);return pp;}//出队列void outid(process *PQ)//输出就绪队列函数{ printf("当前就绪队列为: ");while(!IsEmpty(PQ)){printf("%d ",PQ->next->data.ID);PQ=PQ->next;}printf("\n");}void dispatch(pcb p,process *PQ)//进程运行函数{if((p.ALLTIME)!=0){p.PRIORITY-=3;p.CPUTIME+=1;p.ALLTIME-=1;printf("进程%d运行\n",p.ID);//printf("进程优先数：%d 进程已占用时间片：%d 进程还需占用时间片：%d\n",p.PRIORITY,p.CPUTIME,p.ALLTIME);outid(PQ);//输出就绪队列}if((p.ALLTIME)==0){printf("进程%d 运行完成!\n",p.ID);return;//完成则不加入链表}EnInitlink(PQ,p); return;//运行之后再加入链表}os_1.cpp:#include<stdio.h>#include<stdlib.h>#include"procelink.h"void main(){process * PQ;int n;//n为进程数pcb pro1;Initlink(& PQ);printf("请输入进程个数：");scanf("%d",&n);printf("请输入各个进程的进程标识数ID,进程优先数，进程已占用时间片，进程还需占用时间片\n");for(int i=1;i<=n;i++){printf("第%d进程: ",i);scanf("%d %d %d %d",&pro1.ID,&pro1.PRIORITY,&pro1.CPUTIME,&pro1.ALLTIME);EnInitlink(PQ,pro1);}while(!IsEmpty(PQ)){dispatch(DeInitlink(PQ),PQ);//进程运行函数调用}if(IsEmpty(PQ))printf("所有进程已运行完!\n");free(PQ);//释放内存空间}五．执行结果：六．实验总结：通过这次操作系统中进程调度算法的模拟，使我对操作系统中的进程调度有了更清晰的认识和了解，程序中也有不足之处，该程序是顺序进链，出链时再选择优先数最大的进程。
实验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.比较三种算法的性能指标，并分析它们的优劣和适用场景。
实验结果与分析：通过模拟实验，我们可以得到每种算法的平均等待时间和平均周转时间。
操作系统实验一进程调度模拟算法
操作系统实验一进程调度模拟算法进程调度是操作系统中的一个重要功能，它负责为计算机系统中的各个进程分配CPU时间，使得所有进程都能够得到公平的执行机会。
进程调度算法的选择对于系统的性能和响应时间有着重要影响。
本文将介绍几种常见的进程调度算法，并进行模拟实验，分析它们的优缺点。
FCFS算法是最简单的调度算法之一，在该算法中，按照进程到达的先后顺序分配CPU时间。
FCFS算法的优点是简单易懂，公平性高，但其缺点是无法有效处理短作业和长作业混合的情况。
长作业会导致其他短作业等待时间过长，从而影响系统的响应时间。
2. 最短作业优先调度算法（Shortest Job First，SJF）SJF算法是一种非抢占式的调度算法，它会根据每个进程的执行时间来选择下一个执行的进程。
该算法的优点是可以最小化平均等待时间，但其缺点是无法预测进程的执行时间，如果估计不准确，会导致长作业等待时间过长。
3. 最高响应比优先调度算法（Highest Response Ratio Next，HRRN）HRRN算法是一种动态优先级调度算法，它根据每个进程的等待时间和服务时间的比值来选择最优的进程。
该算法考虑了进程的等待时间和服务时间的关系，能够相对公平地分配CPU时间，并且能够避免长作业的垄断。
4. 时间片轮转调度算法（Round Robin，RR）RR算法是一种抢占式的调度算法，它将所有进程按照到达顺序分配一个时间片，每个进程得到执行的时间是固定的。
当一个进程的时间片用完后，它会被放到就绪队列的末尾，等待下一次调度。
RR算法的优点是实现简单，能够保证所有进程能够得到公平的执行机会，但其缺点是当进程数量较大时，调度开销会增加。
在进程调度的模拟实验中，首先需要定义进程的数据结构，包括进程ID、到达时间、优先级、执行时间等属性。
然后，模拟进程的到达过程，可以使用随机数生成器模拟进程的到达时间和执行时间。
接下来，根据选择的调度算法，模拟进程的执行过程。
操作系统进程调度模拟算法附源码
先来先服务（FCFS）
定义：按照进程到 达的先后顺序进行 调度
优点：实现简单， 适用于CPU繁忙型 进程
缺点：等待时间较 长，可能导致饥饿 现象
适用场景：适用于 CPU密集型进程， 不适用于I/O密集 型进程
最短作业优先（SJF）
定义：按照作业的估计运行时间进行排序，选择最短作业优先执行 优点：响应时间快，作业平均等待时间少 缺点：存在饥饿现象，长作业可能长时间得不到执行 适用场景：适用于作业量较大且作业到达时间间隔较长的情况
Part Five
模拟实验结果及分 析
实验环境及参数设置
处理器：Intel Core i78700K
操作系统：Linux
内存：16GB DDR4 硬盘：256GB SSD
实验结果展示
实验数据：模拟算法在不同情况下的运行结果 数据分析：对实验数据进行分析，得出结论 结果对比：将模拟算法与实际操作系统进行对比，分析差异 结果展示：以图表、表格等形式展示实验结果
优先级调度算法
定义：根据进 程的优先级进 行调度，优先 级高的进程优 先获得处理器
资源
分类：静态优 先级调度算法 和动态优先级
调度算法
静态优先级调 度算法：优先 级在进程创建 时就确定，且 在运行过程中
保持不变
动态优先级调 度算法：优先 级根据进程的 行为和需求动
态调整
轮转法（RR）
定义：轮转法是 一种简单且常用 的进程调度算法， 也称为循环调度
算法。
原理：按照进程 到达的先后顺序， 按照固定的时间 片进行循环调度。
特点：每个进程 分配一个固定时 间片，时间片用 完后自动切换到 下一个进程，如 果时间片未用完， 则一直运行直到
《进程调度》PPT课件
4 Linux中的进程管理
– 4.1 Linux进程概述 • 1．进程实体的组成
• Linux进程由3部分组成：正文段、用户数 据段和系统数据段。
系
进 程
统 数 据
段
正文段 用户数据段
图 Linux进程组成
• 2．进程的状态 • 进程是一个动态的概念，在其运行的整个生
命周期中可根据具体情况不断改变其状态。 Linux进程主要有如下几种状态。
wait_interruptible
申请资源未成功 sleep_on() schedule()
拥有CPU
申请资源未成功 interruptible_sleep_on() schedule()
跟踪系统调用 执行syscall_trace() sys_exit() schedule()
Linux内核功能
进程调度与内存管理之间的关系：这两个子系统互 相依赖。在多道程序环境下，程序要运行必须为之 创建进程，而创建进程的第一件事情，就是将程序 和数据装入内存。
进程间通信与内存管理的关系：进程间通信子系统 要依赖内存管理支持共享内存通信机制，这种机制 允许两个进程除了拥有自己的私有空间，还可以存 取共同的内存区域 。
这种暂停状态被称为阻塞状态。
• 2．进程的状态转换 图1 进程的3种基本状态及其转换
1.4 进程的结构
• 进程结构 PCB
进程控制块
程序段 数据段
动态特征的集中反映 描述要完成的功能 操作对象及工作区
2．进程控制块
• 进程控制块是进程实体的一部分，是操作
系统中最重要的记录型数据结构。PCB中记录 了操作系统所需的，用于描述进程进展情况及 控制进程运行所需的全部信息。
在一个系统中，通常拥有数十个、数百 个乃至数千个PCB。为了对PCB进行有 效地管理，系统应把所有的PCB用适当 的方式组织起来。
进程调度算法模拟演示
进程调度算法模拟演⽰进程调度算法模拟演⽰⼀、设计⽬的进程管理是操作系统中的重要功能，⽤来创建进程、撤消进程、实现进程状态转换，它提供了在可运⾏的进程之间复⽤CPU 的⽅法。
在进程管理中，进程调度是核⼼，因为在采⽤多道程序设计的系统中，往往有若⼲个进程同时处于就绪状态，当就绪进程个数⼤于处理器数⽬时，就必须依照某种策略决定哪些进程优先占⽤处理器。
本实验模拟在单处理器情况下的进程调度，⽬的是加深对进程调度⼯作的理解，掌握不同调度算法的优缺点。
⼆、设计内容设计⼀个按先来先服务，算法时间⽚轮转法，优先数调度算法实现处理器调度的程序。
三、开发环境windows环境，VC6.0平台。
四、分析设计1、实验原理进程是程序在处理机上的执⾏过程。
进程存在的标识是进程控制块（PCB），所谓系统创建⼀个进程，就是由系统为某个程序设置⼀个PCB，⽤于对该进程进⾏控制和管理。
进程任务完成，由系统收回其PCB，该进程便消亡。
每个进程可有三个状态：运⾏状态、就绪状态和完成状态。
因此设计三个链队列，finish为完成队列的头指针，ready为就绪队列的头指针，tail为循环轮转法中的就绪队列的尾指针。
因为每⼀时刻，CPU只能运⾏⼀个进程，所以运⾏队列只有⼀个run指针指向当前运⾏的进程。
考虑到处理的⽅便，将它们设为全局变量。
（1）优先调度算法优先调度算法要为每⼀个进程设⼀个优先数，它总是把处理机给就绪队列中具有最⾼优先权的进程。
常⽤的算法有静态优先权法和动态优先权法。
本程序采⽤了动态优先权法，使进程的优先权随时间⽽改变。
初始的进程优先数取决于进程运⾏所需的时间，时间⼤，则优先数低，所以采取了将进程优先数定位⼀个较⼤的数（50）减去进程运⾏所需要的时间，随着进程的运⾏优先数进⾏调整，每次运⾏时都是从就绪队列中选取优先数最⼤的进程运⾏，所以将就绪队列按照优先数的⼤⼩从⾼到低排序，这样，每次取对头进程即可。
（2）时间⽚轮转算法时间⽚轮转算法是将所有进程按先来先服务的规则排成⼀个队列，把CPU分配给就绪队列的对⾸进程，并规定它执⾏⼀定时间，称此时间间隔为时间⽚。
实验一 进程调度算法模拟
操作系统实验报告（一）班级：计1001姓名：车琛学号：201007010113实验一 进程调度算法模拟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 4 PRIORITY 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,STA TE 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;}屏幕截图优先级最高的进程2运行完实验心得这次实验开始觉得无从下手，于是在网上搜了些类似代码借鉴，懂得了基本算法思想。
方案进程调度算法模拟
⽅案进程调度算法模拟设计1 进程调度算法的模拟⼀、设计⽬的1、通过编程实现进程调度算法的模拟，了解进程调度的过程，理解进程调度各⽅法的特点。
⼆、设计要求1．⽤语⾔来实现对n个进程采⽤不同调度算法的进程调度。
2．每个⽤来标识进程的进程控制块PCB⽤结构来描述，包括以下字段：<1）进程优先数ID，其中0为闲逛进程，⽤户进程的标识数为1，2，3…。
<2）进程优先级Priority，闲逛进程<3）进程占⽤的CPU时间CPUtime，进程每运⾏⼀次，累计值等于4。
<4）进程总共需要运⾏时间Alltime，利⽤随机函数产⽣。
<5）进程状态，0：就绪态；1：运⾏态；2：阻塞态。
<6）队列指针next，⽤来将多个进程控制块PCB链接为队列。
3．优先数改变的原则<1）进程在就绪队列中每呆⼀个时间⽚，优先数增加1。
<2）进程每运⾏⼀个时间⽚，优先数减3。
4．在调度前，系统中拥有的进程数PCB_number由键盘输⼊，经初始化后，所有的进程控制块PCB链接成就绪队列。
三、设计说明FCFS算法，按照进程先后顺序输出SJS算法，按照ALLTIME从⼩到⼤依次输出优先级算法，按照优先从⼤到⼩输出，进程执⾏依次P-3，就绪队列中的进程1 FCFS模块1.1功能对于先到达的进程优先分配CPU，按照先来先服务的原则依次执⾏各进程。
1.2 数据结构typedef struct PCB{int ID。
//进程优先数,⽤于标⽰不同的进程int Priority。
//进程优先级int CPUTime。
//进程占⽤的CPU时间CPUtime，进程每运⾏⼀次，累计值等于4int ALLTime。
//进程总共需要运⾏时间Alltimeint Status。
//⽤于表⽰进程状态，0：就绪态；1：运⾏态；2：阻塞态}PCB。
1.3算法void FCFS(>{Node *p=head->next。
进程调度算法示例
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
A B C D E
来源：W.Stallings《操作系统-精髓与设计原理》，制作：本末终始 2011-9-30北理珠
进程
A
到达时间
0
服务时间
3
B C D E
2 4 6 8
6 4 5 2
进程调度轮转算法（时间片=4）
A B B C C D C D D B B D B E D B B E E B E E D D E D D D
反馈(q=2i)(多级队列调度算法)(教材)
0 级 1 级 2 级 3 级 0 级 1 级 2 级 3 级 0 级 1 级 2 级 3 级 E D C B 0 级 1 级 2 级 3 级 E D B 0 级 1 级 2 级 3 级 E D C B 0 级 1 级 2 级 3 级 E C B 0 级 1 级 2 级 3 级 E D C B 0 级 1 级 2 级 3 级 D C B 0 级 1 级 2 级 3 级 D C 0 级 1 级 2 级 3 级 D C 0 级 1 级 2 级 3 级 D C 0 级 1 级 2 级 3 级 D 0 级 1 级 2 级 3 级
响应比计算：（响应比=等待时间/运行时间）
9时刻 C：（9-4）/4=5/4 D：（9-6）/5=4/5 E：（9-8）/2=1/2 最大者：C 其它时刻 只有一个进程可选 平均周转时间=(3+7+9+14+7)/5=8
来源：W.Stallings《操作系统-精髓与设计原理》，制作：本末终始 2011-9-30北理珠
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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;
学海无涯
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;
{ 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;
学海无涯
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))/*寻找到达时间相同优先级最高的 进程。*/ { if (tasks[j].priority>tasks[i].priority)
/*循环查找下一个被调度的进程，直到所有的 tasks[j].run_flag ==1*/ while (temp_counter<counter) {
学海无涯
max_priority=0; for(j=0;j<counter;j++) { if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)) if (tasks[j].priority>max_priority)
#include<stdio.h>
//using namespace std;
#define MAX 10
struct task_struct
{ char name[10]; int number; float come_time; float run_begin_time;
/*进程名称*/ /*进程编号*/ /*到达时间*/ /*开始运行时间*/
/*先来先服务*/
int ps();
/*优先级调度*/
int sjf();
/*短作业优先*/
int hrrn();
/*响应比高优先*/
int pinput(); /*进程参数输入*/
int poutput(); /*调度结果输出*/
学海无涯
void main() { int option;
pinput(); printf("请选择调度算法（0~4）:\n"); printf("1.先来先服务\n"); printf("2.优先级调度\n"); printf(" 3.短作业优先\n");
4．先来先服务调度算法描述
系统中有未运行的作业
在未运行的作业中选择一个提 交时间最早的作业 把运行次序填入数组相应位置； 分别计算出该作业进入输入井时 间、开始运行时间、运行结束时 间、周转时间、带权周转时间， 并填入数组相应位置。
调用输出程序输出结果
先来先服务调度算法
学海无 涯
5．优先级调度算法
时间、优先数、进入输入井时间、开始运行时间、尚需运行时间、运行结束时间、周转时
间、带权周转时间、运行次序等。
2
利用定义的结构体，定义一个结构体数组，用来记录系统中的作业或进程。
6.2 算法描述：
1．主控程序算法描述
学海无 涯
进程（作业）参数输入 重复执行
选择调度算法
0
1
2
3
4
调用 先来 先服 务调 度程 序
系统中有未运行的作业
在未运行的作业中选择一个响应比最 高的作业运行 （响应比相同按先来先服务进行选择）
把运行次序填入数组相应位置； 分别计算出该作业进入输入井时 间、开始运行时间、运行结束时 间、周转时间、带权周转时间， 并填入数组相应位置。
调用数据输出程序输出结果
响应比高优先调度算法
6.3 C 语言程序实现
/*循环查找下一个被调度的进程，直到所有的 tasks[j].run_flag ==1*/ while (temp_counter<counter) { /*找到在上一个进程执行期间（到“目前”为止）到达时间最晚的一个进程*/
学海无涯
实验二 进程管理
2.5 作业（进程）调度算法模拟
1. 实验目的与要求
本实验的目的是通过作业或进程调度算法模拟设计，进一步加深对作业或进程调度算法的 理 解，通过计算平均周转时间和带权平均周转时间，进一步加深对算法的评价方法的理解。
2. 实验类型：验证型 3. 实验学时：4
4. 实验原理和知识点
float run_time;
/*运行时间*/
float run_end_time;
/*运行结束时间*/
int priority; int order;
/*优先级*/ /*运行次序*/
int run_flag;
/*调度标志*/
}tasks[MAX];
int counter; /*实际进程个数*/
int fcfs();
有未运行的作业
作业的优先数 与 Pnim 比较 大
Pmin该作业 的优先数 k该作业的 在数组中的下标
6．短作业（或进程）优先调度算法
未找到
找到
有未运行的作业
作业的运行时间
与 Rnim 比较
长
短
Rmin该作业 的运行时间 k该作业的 在数组中的下标
选择运行时间最短作业的算法
学海无 涯
7．响应比高优先调度算法
break; case 2:
printf("对进程按优先级调度。\n\n"); ps();
poutput(); break; case 3:
printf("对进程按短作业优先调度。\n\n"); sjf();
poutput(); break; case 4: