实验二 处理机调度
计算机操作系统-处理机调度实验报告(精品)

中南大学实验名称:处理机调度课程名称:计算机操作系统学生姓名盛希玲学号 ********** 学院信息科学与工程学院专业班级电子信息工程0602 完成时间 2008年10月12日目录一实验内容 (2)二实验目的 (2)三实验题目 (2)四基本思想 (2)五算法分析 (2)六流程图 (3)七算法描述 (4)八运行输出结果 (9)一实验内容选择一个调度算法,实现处理机调度。
二实验目的多道系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度,以加深了解处理机调度的工作。
三实验题目设计一个按优先权调度和时间片轮转算法实现处理机调度的程序。
四基本思想先选择时间片的个数和每个时间片需要的时间,正在运行的进程每运行一秒其优先权数目加一,即其优先权减小。
每个时间片运行结束后,选择进入时间片进程优先权数目最小的进程,开始下一个时间片的运行。
如果有进程运行结束,则离开,再在就绪队列中选择优先权数目最小的进程进入。
在运行期间,如果有新的进程来到,按优先权大小放入就绪队列中。
五算法分析定义一个结构体,此包含了PCB的信息:struct PCB{char PID[5]; /*进程名*/int needtime; /*要求运行的时间*/int cputime; /*已运行时间*/int priority; /*优先权(越小越高)*/int starttime; /*进入就绪队列的时间*/int overtime; /*运行完成的时间*/int state; /*状态:1就绪2运行3完成*/struct PCB *next;};子函数struct PCB *create(int num,int n)用来建立一个按优先级大小排列的就绪进程链表和一个按时间先后循序排列的将进入就绪进程的链表。
main()函数中用一while循环输出进入时间片的进程状态。
六流程图七算法描述#define NULL 0#define LEN sizeof(struct PCB)#include"stdio.h"#include"stdlib.h"struct PCB{char PID[5]; /*进程名*/int needtime; /*要求运行的时间*/int cputime; /*已运行时间*/int priority; /*优先权(越小越高)*/int starttime; /*进入就绪队列的时间*/int overtime; /*运行完成的时间*/int state; /*状态:1就绪2运行3完成*/struct PCB *next;};struct PCB *create(int num,int n)/*创建进程,并将进程按优先级顺序插入队列中*/ {struct PCB *head,*p,*p1,*p2;int i;head=NULL; /*头指针指零*/for(i=1;i<=num;i++) /*循环建立所有进程*/{printf("请输入第%d个进程的信息\n",i);p=(struct PCB *)malloc(LEN); /*开辟一个空间*/printf("进程名:"); /*输入进程名*/scanf("%s",p->PID);printf("要求运行的时间:"); /*输入要运行的时间*/scanf("%d",&p->needtime);p->cputime=0; /*占用处理机的时间赋为零*/printf("优先权:"); /*输入优先权*/scanf("%d",&p->priority);if(n==1)p->starttime=0; /*进入就绪队列的时间赋为零*/else{printf("进入就绪队列时间:"); /*输入进入就绪队列的时间*/scanf("%d",&p->starttime);}p->overtime=-1; /*运行没有结束所以运行完成的时间赋为-1*/p->state=1; /*状态赋为就绪状态*/p1=head; /*p1指针指向头指针*/if(head==NULL) /*如果头指针为零将头指针指向新建立的进程*/ {head=p;head->next=NULL;}else /*头指针不为零的情况*/{if(n==1)while(p1!=NULL&&p->priority>p1->priority) /*查找插入点*/{p2=p1;p1=p1->next;}elsewhile(p1!=NULL&&p->starttime>p1->starttime) /*查找插入点*/{p2=p1;p1=p1->next;}if(head==p1) /*优先权的值最小作为表头*/{p->next=head;p2=head=p;}else /*否则的话插入*/{p2->next=p;p->next=p1;}}}return(head);}void main(){char now[5];int cho,num,num1,timepiece,time,i,j,k,flag,choo,clock=0;struct PCB*head,*head1,*over,*later,*l,*l1,*l2,*p,*p0,*p1,*p2,*q,*q1,*q2,*q3;over=NULL;printf("初始化进程...\n");printf("输入总的就绪进程数:");scanf("%d",&num);head=create(num,1); /*建立就绪进程的链表*/printf("输入将会就绪的进程数:");scanf("%d",&num1); /*建立将会进入就绪进程的链表*/later=create(num1,2);printf("cpu是否开始运行:1是 2不是--");scanf("%d",&cho);if(cho==1) /*处理机开始进行调度*/{printf("现在的时间是:");scanf("%s",now);printf("显示所有就绪的进程:\n");p2=head;printf("进程名\t要求运行时间\t已运行时间\t优先权\t状态(1就绪2运行3结束)\n");while(p2!=NULL){printf("%s\t%d\t\t%d\t\t%d\t%d\n",p2->PID,p2->needtime,p2->cputime ,p2->priority,p2->state);p2=p2->next;}printf("请输入时间片总数:");scanf("%d",&timepiece);printf("请输入时间片的时间:");scanf("%d",&time);printf("运行正式开始!\n");head1=head;printf("\t\t进程名\t要求运行时间\t已运行时间\t优先权\t状态\n"); for(i=1;i<=timepiece;i++) /*将进入时间片运行的进程用头指针head1指示,并改变就绪进程头指针head的指向*/{if(head!=NULL){p=head;head=head->next;}else break;}p->next=NULL;while(head1!=NULL) /*就绪进程头指针不为零就循环*/{head1->state=2; /*状态:1就绪2运行3完成*/for(j=1;j<=time;j++) /*每个时间片所需时间的循环*/{clock++; /*定时器每秒加1*/if(later!=NULL&&clock==later->starttime)/*如果将进入就绪队列的进程时间到达加入就绪队列*/ {l=later;l1=head;later=later->next;if(head==NULL){head=l;head->next=NULL;}else{while(l1!=NULL&&l1->priority<=l->priority){l2=l1;l1=l1->next;}if(l1==head){l->next=head;head=l;}else{l2->next=l;l->next=l1;}}}flag=0;printf("\n%3d秒时间片第%d秒 ",clock,j);q=head1;if(head1->needtime>head1->cputime) /*以运行时间和优先权都加1*/ {head1->cputime++;head1->priority++;while(q) /*运行队列不为零输出其信息*/ {if(q==head1)printf("%s\t%d\t\t%d\t\t%d\t%d\n",q->PID,q->needtime,q->cputime,q->pr iority,q->state);elseprintf("\t\t %s\t%d\t\t%d\t\t%d\t%d\n",q->PID,q->needtime,q->cputim e,q->priority,q->state);q=q->next;}}if(head1->needtime==head1->cputime)/*运行完成将其放入over为头指针的链表中*/ {head1->state=3;head1->overtime=clock;if(over==NULL){over=head1;head1=head1->next;over->next=NULL;}elseif(over!=NULL&&head1!=NULL){p1=head1->next;p0=over;over=head1;over->next=p0;head1=p1;}flag=1;}if(flag==1) break;}if(flag==1) /*有进程结束的情况*/{if(head!=NULL) /*就绪队列不为零将优先权最高的放入运行链表中*/ {q1=head;head=head->next;q2=head1;while(q2!=NULL&&q2->priority<=q1->priority){q3=q2;q2=q2->next;}if(q2==head1){q1->next=head1;head1=q1;}else{q3->next=q1;q1->next=q2;}}}else /*无进程结束的情况,寻找优先权最高的运行*/{head1->state=1;q1=head1;head1=head1->next;q2=head1;while(q2!=NULL&&q2->priority<=q1->priority){q3=q2;q2=q2->next;}if(q2==head1){q1->next=head1;head1=q1;}else{q3->next=q1;q1->next=q2;}}}}printf("cpu结束运行!\n");printf("是否输出所有结束的进程:1是2不是--");scanf("%d",&choo);if(choo==1) /*输出所有完成运行的进程*/{printf("开始时间:%s\n",now);printf("进程名\t要求运行时间\t进入就绪队列的时间\t运行完成的时间\n");while(over!=NULL){printf("%s\t%d\t\t%d\t\t\t%d\n",over->PID,over->needtime,over->startt ime,over->overtime);over=over->next;}}}八运行输出结果初始化进程如右图显示现在的时间和所有就绪的进程输入时间片的总数和每个时间片的时间运行时显示的信息。
处理机调度实验

int timeSlice=2;
int hodeUpTime=5; int changePrio=0; void sort();
void changeRunPrio(); void changeReadyPrio();
//改变 run 的优先级函数声明 //改变 ready 的优先级函数声明
int randomPrio(double from,double to){ //产生 from 到 to 之间的随机数 return 1+(int)((to)*rand()/(RAND_MAX+from));
四、 实验总结(包括:实验效果分析、心得体会、遗留问题) 过本实验。了解了处理机调度的常用策略:优先权调度和时间片 轮转两种调度算法,熟悉了处理机调度算法的具体流程,同时也对操 作系统中处理机调度的概念有了更深的理解。 教师评语
成绩:
教室签名:
年
月
日
pid name status type prio res totalTime count runTime Finished…… 1005 pid5 0 1 2 6 12 1 12 1003 pid3 0 1 -1 6 12 1 12 1001 pid1 0 1 0 6 12 1 12 1004 pid4 0 0 -1 6 12 2 12 1002 pid2 0 0 -1 6 12 1 12
三、 实验结果(包括:运行结果、结果分析) 动态优先调度算法运行结束后结果:
pid name status type prio res totalTime count runTime
Rnning…… 1005 pid5 1 1 1 6 12 0 11 Finished…… 1003 pid3 0 1 -1 6 12 1 12 1001 pid1 0 1 0 6 12 1 12 1004 pid4 0 0 -1 6 12 2 12 1002 pid2 0 0 -1 6 12 1 12
操作系统实验之处理机调度实验报告

操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一,本次实验的主要目的是通过模拟不同的处理机调度算法,深入理解操作系统对处理机资源的分配和管理策略,比较不同调度算法的性能差异,并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 Python 38。
实验中使用了 Python 的相关库,如`numpy`、`matplotlib`等,用于数据生成、计算和图形绘制。
三、实验原理1、先来先服务(FCFS)调度算法先来先服务算法按照作业到达的先后顺序进行调度。
先到达的作业先被服务,直到完成或阻塞,然后再处理下一个到达的作业。
2、短作业优先(SJF)调度算法短作业优先算法选择预计运行时间最短的作业先执行。
这种算法可以有效地减少作业的平均等待时间,但可能导致长作业长时间等待。
3、时间片轮转(RR)调度算法时间片轮转算法将处理机的时间分成固定长度的时间片,每个作业轮流获得一个时间片的处理时间。
当时间片用完后,如果作业还未完成,则将其放入就绪队列的末尾等待下一轮调度。
4、优先级调度算法优先级调度算法为每个作业分配一个优先级,优先级高的作业先被执行。
优先级可以根据作业的性质、紧急程度等因素来确定。
四、实验内容与步骤1、数据生成首先,生成一组模拟的作业,包括作业的到达时间、预计运行时间和优先级等信息。
为了使实验结果更具代表性,生成了不同规模和特征的作业集合。
2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。
在实现过程中,严格按照算法的定义和规则进行处理机的分配和调度。
3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果:平均等待时间:作业在就绪队列中的等待时间的平均值。
平均周转时间:作业从到达系统到完成的时间间隔的平均值。
系统吞吐量:单位时间内完成的作业数量。
4、实验结果分析对每种调度算法进行多次实验,使用不同的作业集合,并记录相应的性能指标数据。
操作系统实验--处理机调度算法实现

当程序启动时,用户可以选择不同的调度算法。然后用户从控制台输入各个进程的信息,这些信息保存到进程容器中。进程信息输入完毕后,就开始了进程调度,每调度一次判断就绪队列是否为空,若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。
struct proc //定义进程结构体
{
char name[5];
int num;
int pri;
};
void main()//主函数
{ char ch;
struct proc pr[n];//声明结构体数组
int i,k,j;
int count=n;
for(i=0;i<n;i++)//输入5个进程
函数描述:
struct proc/*定义结构体内部包含进程的信息*/
{
char name[5]; /*定义进程名*/
int num; /*定义运行时间*/
int pri; /*定义优先权*/
};
Void main()/*主函数:掌控整个程序的运行过程,是程序的主体部分*/
struct proc pr[n];/*声明结构体数组*/
4.处理机调度总是选队首进程运行。采用动态优先数算法,进程每运行一次优先数就减“1”,同时将运行时间减“1”。
5.若要求运行时间为零,则将其状态置为“结束”,且退出队列。
6.运行所设计程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程
实验过程与实验结果(可包括实验实施的步骤、算法描述、流程、结论等)
for(k=1;k<n;k++)
实验二--单处理器系统的进程调度

实验二–单处理器系统的进程调度
简介
在操作系统中,进程调度是非常重要的一项工作。
进程调度负责将CPU分配
给各个进程,使得每个进程都能够有机会占用CPU资源。
在单处理器系统中,CPU只有一个,因此进程调度是非常重要的。
本次实验将会探究单处理器系统的进程调度,了解各种进程调度算法的实现和
比较,利用模拟操作系统的实验平台进行实验。
实验目的
1.了解进程调度的基本概念和实现方法;
2.学习多种进程调度算法,并比较其优缺点;
3.熟悉模拟操作系统的实验环境,学习如何将算法实现到具体的系统中。
实验内容
进程调度的基本概念
进程调度是指将CPU资源分配给各个进程的过程。
在单处理器系统中,当有
多个进程需要使用CPU时,操作系统需要进行进程调度,使得每个进程都能够得
到CPU资源。
在进程调度中,需要考虑各个进程的优先级、进程的状态和进程的等待时间等
因素。
根据不同的调度算法,可以根据这些因素来确定哪个进程应该先占用CPU。
进程调度算法比较
常见的进程调度算法包括:
1.先来先服务算法(FCFS)
2.短作业优先算法(SJF)
3.优先级调度算法
4.时间片轮转算法(RR)
下面将对这些算法进行比较和介绍。
先来先服务算法(FCFS)
先来先服务算法是最简单的一种进程调度算法。
该算法将按照进程的到达时间
的先后顺序进行调度,先到达的进程先得到CPU资源。
这种算法的优点是实现简单,适用于短作业和计算密集型进程。
缺点是无法充分利用CPU资源,导致长作业需要等待较长时间才能被调度,容易产生。
操作系统实验(处理机调度)

实验报告学院(系)名称:计算机与通信工程学院
【实验过程记录(源程序、测试用例、测试结果及心得体会等)】
一、实验效果:
1)打开主界面
2)初始化线程的时间和优先级,设置各个进程的时间和优先级。
3) 开始运行模拟线程。
绿色代表当前正在运行的线程。
二、实验代码
1)本实验使用Java的Swing绘制GUI,能够简单便捷的观察到处理机是如何根据时间和优先级来调度进程的。
代码结构:Swing绘制GUI:
2)Java ,Swing优点:
使用Swing的Jtable,JTabbedPane,能清楚的观察某一时刻各个进程的状态,以及正在运行哪个进程
3)模拟进程的数据结构:
自定义一个类ThreadBean,通过这种数据结构来代表进程。
这个类中有id,time(时间), property(优先级)的属性
4) 进程调度算法:
一、编写了一个SortList类,来完成调度算法
二、每一次通过遍历每个进程,找出优先级以及时间最多的进程,准备被处理机调度。
三、处理机调度后,这个线程的时间以及优先级减1
5)细节的处理
一、果没有进行初始设置进程的优先级和时间就点击了运行,会弹出提示框,不允许运行。
二、数据过滤,输入时间,优先级时只能填写整数,如果不是整数会进行过滤,提示。
三、扩展性
程序各个部分已经模块化,可以直接进行扩展。
通过选择不同的标签来显示几个不同的实验,完成三个实验均可以同时显示,不影响程序性能。
处理机调度实验报告

处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念,它涉及到如何合理地分配处理机资源以提高系统的运行效率。
本文将针对处理机调度进行实验,探讨不同调度算法对系统性能的影响。
二、实验目的本实验的目的是通过模拟不同的处理机调度算法,比较它们在不同负载下的性能表现,进而分析其优缺点,为实际操作系统的调度算法选择提供参考。
三、实验方法1. 实验环境本实验使用了一台配置较高的计算机作为实验环境,操作系统为Linux,处理器为Intel Core i7,内存为8GB。
2. 实验设置为了模拟不同的负载情况,我们使用了三个不同的测试程序:程序A、程序B和程序C。
程序A是一个计算密集型任务,程序B是一个I/O密集型任务,程序C是一个混合型任务。
3. 实验步骤首先,我们分别运行程序A、程序B和程序C,并记录它们的运行时间。
然后,我们使用不同的调度算法来调度这些任务,并记录它们的运行时间和系统资源利用率。
四、实验结果与分析1. 调度算法1:先来先服务(First-Come, First-Served,FCFS)FCFS算法按照任务到达的先后顺序进行调度,即先到先服务。
实验结果显示,在计算密集型任务下,FCFS算法表现较好,但在I/O密集型任务和混合型任务下,其性能明显下降。
这是因为在FCFS算法中,任务的执行顺序是固定的,无法根据任务的特性进行灵活调度。
2. 调度算法2:最短作业优先(Shortest Job First,SJF)SJF算法根据任务的执行时间进行调度,即执行时间最短的任务先执行。
实验结果显示,在计算密集型任务和混合型任务下,SJF算法表现较好,但在I/O密集型任务下,其性能较差。
这是因为在I/O密集型任务中,任务的执行时间不仅与计算量有关,还与I/O操作的耗时有关,因此SJF算法无法有效地进行调度。
3. 调度算法3:时间片轮转(Round Robin,RR)RR算法将处理机的运行时间划分为若干个时间片,每个任务在一个时间片内执行一定的时间,然后切换到下一个任务。
实验二 进程调度实验

实验二进程调度实验(2学时)一、实验目的用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。
二、实验内容:任务:设计一个有N个进程并行的进程调度程序进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和同优先级条件下先来先服务算法。
每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含如下信息:进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
调度算法的流程图2如下:图2调度算法的流程图三、实验步骤(1) 打开VC,选择菜单项file->new,选择projects选项卡并建立一个名为" ry2"的win32 console applicatoin工程;创建时注意指定创建该工程的目录;(2) 在工程中创建源文件" ry2.cpp":选择菜单项project->add to project->files,在选择框中输入自己想要创建的文件名,这里是" ry2.cpp";在接下来询问是否创建新文件时回答"yes";然后通过Workspace->FileView->Source Files打开该文件,在其中编辑源文件并保存.(3) 通过调用菜单命令项build->build all进行编译连接,可以在指定的工程目录下得到debug-> sy2.exe程序,运行sy2.exe。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二处理机调度一、实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,为了使系统中的各进程有条不紊地运行,必须选择某种调度策略,以选择一个进程占用处理机。
本次实验设计一个模拟单处理机调度的算法,以加深处理机调度的算法的理解。
二、实验要求1.按照轮转(时间片)算法设计模拟调度程序。
2.输出进程的调度过程。
三、思路分析由于本实验是按照处理机调度算法模拟实现处理机的调度,与真正的处理机调度过程不完全相同,如没有实现中断,进程的运行也不是真正的运行,而是在屏幕上打印其运行时间等。
以下是实验的大致思路:(1)建立三个队列:PCB队列,就绪队列,完成队列。
PCB队列:保存将进入系统的进程。
(由于没有实现中断,所以将进入系统运行的进程必须在程序运行前给出)。
就绪队列:到达进程进入系统的时间,将该进程放入就绪队列,等待调度。
完成队列:将“运行”完的进程放入完成队列。
(2)进程运行过程是在屏幕上打印相关信息。
使用轮转算法调度的进程应打印的信息包括:进程占用处理机序列,该进程每次占用处理机的开始时间与结束时间。
可参考下图:(3)统计出进程的周转时间T和带权周转时间W。
四、流程图五、实验内容编写程序实现轮转算法的模拟调度程序。
(可参考FCFS算法的模拟调度程序。
//************************************************************************ ******////* 实验二处理机调度*////************************************************************************ ******//#include<stdio.h>#include<string.h>#include<iostream.h>#include<malloc.h>#define slice_time 10 //定义时间片的长度为10//定义进程控制块PCBstruct pcb{int id; //进程号int status; //进程状态0-Ready, 1-Run, 2-Finish int arrive_time; //进程到达时间int time; //估计运行时间int run_time; //已运行时间int wait_time; //等待时间int priority; //优先级struct pcb* next; //链接指针};#define length sizeof(struct pcb)int cur_time=0; //系统当前运行时间int num=0; //进程的个数struct pcb *ready_head=NULL;struct pcb *pcb_head=NULL;struct pcb *finish_head=NULL;/*读文件数据,将文件中给出的进程放入PCB队列,以便后续使用返回值:0-失败1-成功*/int readData(){FILE *fp;char fname[20];cout<<"注意:文件中应包含以下信息:\n";cout<<"进程ID 到达时间估计运行时间优先级\n";cout<<"并且应按到达时间顺序排列!\n\n";cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL)cout<<"错误,文件打不开,请检查文件名"<<endl;return 0;}else{//建立PCB链表struct pcb *p1, *p2;pcb_head=NULL;p1=p2=(struct pcb*)malloc(length);fscanf(fp,"%d %d %d %d",&p1->id,&p1->arrive_time,&p1->time,&p1->priority);p1->status=0; p1->run_time=0; p1->wait_time=0; //初始化while(!feof(fp)){num++;if(num==1){pcb_head=p1;p1->next=NULL;}elsep2->next=p1;p2=p1;p1=(struct pcb*)malloc(length);fscanf(fp,"%d %d %d %d",&p1->id,&p1->arrive_time,&p1->time,&p1->priority);p1->status=0; p1->run_time=0; p1->wait_time=0;}p2->next=NULL;free(p1);fclose(fp);return 1;}}//建立就绪队列(前提:PCB队列是按到达时间排序的)//返回值:0-就绪队列空1-就绪队列不空int readyProcess(){struct pcb *p1, *pready;p1=pcb_head;pready=ready_head;//将pready指向就绪队列最后一个结点if(pready){while(pready->next){pready=pready->next;}}/*将新到达进程插入就绪队列末尾*/while(p1){if(p1->arrive_time<=cur_time){if(pready){pready->next=p1;}if(ready_head==NULL){ready_head=p1;}pready=p1;p1=p1->next;pready->next=NULL;}else{pcb_head=p1; //确定新的PCB队列头if(ready_head){return 1; //就绪队列中有元素}else{return 0;}}}if(p1==NULL) //已经处理完PCB队列中的结点,将pcb队列头赋NULL {pcb_head=NULL;}if(ready_head){return 1; //就绪队列中有元素}else{return 0;}}/*轮转算法中时间片用完的进程插入就绪队列的末尾*///参数:p-插入的进程void insertReadyQueueByRR(struct pcb* p){struct pcb *pready;readyProcess(); //若有新进程进入系统,先将其放入就绪队列if(ready_head==NULL){ready_head=p;return;}pready=ready_head;//将pready指向就绪队列最后一个结点while(pready->next)pready=pready->next;pready->next=p;p->next=NULL;}//按先进先出的方法从就绪队列中取出一个就绪进程//返回值p-从队列中取出的进程0-就绪队列空,无进程取出pcb* getReadyProcessByFIFO(){struct pcb * p;if(ready_head){p=ready_head;ready_head=ready_head->next;return p;}elsereturn 0;}//按先来先服务算法模拟调度过程void runProcessByFCFS(){struct pcb *p, *pFinish=NULL;int t=0,t_sum=0;float w=0.0, w_sum=0.0;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<en dl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间周转时间带权周转时间"<<endl;ready_head=NULL;while(pcb_head||ready_head) //当系统中还有未“运行”完的进程,则循环{while(1) //一直循环,直到有进程进入系统,能从就绪队列中取出进程{if(readyProcess()){p=getReadyProcessByFIFO();break;}elsecur_time++;}p->status=1;cout<<p->id<<"\t\t"<<cur_time-p->arrive_time<<"\t\t"; //“运行”cur_time+=p->time; //修改系统当前“运行”时间//统计数据t=cur_time-p->arrive_time;t_sum+=t;cout<<t<<"\t\t";w=(float)t/p->time;w_sum+=w;cout<<w<<endl;p->status=2; //“运行”完if(finish_head==NULL) //“运行”完的进程加入完成队列finish_head=pFinish=p;elsepFinish->next=p;}p->next=NULL;cout<<"平均周转时间为:"<<(float)t_sum/num<<"\t"<<"平均带权周转时间为:"<<(float)w_sum/num<<endl;}//时间片轮转算法void runProcessByRR(){struct pcb *p, *pFinish=NULL;int t=0,t_sum=0;float w=0.0, w_sum=0.0;//输出RR算法执行流cout<<endl<<"*****************************************************"<<en dl;cout<<"RR算法执行流:"<<endl; cout<<"进程名本次开始时间本次结束时间周转时间带权周转时间"<<endl;ready_head=NULL;while(pcb_head||ready_head){while(1){if(readyProcess()){p=getReadyProcessByFIFO();break;}elsecur_time++;}p->status=1;cout<<p->id<<"\t\t"<<cur_time<<"\t\t";if(p->time-p->run_time>slice_time) //判断本次时间片用完,该进程是否能“运行”完{ //未“运行”完,插入就绪队列cur_time+=slice_time;p->run_time+=slice_time;cout<<cur_time<<endl;p->status=0;insertReadyQueueByRR(p);}else{ //“运行”完,插入完成队列cur_time=cur_time+p->time-p->run_time;cout<<cur_time<<"\t";//统计数据t=cur_time-p->arrive_time;t_sum+=t;cout<<t<<"\t\t";w=(float)t/p->time;w_sum+=w;cout<<w<<endl;p->status=2;if(finish_head==NULL)finish_head=pFinish=p;elsepFinish->next=p;p->next=NULL;}}cout<<"平均周转时间为:"<<(float)t_sum/num<<"\t"<<"平均带权周转时间为:"<<(float)w_sum/num<<endl;}void main(){if(readData())//runProcessByFCFS();runProcessByRR();}。