模拟一种处理机调度算法讲解
进程调度模拟算法
进程调度模拟算法进程调度是操作系统中的重要组成部分之一，它负责决定在多道程序环境下，哪个进程将获得CPU的使用权。
进程调度模拟算法是为了研究和评估不同调度策略的性能而开发的一种仿真方法。
在实际系统中，调度算法会受到多种因素的影响，如进程优先级、进程的I/O需求、进程的实际执行时间等。
通过模拟这些因素，可以更好地理解不同调度算法之间的差异，并选择最合适的算法来满足特定需求。
下面介绍两种常见的进程调度模拟算法：先来先服务（FCFS）和最短作业优先（SJF）算法。
1. 先来先服务（FCFS）算法：该算法按照进程到达的顺序来调度任务。
当一个进程完成或阻塞时，下一个已到达的进程将获得CPU的使用权。
这种算法非常简单，但是不适用于长作业时间和短作业时间交替出现的情况。
在短作业启动时，长作业仍然在运行，使得短作业的等待时间增加。
2. 最短作业优先（SJF）算法：该算法根据任务的执行时间来调度进程。
在该算法中，每个进程的执行时间都是已知的，并且操作系统根据已知的执行时间来决定哪个进程获得CPU的使用权。
在短作业优先算法中，短作业将会先被调度，这样有助于减少平均周转时间和等待时间。
但是，短作业优先算法容易产生“饥饿”现象，即长作业可能会一直等待，而短作业一直得到CPU的使用权。
除了以上两种算法，还有其他的进程调度模拟算法。
例如：- 时间片轮转（RR）调度算法：使用固定的时间片来调度进程，当时间片用完后，该进程被放入就绪队列的末尾。
- 优先级调度算法：每个进程都拥有一个优先级，优先级越高的进程越早被调度。
这种方法可以根据不同进程的紧迫程度和重要性来进行调度。
- 多级反馈队列调度算法：将就绪队列划分为多个队列，并根据进程的性质和优先级将进程放入不同的队列。
每个队列都有不同的优先级和时间片大小，进程可以通过提高优先级或时间片大小来提高被调度的机会。
在实际应用中，需要根据系统需求和性能指标选择合适的调度算法。
常用的性能指标包括平均周转时间、平均等待时间、CPU利用率等。
操作系统进程调度算法的模拟
操作系统进程调度算法的模拟其次，我们来介绍短作业优先（Shortest Job Next，SJN）算法。
SJN算法按照任务的运行时间来决定运行顺序，即先运行运行时间最短的进程。
该算法能够最大程度地减少平均等待时间，但对于长任务可能导致长时间的等待。
接下来，我们介绍轮转（Round Robin，RR）算法。
RR算法是一种基于时间片的调度算法，将CPU分为若干个时间片，并依次分配给各个进程。
当一个进程的时间片用完后，将其放入队列尾部，继续运行下一个进程。
该算法具有公平性和响应性较高的特点，但对于长时间运行的进程，可能会导致较大的上下文切换开销。
此外，还有最高响应比优先（Highest Response Ratio Next，HRRN）算法。
HRRN算法通过计算等待时间和服务时间的比例来决定运行顺序，即选取响应比最高的进程先执行。
该算法能够尽可能减少平均响应时间，但对于长任务可能存在运行时间过长的问题。
最后，我们介绍最短剩余时间优先（Shortest Remaining Time First，SRTF）算法。
SRTF算法是SJN算法的抢占版本，当有新进程到达时，会比较其剩余运行时间与当前运行进程的时间，如果新进程的剩余时间较短，则立即进行进程切换。
该算法能够最大程度地减少平均等待时间和响应时间，但对于切换开销较大。
针对这几种进程调度算法，我们可以通过编写模拟程序来验证其性能和特点。
首先，我们需要定义进程的数据结构，包括进程ID、到达时间、服务时间等属性。
然后，我们可以编写一个模拟函数来按照不同的算法进行调度，并统计平均等待时间、平均响应时间、吞吐量等指标。
通过对比不同算法在不同场景下的表现，可以评估其优劣。
总结起来，不同的进程调度算法有着各自的优缺点，根据实际需求选择合适的算法能够提高系统的性能和用户体验。
通过模拟和评估这些算法，我们可以更好地理解其原理和适用范围，并为实际系统的设计和优化提供参考。
希望这篇文章能够帮助你更好地理解和应用进程调度算法。
实验三模拟进程调度算法
实验三模拟进程调度算法先进先出算法算法总是把处理机分配给最先进入就绪队列的进程,一个进程一旦分得处理机,便一直执行下去,直到该进程完成或阻塞时,才释放处理机。
最高优先权(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);}}。
处理机调度的常用算法
处理机调度的常用算法包括以下几种：
1. 先来先服务调度算法（FCFS，First Come First Service）：这是一种最简单的调度算法，按先后顺序进行调度。
既可用于作业调度，也可用于进程调度。
2. 短作业优先调度算法（SJF/SPF，Shortest Job First）：该算法根据作业长短进行调度，有利于短作业（进程）的完成。
3. 高响应比优先调度算法（HRRN，Highest Response Raito Next）：该算法综合考虑了作业长短和等待时间，能够适用于短作业较多的批处理系统中，但长作业的运行可能得不到保证。
4. 基于时间片的轮转调度算法（RR，Round Robin）：该算法将系统中所有的就绪进程按照FCFS原则，排成一个队列。
每次调度时将CPU 分派给队首进程，让其执行一个时间片。
时间片的长度从几个ms到几百ms。
在一个时间片结束时，发生时钟中断。
调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前就绪的队首进程。
进程阻塞情况发生时，未用完时间片也要出让CPU。
这些算法各有优缺点，需要根据实际应用场景选择合适的算法。
操作系统-模拟进程调度算法-最新
操作系统——项目文档报告进程调度算法专业：班级：指导教师：姓名：学号：一、核心算法思想1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。
当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。
2.短作业（进程）优先调度算法短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。
而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。
该算法对长作业不利，完全未考虑作业的紧迫程度。
3.高响应比优先调度算法在批处理系统中，短作业优先算法是一种比较好的算法，其主要不足之处是长作业的运行得不到保证。
如果我们能为每个作业引人动态优先权，并使作业的优先级随着等待时间的增加而以速率a提高，则长作业在等待一定的时间后，必然有机会分配到处理机。
该优先权的变化规律可描述为:优先权=（等待时间+要求服务时间）/要求服务时间即优先权=响应时间/要求服务时间如果作业的等待时间相同，则要求服务的时间越短，其优先权越高，因而该算法有利于短作业。
当要球服务的时间相同时，作业的优先权决定于其等待时间，等待时间越长，优先权越高，因而它实现的是先来先服务对于长作业，作业的优先级可以随着等待时间的增加而提高，当其等待时间足够长时，其优先级便可以升到很高，从而也可获得处理机。
进程调度模拟算法
进程调度模拟算法进程调度模拟算法是操作系统中的关键之一，通过合适的进程调度算法可以达到合理分配资源、提高系统吞吐量和响应速度等目的。
下面将介绍几种常用的进程调度算法以及它们的优缺点。
1. 先来先服务调度算法（FCFS）FCFS是最简单也是最常见的调度算法之一，即先请求的进程先获得CPU资源。
FCFS实现简单，易于理解和实现，但是存在短作业等待长作业的现象，进程响应时间长、带来的影响不容忽视。
2. 短作业优先调度算法（SJF）SJF调度算法采用短作业优先原则，即拥有最短执行时间的进程优先获得CPU资源。
SJF可以减少平均等待时间，提高系统吞吐量，但可能出现“饥饿”的情况，即长作业一直无法得到CPU资源。
此外，SJF需要提前得知作业执行时间，实现起来比较困难。
3. 时间片轮转调度算法（RR）RR算法将进程分配一个时间片，CPU在该时间片内运行进程，时间片结束后，CPU将被切换到下一个进程。
RR算法顺序公平，避免长作业等待短作业，但需要设置适当的时间片大小，过小的时间片会导致频繁切换进程，造成系统开销大，过长的时间片会影响系统响应速度。
4. 优先级调度算法优先级调度算法将进程划分为不同的优先级，高优先级的进程优先获得CPU资源。
优先级可以是系统静态设定或动态变化，利用此算法可以实现多种调度策略，如SJF、FCFS等。
但是优先级调度可能导致低优先级进程长时间得不到CPU资源，出现“饥饿”的情况。
总体来说，不同的进程调度算法有着各自的优缺点，需要根据具体情况选择合适的算法。
实际操作中，操作系统往往综合多种算法，采取多种策略来管理进程，以达到最优的效果。
处理机调度算法
处理机调度算法处理机调度算法（CPU Scheduling Algorithm）是操作系统中一个非常重要的概念，它指的是在多个进程需要占用系统处理器的情况下，如何高效地分配时间片，使得每个进程都能得到公平的处理机时间，系统能够充分利用处理器的资源。
算法分类常见的处理机调度算法主要有以下几种：1. 先来先服务（FCFS）调度算法先来先服务是最简单的处理机调度算法。
它的基本思想是，一个进程需要处理时，处理器按照进程提交的顺序进行调度。
即，先提交的进程先执行，等前一个进程执行完后，下一个进程才会被处理。
这种算法的优点是简单易行，缺点是可能导致一些进程等待时间较长。
2. 短作业优先（SJF）调度算法短作业优先是一种非抢占式的算法，它的基本思想是根据每个进程需要处理的总时间长短来排序，先处理需要处理时间较短的作业，这种方法可以最小化平均等待时间。
但是，由于它需要知道每个进程的总执行时间，因此难以实现。
3. 时间片轮转（RR）调度算法时间片轮转是一种抢占式的算法，它的基本思想是将处理机分为时间片，每个进程都可以运行一个时间片，时间片到期后，如果还未结束，则该进程被挂起，另一个就绪进程插入，并重新分配一个时间片。
这种算法能够避免某些进程长时间占用资源，每个进程都能在一定时间内得到处理机的时间。
4. 优先级调度（Priority Scheduling）算法优先级调度是一种非抢占式的算法，它的基本思想是为每个进程设置不同的优先级，进程具有最高优先级的先被处理，如果存在两个相等的进程优先级，那么会使用先来先服务的方式进行处理。
缺点是可能导致低优先级的进程等待时间太长。
5. 多级反馈队列（MFQ）调度算法多级反馈队列是一种复杂的算法，它的基本思想是将所有进程按照其优先级分为多个队列，优先级相同的进程被分成同一个队列，不同队列之间根据时间片大小相差不同。
例如，第一队列的时间片为10ms，第二队列的时间片为20ms，第三队列的时间片为40ms，以此类推。
处理机调度算法rr案例
处理机调度算法rr案例
那咱们就来个简单又有趣的时间片轮转（RR Round Robin）调度算法的案例吧。
想象一下，你是一个超级繁忙的餐厅经理，餐厅里有好多桌客人，而服务员就那么几个，这服务员就好比是处理机，客人就是各个进程啦。
比如说现在有三个客人（进程），分别是甲、乙、丙。
每个客人点菜、吃饭、聊天啥的就相当于进程在执行自己的任务。
这个时间片呢，就假设是10分钟（在计算机里时间片可是超级短的，这里为了好理解就设长一点啦）。
服务员先到甲客人这桌，开始服务甲客人点菜啥的，这就是甲进程开始占用处理机啦。
10分钟一到，不管甲客人点完菜没，服务员就得按照RR调度算法，去乙客人那桌啦，这时候甲客人就只能先等等，乙客人就开始占用服务员（处理机）10分钟，乙客人可能正跟服务员说自己的特殊要求呢，时间一到，服务员又得去丙客人那桌，丙客人就开始享受这10分钟的专属服务，可能是在加菜或者询问菜品之类的。
等丙客人这10分钟用完了，服务员又轮回到甲客人这桌啦。
这时候甲客人可能因为之前被打断了，得重新和服务员沟通，不过没关系，按照RR算法就是这样循环着来，保证每个客人（进程）都能得到相对公平的服务（处理机时间）。
如果甲客人很快就结束了自己的事情，比如说点完菜了，那甲客人就可以先在那等着上菜，服务员还是按照RR算法去服务乙和丙客人。
直到所有客人都完成了他们在餐厅的流程（进程结束）。
这样通过RR调度算法，每个客人（进程）都能得到一些时间的服务（处理机时间），不会出现一个客人（进程）一直霸占着服务员（处理机），而其他客人（进程）干等的情况。
是不是还挺好理解的呀 。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计报告设计名称：模拟实现一种处理机调度算法学生姓名： xxx专业：计算机科学与技术班别： xxxxxxxx 学号： xxxxxx 指导老师： xxxxx日期： 2014 年 6 月 20 日初始条件：1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟进程调度，能够处理以下的情形：⑴能够选择不同的调度算法（要求中给出的调度算法）；⑵能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；⑶根据选择的调度算法显示进程调度队列；⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2．设计报告内容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；进程调度模拟设计——先来先服务、优先级法1、背景：当计算机系统是多道程序设计系统时，通常会有多个进程或线程同时竞争CPU。
只要有两个或更多的进程处于就绪状态，这种情形就会发生。
如果只有一个CPU可用，那么就必须选择下一个要运行的进程。
在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法成为调度算法。
进程调度的核心问题是采用什么样的算法把处理机分配给进程，好的算法将提高资源利用率，减少处理机的空闲时间，避免有些作业长期得不到相应的情况发生等，从而设计出受欢迎的操作系统。
较常见的几种进程调度算法有：先来先服务调度算法；短作业优先调度算法；时间片轮转调度算法；优先级调度算法；高响应比优先算法和多级反馈队列调度算法等。
2.1设计目的无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。
另外，系统进程也同样需要使用处理机。
这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
本次课程设计的主要任务是用高级语言模拟进程调度的算法，包括先来先服务和优先级法。
通过输入进程的信息，模拟某种调度算法，得到进程调度的顺序，从而进一步分析进程的调度过程，并通过分析程序的运行，探讨各种调度算法的优劣。
2.2 设计内容及要求1）充分体现设计、实现过程；2）报告包括算法流程描述、数据结构代码描述、算法实现代码描述、模拟执行过程截图；3）单人完成课程设计，每人一份报告；4）报告双面打印；2.3算法与设计的思想2.3.1算法思想：·一个进程的生命期可以划分为一组状态，这些状态刻画了整个进程。
系统根据PCB结构中的状态值控制过程。
在进程的生命期内，一个进程至少具有5种基本状态，它们是：初始态、执行状态、等待状态、就绪状态和终止状态。
通过系统设计，实现进程相关数据结构的创建和查看功能；实现多种进程调度算法：先来先服务算法、优先级调度算法、时间片轮转法等；实现对执行进程的阻塞，对等待进程的唤醒等功能。
进程的转换过程如上·进程的先来先服务调度算法：首先定义进程结构体，用于记录进程的基本信息，包括进程名，优先级，进程到达时间，进程运行时间，然后将用户输入的进程信息保存到定义的结构数组中，并按进程到达的先后时间对数组进行排序，并记录它们的周转时间、带权周转时间、平均周转时间及平均带权周转时间。
·进程的优先级调度算法：同样先定义进程结构替，记录进程信息，将用户输入的进程信息保存在结构体数组中。
遍历数组，找出最先到达的进程，若有多个，则取优先级最高的一个，与数组中的第一个位置的进程互换位置，记录此进程执行完的时间，然后从第二个位置开始遍历数组，找到在第一个进程执行结束前到达的进程，若没有，则找到余下进程中到达时间最早的进程，找到优先级最高的一个，若并与数组的第二个位置的进程互换位置。
按同样的方法为余下的进程排序。
同样记录它们的周转时间，带权周转时间，并算出平均周转时间和平均带权周转时间。
2.3.2设计思想：a)每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先级数、到达时间、需要运行时间等等。
b)进程的信息，包括到达时间，优先数及需要的运行时间等都是事先人为地指定。
c)每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
2、功能设计（数据结构及模块说明）；3.1 系统流程如下：3.2数据结构及模块说明：（1）输入模块能够满足输入进程基本信息的功能，尽可能提供友好的交互界面。
给用户很好的提示，使用户能够方便的操作。
（2）算法模块先来先服务算法：可以根据进程到达的先后顺序来确定进程的运行顺序，并算出进程的周转时间，平均周转时间等。
优先级法：根据进程的优先级和进程到达的时间来确定进程的调度顺序，并算出周转时间，带权周转时间等。
（3）输出模块根据算法得到的进程调度顺序以及算出的其他参数，将其输出。
3、开发平台及源程序的主要部分；4.1软硬件环境●硬件设备： PC机●软件设备：WINDOWSXP、Microsoft Visual C++ 6.04.2 源代码主要部分：（1）信息输入函数：void getInput(char *pname,int *priority,char *begintime,float *runtime) {printf("请输入进程名：");scanf("%s",pname);printf("请输入优先级");scanf("%d",priority);printf("请输入到达时间：");scanf("%s",begintime);printf("请输入¨运行时间(min)：");scanf("%f",runtime);}（2）先来先服务的算法：void fcfs(struct process *pro,int n){int i,j;struct process p;for(i = 0;i < n;i ++){for(j = 0;j < n - i -1;j ++){if(!timecompare(pro[j],pro[j+1])){p = pro[j + 1];pro[j + 1] = pro[j];pro[j] = p;}}}}（3）优先级法的算法：void prior(struct process *pro,int n) {int i,j,pt,t,bt,m;bt = 0;int a[MAXPROCESS];struct process p;float curtime = 1500;for(i = 0;i < n;i ++){if(curtime > pro[i].btime){curtime = pro[i].btime;}}for(i = 0;i < n;i ++){t = 0;pt = 0;for(j = i;j < n;j++){if(pro[j].btime <= curtime){a[t++] = j;}}if(t == 0){curtime = 1500;for(j = i;j < n;j ++){if(curtime > pro[j].btime){curtime = pro[j].btime;}}for(j = i;j < n;j++){if(pro[j].btime <= curtime){a[t++] = j;}}}for(j = 0;j < t;j++){bt = a[j];if(pro[bt].priority > pt){pt = pro[bt].priority;m = bt;}}if(m != i){p = pro[m];pro[m] = pro[i];pro[i] = p;}curtime = curtime + pro[i].runtime;}}4、测试用例，运行结果与运行情况分析；5.1测试用例：①进程个数为4②进程名唯一③预计运行结果：先来先服务：c a d b优先级法：c a b d进程名进程到达时间运行时间优先级a 2:12 34 2b 3:10 31 3c 1:15 21 1d 2:13 11 25.2运行结果：。