进程调度算法的模拟实现Word版

合集下载

(完整word版)操作系统-进程调度算法设计与实现实验报告

实验报告课程名称操作系统实验名称进程调度算法设计与实现姓名学号专业班级实验日期成绩指导教师(①实验目的②实验设备和环境③实验内容与步骤④实验结果与分析⑤总结,问题及建议）一、内容：设计一个简单的进程调度算法，模拟OS中的进程调度过程二、要求：①进程数不少于5个；②进程调度算法任选;最好选用动态优先数法，每运行一个时间片优先数减3③用C++（或C）语言编程；④程序运行时显示进程调度过程。

三、步骤:①设计PCB及其数据结构：进程标识数：ID进程优先数：PRIORITY（优先数越大，优先级越高）进程已占用时间片：CPUTIME进程尚需时间片:ALLTIME（一旦运行完毕,ALLTIME为0）进程队列指针：NEXT,用来将PCB排成队列进程状态：STATE(一般为就绪，不用）②设计进程就绪队列及数据结构；③设计进程调度算法,并画出程序流程图;④设计输入数据和输出格式;结构格式：当前正运行的进程:0当前就绪队列:2，1，3,4⑤编程上机，验证结果。

四、分析假设调度前，系统中有5个进程，其初始状态如下：①以时间片为单位调度运行；②每次总是从ALLTIME中不为0，且PRIORITY最大的进程调度运行一个时间片；③上述进程运行后其优先数减3，再修改其CPUTIME和ALLTIME，重复②，③④直到所有进程的ALLTIME均变为0。

五、代码＃include〈iostream〉＃include〈string〉#include<queue〉using namespace std;typedef struct pcb ｛string pName;//进程名int priorityNumber；//优先数float serviceTime；//服务时间float estimatedRunningtime;//估计运行时间char state；//状态bool operator〈(const struct pcb ＆a)const {return priorityNumber > a。

操作系统进程调度算法的模拟

操作系统进程调度算法的模拟其次，我们来介绍短作业优先（Shortest Job Next，SJN）算法。

SJN算法按照任务的运行时间来决定运行顺序，即先运行运行时间最短的进程。

该算法能够最大程度地减少平均等待时间，但对于长任务可能导致长时间的等待。

接下来，我们介绍轮转（Round Robin，RR）算法。

RR算法是一种基于时间片的调度算法，将CPU分为若干个时间片，并依次分配给各个进程。

当一个进程的时间片用完后，将其放入队列尾部，继续运行下一个进程。

该算法具有公平性和响应性较高的特点，但对于长时间运行的进程，可能会导致较大的上下文切换开销。

此外，还有最高响应比优先（Highest Response Ratio Next，HRRN）算法。

HRRN算法通过计算等待时间和服务时间的比例来决定运行顺序，即选取响应比最高的进程先执行。

该算法能够尽可能减少平均响应时间，但对于长任务可能存在运行时间过长的问题。

最后，我们介绍最短剩余时间优先（Shortest Remaining Time First，SRTF）算法。

SRTF算法是SJN算法的抢占版本，当有新进程到达时，会比较其剩余运行时间与当前运行进程的时间，如果新进程的剩余时间较短，则立即进行进程切换。

该算法能够最大程度地减少平均等待时间和响应时间，但对于切换开销较大。

针对这几种进程调度算法，我们可以通过编写模拟程序来验证其性能和特点。

首先，我们需要定义进程的数据结构，包括进程ID、到达时间、服务时间等属性。

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

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

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

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

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

进程调度算法实验报告doc

进程调度算法实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：XXXXX 学号：XXXXX 姓名：XXX实验日期：20XX年XX月XX日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。

二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。

三、实验方法内容1. 算法设计思路将每个进程抽象成一个控制块PCB， PCB用一个结构体描述。

构建一个进程调度类。

将进程调度的各种算法分装在一个类中。

类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。

还有一个PCB实例。

主要保存正在运行的进程。

类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。

主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。

当程序启动时，用户可以选择不同的调度算法。

然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。

进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。

判断进程容器中是否有新的进程可以加入就绪队列。

2. 算法流程图主程序的框架：();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息();.m_WaitQueue.empty()||.m_ProcessQueue.empt() ();();进程调度过程：;3. 算法中用到的数据结构struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;floatdqzztime;};//定义一个结构体，里面包含的有一个进程相关的信息4. 主要的常量变量vectorm_ProcessQueue;//进程输入队列vectorm_WaitQueue;//进程就绪队列vectorm_FinishQueue;//完成队列vector::iterator m_iter;//迭代器 PCB m_runProcess;//运行中的进程int m_ProcessCount;//进程数 float m_RunTime;//运行时间int m_tagIsRun;//是否在运行标志。

5种进程调度算法实验报告

操作系统教程——进程调度算法院系计算机与软件学院班级08软件工程2班学号20081344066姓名何丽茗进程调度算法的模拟实现⏹实验目的1．本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。

2．利用程序设计语言编写算法，模拟实现先到先服务算法FCFS、轮转调度算法RR、最短作业优先算法SJF、优先级调度算法PRIOR、最短剩余时间优先算法SRTF。

3．进行算法评价，计算平均等待时间和平均周转时间。

⏹实验内容及结果1．先来先服务算法2．轮转调度算法3. 优先级调度算法4. 最短时间优先算法5. 最短剩余时间优先算法实验总结在此次模拟过程中，将SRTF单独拿了出来用指针表示，而其余均用数组表示。

完整代码【Srtf.cpp代码如下：】//最短剩余时间优先算法的实现#include<stdio.h>#include<stdlib.h>#include<time.h>typedef struct{int remain_time; //进程剩余执行时间int arrive_time; //进程到达时间int Tp; //进入就绪队列的时间int Tc; //进入执行队列的时间int To; //进程执行结束的时间int number; //进程编号}Process_Block; //定义进程模块typedef struct _Queue{Process_Block PB;struct _Queue *next;}_Block,*Process; //定义一个进程模块队列中结点typedef struct{Process head; //队列头指针Process end; //队列尾指针}Process_Queue; //进程队列Process_Queue PQ; //定义一个全局队列变量int t; //全局时间Process Run_Now; //当前正在运行的进程，作为全局变量void InitQueue(Process_Queue PQ){PQ.head ->next = NULL;PQ.end ->next = PQ.head;}/*初始化队列*/int IsEmpty(Process_Queue PQ){if(PQ.end->next == PQ.head)return 1; //队列空的条件为头指针指向尾指针并且尾指针指向头指针return 0;}/*判定队列是否为空队列*/void EnQueue(Process_Queue PQ,Process P){Process temp =(Process)malloc(sizeof(_Block));temp = PQ.end;temp->next->next = P;PQ.end->next = P;}/*插入队列操作*/Process DeQueue(Process_Queue PQ){if(IsEmpty(PQ))return NULL;Process temp = PQ.head->next;PQ.head->next= temp ->next;if(PQ.end->next == temp)PQ.end->next = PQ.head;return temp;}/*出列操作*/Process ShortestProcess(Process_Queue PQ){if(IsEmpty(PQ)) //如果队列为空，返回{if(!Run_Now)return NULL;elsereturn Run_Now;}Process temp,shortest,prev;int min_time;if(Run_Now) //如果当前有进程正在执行，{shortest = Run_Now; //那么最短进程初始化为当前正在执行的进程，min_time = Run_Now->PB.remain_time;}else//如果当前没有进程执行，{shortest = PQ.head->next; //则最短进程初始化为队列中第一个进程min_time = PQ.head->next->PB.remain_time;}temp = PQ.head;prev = temp;while(temp->next)if(temp->next->PB.remain_time <min_time) //如果当前进程的剩余时间比min_time短，{shortest = temp->next; //则保存当前进程，min_time = shortest->PB.remain_time;prev=temp; //及其前驱}temp=temp->next;}if(shortest == PQ.end->next) //如果最短剩余时间进程是队列中最后一个进程，PQ.end->next = prev; //则需要修改尾指针指向其前驱prev->next = shortest->next; //修改指针将最短剩余时间进程插入到队头return shortest;}/*调度最短剩余时间的进程至队头*/void Run(){Run_Now->PB.remain_time--; //某一时间运行它的剩余时间减return;}/*运行函数*/void Wait(){return ;}int sum(int array[],int n){int i,sum=0;for(i=0;i<n;i++)sum+=array[i];return sum;}int main(){PQ.head = (Process)malloc(sizeof(_Block));PQ.end = (Process)malloc(sizeof(_Block));Run_Now = (Process)malloc(sizeof(_Block));Run_Now =NULL;InitQueue(PQ);int i,N,Total_Time=0; //Total_Time为所有进程的执行时间之和printf("请输入计算机中的进程数目:\n");scanf("%d",&N);Process *P,temp;P = (Process*)malloc(N*sizeof(Process));int *wt,*circle_t;wt =(int*)malloc(N*sizeof(int));circle_t =(int*)malloc(N*sizeof(int));for(i=0;i<N;i++){P[i] = (Process)malloc(sizeof(_Block));P[i]->PB.number =i+1;P[i]->next =NULL;wt[i] =0;circle_t[i] =0;printf("输入第%d个进程的到达时间及剩余执行时间:\n",i+1);scanf("%d %d",&P[i]->PB.arrive_time,&P[i]->PB.remain_time);}for(i=0;i<N;i++)Total_Time+=P[i]->PB.remain_time;printf("\n进程按顺序运行依次为:\n");i=0;int k=0;for(t=0;;t++){if(Run_Now) //如果当前有进程正在执行{Run();if(t == P[i]->PB.arrive_time) //如果当前时间正好有进程进入{if(P[i]->PB.remain_time < Run_Now->PB.remain_time){temp = P[i];P[i] = Run_Now;Run_Now = temp; //则调度它至运行队列中，Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}EnQueue(PQ,P[i]); //并将当前运行进程重新插入队列中P[i]->PB.Tp=t;k++;i=(i+1)>(N-1)?(N-1):(i+1);}if(Run_Now->PB.remain_time == 0) //如果当前进程运行结束，{Run_Now->PB.To=t; //进程运行结束的时间circle_t[Run_Now->PB.number-1] +=t-Run_Now->PB.arrive_time;free(Run_Now); //则将它所占资源释放掉，Run_Now =NULL; //并修改Run_Now为NULLRun_Now = ShortestProcess(PQ); //从就绪队列中调出最短剩余时间进程至队头，if(!Run_Now) //如果队列为空，转为等待状态{if(IsEmpty(PQ) && k >= N) break;Wait();continue;}else{Run_Now->PB.Tc=t;wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp;printf("%d ",Run_Now->PB.number);}}}else//如果当前运行进程为空，那么{if(t == P[i]->PB.arrive_time) //如果正好这时有进程入队{k++;EnQueue(PQ,P[i]);Run_Now = DeQueue(PQ); //则直接被调入运行队列中Run_Now->PB.Tp=t;Run_Now->PB.Tc=t;printf("%d ",Run_Now->PB.number);i=(i+1)>(N-1)?(N-1):(i+1);}else{Wait();continue;}}}printf("\n");printf("平均等待时间是:\n%f\n",((float)sum(wt,N))/N);printf("平均周转时间是:\n%f\n",((float)sum(circle_t,N))/N);return 0;}//////////////////////////////////////////////////////【Process.cpp代码如下：】#include<iostream>#include<string>using namespace std;class Process{public:string ProcessName; // 进程名字int Time; // 进程需要时间int leval; // 进程优先级int LeftTime; // 进程运行一段时间后还需要的时间};void Copy ( Process proc1, Process proc2); // 把proc2赋值给proc1 void Sort( Process pr[], int size) ; // 此排序后按优先级从大到小排列void sort1(Process pr[], int size) ; // 此排序后按需要的cpu时间从小到大排列void Fcfs( Process pr[], int num, int Timepice); // 先来先服务算法void TimeTurn( Process process[], int num, int Timepice); // 时间片轮转算法void Priority( Process process[], int num, int Timepice); // 优先级算法void main(){int a;cout<<endl;cout<<" 选择调度算法："<<endl;cout<<" 1: FCFS 2: 时间片轮换 3: 优先级调度 4: 最短作业优先 5: 最短剩余时间优先"<<endl;cin>>a;const int Size =30;Process process[Size] ;int num;int TimePice;cout<<" 输入进程个数:"<<endl;cin>>num;cout<<" 输入此进程时间片大小: "<<endl;cin>>TimePice;for( int i=0; i< num; i++){string name;int CpuTime;int Leval;cout<<" 输入第"<< i+1<<" 个进程的名字、cpu时间和优先级:"<<endl;cin>>name;cin>> CpuTime>>Leval;process[i].ProcessName =name;process[i].Time =CpuTime;process[i].leval =Leval;cout<<endl;}for ( int k=0;k<num;k++)process[k].LeftTime=process[k].Time ;//对进程剩余时间初始化cout<<" ( 说明: 在本程序所列进程信息中，优先级一项是指进程运行后的优先级!! )";cout<<endl; cout<<endl;cout<<"进程名字"<<"共需占用CPU时间 "<<" 还需要占用时间 "<<" 优先级"<<" 状态"<<endl;if(a==1)Fcfs(process,num,TimePice);else if(a==2)TimeTurn( process, num, TimePice);else if(a==3){Sort( process, num);Priority( process , num, TimePice);}else// 最短作业算法，先按时间从小到大排序，再调用Fcfs算法即可{sort1(process,num);Fcfs(process,num,TimePice);}}void Copy ( Process proc1, Process proc2){proc1.leval =proc2.leval ;proc1.ProcessName =proc2.ProcessName ;proc1.Time =proc2.Time ;}void Sort( Process pr[], int size) //以进程优先级高低排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.leval<pr[j-1].leval){pr[j] = pr[j-1];j--;}pr[j] = temp;} // 直接插入排序后进程按优先级从小到大排列for( int d=size-1;d>size/2;d--){Process temp;temp=pr [d];pr [d] = pr [size-d-1];pr [size-d-1]=temp;} // 此排序后按优先级从大到小排列}/* 最短作业优先算法的实现*/void sort1 ( Process pr[], int size) // 以进程时间从低到高排序{// 直接插入排序for( int i=1;i<size;i++){Process temp;temp = pr[i];int j=i;while(j>0 && temp.Time < pr[j-1].Time ){pr[j] = pr[j-1];j--;}pr[j] = temp;}}/* 先来先服务算法的实现*/void Fcfs( Process process[], int num, int Timepice){ // process[] 是输入的进程，num是进程的数目，Timepice是时间片大小while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}else if(process[num-1].LeftTime==0){cout<<" 进程"<<process[num-1].ProcessName<< " 已经执行完毕!"<<endl;num--;}else{cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice; process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<""<<process[0].Time <<" ";cout<<process[0].LeftTime <<""<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<""<<process[s].Time <<" ";cout<<process[s].LeftTime <<""<<process[s].leval<<" 等待"<<endl; ;}} // elsecout<<endl;system(" pause");cout<<endl;} // while}/* 时间片轮转调度算法实现*/void TimeTurn( Process process[], int num, int Timepice){while(true){if(num==0){cout<<" 所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程"<<process[0].ProcessName<< " 已经执行完毕!"<<endl;for (int i=0;i<num;i++)process[i]=process[i+1];num--;}if( process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕! "<<endl;num--;}else if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<""<<process[0].Time <<" ";cout<<process[0].LeftTime <<""<<process[0].leval<<" 运行";cout<<endl;for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<""<<process[s].Time <<" ";cout<<process[s].LeftTime <<""<<process[s].leval;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待"<<endl;}Process temp;temp = process[0];for( int j=0;j<num;j++)process[j] = process[j+1];process[num-1] = temp;} // elsecout<<endl;system(" pause");cout<<endl;} // while}/* 优先级调度算法的实现*/void Priority( Process process[], int num, int Timepice){while( true){if(num==0){cout<< "所有进程都已经执行完毕!"<<endl;exit(1);}if(process[0].LeftTime==0){cout<<" 进程" << process[0].ProcessName <<" 已经执行完毕! "<<endl; for( int m=0;m<num;m++)process[m] = process[m+1]; //一个进程执行完毕后从数组中删除num--; // 此时进程数目减少一个}if( num!=1 && process[num-1].LeftTime ==0 ){cout<<" 进程" << process[num-1].ProcessName <<" 已经执行完毕!"<<endl;num--;}if(process[0].LeftTime > 0){cout<<endl; //输出正在运行的进程process[0].LeftTime=process[0].LeftTime- Timepice;process[0].leval =process[0].leval-1;cout<<" "<<process[0].ProcessName <<" "<<process[0].Time <<" ";cout<<process[0].LeftTime <<""<<process[0].leval<<" 运行";cout<<endl; // 输出其他进程for(int s=1;s<num;s++){cout<<" "<<process[s].ProcessName <<" "<<process[s].Time <<" ";cout<<process[s].LeftTime <<""<<process[s].leval ;if(s==1)cout<<" 就绪"<<endl;elsecout<<" 等待 "<<endl;}} // elseSort(process, num);cout<<endl;system(" pause");cout<<endl;} // while}。

进程调度算法实验报告

操作系统实验报告（二）实验题目：进程调度算法实验环境：C++实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较各种算法的性能优劣。

实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。

设计分析：程序流程图：1.先来先服务算法2.短进程优先算法3.时间片轮转调度算法实验代码：1.先来先服务算法#include <iostream.h>#define n 20typedef struct{int id; //进程名int atime; //进程到达时间int runtime; //进程运行时间}fcs;void main(){int amount,i,j,diao,huan;fcs f[n];cout<<"请输入进程个数:"<<endl;cin>>amount;for(i=0;i<amount;i++){cout<<"请输入进程名，进程到达时间，进程运行时间:"<<endl; cin>>f[i].id;cin>>f[i].atime;cin>>f[i].runtime;}for(i=0;i<amount;i++) //按进程到达时间的先后排序{ //如果两个进程同时到达，按在屏幕先输入的先运行for(j=0;j<amount-i-1;j++){ if(f[j].atime>f[j+1].atime){diao=f[j].atime;f[j].atime=f[j+1].atime;f[j+1].atime=diao;huan=f[j].id;f[j].id=f[j+1].id;f[j+1].id=huan;}}}for(i=0;i<amount;i++){cout<<"进程:"<<f[i].id<<"从"<<f[i].atime<<"开始"<<","<<"在"<<f[i].atime+f[i].runtime<<"之前结束。

操作系统进程调度算法模拟实验

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

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

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

实验一模拟实现进程调度算法

实验一模拟实现进程调度算法实验一进程调度算法的模拟实现(4小时)①，实验目的a，进程调度是处理器管理的核心内容观察和理解操作系统的进程调度方法，并通过一个简单的进程调度模拟程序的实现，加深对进程控制块、进程队列、进程调度算法和进程切换的理解，理解和理解各种调度算法的具体实现方法b，提高实际编程能力，为今后的软件开发工作打下坚实的基础。

(2)实验内容a，设计进程控制块的PCB表结构，模拟并实现进程调度算法:FIFO、静态优先级调度、时间片轮换调度、短进程优先级调度算法、多级反馈队列调度(实现静态优先级调度算法和短流程优先级调度算法)b，编写一个进程调度模拟器仿真程序只对印刷电路板进行相应的调度仿真操作，不需要实际程序。

c、进程名称、进程状态、进程运行时间、进程优先级和用户输入的其他数据(通过文件输入)③、实验要求a，采用模块化设计思想进行设计b，给出了主要功能和各算法功能的流程图c，学生可以根据自己的情况选择自己想要使用的算法(例如，使用冒泡法编写程序来实现短流程优先级调度的算法)d，进程调度模拟器只在印刷电路板上进行相应的调度模拟操作，不需要实际程序(4)运行结果a，给出该流程的调度模拟操作排序结果⑤提示a，每个进程可以有三种状态，并假设初始状态为就绪状态为了便于处理，程序中的进程运行时间是以纳秒计算的C，每个进程的优先级或循环时间以及进程需要运行的初始纳秒值都由用户给出。

在优先级算法中，采用静态优先级在时间片旋转算法中，采用可变时间片并由用户给出e。

采用先进先出策略解决优先级一致性问题。

f，输入:进程流文件(文本文件)，它存储一系列要执行的进程，每个进程包括四个数据项:进程名、进程状态(1就绪2等待3运行)、时间优先级(最高级别0)g，输出:流程执行流程的平均等待时间⑥分析和讨论a和各种进程调度算法的异同？b，如何理解“算法+数据结构=编程”？如何理解“数据结构总是服务于功能的实现”？⑦参考代码见附录A1:1，实验报告50%，程序设计30%，出席率20%；3.每个实验得100分，两个实验的平均分就是最终的实验结果。

实验六进程调度算法模拟实现

实验六进程调度算法模拟一、实验类型本实验为设计性实验。

二、实验目的与任务1）通过对进程调度算法的设计，加深对进程调度原理的理解，进一步掌握各种调度算法的特征；2）针对你所选择的算法的模拟情况进行对算法进行评价(通过比较计算平均周转时间和平均带权周转时间)。

三、预习要求1）理解各调度算法原理；2）理解平均周转时间和平均带权周转时间四、实验基本原理（1）设计程序模拟先来先服务（FCFS）进程调度、短进程优先调度（SJF）、高响应比优先调度（HRN）、最高优先权优先调度、时间片轮转调度等算法，要求比较所选算法的平均周转时间和平均带权周转时间，可选用C 、C++或Java 等编程语言中任一种语言。

（2）自设模拟的情景，但要求至少包括四个进程调度。

注意，问题情境最好允许用户设定。

即当程序启动时，应允许用户可以选择不同的调度算法；然后用户从控制台输入各个进程的信息，进程信息输入完毕后，就开始了进程调度。

参考代码如下：（3）认真完成实验报告，同时要求说明模拟的情境、数据结构的使用，程序流程图或步骤，并给出实验结果分析和实验小结；五、实验仪器与设备（或工具软件）实验设备：计算机一台；六、实验内容[参考代码如下]#include"stdio.h"#include"stdlib.h"void dayin();typedef struct PCB //定义进程控制块{char num[2]; //进程号char state; //运行状态int tijiaotime; //提交进程时间int starttime; //进程开始时间int finishtime; //结束时间int needtime; //运行需要时间float roundtime; //周转时间float weightroundtime; //带权周转时间struct PCB *next; //指向下个进程}pcb;int time=10000,n; //计时器（假设当前时间）float sumroundtime=0,sumweightroundtime=0,avgroundtime,avgweightroundtime; //定义全局平均变量。

实验四.进程调度doc

实验四.进程调度doc实验四、进程调度1、实验目的进程是操作系统中最基本、最重要的概念，进程调度是操作系统的核心模块。

本实验要求学生独立地用 C 或C++语言编写一个简单的进程管理程序，其主要部分是进程调度。

调度算法可由学生自行选择，如基于先进先出调度算法、时间片轮转调度算法、动态优先级的调度算法或多级反馈队列调度算法。

通过本实验进一步了解系统如何组织、创建进程。

2、实验内容：（1,2必做）以链式结构组成空闲PCB 栈，以双向链式结构组成进程的就绪队列和睡眠队列，模拟LINUX的进程管理程序，实现以下操作（可用键盘命令或由产生的随机数决定操作和参数）。

1）．创建一个新进程：如pid=newp(pri,size,time)，申请空闲PCB和所需内存，填写PCB的各项初始数据，将该PCB 送入就绪队列。

2）．调度和执行：自己设计调度算法，在就绪队列中选择一个进程，使其运行若干个单位时间。

要求在运行期间进程的p_cpu、p_pri 和p_time 要变化，并在适当的时机重新调度。

3）．进程睡眠：进程运行时可调用自编的睡眠函数，主动进入睡眠状态，并转调度程序。

也可由操作使进程强迫挂起，睡眠适当时间。

进程睡眠时要在PCB 中记录睡眠原因和优先数。

4）．进程的唤醒：根据睡眠原因，将相应的进程从睡眠队列中调出，转入就绪队列。

如该进程优先级比现运行进程优先级高，转调度程序。

5）．进程的终止：如一个进程运行完作业所需的时间，或者用操作杀死该进程，该进程就终止，释放所占用的内存和PCB资源，转调度程序。

3、实验报告要求：要说明调度算法和程序主要的数据结构，画出系统的总体框图。

在执行了每一种操作后，记录输出进程状态和参数的变化情况，以便于观察进程的调度过程。

一、设计思想实现多级犯规队列调度算法，多级调度队列分别高优先级（H或h）队列、中优先级（M或m）队列和低优先级的（L或l）队列。

（1）当一个进程在一次运行中用完了时间片（100单位时间）还未完成任务或没有进入阻塞状态，降低其优先级，进入低一级的调度队列。

实验06进程调度算法模拟

实验06进程调度算法模拟引言：进程调度算法是操作系统中非常重要的一部分，它决定了进程如何被安排执行的顺序和时间分配。

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

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

实验目标：1.理解进程调度算法的设计原理和特点；2.掌握几种常见的进程调度算法，并能够使用程序模拟它们；3.对比不同的进程调度算法，分析它们的优缺点和适用场景。

实验内容：本实验将模拟三种常见的进程调度算法：先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）调度算法。

1.先来先服务（FCFS）调度算法：FCFS调度算法是最简单的一种调度算法，按照进程到达的顺序进行调度，先到先执行。

当一个进程执行完成后，才能执行下一个进程。

它适用于执行时间较短的进程，但当执行时间较长的进程到达时，会导致平均等待时间增加。

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

当一个进程抵达时，如果它的执行时间比当前正在执行的进程短，那么立即执行它，否则将其放到就绪队列的队尾。

这样做的目的是为了减少平均等待时间。

然而，SJF调度算法存在着无法预测执行时间导致的不公平问题。

3.时间片轮转（RR）调度算法：RR调度算法是为了解决长作业等待时间长的问题而设计的。

它将每个进程分配一个时间片，当一个进程的时间片用完后，将其放到就绪队列的末尾，执行下一个进程。

这样可以确保每个进程都有机会执行，并且减少了长作业的等待时间。

然而，时间片过小可能会导致频繁的切换，降低系统的效率。

实验步骤：1.定义进程类，包含进程名、到达时间、执行时间和优先级等属性；2.创建进程队列，并根据到达时间对进程进行排序；3.分别使用FCFS、SJF和RR算法进行模拟调度，计算平均等待时间和平均周转时间；4.比较三种算法的性能指标，并分析它们的优劣和适用场景。

实验结果与分析：通过模拟实验，我们可以得到每种算法的平均等待时间和平均周转时间。

(完整word版)操作系统作业调度实验报告-多道批处理

计算机学院计算机科学与技术专业07 班姓名学号教师评定_________________实验题目作业调度一、实验目的本实验要求学生模拟作业调度的实现，用高级语言编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。

二、实验内容和要求1、为单道批处理系统设计一个作业调度程序(1)、编写并调试一个单道处理系统的作业调度模拟程序。

(2)、作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）的调度算法。

(3)、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU时限等因素。

(4)、每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。

每个作业的最初状态总是等待W。

(5)、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，并比较各种算法的优缺点。

2、模拟批处理多道操作系统的作业调度（1）写并调试一个作业调度模拟程序。

（2）作业调度算法：分别采用先来服务（FCFS）调度算法。

（3）在批处理系统中，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求，所需要的资源是否得到满足。

作业调度程序负责从输入井选择若干个作业进入主存，为它们分配必要的资源，当它们能够被进程调度选中时，就可占用处理机运行。

作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。

但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业要求，那么，作业调度必须按一定的算法在这些作业中作出选择。

(完整word版)进程调度模拟程序设计

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

二、实验内容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。

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

进程调度算法模拟-

进程调度算法模拟专业：计算机科学与技术学号：120602105姓名：黄凡实验日期：2014年12月2日一.算法综述调度也称dispatcher，这是内核的主要职责之一就是决定该轮到哪个任务运行了多数实时内核是基于优先级调度算法的每个任务根据其重要程度的不同被赋予一定的优先级，基于优先级的调度法指CPU 总是让处在就绪态的优先级最高的任务先运行，然而究竟何时让高优先级任务掌握CPU 的使用权，有两种不同的情况这要看用的是什么类型的内核是非占先式还是占先式的内核一个良好的任务调度算法应该主要体现在以下几个方面：1.公平保证每个进程得到合理的CPU 时间2.高效使CPU 保持忙碌状态即总是有进程在CPU 上运行3.响应时间使交互用户的响应时间尽可能短4.周转时间使批处理用户等待输出的时间尽可能短5.吞吐量使单位时间内处理的进程尽可能多很显然在任何操作系统中这几个目标不可能同时达到所以不同的。

操作系统会在这几个方面中做出相应的取舍从而确定自己的调度算法，常用的处理机调度算法有：先来先服务FCFS短作业优先SJF优先级时间片轮转法多级队列法多级反馈队列法先来先服务：FCFS 是最简单的CPU 调度算法，即按进程到来的先后次序进行调度，这样在系统中等待时间最长的进程被优先调度，而不管其所需运行时间的长短。

作业优先SJF 算法是指当CPU 可供使用时SJF 算法把CPU 分给需要运行时间最短的进程。

多级队列调度算法：把就绪队列划分成几个单独的队列一般根据进程的某些特性如内存大小和进程类型永久性地把各个进程分别链入其中某一个队列中，每个队列都有自己的调度算法，此外在各个队列之间也要进行调度。

通常采用固定优先级的抢占式调度，例如某系统中有 5 个队列，各个队列的优先级自上而下降低，只有当前3 个队列中都为空的时候队列4 中的进程才可以运行，而当队列4 中的进程在运行时，如果队列1 中进入了一个就绪进程，则队列4 中的进程要立刻让出CPU 使用权。

(完整word版)设计一个有 N个进程共行的进程调度程序

一、目的要求用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．二、实验题：设计一个有 N个进程共行的进程调度程序。

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

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

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

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

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

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

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

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

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

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

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

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

三、实验参考：调度算法的流程图如下 :进程调度源程序如下：jingchendiaodu.cpp#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/{p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/ { /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if(insert==0) first->link=p;}}input() /* 建立进程控制块函数*/{int i,num;clrscr(); /*清屏*/printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n qname \t state \t super \t ndtime \t runtime \n"); printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/ while(pr!=NULL){disp(pr);pr=pr->link;}}destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ {printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}main() /*主函数*/{int len,h=0;char ch;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 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}四．选做题：．编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。

操作系统进程调度文档

实验一进程调度实验学时：2学时实验类型：设计实验要求：必修一、实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。

二、实验内容1．优先权法、轮转法简化假设1）进程为计算型的（无I/O）2）进程状态：ready、running、finish3）进程需要的CPU时间以时间片为单位确定2．算法描述1）优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。

2）轮转法三、流程图产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？撤销该进程就绪队列为空吗？ =轮转时间片数？NY Y Y 结束 N 开始键盘输入进程数n ，和调度方法的选择优先权法？轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？结束N YY四、实验要求1．产生的各种随机数的取值范围加以限制，如所需的CPU时间限制在1~20之间。

2．进程数n不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法6．若有可能请在图形方式下，将PCB的调度用图形成动画显示。

实验代码：#include <stdio.h>#include<iostream.h>#include<stdlib.h>#include"windows.h"struct PCB{int pi;int pri;int size;int state;//0阻塞，1就绪，2挂起,3运行,4不在内存int time;struct PCB *next;}neicun[20],*head,*last;int creat(int n){PCB *p;int i,pi,pri,size,state=1,time,flag=0;if(n>20)cout<<"系统内存已满!"<<endl;else{for(i=0;i<n;i++){cout<<"输入进程"<<i<<"的名字"<<endl;cin>>pi;neicun[i].pi=pi;cout<<"输入进程"<<i<<"的大小"<<endl;cin>>size;neicun[i].size=size;neicun[i].state=state;pri=0+(int)9*rand()/(RAND_MAX+1);neicun[i].pri=pri;time=(rand() % (8-1))+ 1 + 1;neicun[i].time=time;}flag=1;head=NULL;head=new PCB;last=head;for(int i=0;i<n;i++){p=new PCB;*p=neicun[i];//p->pi=neicun[i].pi;//p->pri=neicun[i].pri;//p->size=neicun[i].size; //p->state=neicun[i].state; //p->time=neicun[i].time; last->next=p;last=p;p->next=NULL;}}return flag;}void queue(int n){int exchange=n,bound=0; PCB *f,*l,*m;while(exchange){bound=exchange;exchange=0;f=head;l=f->next;for(int j=0;j<bound-1;j++){f=l;l=l->next;if((l->pri)>(f->pri)){m=new PCB;m->pi=l->pi;m->pri=l->pri;m->size=l->size; m->state=l->state; m->time=l->time;l->pi=f->pi;l->pri=f->pri;l->size=f->size; l->state=f->state; l->time=f->time;f->pi=m->pi;f->pri=m->pri;f->size=m->size; f->state=m->state; f->time=m->time;m->next=NULL;exchange=j+1;}}}}void print1(int n){int i;for(i=0;i<n;i++){cout<<neicun[i].pi<<neicun[i].pri<<neicun[i].size<<neicun[i].state<<neicun[i].time<<endl;}}void print2(PCB *head){PCB *p;p=head->next;while(p){cout<<p->pi<<p->pri<<p->size<<p->state<<p->time<<endl;p=p->next;}}void run(PCB *head){PCB *p;p=head->next;p->state=3;cout<<"链首"<<p->pi<<"进程正在运行中!"<<endl;}int printrun(PCB *head){int count=0;PCB *p;p=head->next;if(p->state==3){cout<<p->pi<<"进程时间片到!"<<endl;p->time=(p->time-1);p->pri=(p->pri-3);cout<<p->pi<<"进程剩余时间为"<<p->time<<endl;cout<<p->pi<<"进程优先级为"<<p->pri<<endl;if(p->time==0){p->state=4;p->pri=-1000;cout<<p->pi<<"进程运行完毕!"<<endl;count++;}else{cout<<p->pi<<"进程进入就绪等待!"<<endl;p->state=1;}}return count;}//________________________________________________________________struct PCB2{int pi;int state;//0阻塞，1就绪，2挂起,3运行,4不在内存int time;int zhanyt;struct PCB2 *next;}*first,*rear;int creat2(int n){int pi,state=1,time,zhanyt=0,flag=0;PCB2 *p;if(n>20)cout<<"内存已满!"<<endl;else{first=NULL;first=new PCB2;rear=first;for(int i=0;i<n;i++){p=new PCB2;cout<<"输入进程名:"<<endl;cin>>pi;p->pi=pi;p->state=state;time=(rand() % (8-1))+ 1 + 1;p->time=time;p->zhanyt=zhanyt;rear->next=p;rear=p;p->next=NULL;}flag=1;}return flag;}void print3(PCB2 *first){PCB2 *p;p=first->next;while(p){cout<<p->pi<<p->state<<p->time<<p->zhanyt<<endl;p=p->next;}}void run2(PCB2 *first){PCB2 *p;p=first->next;p->state=3;cout<<"链首"<<p->pi<<"进程正在运行中!"<<endl;}int runprint(PCB2 *first){int count=0;PCB2 *p;p=first->next;if(p->state==3){cout<<p->pi<<"进程时间片到!"<<endl;p->time=(p->time-1);p->zhanyt=(p->zhanyt+1);cout<<p->pi<<"进程剩余时间片为"<<p->time<<endl;cout<<p->pi<<"进程已占用CPU时间片数:"<<p->zhanyt<<endl;if(p->time==0){cout<<p->pi<<"进程运行完毕!"<<endl;first->next=p->next;count++;}else if((p->zhanyt)==(p->time)){p->zhanyt=0;p->state=1;first->next=p->next;rear->next=p;rear=p;cout<<p->pi<<"进程进入就绪等待!"<<endl; p->next=NULL;}else{cout<<p->pi<<"进程进入就绪等待!"<<endl;p->state=1;first->next=p->next;rear->next=p;rear=p;p->next=NULL;}}return count;}//----------------------------------------------------------------------- struct PCB3{int pi;int arrivet;int servert;int startt;int zhouzhuant;int dzhouzhuant;int size;int state;//0阻塞，1就绪，2挂起,3运行,4不在内存struct PCB3 *next;}*first1,*rear1;int creat3(int n){int pi,size,flag=0,state=1;PCB3 *p;if(n>20)cout<<"内存已满!"<<endl;else{first1=NULL;first1=new PCB3;rear1=first1;for(int i=0;i<n;i++){p=new PCB3;cout<<"输入进程名:"<<endl;cin>>pi;p->pi=pi;size=(rand() % (8-1))+ 1 + 1;p->size=size;p->state=state;rear1->next=p;rear1=p;p->next=NULL;}flag=1;}return flag;}void print4(PCB3 *first){PCB3 *p;p=first->next;while(p){cout<<p->pi<<p->size<<p->state<<endl;p=p->next;}}void run3(PCB3 *first){p=first->next;p->state=3;cout<<"链首"<<p->pi<<"进程正在运行中!"<<endl; }void printrun1(PCB3 *first){PCB3 *p;p=first->next;if(p->state==3){int j;j=p->size;for(int i=0;i<j;i++){cout<<p->pi<<"进程大小:"<<p->size<<endl;Sleep(1000);p->size=(p->size-1);}if(p->size==0)cout<<p->pi<<"进程运行完毕!"<<endl;first1->next=p->next;}}}//-------------------------------------------------------------------- void queue2(int n){int exchange=n,bound=0;PCB3 *f,*l,*m;while(exchange){bound=exchange;exchange=0;f=first1;l=f->next;for(int j=0;j<bound-1;j++){f=l;l=l->next;if((l->size)<(f->size)){m=new PCB3;m->pi=l->pi;m->arrivet=l->arrivet;m->servert=l->servert;m->startt=l->startt;m->zhouzhuant=l->zhouzhuant; m->dzhouzhuant=l->dzhouzhuant; m->size=l->size;m->state=l->state;l->pi=f->pi;l->arrivet=f->arrivet;l->servert=f->servert;l->startt=f->startt;l->zhouzhuant=f->zhouzhuant;l->dzhouzhuant=f->dzhouzhuant; l->size=f->size;l->state=f->state;f->pi=m->pi;f->arrivet=m->arrivet;f->servert=m->servert;f->startt=m->startt;f->zhouzhuant=m->zhouzhuant;f->dzhouzhuant=m->dzhouzhuant;f->size=m->size;f->state=m->state;m->next=NULL;exchange=j+1;}}}}void main(){int m,flag=1;while(flag){cout<<"*********进程调度****************"<<endl;cout<<"进程调度算法列表:"<<endl;cout<<"0:结束演示"<<endl;cout<<"1:动态优先权法"<<endl;cout<<"2:轮转法"<<endl;cout<<"3:先来先服务调度算法"<<endl;cout<<"4:短作业优先调度算法"<<endl;cout<<"*********************************"<<endl;cout<<"输入调度方法:"<<endl;cin>>m;switch(m){case 0:flag=0;break;case 1: { int n;cout<<"输入进程数:" <<endl;cin>>n;if(creat(n))cout<<n<<"个进程创建成功!"<<endl; queue(n);cout<<"进程已进入就绪队列!"<<endl; print1(n);print2(head);int lag=1,j=0,k=0;while(lag){run(head);Sleep(1000);j=printrun(head);k+=j;queue(n);print2(head);if(k==n)lag=0;}}break;case 2:{ int n;cout<<"输入进程数:" <<endl;cin>>n;if(creat2(n))cout<<n<<"个进程创建成功!"<<endl;cout<<"进程已进入就绪队列!"<<endl;print3(first);int lag=1,j=0,k=0;while(lag){run2(first);Sleep(1000);j=runprint(first);k+=j;print3(first);if(k==n)lag=0;}}break;case 3:{int n;cout<<"输入进程数:"<<endl;cin>>n;if(creat3(n))cout<<n<<"个进程创建成功!"<<endl;cout<<"进程已进入就绪队列!"<<endl;print4(first1);for(int i=0;i<n;i++){run3(first1);printrun1(first1);}}break;case 4:{int n;cout<<"输入进程数:"<<endl;cin>>n;if(creat3(n))cout<<n<<"个进程创建成功!"<<endl;print4(first1);queue2(n);cout<<"进程已进入就绪队列!"<<endl;print4(first1);for(int i=0;i<n;i++){run3(first1);printrun1(first1);}}default:;}}}编译结果：五、实验报告主要包括实验预习和实验报告两部分。