进程调度算法模拟带答案版.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、到达时间、服务时间等属性。

然后，我们可以编写一个模拟函数来按照不同的算法进行调度，并统计平均等待时间、平均响应时间、吞吐量等指标。

通过对比不同算法在不同场景下的表现，可以评估其优劣。

总结起来，不同的进程调度算法有着各自的优缺点，根据实际需求选择合适的算法能够提高系统的性能和用户体验。

通过模拟和评估这些算法，我们可以更好地理解其原理和适用范围，并为实际系统的设计和优化提供参考。

希望这篇文章能够帮助你更好地理解和应用进程调度算法。

操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。

为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。

实验设想：我们设想有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。

实验一进程调度模拟算法
进程调度模拟算法是操作系统中的重要概念，它是指操作系统如何安排进程的执行顺序，以达到最优的系统性能。

常见的进程调度算法包括先来先服务（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进程调度算法模拟引言：进程调度算法是操作系统中非常重要的一部分，它决定了进程如何被安排执行的顺序和时间分配。

进程调度算法的设计对系统的性能和响应时间都有很大的影响。

本实验将会模拟几种常用的进程调度算法，并通过比较它们的性能指标来评估其优劣。

实验目标：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、到达时间、优先级、执行时间等属性。

然后，模拟进程的到达过程，可以使用随机数生成器模拟进程的到达时间和执行时间。

接下来，根据选择的调度算法，模拟进程的执行过程。

进程调度算法模拟演⽰进程调度算法模拟演⽰⼀、设计⽬的进程管理是操作系统中的重要功能，⽤来创建进程、撤消进程、实现进程状态转换，它提供了在可运⾏的进程之间复⽤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。