模拟进程调度的程序

进程调度算法模拟以及代码实现原创实验一进程调度算法模拟，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#include#include#include#include#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;< p="">cout<<"****************************进程调度表**************************"<<endl;< p="">while(p != head){cout<<endl;< p="">cout<<"进程号为"<pid<<" ";cout<<"优先级为"<priority<<" ";cout<<"剩余ALLTIME为"<alltime<<" ";cout<<"运行时间cputime为"<cputime<<" ";cout<<endl;< p="">cout<<endl;< p="">p = p->next;}cout<<"****************************************************** **********"<<="" p="">}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<<"进程"<pid<<"已经销毁！"<<endl;< p=""> 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;< p="">cout<<"当前正在执行的进程为:"<pid<<endl;< p=""> if(p->priority<=0){p->priority =0;}cout<<endl;< p="">cout<<"进程号为"<pid<<" ";cout<<"优先级为"<priority<<" ";cout<<"剩余ALLTIME为"<alltime<<" ";cout<<"运行时间cputime为"<cputime<<" ";cout<<endl;< p="">cout<<endl;< p="">cout<<endl;< p="">cout<<endl;< p="">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;< p=""> cin>>num;for(int i = 0;i<num;++i)< p="">{count+=1;cout<<"请输入第"<<count<<"个进程的优先级和总运行时间alltime"<<endl;< p="">cin>>PRIORITY>>ALLTIME;p=create_process(count,PRIORITY,CPUTIME,ALLTIME,state);push(head,p);}show_process(head);process_running(head);return 0;}</count<<"个进程的优先级和总运行时间alltime"<<endl;<> </num;++i)<></endl;<></endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<> </endl;<>。

进程调度模拟程序设计进程调度模拟程序设计进程调度是操作系统中的重要组成部分。

一个好的进程调度算法可以提高操作系统的性能和响应速度。

因此，设计一个可以模拟进程调度的程序十分有必要。

本文主要介绍进程调度模拟程序的设计思路和实现方法。

一、模拟进程首先，我们需要模拟进程。

一个进程通常包括进程ID，进程状态、优先级、时间片等信息。

我们可以使用结构体来存储这些信息。

例如：```Cstruct process {int pid; // 进程IDint status; // 进程状态, 1表示就绪，0表示不就绪int priority; // 进程优先级，越小表示优先级越高int runtime; // 进程已经运行的时间片int timeslice; // 进程需要的时间片数};```二、设计进程调度算法接着，我们需要设计进程调度算法。

常见的调度算法包括FIFO、SJF、优先级调度、时间片轮转调度等等。

在本文中，我们以时间片轮转调度算法为例。

时间片轮转调度是将CPU的使用权轮流分配给就绪队列中的每一个进程的一种调度算法。

我们需要设置一个时间片长度，每个进程最多运行一个时间片，如果时间片耗尽就切换到下一个进程。

一个简单的时间片轮转调度算法可以采用双向链表来维护就绪队列。

使用队列的好处是可以快速地添加进程、删除进程，同时可以保持进程的顺序。

例如：```Cstruct node {struct process p; // 进程信息struct node *next; // 后继节点struct node *prev; // 前驱节点};struct queue {struct node *head; // 队首节点struct node *tail; // 队尾节点int size; // 队列大小};三、实现进程调度有了进程和调度算法的数据结构，我们就可以实现进程调度程序了。

我们可以先生成一些随机的进程，然后将它们添加到就绪队列中。

操作系统进程调度模拟程序实验报告实验目的：了解操作系统进程调度的基本原理和方法，通过编写模拟程序来验证调度算法的正确性。

实验内容：1. 实现进程调度模拟程序，包括进程的创建、调度、挂起、恢复和销毁等基本操作。

2. 实现三种常用的调度算法：先来先服务（FCFS）、最短作业优先（SJF）和时间片轮转（RR）。

3. 对比不同调度算法的性能，包括平均等待时间、平均周转时间和平均响应时间等指标。

实验步骤：1. 首先定义进程类Process，包括进程的ID、到达时间、执行时间和优先级等属性。

2. 实现创建进程的函数create_process，通过用户输入的方式创建多个进程，并保存到一个进程队列中。

3. 根据选择的调度算法，实现调度函数schedule，按照对应的算法对进程进行调度，并记录每个进程的执行时间和等待时间等信息。

4. 对于FCFS算法，按照进程的到达时间进行排序，然后按顺序执行。

5. 对于SJF算法，按照进程的执行时间进行排序，然后按顺序执行。

6. 对于RR算法，设定一个时间片大小，每个进程执行一个时间片后，将其放回队列末尾，然后继续执行下一个进程，直到所有进程都执行完毕。

7. 在各个调度算法中计算平均等待时间、平均周转时间和平均响应时间等指标，并输出结果。

实验结果：通过对不同进程和不同调度算法的模拟，可以得到如下结果：1. FCFS调度算法的平均等待时间较长，不适用于执行时间较长的任务。

2. SJF调度算法的平均等待时间和平均周转时间较短，适用于执行时间较短的任务。

3. RR调度算法能够平均分配CPU时间，适用于执行时间较长的任务。

实验总结：通过本次实验，我们进一步加深了对操作系统进程调度的理解和认识。

通过编写模拟程序，我们能够清楚地了解不同调度算法的工作原理和对应的性能表现。

在实际应用中，根据任务的特点和需求选择合适的调度算法，能够提高系统的性能和效率。

进程调度模拟程序设计编写一个进程调度程序，允许多个进程共享进程调度程序。

进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。

每个进程有一个进程控制块（ PCB）表示。

进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。

进程的到达时间为输入进程的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。

就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。

重复以上过程，直到所要进程都完成为止模拟进程调度算法用C++的代码描述：#include "iostream.h"//define pcbtypedef struct pcb{char name[10]; //进程名char state; //状态w(就绪)r(运行)f(结束)int id; //id号int super; //优先级int ntime; //需运行的时间int rtime; //已运行的时间struct pcb *next;}*pcb1;pcb1 s,w;//define two publiced linknode ,one is s(ready queue),one is w(blocked queue)//initialize two queuesvoid init(pcb1 &r){r=NULL;//both queues is the kind of head index}//print the information of the ready queuevoid print(){pcb1 p;cout<<"您现在查看的是就绪队列的信息:" ;cout<<"进程号 "<<"进程名 "<<"优先级 "<<"状态"<<"已运行时间 "<<"需运行时间"<<endl;for(p=s;p!=NULL;p=p->next){cout<<p->id<<" "<<p->name<<" "<<p->super<<" "<<p->state<<""<<p->rtime<<" "<<p->ntime<<endl; }}//print the information of the blocked queuevoid print1(){pcb1 p;cout<<"您现在查看的是阻塞队列的信息";cout<<"进程号 "<<"进程名 "<<"优先级 "<<"状态 "<<"已运行时间 "<<"需运行时间"<<endl;for(p=w;p!=NULL;p=p->next){cout<<p->id<<" "<<p->name<<" "<<p->super<<" "<<p->state<<""<<p->rtime<<" "<<p->ntime<<endl; }}//check the queue if emptyint empty(pcb1 &r){if(r==NULL)return 0;elsereturn 1;}//check the first process of the ready queue if finshedint check(){pcb1 p;p=s;if(p->rtime==p->ntime){p->state='F';//if one process finshed then change ti's statecout<<"进程"<<p->id<<" 已经结束"<<endl;return 0;}elsereturn 1;}//sort process according to the super of the process and insert to the ready(blocked) queuevoid sort(pcb1 &r,pcb1 p){pcb1 p1,p2;int in=0;if(r==NULL)//the queue is empty{r=p;}else{if(p->super>=r->super)//the super of the process which wait insert to the queue is highter than the super of the first process of the queue {p->next=r;r=p;}else{p1=r;p2=r->next;if(p2==NULL)//only one process in the queue{r->next=p;}else{while(in==0&&p2!=NULL)//insert to the middle of the queueif(p->super>=p2->super){p->next=p2;p1->next=p;in=1;}else{p1=p1->next;p2=p2->next;}}}if(in==0)//link to the last of ready queuep1->next=p;}}}//block one process and insert to block queuevoid block(){if(empty(s)){if(s->next==NULL){sort(w,s);s=s->next;}else{pcb1 p1;p1=s;s=s->next;p1->next=NULL;sort(w,p1);}}else{cout<<"现在就绪队列已经为空，再没有进程需要阻塞"<<endl; }}//wake one process of block queue and insert to ready queue void wake(){if(empty(w)){pcb1 p1;p1=w;w=w->next;p1->next=NULL;sort(s,p1);}else{cout<<"阻塞队列已经为空，没有进程再需要唤醒"<<endl; }}//runingvoid runing(){if(empty(s)){pcb1 p;p=s;if(check())//check the first process of the queue if finished {//nos=s->next;p->rtime++;p->super--;p->next=NULL;sort(s,p);}else{//yess=s->next;}}else{cout<<"就绪队列已经为空"<<endl; }}//creat processvoid input(){pcb1 p2;p2=new pcb;cout<<"请输入进程号、进程名、进程优先级、需要运行时间";cin>>p2->id>>p2->name>>p2->super>>p2->ntime;p2->rtime=0;p2->state='W';p2->rtime=0;p2->next=NULL;sort(s,p2);}//main functionvoid main(){char ch;init(s);init(w);cout<<"*****************************进程调度模拟程序开始*******************************"<<endl;cout<<"----w/唤醒进程-----r/运行进程-----z/阻塞进程----q/退出程序--"<<endl;cout<<"--------c/创建进程---------s /查看就绪进程---------l/查看阻塞队列----"<<endl;while(ch!='q'){cout<<"请输入一个字符"<<endl;cin>>ch;switch(ch){case 'c':input(); break;case 'r':runing(); break;case 's':print(); break;case 'w':wake(); break;case 'l':print1(); break;case 'z':block(); break;} }。

河北联合大学20XX-20XX学年第二学期操作系统课程上机实验报告班级学号姓名成绩指导教师卢朝辉信息工程学院计算机系实验1：进程调度程序模拟实验目的：编写程序来模拟计算机的四种调度方式：（1）先来先服务调度算法（2）短作业（进程）优先调度算法（3）响应比高者调度算法（4）时间片轮转法程序设计：我为该程序见了四个类Job类：public class Job{int jobId; //作业号int createTime; //作业创建时间int needTime; //作业需求时间int remainTime; //作业剩余时间int startTime; //作业开始时间int endTime; //作业结束时间boolean state; //作业状态int calledTimes;double priority;//作业优先级}jobList类：jobList类第二个类是jobList类该类用于随机的给new出来的Job类赋值。

来生成作业类表。

并传给常量类。

其中num用于记录每个作业的作业号，temp_createTime用于记录每个作业的创建时间。

constant类：public class constant{public static final boolean S_CPU=false;public static final int FCFS=1;//先来先服务public static final int SJF=2;//短作业优先public static final int PFS=3; //高响应比public static final int TS=4; //时间片轮转public static final int timeslice=100; //时间片public static ArrayList al=new ArrayList();//作业生成存放列表}该类主要用于记录程序中用用到的一些常量。

实验三、进程调度模拟程序实验一、实验目的用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

二、实验内容和要求设计一个有 N个进程并发执行的进程调度模拟程序。

用Ｃ＋＋模拟基于时间片的轮转算法、静态优先算法、动态优先算法、多级反馈队列调度算法。

三、实验方法、步骤及结果测试1.原理分析及流程图(1). 每个进程有一个进程控制块（PCB）表示。

进程控制块包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

(2). 进程的优先数及需要的运行时间可以事先人为地指定，进程的运行时间以时间片为单位进行计算。

(3). 每个进程的状态可以是就绪 r（ready）、运行R（Running）、或完成F（Finished）三种状态之一。

(4). 就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

(5). 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待调度。

(6). 每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB，以便进行检查。

(7). 重复以上过程，直到所要进程都完成为止。

2.主要程序段及其解释：动态优先调度：#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 24struct jcb{char name[10];int reqtime;int runtime;int startime;int fintime;int prio;char status;};typedef struct jcb JCB;void input(JCB job[],int *pnum){int num;int i;printf("process 数：");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个process:\n",i+1);printf("输入proc名：");scanf("%s",job[i].name);printf("Priority:");scanf("%d",&job[i].prio);printf("要求服务时间:");scanf("%d",&job[i].reqtime);job[i].status='r';job[i].runtime=0;}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;if (n==0){printf("the queue is null!!\n");return;}printf("\tname\tprio\trqtime\truntime\tstatus");for(i=0;i<n;i++){printf("\nN %d",i+1);printf("\t&s",jcbp[i].name);printf("\t&d",jcbp[i].prio);printf("\t&d",jcbp[i].reqtime);printf("\t&d",jcbp[i].runtime);printf("\t&c",jcbp[i].status);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++)for(i=0;i<n-j;i++)if(btjcb[i].prio<btjcb[i+1].prio){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}main(){JCB jobarrived[MAX],jobfinished[MAX];int numarr, numfin;int systime=0;int i,j,n;JCB jcbrunning;input(jobarrived,&numarr);numfin=0;systime=0;btsort (jobarrived,numarr);printf("经按priority排序后,read queue是\n");jcbprintf(jobarrived,numarr);do{btsort(jobarrived,numarr);printf("\n\n\t\t现在系统时间%d:\n\n",systime);printf("ready queue 有\n");jcbprintf(jobarrived,numarr);jcbrunning=jobarrived[0];numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jcbrunning.status='R';jcbrunning.startime=systime;printf("\n\n\t\t处于运行态的作业名%s\n",);systime++;jcbrunning.runtime++;if (jcbrunning.runtime==jcbrunning.reqtime){jobfinished[numfin]=jcbrunning;jobfinished[numfin].status='F';numfin++;}else{jcbrunning.prio--;jcbrunning.status='r';jobarrived[numarr]=jcbrunning;numarr++;}printf("\n\n\t\t系统时间：%d已经完成的有\n\n",systime);jcbprintf(jobfinished,numfin);getchar();getchar();}while((numarr!=0));printf("\nCompleted!! ByeBye!!");getchar();getchar();}2、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1); printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t运行时间");for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].reqtime); }}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d\n",job[i].name,job[i].reqtime,job[i].ru ntime);}}void main(){JCB jobarrived[MAX];int numarr,i;JCB jcbrunning;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后，就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");while(numarr>0){jcbrunning=jobarrived[0];jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");if(jcbrunning.reqtime>0){for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jobarrived[numarr-1]=jcbrunning;}else{numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int firsttime;int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序数目:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);printf("优先级:");scanf("%d",&jcb[i].firsttime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1);printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].firsttime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t优先级\t运行时间"); for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].firsttime); printf(" %d",jcbp[i].reqtime);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称优先级运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d %d\n",job[i].name,job[i].firstti me,job[i].reqtime,job[i].runtime);}}void main(){JCBjobarrived1[MAX],jobarrived2[MAX],jobarrived3[MAX],jobarrived[MAX]; int numarr1,numarr2,numarr3,numarr,i;JCB jcbrunning;numarr2=0;numarr1=0;numarr3=0;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后，就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}for(i=0;i<numarr;i++){jobarrived3[i]=jobarrived[i];numarr3++;}printf("\n.............就绪队列3是..........\n");jcbprintf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");jcbprintf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");jcbprintf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();while(numarr3>0){jcbrunning=jobarrived3[0];if(jcbrunning.firsttime==3){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1; jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");}jobarrived3[0]=jcbrunning;}if(jobarrived3[0].reqtime>0){jobarrived2[numarr2]=jobarrived3[0];numarr2++;}numarr3--;for(i=0;i<numarr3;i++){jobarrived3[i]=jobarrived3[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr2>0){jcbrunning=jobarrived2[0];if(jcbrunning.firsttime==2){if(jcbrunning.reqtime>2){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-2;jcbrunning.runtime=jcbrunning.runtime+2;printf("\n正在执行的进程名称是%s\n",);}else{jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime;jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime;printf("\n正在执行的进程名称是%s\n",); }jobarrived2[0]=jcbrunning;}if(jobarrived2[0].reqtime>0){jobarrived1[numarr1]=jobarrived2[0];numarr1++;}numarr2--;for(i=0;i<numarr2;i++){jobarrived2[i]=jobarrived2[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr1>0){jcbrunning=jobarrived1[0];if(jcbrunning.firsttime==1){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime; jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime; printf("\n正在执行的进程名称是%s\n",); }}numarr1--;for(i=0;i<numarr1;i++){jobarrived1[i]=jobarrived1[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3.运行结果及分析四、 实验总结这次的实验是我们这门课第一次以个人为单位来完成的实验，然后这次实验用了三个星期去完成，虽然每次上机课老师都会先讲，可是我还是不太懂，到自己做的时候又不会，都是照样画葫芦。

#include<windows.h>#include<dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5 //进程数#define P_TIME 50//时间片长度#define MIN -9999 //最小优先级enum state{ready, //就绪execute, //执行block, //阻塞finish //完成};struct pcb{ //进程控制块结构char name[4]; //进程名int priority; //优先级int cputime; //占用CPU时间int needtime; //还需要执行的时间int count;int round;state process; //进程状态pcb * next;};pcb * get_process()//获取进程信息{pcb *q;pcb *t;pcb *p;//进程链表头指针int i=0;cout<<"input "<<P_NUM<<" names and times"<<endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime;q->cputime = 0;q->priority = P_TIME - q->needtime;//计算优先级 q->round = 0;q->count = 0;q->process = ready;q->next = NULL;if (i==0) //第一个pcb{p = q;t = q;}else{t->next = q;t = q;}i++;} //whilereturn p;}void display(pcb *p){cout<<"NAME"<<" "<<"CPUTIME"<<" "<<"NEEDTIME" <<" "<<"PRIORITY"<<" "<<"STATE"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->priority;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case block:cout<<"block"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;}}int process_finish(pcb *q){//判断进程是否均已执行完毕int bl=1;while(bl&&q){bl = bl&&(q->needtime==0);q = q->next;}return bl;}void cpuexe(pcb *q){pcb* t=q;int tp= MIN;while(q){ //寻找优先级最大的进程if (q->process!=finish){q->process=ready;if(q->needtime==0){q->process=finish;}}if(tp<q->priority&&q->process!=finish){tp=q->priority;t=q;}q=q->next;}if(t->needtime!=0){ //执行进程tt->priority-=3;t->needtime--;t->process=execute;t->cputime++;}}void priority_cal()//优先级调度{pcb * p;system("cls");//清屏clrscr();p = get_process(); //获取进程链表system("cls");int cpu=0;system("cls"); //clrscr();while(!process_finish(p)){cpu++;cout<<"cputime:"<<cpu<<endl;cpuexe(p);display(p);Sleep(2000);system("cls");}cout<<"All processes have finished,press any key to exit"<<endl; getch();}void display_menu()//显示菜单{cout<<"CHOOSE THE ALGORITHM:"<<endl;cout<<"1 PRIORITY"<<endl;//优先级调度cout<<"2 ROUNDROBIN"<<endl;//时间片轮转cout<<"3 EXIT"<<endl;//推出}void cpu_round(pcb *q){q->cputime+=2;q->needtime-=2;if(q->needtime<0) {q->needtime=0;}q->count++;q->round++;q->process=execute;}pcb * get_next(pcb * k,pcb * head){//获取下一个没执行完的进程pcb * t;t=k;do{t=t->next;}while (t && t->process==finish);if(t==NULL){t=head;while (t->next!=k && t->process==finish){t=t->next;}}return t;}void set_state(pcb *p){//设置进程状态while(p){if (p->needtime==0){p->process=finish;}if (p->process==execute){p->process=ready;}p=p->next;}}void display_round(pcb *p){cout<<"NAME"<<" "<<"CPUTIME"<<" "<<"NEEDTIME"<<" "<<"COUNT"<<" "<<"ROUND"<<" "<<"STATE"<<endl;while(p){cout<<p->name<<" "<<p->cputime<<" "<<p->needtime<<" "<<p->count<<" "<<p->round<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;}}void round_cal(){pcb * p;pcb * r;system("cls");p=get_process();int cpu=0;system("cls");r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);cout<<"cpu "<<cpu<<endl;display_round(p);set_state(p);Sleep(5000);system("cls");}cout<<"All processes have finished,press any key to exit"<<endl;getch();}void main(){display_menu();//显示菜单int k;cin>>k;switch(k){case 1:priority_cal(); //调用优先级调度函数break;case 2:round_cal(); //调用轮转调度函数break;case 3:break; //推出default:cout<<"Input error!";}}。

进程调度算法模拟程序设计引言进程调度算法是操作系统中的重要组成部分，它决定了进程在系统中的执行顺序和分配时间片的策略。

为了更好地理解和研究不同的进程调度算法，我们可以设计一个模拟程序来模拟进程的调度过程。

本文将介绍进程调度算法的基本概念和常见的调度算法，并详细讨论如何设计一个进程调度算法模拟程序。

什么是进程调度算法进程调度算法是操作系统中的一种策略，用于决定在多个进程同时请求执行时，系统按照什么样的顺序来选择并分配CPU资源。

进程调度算法的目标是尽可能地提高系统的吞吐量、响应时间和公平性。

常见的进程调度算法先来先服务（FCFS）先来先服务是最简单的进程调度算法，它按照进程到达的先后顺序进行调度。

当一个进程到达系统后，它会被放入就绪队列中，然后按照先后顺序执行。

这种算法的优点是简单易懂，但是存在”饥饿”问题，即长作业会占用CPU资源，导致其他短作业等待时间过长。

短作业优先（SJF）短作业优先算法是根据进程的执行时间来进行调度的。

当一个进程到达系统后，系统会根据其执行时间将其放入适当的位置，执行时间短的进程优先执行。

这种算法可以最大限度地减少平均等待时间，但是对于长作业来说可能会饥饿。

时间片轮转（RR）时间片轮转算法是一种分时调度算法，它将CPU的执行时间划分为多个时间片，每个进程在一个时间片内执行一定的时间，然后切换到下一个进程。

这种算法可以保证所有进程都有机会执行，并且对于响应时间要求较高的任务比较合适。

多级反馈队列（MFQ）多级反馈队列算法是一种综合了FCFS和RR的调度算法。

系统将进程根据优先级划分为多个队列，每个队列都有不同的时间片大小。

当一个进程到达系统后，它被放入第一个队列中，如果在时间片内没有执行完，则被移到下一个队列中。

这种算法可以根据进程的优先级和执行时间动态调整调度策略，提高系统的响应性能。

进程调度算法模拟程序设计程序结构为了设计一个进程调度算法模拟程序，我们需要考虑以下几个方面的内容：1.进程的数据结构：我们可以使用一个进程控制块（PCB）来表示一个进程，PCB包含了进程的状态、优先级、执行时间等信息。

进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 CPU 资源给各个进程，以提高系统的性能和效率。

本次实验的目的是通过编写和模拟进程调度程序，深入理解不同的进程调度算法的原理和特点，并比较它们在不同情况下的性能表现。

二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。

操作系统为 Windows 10。

三、实验原理1、先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 资源。

2、短作业优先（SJF）调度算法短作业优先调度算法优先调度执行时间短的进程。

3、时间片轮转（RR）调度算法时间片轮转调度算法将 CPU 时间划分为固定大小的时间片，每个进程轮流获得一个时间片的 CPU 资源。

四、实验设计1、进程类的设计创建一个进程类，包含进程 ID、到达时间、服务时间、剩余服务时间等属性，以及用于更新剩余服务时间和判断进程是否完成的方法。

2、调度算法实现分别实现先来先服务、短作业优先和时间片轮转三种调度算法。

3、模拟流程（1）初始化进程列表。

（2）按照选定的调度算法进行进程调度。

（3）计算每个进程的等待时间、周转时间等性能指标。

五、实验步骤1、定义进程类｀｀｀pythonclass Process:def ＿_init__(self, pid, arrival_time, service_time)：selfpid ＝ pidselfarrival_time ＝ arrival_timeselfservice_time ＝ service_timeselfremaining_service_time ＝ service_time｀｀｀2、先来先服务调度算法实现｀｀｀pythondef fcfs_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0for process in process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂先来先服务调度算法的平均等待时间：＂，average_waiting_time)print(＂先来先服务调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀3、短作业优先调度算法实现｀｀｀pythondef sjf_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0sorted_process_list ＝ sorted(process_list, key=lambda x: xservice_time) for process in sorted_process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂短作业优先调度算法的平均等待时间：＂，average_waiting_time)print(＂短作业优先调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀4、时间片轮转调度算法实现｀｀｀pythondef rr_scheduling(process_list, time_slice)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0ready_queue ＝while len(process_list) ＞ 0 or len(ready_queue) ＞ 0:for process in process_list:if processarrival_time ＜＝ current_time:ready_queueappend(process)process_listremove(process)if len(ready_queue) ＝＝ 0:current_time ＋＝ 1continueprocess ＝ ready_queuepop(0)if processremaining_service_time ＜＝ time_slice: waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processremaining_service_time turnaround_time ＝ current_time processarrival_time total_turnaround_time ＋＝ turnaround_time processremaining_service_time ＝ 0else:waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ time_sliceprocessremaining_service_time ＝ time_sliceready_queueappend(process)average_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均等待时间：＂， average_waiting_time)print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均周转时间：＂， average_turnaround_time)｀｀｀5、主函数｀｀｀pythonif ＿_name__ ＝＝＂＿_main__"：process_list ＝Process(1, 0, 5)，Process(2, 1, 3)，Process(3, 2, 8)，Process(4, 3, 6)print(＂先来先服务调度算法：＂）fcfs_scheduling(process_list)print(＂短作业优先调度算法：＂）sjf_scheduling(process_list)time_slice ＝ 2print(＂时间片轮转调度算法（时间片大小为"，time_slice, ＂）：＂）rr_scheduling(process_list, time_slice)｀｀｀六、实验结果与分析1、先来先服务调度算法平均等待时间为 575，平均周转时间为 1275。

进程调度算法模拟程序设计一、背景介绍进程调度算法是操作系统中的一个重要概念，它决定了操作系统如何分配CPU时间片给不同的进程。

不同的调度算法有不同的优缺点，需要根据具体情况进行选择。

为了更好地理解和掌握进程调度算法，我们可以设计一个模拟程序来模拟不同的调度算法。

二、程序设计思路1. 定义进程结构体首先需要定义一个进程结构体，包含进程ID、到达时间、服务时间、开始时间、完成时间等信息。

这些信息是模拟程序中需要用到的基本信息。

2. 选择调度算法接下来需要选择要模拟的调度算法，常见的有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。

不同的算法对应着不同的实现方法和数据结构。

3. 实现调度算法对于每种调度算法，都需要实现相应的函数来进行模拟。

比如对于FCFS算法，可以按照到达时间从小到大排序，然后依次执行每个进程；对于SJF算法，则需要按照服务时间从小到大排序，在每个时刻选择服务时间最短的进程执行；对于RR算法，则需要使用队列来保存就绪队列中的所有进程，并按照时间片轮转的方式依次执行。

4. 输出结果最后需要输出每个进程的开始时间、完成时间、周转时间、带权周转时间等信息，以便进行比较和分析。

三、程序设计实现1. 定义进程结构体```c++struct Process {int pid; // 进程IDint arriveTime; // 到达时间int serviceTime; // 服务时间int startTime; // 开始时间int finishTime; // 完成时间};```2. 选择调度算法这里我们选择实现FCFS算法。

FCFS算法的实现比较简单，只需要按照到达时间从小到大排序，然后依次执行每个进程即可。

3. 实现调度算法```c++void fcfs(vector<Process>& processes) {sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {return a.arriveTime < b.arriveTime;});int currentTime = 0;for (int i = 0; i < processes.size(); i++) {if (currentTime < processes[i].arriveTime) {currentTime = processes[i].arriveTime;}processes[i].startTime = currentTime;processes[i].finishTime = currentTime +processes[i].serviceTime;currentTime = processes[i].finishTime;}}```4. 输出结果```c++void printResult(const vector<Process>& processes) {double totalTurnaroundTime = 0, totalWeightedTurnaroundTime = 0;cout << "进程ID\t到达时间\t服务时间\t开始时间\t完成时间\t 周转时间\t带权周转时间" << endl;for (const auto& p : processes) {int turnaroundTime = p.finishTime - p.arriveTime;double weightedTurnaroundTime =(double)turnaroundTime / p.serviceTime;totalTurnaroundTime += turnaroundTime;totalWeightedTurnaroundTime += weightedTurnaroundTime;printf("%d\t%d\t%d\t%d\t%d\t%d\t%.2f\n", p.pid,p.arriveTime, p.serviceTime, p.startTime,p.finishTime, turnaroundTime, weightedTurnaroundTime);}int n = processes.size();printf("平均周转时间：%.2f\n", (double)totalTurnaroundTime / n);printf("平均带权周转时间：%.2f\n", totalWeightedTurnaroundTime / n);}```四、总结通过以上程序设计实现，我们可以更好地理解和掌握进程调度算法。

进程调度模拟程序设计一、实验目的按优先数调度算法或时间片轮转法模拟处理器调度,从而进一步理解处理器调度的原理。

二、实验内容1.设计思路（1）数据结构定义（a)对于不同的调度算法，定义不同的PCB结构体typedef struct PCB_type1 {char name［10］; //进程名char state；//进程状态R—-就绪状态E——结束状态int need_time; //运行需要的CPU时间(需运行的时间片个数）int priority;｝PCB_P; //按优先数调度算法的PCB结构体typedef struct PCB_type2 ｛char name［10]；//进程名int state; //进程状态R-—就绪状态E——结束状态int need_time; //运行需要的CPU时间（需运行的时间片个数）int used_time; //}PCB_T；//按时间片轮转算法的PCB结构体(b）用全局变量choice来指明当前应用的调度算法int choice；(c)为了模拟调度,可以利用STL定义队列deque<PCB_P> q1;queue〈PCB_T〉q2；(2）程序主要模块一共有三个自定义函数,分别是：start_state（) 提示用户选择调度算法，初始化进程信息。

dispatch(）模拟调度(a)对于优先数调度算法，每次调度前对队列里的进程按优先数从大到小排序,然后调度选中队首的进程，将其出队列，并将进程优先数和需要运行时间减1。

如果此进程的需要运行时间不为0，则继续将此进程入队；如果此进程的需要运行时间为0了,则将其状态置为结束状态。

重复上述过程直至队列为空.(b)对于时间片轮转算法，调度选中队首的进程，将其出队列,并将进程已用时间加1。

如果此进程要求运行时间已运行时间，则尚未执行结束，继续将此进程入队；如果此进程的要求运行时间=已运行时间，则已经执行结束，将其状态置为结束状态。

进程调度模拟程序一、引言进程调度是操作系统中的重要组成部分，它负责决定哪个进程能够获得CPU的使用权，以及何时、多久获得。

进程调度算法的设计直接影响到系统的性能和效率。

为了评估和比较不同调度算法的性能，我们需要进行进程调度模拟程序的开发。

二、背景在操作系统中，进程调度是为了合理、高效地利用CPU资源，提高系统的吞吐量和响应时间。

进程调度算法的选择和实现需要考虑多个因素，如进程的优先级、进程的等待时间、进程的执行时间等。

为了更好地理解和评估不同的调度算法，我们需要开发一个进程调度模拟程序。

三、目的本文档的目的是详细描述进程调度模拟程序的标准格式，包括程序的输入、输出、功能和实现细节。

通过本文档，读者将了解到如何使用该模拟程序进行不同进程调度算法的模拟，并根据模拟结果评估不同算法的性能。

四、程序输入1. 进程信息：模拟程序需要输入一组进程信息，包括进程ID、到达时间、执行时间和优先级等。

可以通过读取文件或手动输入的方式提供进程信息。

2. 调度算法选择：模拟程序需要用户选择要使用的调度算法，如先来先服务（FCFS）、最短作业优先（SJF）、优先级调度等。

3. 其他参数设置：模拟程序可能需要用户设置其他参数，如时间片大小（对于时间片轮转调度算法）、优先级范围等。

五、程序输出1. 进程调度顺序：模拟程序将输出进程按照调度算法执行的顺序，包括进程ID和执行时间等。

2. 平均等待时间：模拟程序将输出平均等待时间，用于评估调度算法的性能。

3. 其他评价指标：根据具体的调度算法，模拟程序可能还输出其他评价指标，如响应时间、周转时间等。

六、程序功能1. 进程调度模拟：模拟程序根据输入的进程信息和调度算法，模拟执行进程调度过程，并输出调度结果。

2. 性能评估：模拟程序根据调度结果，计算出各种评价指标，用于评估不同调度算法的性能。

七、实现细节1. 数据结构：模拟程序可以使用适当的数据结构来表示进程信息和调度队列，如数组、链表、优先队列等。

操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序，以加深对进程调度算法的理解。

二、实验内容1. 实现进程相关的数据结构：进程PCB（Process Control Block）。

2.实现进程的创建、撤销以及调度等操作函数。

3. 实现常见的进程调度算法：先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（RR）、优先级调度（Priority）。

4.编写测试程序，验证实现的进程调度算法在不同场景下的表现。

三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构，用于存储和管理进程相关的信息，包括进程状态（就绪、运行、阻塞）、优先级、执行时间等。

2.进程的创建、撤销及调度函数的实现（1）进程创建函数：实现进程的创建，包括为其分配空间、初始化进程PCB等。

可以根据实际需求，设定进程的优先级、执行时间等属性。

（2）进程撤销函数：实现进程的撤销，包括释放其占用的资源、回收其使用的空间等。

（3）进程调度函数：根据不同的调度算法，实现进程的调度。

可以通过设置时间片大小、优先级设定等方式，实现不同调度算法的效果。

3.进程调度算法的设计与实现（1）先来先服务（FCFS）调度算法：按照进程到达的先后顺序，依次进行调度。

（2）最短作业优先（SJF）调度算法：根据进程的执行时间，选择执行时间最短的进程进行调度。

（3）轮转调度（RR）算法：按照时间片的大小进行调度，每个进程在一个时间片内执行，超过时间片后，暂停并进入等待队列，让其他进程执行。

（4）优先级调度（Priority）算法：根据进程的优先级，选择优先级最高的进程进行调度。

4.测试程序编写测试程序，模拟不同的进程到达顺序、执行时间和优先级等场景，验证不同调度算法的表现。

四、实验结果与分析通过测试程序的运行结果，观察不同调度算法的特点和效果。

可以得出以下结论：1.FCFS算法适用于进程到达时间差异较大的场景，保证了先到先服务。

模拟进程调度程序一实验目的进程及进程管理是操作系统最重要的内容之一。

本实验要求学生选用某种进程调度算法用“C”语言编制模拟进程调度的程序，并在机器上运行通过。

通过本实验，使学生对进程调度的算法、数据结构及其实现程序有一个较为深入具体的了解。

二实验题第一题设计一个按时间片轮转算法调度的模拟程序。

1，设系统中有若干个（3—5）进程，每个进程由进程控制块（PCB）来标识。

进程控制块的内容有：进程名、链接指针、到达时间、运行时间、完成时间和进程状态等。

2，进程个数，每个进程的进程名、到达时间、运行时间由设计者确定，并从键盘输入：进程名为字符或字符串，到达时间和运行时间均为整数型；进程状态：为简单起见，假定只有2种状态，即“就绪”和“完成”。

“就绪”用R表示，“完成”用C表示。

进程的初始状态为“R”，运行完成后为“C”；完成时间：根据进程的实际完成时间进行登记；链接指针：用于将各个进程按到达时间的先后次序排序，到达时间相同的次序可随意。

3，调度是在每个进程都到达后的下一时刻开始。

调度时，总是选择当前排在队列最前面且“运行时间”不为0的进程运行。

4，一个进程被调度运行一次，只需且必须打印一行字符，例如：“第*个进程运行一次”。

进程运行一次后，其运行时间减1，并将其PCB插入PCB队列的末尾；当其运行时间等于0时，将其状态置为“C”；并登记其完成时间。

一个状态为“C”的进程，此后不再被调度到运行。

5，运行结果：根据每个进程的到达时间和完成时间算出并输出其周转时间和带权周转时间，算出并输出所有进程的平均周转时间和平均带权周转时间。

进程0 进程2 进程4进程1进程3第二题设计一个按优先级算法调度的模拟程序。

1，设系统中有若干个（3—5）进程，每个进程由进程控制块（PCB）来标识。

进程控制块的内容有：进程名、链接指针、到达时间、运行时间、完成时间、进程优先数和进程状态等。

进程优先数为整数型，优先数小优先级高。

2，进程个数，每个进程的进程名、到达时间、运行时间和优先数由设计者确定，并从键盘输入：进程名为字符或字符串，到达时间、运行时间和优先数均为整数型；进程状态：为简单起见，假定只有2种状态，即“就绪”和“完成”。