实验三 模拟进程调度
进程调度实验报告
进程调度实验报告
实验名称实验三进程调度
⼀.实验⽬的
了解进程的调度机制，掌握短作业优先算法、时间⽚轮转算法（RR）和优先数算法，并理解响应时间和周转时间的意义。
⼆.实验内容
模拟短作业优先算法、时间⽚轮转算法（RR）和优先数算法的执⾏情况，并动态画出其进程执⾏的 Gantt 图，计算以上算法的每个进程的响应时间和周转时间。
三.实验步骤和结果
1、需要模拟执⾏的进程序列如下：
进程名到达时间运⾏时间优先数
P1 0 7 5
P2 1 1 1
P3 1 3 4
P4 2 5 3
P5 4 4 2
假设：优先数越⼩优先级越⾼；所有进程都是纯 CPU 型进程。
请把上表的数据按照你⾃⼰设计的格式存为⼀个⽂本⽂件 JOB1.TXT。
2、编写⼀个模拟程序，可以读⼊⽂本⽂件 JOB1.TXT 中描述的进程序列，然后模拟短作业优先算法、时间⽚轮转算法（RR）和优先数算法的执⾏情况，并动态画出其进程执⾏的 Gantt 图，计算以上算法的每个进程的响应时间和周转时间。
3、读⼊⽂本⽂件 JOB1.TXT 中描述的进程序列，按照短作业优先算法执⾏程序。
4、按照时间⽚轮转算法执⾏程序时间⽚⼤⼩分布为 1、2 和 3。
5、按照优先数算法执⾏程序。
程序执⾏结果见下图：
第1页，共2页
教务处制
四.实验总结
通过这次试验，我们更加深刻地理解了有关于进程调度的内容，响应时间就是进程刚开始被执⾏的时间，等待时间就是进程在就绪队列中等待的时间，周转时间就是进程被执⾏完毕的时间（包括等待进⼊内存的时间，在就绪队列中的等待时间，执⾏时间，I/O时间）。
模拟进程调度实验报告
模拟进程调度实验报告模拟进程调度实验报告引言：进程调度是操作系统中的一个重要功能，它决定了各个进程在处理器上的执行顺序。
合理的进程调度算法能够提高系统的性能和效率。
为了深入了解进程调度算法的工作原理和效果，我们进行了一系列的模拟实验。
实验目的：1. 了解不同进程调度算法的工作原理；2. 分析不同算法对系统性能的影响；3. 探索如何选择合适的进程调度算法。
实验过程：1. 实验环境的搭建我们使用了一台配置较高的计算机作为实验环境，操作系统选择了Linux。
为了模拟多个进程同时运行的情况，我们编写了一段简单的多进程程序，并通过设置不同的优先级和时间片来模拟不同的进程调度算法。
2. FCFS（先来先服务）调度算法FCFS是最简单的进程调度算法，它按照进程到达的顺序进行调度。
我们通过设置不同的进程到达时间，观察FCFS算法的运行情况。
实验结果显示，FCFS算法对于长时间运行的进程效果较好，但是对于短时间进程会出现饥饿现象。
3. SJF（短作业优先）调度算法SJF算法是根据进程的执行时间来进行调度的，执行时间短的进程优先执行。
我们通过设置不同的进程执行时间，观察SJF算法的运行情况。
实验结果显示，SJF算法能够有效地减少平均等待时间和周转时间，但是对于长时间进程会出现饥饿现象。
4. RR（时间片轮转）调度算法RR算法是按照时间片的方式进行调度的，每个进程被分配一个固定的时间片，当时间片用完后，进程被挂起，等待下一次调度。
我们通过设置不同的时间片长度，观察RR算法的运行情况。
实验结果显示，RR算法能够公平地分配CPU 时间，并且能够较好地处理长时间和短时间进程。
实验结果与讨论：通过对不同进程调度算法的模拟实验，我们得出了以下结论：1. FCFS算法适用于长时间运行的进程，但对于短时间进程容易出现饥饿现象。
2. SJF算法能够有效地减少平均等待时间和周转时间，但对于长时间进程也容易出现饥饿现象。
3. RR算法能够公平地分配CPU时间，但对于长时间进程可能会产生较大的上下文切换开销。
实验三 进程调度(实验报告格式)
实验三：进程调度一、实验目的（1）理解进程控制块和进程组织方式；（2）掌握时间片轮转调度算法实现处理机调度。
二、实验环境微型计算机，Ubuntu Linux10.04 ，gedit，gcc三、实验内容1建立合理的PCB数据结构，建立含有8个进程结点的就绪队列，每个进程的要求运行时间随机产生，要求每个进程的要求运行时间不大于15。
2 设置时间片大小（3~6），使用时间片轮转调度算法实现处理机调度。
四、实验结果五、源代码#include<stdio.h>#include<time.h>#include<malloc.h>#define T 8#define NUM 10typedef struct PCB{int name;int runtime;int runedtime;int killtime;struct PCB *next;}PCB;PCB *creat_jiuxu(PCB *top){PCB *temp;int i;srand((int)time(0));for(i=0;i<NUM;i++){temp=(PCB *)malloc(sizeof(PCB));temp->name=i;temp->runtime=rand()%15;temp->runedtime=0;temp->next=NULL;temp->killtime=0;if(i==0) top=temp;else{temp->next=top;top=temp;}}return top;}void run(PCB *top){PCB *tail=top;if(tail->next!=NULL)tail=tail->next;PCB *rq=NULL;while(top!=NULL){rq=top;if(rq->runtime<=rq->runedtime+T){printf("process_name:%d,runtime:%d,killtime:%d\n",rq->name,rq->runtime,rq->killtime);/*if(rq!=NULL) free(rq);*/top=top->next;}else{top=top->next;rq->runedtime+=T;rq->killtime++;tail->next=rq;tail=rq;rq->next=NULL;}}return;}int main(){PCB *top=NULL;top=creat_jiuxu(top);run(top);return 0;}。
模拟进程调度实验报告
模拟进程调度实验报告摘要本实验主要采用C语言编写程序，模拟简单的进程调度框架，通过调度算法模拟CPU对于不同进程的调度过程，进一步深化对进程调度算法的理解和应用。
在实验过程中，我们采用了先来先服务（FCFS）、时间片轮转（RR）和优先级调度算法（PSA）三种调度算法进行模拟，并对不同算法的表现进行性能比较和分析。
实验结果表明，PSA算法和FCFS算法的平均等待时间和平均周转时间要比RR算法更小。
RR算法通过时间片的切换，能够较好地解决短进程优先的问题，但对于长进程来说仍然存在较大的等待时间。
在进行进程调度算法的选择时，需根据具体需求和系统特性综合考虑，选择合适的算法以达到最佳性能。
关键词：进程调度、先来先服务、时间片轮转、优先级调度算法、等待时间、周转时间Abstract一、引言进程调度是操作系统的核心概念之一，是操作系统对计算机硬件资源的有效管理机制。
操作系统需要根据一定的策略对进程进行调度，分配CPU时间片、内存等资源，使多个进程在同时执行的情况下，能高效地共享计算机硬件资源。
进程调度算法的优化和改进对操作系统的性能和运行效率至关重要。
本实验主要针对常用的三种进程调度算法，即先来先服务（FCFS）、时间片轮转（RR）和优先级调度算法（PSA），通过程序模拟这些算法的调度过程，进一步深入理解和应用进程调度算法，对进程调度算法进行性能比较和分析。
二、实验设计1.先来先服务算法（FCFS）我们通过先来先服务算法（FCFS）进行模拟。
FCFS算法即按照进程到达时间的先后顺序进行调度，当前一个进程执行完成后，才调度下一个进程，并按照到达的先后顺序不断地运行进程，直到所有进程执行完成。
在程序中，我们首先对进程进行排序，按照到达的先后顺序排列，模拟进程的到达过程。
然后，我们采用循环语句和判断语句模拟CPU对进程的调度过程，记录每个进程的等待时间和周转时间，并计算出平均等待时间（AWT）和平均周转时间（ATT）。
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
操作系统实验·模拟进程调度资料
实验二 程序模拟“进程调度”一、实验要求1． 设计进程调度算法，进程数不定2． 包含几种调度算法，并加以实现3． 输出进程的调度过程——进程的状态、链表等。
4． 编写出源程序二、参考例1．题目——优先权法、轮转法简化假设1） 进程为计算型的（无I/O ）2） 进程状态：ready 、running 、finish3） 进程需要的CPU 时间以时间片为单位确定2．算法描述1） 优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。
2） 轮转法3） F IFO 调度三、实验部分流程图 开始 读入文件进程流文件 优先权法？ 轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时间 按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？结束 N YY FIFO注意：1．产生的各种随机数的取值范围加以限制，如所需的CPU 时间限制在1~20之间。
2．进程数n 不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法四、实验过程：（1）输入：进程流文件（1.txt ），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO 算法，优先数调度算法，时间片轮转调度算法实验代码如下：#include<stdio.h> 产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时间片数？NY YY 结束 N#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time;}pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].status<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0; pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j;int total;//输出FIFO算法执行流cout<<endl<<"**"<<endl;cout<<"FIFO算法执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){pcbs[j].wait_time+=pcbs[j].time;}}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;//由学生完成}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){ p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){ total+=pcbs[i].wait_time; }cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;//由学生完成}//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){ number++; j=i; }}if(number==1){ queue[total]=j; total++; pcbs[j].finished=1; }if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){ total--; }cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}//由学生完成}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl; }//主函数int main(){int flag;version();initial();flag=readData();if(flag==1){ FIFO();init();privilege();init();timer();}return 0;}运行结果如下：。
实验三模拟进程调度算法
实验三模拟进程调度算法先进先出算法算法总是把处理机分配给最先进入就绪队列的进程,一个进程一旦分得处理机,便一直执行下去,直到该进程完成或阻塞时,才释放处理机。
最高优先权(FPF)优先调度算法该算法总是把处理机分配给就绪队列中具有最高优先权的进程。
常用以下两种方法来确定进程的优先权:轮转法前几种算法主要用于批处理系统中,不能作为分时系统中的主调度算法,在分时系统中,都采用时间片轮转法。
简单轮转法:系统将所有就绪进程按FIFO规则排队,按一定的时间间隔把处理机分配给队列中的进程。
这样,就绪队列中所有进程均可获得一个时间片的处理机而运行。
多级队列方法:将系统中所有进程分成若干类,每类为一级。
多级反馈队列多级反馈队列方式是在系统中设置多个就绪队列,并赋予各队列以不同的优先权。
实验内容①本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
②为了便于处理,程序中的某进程运行时间以时间片为单位计算。
各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。
③在优先数算法中,优先数可以先取值为98,进程每执行一次,优先数减3, CPU时间片数加1,进程还需要的时间片数减1。
在轮转算法中,采用固定时间片(即:每执行一次进程,该进程的执行时间片数为已执行了2个单位),这时, CPU时间片数加2,进程还需要的时间片数减2,并排列到就绪队列的尾上。
④对于遇到优先数一致的情况,采用FIFO策略解决。
实验的示例程序如下:#include<stdio.h>#include <dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5#define P_TIME 50#define clrscr()enum state{ready,execute,block,finish};/* 定义进程控制块PCB */ struct pcb{char name[4];int priority;int cputime;int needtime;int count;int round;state process;pcb * next;};pcb * get_process(); pcb * get_process(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<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->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}} //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=0;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){t->priority-=3;t->needtime--;t->process=execute;t->cputime++;}}//计算优先权void priority_cal(){pcb * p;clrscr();p=get_process();int cpu=0;clrscr();while(!process_finish(p)){cpu++;cout<<"cputime:"<<cpu<<endl;cpuexe(p);display(p);sleep(2);clrscr();}printf("All processes have finished,press any key to exit"); getch();}void display_menu(){cout<<"CHOOSE THE ALGORITHM:"<<endl;cout<<"1 PRIORITY"<<endl;cout<<"2 ROUNDROBIN"<<endl;cout<<"3 EXIT"<<endl;}pcb * get_process_round(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<endl; while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb)); cin>>q->name;cin>>q->needtime;q->cputime=0;q->round=0;q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;} //whilereturn p;}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"<<" "<<"STA TE"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->count;cout<<" ";cout<<p->round;cout<<" ";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;clrscr();p=get_process_round();int cpu=0;clrscr();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(5);clrscr();}}void main(){display_menu();int k;scanf("%d",&k);switch(k){case 1:priority_cal();break; case 2:round_cal();break; case 3:break;display_menu();scanf("%d",&k);}}。
【精品】进程调度算法模拟实验报告
【精品】进程调度算法模拟实验报告一、实验目的本实验通过模拟进程的调度算法，使学生掌握多种进程调度算法的实现过程及其优缺点。
二、实验内容本实验实现了三种进程调度算法：先来先服务（First Come First Served，FCFS）、最短作业优先（Shortest Job First，SJF）、时间片轮转（Round Robin，RR）。
（一）FCFS算法FCFS算法是一种非抢占式的进程调度算法，按照进程到达的先后顺序进行执行，即先到达的进程先被执行，后到达的进程后被执行。
当一个进程在执行过程中发生等待时，其他新到达的进程会继续执行。
等待时间长的进程会长时间等待，造成了响应时间长的问题。
SJF算法是一种动态优先级的进程调度算法，按照进程预计运行时间的大小来决定其优先级，预计运行时间短的进程具有高优先级。
当一个新进程到达时，如果其预计运行时间比当前正在运行的所有进程都短，那么这个新进程就可以立即执行。
该算法在保证短作业优先的同时，可能会导致长作业饥饿的问题。
（三）RR算法RR算法是一种抢占式的进程调度算法，每个进程被分配一个时间片，当一个进程的时间片用完时，就被剥夺CPU，然后排到队列的末尾，等待下一次调度。
该算法能够保证每个进程的响应时间比较短，但可能会导致CPU利用率较低。
三、实验步骤（一）编写程序框架首先，根据实验要求，编写完整的程序框架，包括进程类Process和调度器类Scheduler。
Process类中包含了进程需要的属性和方法，如进程ID、进程到达时间、进程执行时间、进程状态等。
Scheduler类中包含了进程调度所需要的方法，如FCFS、SJF、RR 调度算法等。
（二）实现进程调度算法FCFS算法较为简单，只需要按照进程到达时间排序即可。
```pythondef FCFS(self):queue = Queue()process_time = 0while not self.is_finished():ready_process = self.get_arrived_process(process_time)if ready_process:queue.put(ready_process)if not queue.empty():current_process = queue.get()current_process.status = 'running'current_process.start_time = process_timecurrent_process.end_time = current_process.start_time + current_process.run_timeself.finished_processes.append(current_process)process_time += 1```2. SJF算法SJF算法需要进行进程预计运行时间的排序，然后按照排序后的顺序进行执行。
实验进程调度的实验报告
一、实验目的1. 加深对进程概念和进程调度算法的理解。
2. 掌握进程调度算法的基本原理和实现方法。
3. 培养编程能力和系统分析能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块（PCB）3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一，负责将CPU分配给就绪队列中的进程。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转（RR）等。
1. 先来先服务（FCFS）算法：按照进程到达就绪队列的顺序进行调度。
2. 短作业优先（SJF）算法：优先调度运行时间最短的进程。
3. 优先级调度算法：根据进程的优先级进行调度，优先级高的进程优先执行。
4. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行，时间片结束后进行调度。
五、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、运行时间、优先级、状态等信息。
2. 创建进程队列，用于存储就绪队列、等待队列和完成队列。
3. 实现进程调度算法：a. FCFS算法：按照进程到达就绪队列的顺序进行调度。
b. SJF算法：优先调度运行时间最短的进程。
c. 优先级调度算法：根据进程的优先级进行调度。
d. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行。
4. 模拟进程调度过程：a. 初始化进程队列，将进程添加到就绪队列。
b. 循环执行调度算法，将CPU分配给就绪队列中的进程。
c. 更新进程状态，统计进程执行时间、等待时间等指标。
d. 当进程完成时，将其移至完成队列。
六、实验结果与分析1. FCFS算法：按照进程到达就绪队列的顺序进行调度，简单易实现，但可能导致短作业等待时间过长。
2. SJF算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验，加深对操作系统进程调度原理的理解，掌握先来先服务（FCFS）、时间片轮转（RR）和动态优先级（DP）三种常见调度算法的实现，并能够分析这些算法的优缺点，提高程序设计能力。
二、实验环境- 编程语言：C语言- 操作系统：Linux- 编译器：GCC三、实验内容本实验主要实现以下内容：1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法：FCFS、RR和DP。
3. 创建一个进程队列，用于存储所有进程。
4. 实现调度函数，根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程，打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体：```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待，1: 运行，2: 完成} PCB;```2. 创建进程队列：```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法：（1）FCFS调度算法：```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（2）RR调度算法：```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```（3）DP调度算法：```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程：%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程：%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程：```cvoid simulateProcess() {printf("请选择调度算法（1：FCFS，2：RR，3：DP）：");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
操作系统实验报告之进度调度模拟程序
目录进程调度程序设计一、实验目的和要求 (1)二、实验内容及原理 (2)三、实验仪器设备 (4)四、操作方法与实验步骤 (4)五、实验数据记录和处理 (5)六、实验结果与分析 (12)七、实验感想 (14)实验一进程调度程序设计一、实验目的和要求1、目的进程是操作系统最重要的概念之一，进程调度是操作系统的主要内容。
理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块PCB。
理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况。
通过实验，加深对进程调度和各种调度算法的认识与了解。
2、要求（1）设计一个有几个进程并发执行的进程调度程序，每个进程由一个进程控制块(PCB)表示，进程控制块通常应包括下述信息：进程名，进程优先数，进程需要运行的时间，占用CPU的时间以及进程的状态等，且可按照调度算法的不同而增删。
（2）调度程序应包含2—3种不同的调度算法，运行时可以任选一种，以利于各种方法的分析和比较。
（3）系统应能显示或打印各进程状态和参数的变化情况，便于观察二、实验内容及原理编写并调试一个模拟的进程调度程序，采用“多级反馈队列”调度算法对五个进程进行调度。
多级反馈队列调度算法的基本思想是：当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度.当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行，以此类推。
1、设置多个就绪队列，并给队列赋予不同的优先级数，第一个最高，依次递减。
2、赋予各个队列中进程执行时间片的大小，优先级越高的队列，时间片越小。
3、当一个新进程进入内存后，首先将其放入一个对列末尾，如果在一个时间片结束时尚未完成，将其转入第二队列末尾。
4、当一个进程从一个对列移至第n个队列后，便在第n个队列中采用时间片轮转执行完。
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有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。
模拟调度实验报告(3篇)
第1篇一、实验背景进程调度是操作系统核心功能之一，它负责在多道程序环境下，按照一定的策略对进程进行调度，以确保系统资源的合理分配和高效利用。
为了加深对进程调度算法的理解，本次实验采用模拟的方式，实现了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种算法，并对实验过程进行了详细记录和分析。
二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。
2. 掌握进程控制块（PCB）的设计与实现。
3. 通过模拟实验，验证三种调度算法的执行效果。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 定义进程控制块（PCB）进程控制块是操作系统用于描述和管理进程的实体，它包含了进程的基本信息。
本实验中，PCB包含以下字段：- 进程ID：唯一标识一个进程。
- 到达时间：进程进入就绪队列的时间。
- 需要运行时间：进程完成所需的时间。
- 已运行时间：进程已运行的时间。
- 状态：进程当前的状态（就绪、运行、阻塞、完成）。
2. 实现三种调度算法（1）先来先服务（FCFS）算法FCFS算法按照进程到达就绪队列的顺序进行调度，先到先服务。
具体实现如下：- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，依次执行进程，直到进程完成或被阻塞。
（2）时间片轮转（RR）算法RR算法将CPU时间划分为时间片，每个进程运行一个时间片后，让出CPU，等待下一个时间片。
具体实现如下：- 设置一个时间片大小。
- 将进程按照到达时间排序，形成就绪队列。
- 遍历就绪队列，每个进程执行一个时间片，如果进程未完成，则将其加入就绪队列队尾。
（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度，优先级高的进程优先执行。
具体实现如下：- 设置一个优先级阈值，当进程的优先级高于阈值时，将其加入就绪队列。
- 遍历就绪队列，选择优先级最高的进程执行，直到进程完成或被阻塞。
进程调度模拟程序实验实验报告
实验三、进程调度模拟程序实验一、实验目的用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验内容和要求设计一个有 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.运行结果及分析四、 实验总结这次的实验是我们这门课第一次以个人为单位来完成的实验，然后这次实验用了三个星期去完成，虽然每次上机课老师都会先讲，可是我还是不太懂，到自己做的时候又不会，都是照样画葫芦。
操作系统实验报告-进程调度实验
进程调度实验一．实验目的及要求：进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
二 . 实验环境：操作系统：Windows XP编译环境：Visual C++ 6.0三．算法描述进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
四. 实验步骤：1.、进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间。
2、程序源码结构：struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort(){…} /* 建立对进程进行优先级排列函数*/ check(){…} /* 建立进程查看函数*/input(){…} /* 建立进程控制块函数*/main() /*主函数*/{...input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n resume......");ch=getchar();}printf("\n\n finished.\n");ch=getchar();}3.、实验截图：简单轮转法4、实验结果的分析及说明在操作系统中，由于进程总数多于处理机，它们必然竞争处理机。
进程调度模拟程序实验实验报告
进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 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。
实验三 进程调度实验上机
实验三进程调度实验上机实验三-进程调度实验上机预览要求：1、事先编好程序；2.准备要输入的中间数据；3.估计可能出现的问题；4.预计可能的运营结果。
实验三进程调度实验本实验的目的是用高级语言编写和调试进程调度器，以加深对进程概念和进程调度算法的理解。
实验内容：1、设计一个有n个进程共行的进程调度程序。
进程调度算法：优先采用优先级最高的调度算法（即将处理器分配给优先级最高的进程）或先到先得算法。
每个过程由过程控制块（PCB）表示。
过程控制块可以包含以下信息：进程名、优先数（假设优先数的值越大优先级别越高）、到达时间、需要运行时间、已用cpu时间、进程状态等等。
进程的优先级和所需的运行时间可以提前手动指定（或通过随机数生成）。
流程的到达时间是流程输入的时间。
进程的运行时间是以时间片计算的。
每个进程的状态可以是三种状态之一：就绪w（等待）、运行R（运行）或完成f（完成）。
就绪进程获得cpu后都只能运行一个时间片。
用已占用cpu时间加1来表示。
如果运行一个时间片后，进程的已占用cpu时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用cpu时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待cpu。
每次，调度器都会打印正在运行的进程、就绪队列和每个进程的PCB以供检查。
重复以上过程，直到所有进程都完成为止。
2.设计流程，根据设计的流程分析其调度顺序，并列出甘特图同学们自己写3.实验总结：同学们自己写4.延伸问题：编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。
轮转法可以是简单轮转法、可变时间片轮转法，或多队列轮转法。
简单轮换法的基本思想是，所有准备就绪的进程都按照FCF排列在一个队列中，处理器总是分配给队列最前面的进程。
每个进程占用相同的CPU时间片。
如果正在运行的进程在用完其时间片后没有完成，它将被发送回就绪队列的末尾，处理器将被重新分配给队列头部的进程。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
1）熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转；2）结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1）本实验要求完成如下任务:2）编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个；3）最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A）, 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为：进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三模拟进程调度
一实验目的
理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块PCB。
理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况
二实验要求
编写一个允许多个进程并发执行的进程调度程序。
1）进程调度算法：进程的调度采用最高优先数优先的调度算法和先来先服务调度算法相结合的算法，并且采用动态优先数策略，选择进程占用处理器后该进程仅能使用一个时间片，运行完后优先数减1。
2）每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等.
3）进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为输入进程的时间。
4）进程的运行时间以时间片为单位进行计算。
5）每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
.
6）就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
7）如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
8）每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止
三概要设计
进程控制块：描述进程的状态信息，用结构体定义
typedef struct process
{ char name[10]; //进程名
int priority; //优先数
Time ReachTime; //到达时间
Time NeedTime; //需要运行时间
Time UsedTime; //已用时间
char state; //进程状态
}PCB; //进程控制块
图1.进程调度模拟程序模块图
算法思想：
定义结构体PCB描述进程的进程控制块，定义数组PCB pcb[Max]存放进程。
进程调度程序调用face()函数选择所要进行的操作。
输入1则增加进程并调度进程，输入2则打印进程，输入0则任务结束。
增加进程，调用AddProcess()函数，将输入的进程存放在数组pcb[Max]中。
打印进程，调用print()函数，在该函数中首先调用sort()函数对进程按优先级和先来先服务排序，然后显示输出排序后的进程。
进程调度，调用attemper()函数，调度优先级最高的进程分配给CPU使之运行一个时间片。
进程优先级排序，调用sort()函数，按照先来先服务和优先级排序，使排序完最优先运行
的进程存放在pcb[0]中。
四流程图
图2.程序设计流程图
图3.sort( )函数流程图
sort()函数：函数用冒泡法排序，首先按到达时间排序，使到达时间最早（即pcb[n].ReachTime最小）的进程被交换到pcb[0]中，再按优先级排序，使具有最高优先级（即
pcb[n].priority最大）的进程被交换到pcb[0]中。
相同优先级的进程只按到达时间排序
图4.print( )函数图5. AddProcess()函数
print( )函数：打印函数，先调用sort（）排序函数对进程进行排序，排序完再打印输出进程。
AddProcess()函数：增加进程函数，输入要添加的进程的进程控制块的信息，并依次存放在数组PCB pcb[Max]中，每加入一个进程后判断是否还要继续增加进程，
若是则继续循环的执行操作
图6.attemper( )函数
attemper( )函数：进程调度函数，调度排完序后存放在pcb[0]中的进程，分配给该进程CPU，使之运行一个时间片，然后比较进程的剩余时间(pcb[0].NeedTime-pcb[0].UsedTime)是否小于时间片的大小pTime，若是，则该进程调度完成，进程处于完成状态，若非，则已用时间加上一个时间片，进程处于就绪状态继续等待运行，然后调用print( )函数打印输出当前进程的状态并排序，直至所有进程处于完成状态后结束运行
图7.face( )函数
face( )函数：函数打印所能进行的操作以供选择。
输入1则是增加进程后调度进程，输入2则是打印进程，输入0则是任务结束。
图8.main( )函数
main( )函数：首先设置时间片的大小pTime，然后调用face()函数选择要进行的操作，choose='1'则增加进程并调度，choose='2'则打印进程，choose='0'则任务结束。
函数间的关系：1）sort( )函数嵌套在print()函数中调用
2）调用AddProcess()函数前必须先调用print()函数对进程进行排序并打印五测试，修改及运行结果
测试过程如上所述，分析得知，进程的调度正确。