操作系统实验模拟进程调度
模拟进程调度实验报告
模拟进程调度实验报告模拟进程调度实验报告引言：进程调度是操作系统中的一个重要功能，它决定了各个进程在处理器上的执行顺序。
合理的进程调度算法能够提高系统的性能和效率。
为了深入了解进程调度算法的工作原理和效果，我们进行了一系列的模拟实验。
实验目的：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时间，但对于长时间进程可能会产生较大的上下文切换开销。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言在计算机科学领域中，操作系统是一个重要的概念，它负责管理和协调计算机系统中的各种资源，包括处理器、内存、输入/输出设备等。
其中，进程调度是操作系统中一个非常重要的组成部分，它负责决定哪个进程在何时获得处理器的使用权，以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验，深入理解不同的进程调度算法对系统性能的影响，并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上，我们使用了C语言编写了一些简单的进程调度算法，并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法（FCFS）先来先服务调度算法是一种简单的进程调度算法，它按照进程到达的顺序进行调度。
在本次实验中，我们编写了一个简单的FCFS调度算法，并通过模拟多个进程同时到达的情况，观察其对系统性能的影响。
2. 短作业优先调度算法（SJF）短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中，我们编写了一个简单的SJF调度算法，并通过模拟不同长度的进程，观察其对系统性能的影响。
3. 时间片轮转调度算法（RR）时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中，我们编写了一个简单的RR调度算法，并通过模拟不同时间片大小的情况，观察其对系统性能的影响。
实验结果通过实验，我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下，长作业会导致短作业等待时间过长；在SJF算法下，长作业会导致短作业饥饿现象；而RR算法则能够较好地平衡不同进程的执行。
因此，在实际应用中，需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验，深入理解了不同的进程调度算法对系统性能的影响，并掌握了进程调度算法的实现方法。
同时，也加深了对操作系统的理解，为今后的学习和研究打下了良好的基础。
模拟进程调度实验报告
模拟进程调度实验报告摘要本实验主要采用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;}运行结果如下：。
进程调度操作系统实验报告
进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理，通过实际编程和模拟，观察不同调度算法对系统性能的影响，并掌握进程调度的实现方法。
二、实验环境操作系统：Windows 10编程语言：C+＋开发工具：Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一，它负责决定哪个进程在何时获得 CPU 资源进行执行。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）、优先级调度等。
先来先服务算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 执行。
这种算法简单直观，但可能导致短作业等待时间过长。
短作业优先算法优先调度执行时间短的进程，能有效减少平均等待时间，但可能导致长作业饥饿。
时间片轮转算法将 CPU 时间划分成固定大小的时间片，每个进程轮流获得一个时间片进行执行。
如果进程在时间片内未完成，则被放回就绪队列等待下一轮调度。
优先级调度根据进程的优先级来决定调度顺序，优先级高的进程先获得 CPU 资源。
四、实验步骤1、设计进程结构体定义进程的标识号（PID）、到达时间、服务时间、剩余时间、优先级等属性。
2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中取出第一个进程进行调度执行，直到其完成。
3、实现短作业优先算法计算每个进程的剩余服务时间。
将进程按照剩余服务时间从小到大排序，放入就绪队列。
从就绪队列中取出剩余服务时间最短的进程进行调度执行。
4、实现时间片轮转算法设定时间片大小。
将进程放入就绪队列，按照先来先服务的原则依次分配时间片执行。
进程在时间片内未完成的，放回就绪队列末尾。
5、实现优先级调度算法为每个进程设置优先级。
将进程按照优先级从高到低排序，放入就绪队列。
从就绪队列中取出优先级最高的进程进行调度执行。
6、计算平均周转时间和平均带权周转时间周转时间＝完成时间到达时间带权周转时间＝周转时间／服务时间平均周转时间＝总周转时间／进程数平均带权周转时间＝总带权周转时间／进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。
操作系统进程调度实验
操作系统进程调度实验操作系统进程调度是操作系统中非常重要的一个功能，它决定了多个进程的执行顺序和调度策略。
进程调度的好坏直接影响着系统的性能和资源利用率。
本实验旨在通过实现一个简单的进程调度模拟，了解不同的调度算法，探讨其优劣和适用场景。
一、实验目的和原理本实验的目标是实现进程调度模拟，并探究不同调度算法的性能和适用场景。
通过实验，我们可以了解以下内容：1.进程调度算法的基本原理和实现方式；2.比较不同调度算法的优劣和特点；3.了解不同调度算法在不同场景下的应用。
二、实验环境和工具本实验使用C语言进行实现，可以选择任何一种编程环境和工具，例如Dev-C++、Visual Studio等。
三、实验过程及方法1.实现一个进程控制块（PCB）的数据结构，用来保存进程的相关信息，包括进程ID、进程状态、优先级等。
2.实现一个进程队列，用来保存就绪队列中的进程。
可以使用数组或链表等数据结构实现。
3. 实现不同调度算法的函数，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和时间片轮转（Round Robin）等。
4.根据实际需求生成一批进程，设置其信息，并根据不同算法进行调度。
5.对比不同算法的运行结果和性能，分析其优劣。
四、实验结果和分析通过实验，我们可以得到每个算法的平均等待时间、平均周转时间和吞吐量等性能指标。
根据这些指标，我们可以对不同算法进行评价和分析。
1.先来先服务（FCFS）算法FCFS算法是最简单的调度算法，按照进程到达的顺序进行调度。
它的主要优点是实现简单、公平性好。
然而，FCFS算法有明显的缺点，会导致长作业等待时间过长，产生"饥饿"现象。
2.最短作业优先（SJF）算法SJF算法是按照进程的执行时间长短进行调度的算法。
它能够最大限度地减少平均等待时间和周转时间，但是需要提前知道所有进程的执行时间，这在实际中是很难做到的。
操作系统进程调度模拟程序实验报告
操作系统进程调度模拟程序实验报告实验目的：了解操作系统进程调度的基本原理和方法，通过编写模拟程序来验证调度算法的正确性。
实验内容：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时间，适用于执行时间较长的任务。
实验总结：通过本次实验，我们进一步加深了对操作系统进程调度的理解和认识。
通过编写模拟程序，我们能够清楚地了解不同调度算法的工作原理和对应的性能表现。
在实际应用中，根据任务的特点和需求选择合适的调度算法，能够提高系统的性能和效率。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
（操作系统原理和linux操作系统相结合的实验）实验三模拟进程调度一实验目的理解操作系统进程管理中进行进程调度的过程和编程方法，掌握先来先服务调度算法和最高优先数优先的调度算法，创建进程控制块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()函数进程调度attemper()函数 打印进程print() 函数 进程调入AddProcess ()函数选择操作 face() 函数进程优先级排序，调用sort()函数，按照先来先服务和优先级排序，使排序完最优先运行的进程存放在pcb[0]中。
四 流程图图2.程序设计流程图设置时间片选择增加进程继续增加优先级排序打印进程进程调度 打印进程结束进程开始结束 是否完成图3.sort( )函数流程图sort()函数：函数用冒泡法排序，首先按到达时间排序，使到达时间最早（即pcb[n].ReachTime 最小）的进程被交换到pcb[0]中，再按优先级排序，使具有最高优先级（即pcb[n].priority 最大）的进程被交换到pcb[0]中。
相同优先级的进程只按到达时间排序 主要代码如下：for (i=0;i<n-1;i++) //先按到达时间排序 { for (j=n-2;j>=i;j--) { if (pcb[j+1].ReachTime<pcb[j].ReachTime) { temp=pcb[j]; pcb[j]=pcb[j+1]; pcb[j+1]=temp;i=0 j=n-2pcb[j+1].Reac hTime<pcb[j].ReachTimetemp=pcb[j]; pcb[j]=pcb[j+1]; pcb[j+1]=temp;j=j-1j>=ii=i+1i<n-1i=0j=n-2pcb[j+1].prior ity>pcb[j].pri oritytemp=pcb[j]; pcb[j]=pcb[j+1]; pcb[j+1]=temp;j=j-1j>=i i=i+1i<n-1开始结束YN YNYN YN} } }for (i=0;i<n-1;i++) //再按优先级进行排序 { for (j=n-2;j>=i;j--) { if (pcb[j+1].priority>pcb[j].priority) { temp=pcb[j];pcb[j]=pcb[j+1]; pcb[j+1]=temp; }}}图4.print( )函数 图5. AddProcess()函数print( )函数：打印函数，先调用sort （）排序函数对进程进行排序，排序完再打印输出进程。
主要代码如下：sort();printf("\n 进程名 优先级 到达时间 需要时间 已用时间 进程状态 \n"); for (i=0;i<n;i++)sort （）排序 i=0 i=i+1 输出pcb[i]进程信息i<n 输入pcb[n] 进程信息n=n+1继续增加进程ch!='Y'&&ch!='N'&&ch!='y'&&ch!='n'ch=getchar()ch=='Y'||ch=='y'开始 结束结束 开始Y N NNYY{printf("%8s%8d%8d%10d%10d%10c\n",pcb[i].name,pcb[i].priority,pcb[i].ReachTime,pcb[ i].NeedTime,pcb[i].UsedTime,pcb[i].state);}AddProcess()函数：增加进程函数，输入要添加的进程的进程控制块的信息，并依次存放在数组PCB pcb[Max]中，每加入一个进程后判断是否还要继续增加进程，若是则继续循环的执行操作主要代码如下：do{printf("\n请输入进程名");scanf("%s",pcb[n].name);printf("请输入进程的优先级");scanf("%d",&pcb[n].priority);printf("请输入进程需要的时间");scanf("%d",&pcb[n].NeedTime);pcb[n].ReachTime=n;pcb[n].UsedTime=0;pcb[n].state='W';n++;printf("还要继续增加进程吗,是(Y),否(N)");do{ch=getchar();} while(ch!='Y'&&ch!='N'&&ch!='y'&&ch!='n');}while (ch=='Y'||ch=='y');图6.attemper( )函数attemper( )函数：进程调度函数，调度排完序后存放在pcb[0]中的进程，分配给该进程CPU ，使之运行一个时间片，然后比较进程的剩余时间(pcb[0].NeedTime-pcb[0].UsedTime)是否小于时间片的大小pTime ，若是，则该进程调度完成，进程处于完成状态，若非，则已用时间加上一个时间片，进程处于就绪状态继续等待运行，然后调用print( )函数打印输出当前进程的状态并排序，直至所有进程处于完成状态后结束运行 主要代码如下： do{ if ((pcb[0].NeedTime-pcb[0].UsedTime)>pTime) { pcb[0].UsedTime+=pTime;//已用时间加时间片 pcb[0].priority--;//优先级减一 pcb[0].state='W'; } else{ pcb[0].UsedTime=pcb[0].NeedTime;//已用时间等于需要时间pcb[0].priority=-1000;//优先级置为零 pcb[0].state='F';//完成进程，将状态置为完成 } print(); }while(pcb[0].state!='F');pcb[0].UsedTime=pcb[0].NeedTime pcb[0].priority=-1000 pcb[0].state='F'print()打印pcb[0].UsedTime+=pTime pcb[0].priority — pcb[0].state='W'(pcb[0].NeedTime-pcb[0].UsedTime)>pTimepcb[0].state!='F'开始结束YNYN图7.face( )函数face( )函数：函数打印所能进行的操作以供选择。
输入1则是增加进程后调度进程，输入2则是打印进程，输入0则是任务结束。
主要代码如下：char choose;printf("\n 增加进程并调度进程，请按1"); printf("\n 打印进程，请按2"); printf("\n 任务结束, 请按0"); printf("\n 请选择:"); do{choose=getchar();} while(choose!='1'&&choose!='2'&&choose!='0'); return choose;}return choosechoose=getchar()增加进程并调度进程，请按1 打印进程，请按2 任务结束, 请按0 请选择:choose!='1'&&choos e!='2'&&choose!='0'开始结束YN图8.main( )函数main( )函数：首先设置时间片的大小pTime ，然后调用face()函数选择要进行的操作，choose='1'则增加进程并调度，choose='2'则打印进程，choose='0'则任务结束。