时间片轮转算法和优先级调度算法 C语言模拟实现

合集下载

时间片轮转调度算法(vc版)

时间片轮转调度算法设计目的:熟悉各种作业/进程调度算法的原理。

设计要求:用高级语言编写和调试多个实现不同的作业/进程调度算法的程序。

设计内容:基于时间片的轮转调度的模拟。

设计一个系统,提供一个界面,供用户输入等待调度的作业信息,显示调度的结果。

//实验名称:时间片轮转调度算法//实验日期:2008/07/16//实验者:qhu-hh//实验环境:Visual C++ 2008 ExPress Edition//编程语言:C语言//程序思想:先模拟建立进程就绪链表----置所有进程的到达时间Parrive_time均为0,依PCB链接顺序从第一个进程PCB开始,////////////////使Pid依次为1,2,3,4……;就绪链表中进程的数量,由常量MAXSIZE 控制; ////////////再模拟建立调度函数--------取表头PCB,修改进程执行时间,得到的新时间,即为剩余执行时间,当剩余时间小于或等于0////////////////时,将此进程的PCB取出,依完成的先后次序链到完成链表中,记录当前完成进程的完成时间Pend_time,////////////////同时修改就绪链表表头;////////////最后计算和打印里程调度信息-----计算出各进程周转时间及所有进程的平均周转时间。

#include"stdio.h"#include"malloc.h"#define TIMESLICE 2//时间片;#define MAXSIZE 4//就绪链中进程数量;typedef struct PCB//定义进程控制块的信息结构;{int Pid;//进程标识号;int Parrive_time;//进程到达时间;int Pend_time;//进程结束时间;int Pexe_time;//进程执行时间;struct PCB *next;//链向一下进程;}Node,*PNode;PNode PCurrent=NULL;//定义全局变量,指向当前进程的PCB;PNode PLast=NULL;//定义全局变量,指向上一进程PCB;PNode PHead=NULL;//定义全局变量,指向第一个进程的PCB;PNode PTail=NULL;//全局变量,指向就绪进程链的最后一个进程的PCB; int Exe_time[MAXSIZE];bool judge=0;//建立进程就绪链表int Create(){int i=1;if(PCurrent==NULL)//就绪链表为空时;{PCurrent=(PNode)malloc(sizeof(Node));PCurrent->Pid=i;i++;//标识新建进程;PCurrent->Parrive_time=0;//初始化;printf("输入执行用时:");scanf("%d",&(PCurrent->Pexe_time));//新进程执行用时; Exe_time[i-2]=PCurrent->Pexe_time;//进程执行用时备份; printf("\n");PCurrent->Pend_time=0;//初始化;PCurrent->next=NULL;//初始化;PHead=PTail=PCurrent;//改变链头、链尾指向;};do{PCurrent=(PNode)malloc(sizeof(Node));PCurrent->Pid=i;i++;//标识新进程;PCurrent->Parrive_time=0;//初始化printf("输入执行用时:");scanf("%d",&(PCurrent->Pexe_time));//新进程执行用时;Exe_time[i-2]=PCurrent->Pexe_time;//进程执行用时备份;printf("\n");PCurrent->Pend_time=0;//初始化;PCurrent->next=NULL;//初始化;PTail->next=PCurrent;//链到链尾PTail=PCurrent;//改变链尾if(i>MAXSIZE)judge=1;}while(judge==0);printf("%d,%d\n",PHead,PTail);return 0;}int Prin(PNode P)//检验就绪链表中各进程PCB储存信息;{printf("打印就绪链表:\n");while(P!=NULL)//就绪链空时,检验完;{printf("标识号:%d,执行时间:%d,到达时间:%d\n ",P->Pid,P->Pexe_time,P->Parrive_time);P=P->next;}printf("打印结束:\n");return 0;}//时间片轮转调度PNode Time_slice_dispatch(PNode PH,PNode PT){printf("I'm Time_slice_dispatch(1);\n");PNode P_Head=NULL;PNode P_Tail=NULL;////处理完成的进程组成的链表头结点和尾结点;//PCurrent=PLast=NULL;//PCurrent=PH;int Time_count=0;//计时器;printf("计时器初始值:%d\n",Time_count);//printf("%d",PH);while(PH!=NULL)//就绪进程链表未处理完时,继续处理; {Time_count+=TIMESLICE;//当前时间;printf("计时器值——————————————%d\n",Time_count); printf("进程 %d 要求执行时间:%d\n",PH->Pid,PH->Pexe_time);PH->Pexe_time-=TIMESLICE;//当前处理进程剩余时间;printf("进程 %d 剩余执行时间:%d\n",PH->Pid,PH->Pexe_time);if(PH->Pexe_time<=0)//当前目标进程执行完时的处理方式;{if(P_Head==NULL)//{P_Head=P_Tail=PH;//处于完成态的进程的链表的表头与表尾; P_Head->Pend_time=Time_count;//记录第一个结束的进程的结束时间;printf("first overti me:………………%d\n",Time_count); PH=PH->next;//改变就绪进程链表的表头;PT->next=NULL;P_Tail->next=NULL;//结束进程的表尾next的域置空;}else{P_Tail->next=PH;//链到结束进程的表尾;P_Tail=PH;P_Tail->Pend_time=Time_count;//记录结束时间;//P_Tail=PCurrent;//改变结束进程的表尾;PH=PH->next;//改变就绪进程链表的表头;//PCurrent=PCurrent->next;/*PLast->next=PCurrent->next;*/P_Tail->next=NULL;//结束进程的表尾next的域置空;}}else//当前目标进程未处理完时的处理方式;{PT->next=PH;//将当前未完成的进程链到就绪链表表尾;PT=PH;///////////////////////////////////////////////**** **********/////////////////////PLast=PCurrent;PH=PH->next;//PCurrent;//这两句是改变就绪进程链表的表头;PT->next=NULL;}}/*if(P_Head==NULL)printf("kkkkkkkkkkkkk");*/ int b;scanf("%c",&b);return P_Head;}int Print(PNode P_H){PCurrent=P_H;char c;double a=0;while(PCurrent!=NULL){printf("\n进程标识号:%d,执行时间:%d,结束时间%d,周转时间:%d",PCurrent->Pid,Exe_time[PCurrent->Pid-1],PCurrent->Pend_time,( PCurrent->Pend_time)-(PCurrent->Parrive_time));printf("\n");a+=(PCurrent->Pend_time)-(PCurrent->Parrive_time); PCurrent=PCurrent->next;}printf("平均周转时间:%f",a/MAXSIZE);scanf("%c",&c);printf("%c",c);return 0;}//////////////////////////////int main(){PNode head;Create();Prin(PHead);head=Time_slice_dispatch(PHead,PTail); Print(head);return 0;}。

进程调度算法(时间片轮转法+优先级)

进程调度算法时间片轮转法+优先级#include<stdio.h>#include<stdlib.h>#include<iostream.h>#define P_NUM 5//进程数#define P_TIME 50//时间片数//状态enum state{ready,//就绪execute,//执行block,//阻塞finish//结束};//PCB结构体struct pcb{char name[5];//进程名IDint priority;//优先级int cputime;//进程已占用时间片int alltime;//还需占用时间片state process;//进程状态pcb * next;//队列指针next，用来将多个进程控制块PCB链接为队列}PCB;pcb * get_process(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input ID and ALLTIME"<<endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));//申请cin>>q->name;cin>>q->alltime;//输入名字及时间q->cputime=0;//初始q->priority=P_TIME-q->alltime;//优先数越大，优先级越高q->process=ready;//就绪q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;}return p;}//输出过程void display(pcb *p){cout<<" ID"<<" "<<"CPUTIME"<<" "<<"ALLTIME"<<" "<<"PRIORITY"<<" "<<"STATE"<<endl;while(p){cout<<" "<<p->name<<" "<<p->cputime<<" "<<p->alltime<<" "<<p->priority<<" ";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;cout<<"\n";}}//状态的函数//结束int process_finish(pcb *q){int a=1;while(a&&q){a=a&&q->alltime==0;q=q->next;}return a;}//执行void cpuexe(pcb *q){pcb *t=q;int tp=0;while(q){if (q->process!=finish){q->process=ready;if(q->alltime==0){q->process=finish;}}if(tp<q->priority&&q->process!=finish){tp=q->priority;t=q;}q=q->next;}if(t->alltime!=0){t->priority-=3;//进程每运行一个时间片,优先数减3t->alltime--;t->process=execute;t->cputime++;}}//进程调度void process_way(){pcb * p;p=get_process();display(p);int cpu=0;while(!process_finish(p)){cpu++;cout<<"cputime:"<<cpu<<endl;cpuexe(p);display(p);}printf("All processes have finished"); }void main(){process_way();}结果：。

进程调度实验报告

进程调度实验报告一、实验目的。

本实验旨在通过对进程调度算法的模拟和实验，加深学生对进程调度原理的理解，掌握各种进程调度算法的特点和应用场景，提高学生的实际操作能力和分析问题的能力。

二、实验环境。

本次实验使用了C语言编程语言，通过模拟实现了先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和多级反馈队列（MFQ）四种进程调度算法。

三、实验过程。

1. 先来先服务（FCFS）调度算法。

先来先服务调度算法是一种非抢占式的调度算法，按照进程到达的先后顺序进行调度。

在本次实验中，我们通过模拟多个进程到达并排队等待CPU执行，观察其平均等待时间和平均周转时间。

实验结果表明，先来先服务调度算法适用于作业长度差异较大的情况，但容易产生“饥饿”现象。

2. 最短作业优先（SJF）调度算法。

最短作业优先调度算法是一种非抢占式的调度算法，按照作业执行时间的长短进行调度。

在本次实验中，我们通过模拟多个作业的执行时间，观察其平均等待时间和平均周转时间。

实验结果表明，最短作业优先调度算法能够最大程度地减少平均等待时间，但可能会导致长作业被“饿死”。

3. 时间片轮转（RR）调度算法。

时间片轮转调度算法是一种抢占式的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被放到队尾等待。

在本次实验中，我们通过模拟多个进程的执行和时间片的调度，观察其平均等待时间和平均周转时间。

实验结果表明，时间片轮转调度算法能够保证每个进程都能得到一定的执行时间，但可能会导致上下文切换频繁。

4. 多级反馈队列（MFQ）调度算法。

多级反馈队列调度算法是一种综合性的调度算法，根据进程的优先级和执行时间进行动态调整。

在本次实验中，我们通过模拟多个进程的执行和不同优先级队列的调度，观察其平均等待时间和平均周转时间。

实验结果表明，多级反馈队列调度算法能够兼顾短作业和长作业，提高了系统的整体性能。

四、实验总结。

通过本次实验，我们深入理解了不同进程调度算法的特点和适用场景。

抢占优先数调度算法和时间片轮转调度算法

#include <iostream>#include <stdlib.h>#include <cstring>#include <stdio.h>using namespace std;class pcb{public:char name;int prioORround;int cputime;int count;int needtime;char state;pcb *next;};class createpcb{public:pcb* newpcb(int count){pcb *apcb=new pcb;switch(count){case 1: apcb->name='a';break;case 2: apcb->name='b';break;case 3: apcb->name='c';break;case 4: apcb->name='d';break;case 5: apcb->name='e';break;default: cout<<"错误";}apcb->prioORround=45+rand()%5;apcb->cputime=0;apcb->count=0;apcb->needtime=10+rand()%5;apcb->state='R';apcb->next=NULL;return apcb;}private:pcb *p;};class print{public:void printf(pcb *ready,pcb *tail,pcb *finish,pcb *run){ p=run;cout<<"运行：";while(p->next!=NULL){p=p->next;cout<<p->name<<":"<<p->needtime<<"\t";}p=ready;cout<<"就绪：";while(p->next!=tail){p=p->next;cout<<p->name<<":"<<p->needtime<<"\t";}p=finish;cout<<"完成：";while(p->next!=NULL){p=p->next;cout<<p->name<<":"<<p->needtime<<"\t";}cout<<endl;}private:pcb *p;};class insert1{public:void insert(pcb *ready,pcb *tail){k=ct.newpcb(ready->count);ready->count+=1;p=ready;while(p->next!=tail&&p->next->prioORround>k->prioORround) p=p->next;k->next=p->next;p->next=k;}void insert(pcb *ready,pcb *tail,pcb *finish,pcb *run){ pt.printf(ready,tail,finish,run);k=run->next;k->prioORround-=3;k->cputime+=1;k->needtime-=1;k->state='R';k->next=NULL;run->next=NULL;if(k->needtime>0){p=ready;while(p->next!=tail&&p->next->prioORround>k->prioORround) p=p->next;k->next=p->next;p->next=k;}else{p=finish;while(p->next!=NULL)p=p->next;p->next=k;}}private:pcb *p;pcb *k;createpcb ct;print pt;};class insert2{public:void insert(pcb *ready,pcb *tail){k=ct.newpcb(ready->count);ready->count+=1;p=ready;while(p->next!=tail)p=p->next;k->next=p->next;p->next=k;void insert(pcb *ready,pcb *tail,pcb *finish,pcb *run){ pt.printf(ready,tail,finish,run);k=run->next;k->cputime+=2;k->needtime-=2;k->state='R';k->next=NULL;run->next=NULL;if(k->needtime>0){p=ready;while(p->next!=tail)p=p->next;k->next=p->next;p->next=k;}else{p=finish;while(p->next!=NULL)p=p->next;p->next=k;}}private:pcb *p;pcb *k;createpcb ct;print pt;};class firstin{public:void runs(pcb *ready,pcb *tail,pcb *run){if(ready->next!=tail){p=run;p->next=ready->next;p=p->next;ready->next=p->next;p->state='W';p->next=NULL;}private:pcb *p;};class prisch{public:prisch(){system("cls");='R';ready.count=1;='T';='F';ready.next=&tail;tail.next=NULL;finish.next=NULL;run.next=NULL;printf("\t\t\t优先级数调度\n");while(1){if(ready.count<=5)inst.insert(&ready,&tail);fir.runs(&ready,&tail,&run);inst.insert(&ready,&tail,&finish,&run);if(ready.next==&tail)break;}pt.printf(&ready,&tail,&finish,&run);getchar();}private:pcb *p;pcb ready;pcb tail;pcb finish;pcb run;insert1 inst;firstin fir;print pt;string algo;};class roundsch{public:roundsch(){system("cls");='R';ready.count=1;='T';='F';ready.next=&tail;tail.next=NULL;finish.next=NULL;run.next=NULL;printf("\t\t\t时间片轮转调度\n");while(1){if(ready.count<=5)inst.insert(&ready,&tail);fir.runs(&ready,&tail,&run);inst.insert(&ready,&tail,&finish,&run);if(ready.next==&tail)break;}pt.printf(&ready,&tail,&finish,&run);getchar();}private:pcb *p;pcb ready;pcb tail;pcb finish;pcb run;insert2 inst;firstin fir;print pt;};class menu{public:menu(){char c;bool z=false;while(1){system("cls");cout<<"\n\n\n\t\t*****抢占优先数调度算法和时间片轮转调度算法******\n\n"<<endl<<"\t\t*\t\t\t1,优先级数调度\t\t*\n"<<endl<<"\t\t*\t\t2,时间片轮转调度\t\t*\n"<<endl<<"\t\t*\t3,退出程序\t\t\t\t*\n"<<endl<<"\t\t*************************************************\ n"<<endl;if(z==true){cout<<"\t\t\t\t选择输入错误！"<<endl;z=false;}cout<<"\t\t请输入选择：";scanf("%c",&c);getchar();if(c=='1') prisch prisch;else if(c=='2') roundsch roundsch;else if(c=='3'){cout<<"\n\n\t\t\t";exit(0);}else z=true;}}};int main(int args,char** argv) {menu menu;return 0;}。

进程的调度实验报告(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("无效的调度算法选择。

优先级和时间片轮转调度

}
for(j=0;j<processnum;j++)
{q=processarray[j];
printf("\n检查进程%3c是否结束,进程当前状态:%3d",q->name,qgame is over!\n");
}
void main()
{
*processarray=createprocess(processarray);
#include "stdio.h"
#include <malloc.h>
#define max 100
#define etime 4
#define pfree 0
#define running 1
#define aready 2
#define blocking 3
typedef struct node
{
char name;
int status;
int pri;
int ptime;
int ax,bx,cx,dx;
int pc;
int psw;
}pcb;
pcb *processarray[max];
static int processnum;
pcb *createprocess(pcb *processarray[])组
q->status=aready;
totaltime-=etime;}
if(i<processnum-1)
i++;
else if(i==processnum-1)
i=0;
}}
void processStaPri(pcb *processarray[])

进程调度模拟设计——时间片轮转、优先级法程序

rq = new rnode;
rq->next = NULL;
rq->pname = dp->pname;
rq->ctime = dp->ctime;
rq->rtime = dp->rtime;
rq->stime = dp->stime;
{
if(dp->bb != 1)
{
dp->stime = letime;
dp->bb = 1;
}
if(dp->rrtime > time)
{
dp->etime = letime + time;
dp->rrtime = dp->rrtime - time;
nn = inhead->yx;
num = inhead->num;
bb = 1;
}
inhead = inhead->next;
}
if(bb == 1)
{
inhead = head->next;
while(inhead)
while(inhead)
{
if(inhead->bj != 1)
{
rq = new rnode;
rq->next = NULL;
rq->pname = inhead->pname;
rq->ctime = inhead->ctime;
rq->etime = letime;
rq->ztime = rq->etime - rq->ctime;

操作系统实验报告时间片轮转调度算法

操作系统实验报告时间片轮转调度算法“网络协议分析”实验4实验名称：用Ethereal研究DNS和HTTP协议实验目的：通过对捕获分组的分析和研究，加深对DNS协议和HTTP协议的工作原理和实现过程的理解。

实验环境：连网PC机，Ethereal网络协议分析软件实验步骤：1．安装Ethereal网络协议分析器。

2．打开Ethereal软件菜单中的Help->Contents，可学习Ethereal的使用方法。

3．开始捕获分组之前，清空客户端Web浏览器的高速缓存和DNS的高速缓存（命令为：ipconfig /flushdns）。

（想一想，为什么？）4．在Capture->Option里选择网卡类型；取消捕获分组的“混杂模式”；设置捕获过滤器为：“host 本机IP”，这样Ethereal就会只捕获从本机发出的和发往本机的分组。

5．点击Start启动协议分析器，用Ethereal捕获从本机发出和发往本机的分组。

6．在Web浏览器中输入URL（如.cn, 等，网页较简单）。

网页显示出来后，过一会儿停止捕获。

将跟踪文件保存在一个文件中。

实验结果分析：1．在跟踪列表框中找出请求网页时发出的DNS查询报文和回答报文，找出发起TCP连接的三次握手报文，找出HTTP请求报文和响应报文。

2．在协议框中找出各层协议，观察各层协议，并对照教材中DNS查询/回答报文结构和HTTP请求/响应报文结构对这些应用层报文进行分析，找出报文中各字段相应的内容，解释其含义和用途。

3．你的主机所用的DNS服务器的IP地址是多少？你的浏览器与DNS服务器之间使用传输层的什么协议进行通信？202.196.0.1DNS请求报文和应答报文的ID号一样吗？是什么？一样，0xc4a6你所请求网站的规范名是什么？mail.DNS服务器对你的域名解析请求在应答中给出了几个可用的IP地址？都是什么？2个，202.196.0.16，202.196.0.17和DNS服务器通信时，你的客户机使用的端口号是多少？DNS服务器使用的端口号是多少？64384，53你所请求Web服务器的IP地址是什么？其域名有几个层次（参看教材127页）？202.196.0.16 4个如果请求一个存在/不存在的网页，Web服务器分别会应答什么？ ??等等。

实验报告：模拟时间片轮转和优先级调度算法

1．实验内容（时间片轮转和优先级调度算法）（1）用C/C++/JA V A等语言来实现对N个进程采用优先权调度和时间片轮转调度。

（2）每个用来标识进程的进程控制块PCB用结构来描述，可能需要包括以下字段：⏹进程标识数ID。

⏹进程优先数PRIORITY，并规定优先数越小的进程，其优先权越高。

⏹进程已占用的CPU时间CPUTIME。

（初始都为0）⏹进程总的需要运行的时间ALLTIME。

⏹进程剩余运行时间remainTime, 当进程运行完毕时，remainTime变为0。

⏹进程的结束时间finishTime, 当进程结束时，“系统”的时间，计算周转时间用⏹进程状态STATE。

（就绪，运行，结束，根据需要决定是否使用）（3）输出：为观察进程调度是否正确，应输出进程的“执行”过程。

但是注意，我们是模拟进程执行，所以进程并不会真正“执行”，只是输出进程执行的先后顺序，和进程执行，结束的时间点。

对于时间片轮转，应该每个时间片输出一次----------------------------------------------------------Id pri cpuTime allTime0 4 3 41 32 60 4 3 4对于优先权调度，每次调度输出一次，进行的结束时间，依次输出调度进程的信息最后输出进程的周转时间，带权周转时间和系统平均周转时间等（4）实验数据：作业执行时间优先数----------------------1 10 32 6 13 2 44 4 55 8 2如果使用时间片调度算法，请自行设定时间片（如1，2等），并比较不同时间片下的周转时间等（5）实验设计：实验的小数据量使用数组或链表都可以，但考虑到真实的应用经常要删除和添加PCB，应该使用链表，如果涉及动态的插入删除，并且需要随时找最大/最小，也可以考虑用树/堆等其他数据结构（如C++中的优先级队列）。

（6）提高要求：给每个进程增加“到达”时间，重新计算优先级调度的各个结果，并验证结果是否正确2．实验目的通过模拟进程调度算法加深对进程调度的理解3．实验原理（1）周转时间：●概念：作业提交到操作系统开始到作业完成的时间包括四个部分：1、从外存中后备队列等待作业调度（高级调度）的时间2、进程在就绪队列等待进程调度（低级调度）的时间3、进程在cpu执行的时间4、进程等待IO操作完成的时间●计算：1、周转时间= 作业完成时间- 作业提交时间2、平均周转时间= 各作业周转时间之和/ 作业数3、带权周转时间= 作业周转时间/ 作业实际运行时间4、平均带权周转时间= 各作业带权周转时间之和/ 作业数（2）等待时间：1、进程/作业处于等待处理机状态时间之和2、对于进程：进程建立后等待被服务的时间之和3、对于作业：除了进程建立后的等待还包括作业在外存后备队列中等待的时间4、相应时间：用户提交请求到首次产生相应所用的时间（3）时间片轮转：●思想：公平、轮流为每个进程服务、每个进程在一定时间内得到相应●规则：按照到达就绪队列的顺序，轮流让各个进程执行一个时间片。

时间片轮转调度算法实验报告

******************************************** 测试数据2：2 3 11 2 35 4 2测试数据3：【结论】（结果）测试数据1的运行结果（截图）：测试数据2的运行结果：测试数据3的运行结果：源程序代码：#include"stdio.h"#include"stdlib.h" struct stud{错误分析：链表初始化排序过程中：指针p=Null时，不能执行q->arrive等命令；错误解决方法：将while(q->arrive<p->arrive &&q){t=q;q=q->next;}改为：while(q&&q->arrive<p->arrive){t=q;q=q->next;}2、进程运行时间大于时间片时，程序进入死循环：当进程所需时间等于时间片时，运行结果正确：进程运行时间大于时间片时，程序进入死循环：错误分析：进程所需剩余时间计算错误；错误修改：即进入死循环。

当进程所需时间小于时间片时，应立即跳出进程就绪对列。

错误修改：在output()子函数中p->rest=p->rest-slice;后面加上一个语句：if(p->rest<0)p->rest=0;实验运行结果为：实验的体会及收获：通过这次试验，我对处理机的调度算法---基于时间片轮转调度算法思想有了更深的理解;另外使我对链表的知识有了更深的理解，而且锻炼了我的思维能力，使我能更全面地思考问题，以后还需要多做些这方面的练习。

实验还需改进之处：为考虑进程所需时间小于时间片大小的情况，如：进程运行完一次时间片时间中断后，但下一个进程的提交时间要迟很多，这时候就会浪费很多时间等待，这是该程序还需改进的地方。

另外，本实验中的RR算法的时间片大小固定，所以实际是属于基本轮转法，还有种是时间片长短是变化的，即改进轮转法。

进程调度先来先服务时间片轮转法优先服务调度处理器调度免费下载 C或C++

}
}
}
return head;//返回队首
printf("输入第%d个进程的名字、到达时间、服务时间:\n",i+1);
scanf("%s%d%d",&p->name,&p->daodatime,&p->fuwutime);
p->shengyutime=p->fuwutime;
p->state="就绪";
head=rear=NULL;//初始化队首和队尾为空
printf("请输入进程数目：");
scanf("%d",&a);
for(i=0;i<a;i++)
{
p=(struct shijian*)malloc(sizeof(struct shijian)); //初始化一个空间给进程进入
{ int k;
for(k=0;k<=N-1;k++)
{
if(k==0)//K=0,表示第一个进程到达
{
p[k].kaishitime=p[k].daodatime;//那么开始时间=到达时间
p[k].wanchengtime=p[k].daodatime+p[k].fuwutime;//完成时间=到达时间+服务时间
{
fcfs temp;//在结构体中定义第三个变量进行交换
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
}
//核心的运行阶段
void deal(fcfs *p, float daodatime,float fuwutime,float kaishitime,float wanchengtime,float zhouztime,float daiquantime,int N)

调度算法实验报告总结(3篇)

第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程，加深对进程调度算法的理解。

实验中，我们重点研究了先来先服务（FCFS）、时间片轮转（RR）和动态优先级调度（DP）三种常见的调度算法。

通过编写C语言程序模拟这些算法的运行，我们能够直观地观察到不同调度策略对进程调度效果的影响。

二、实验内容1. 数据结构设计在实验中，我们定义了进程控制块（PCB）作为进程的抽象表示。

PCB包含以下信息：- 进程编号- 到达时间- 运行时间- 优先级- 状态（就绪、运行、阻塞、完成）为了方便调度，我们使用链表来存储就绪队列，以便于按照不同的调度策略进行操作。

2. 算法实现与模拟（1）先来先服务（FCFS）调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。

在模拟过程中，我们首先将所有进程按照到达时间排序，然后依次将它们从就绪队列中取出并分配CPU资源。

（2）时间片轮转（RR）调度算法RR算法将CPU时间划分为固定的时间片，并按照进程到达就绪队列的顺序轮流分配CPU资源。

当一个进程的时间片用完时，它将被放入就绪队列的末尾，等待下一次调度。

（3）动态优先级调度（DP）算法DP算法根据进程的优先级进行调度。

在模拟过程中，我们为每个进程分配一个优先级，并按照优先级从高到低的顺序进行调度。

3. 输出调度结果在模拟结束后，我们输出每个进程的调度结果，包括：- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时，我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。

三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现，但可能会导致进程的响应时间较长，尤其是在存在大量短作业的情况下。

此外，FCFS算法可能导致某些进程长时间得不到调度，造成饥饿现象。

2. 时间片轮转（RR）调度算法RR算法能够有效地降低进程的响应时间，并提高系统的吞吐量。

然而，RR算法在进程数量较多时，可能会导致调度开销较大。

时间片轮转算法和优先级调度算法C语言模拟实现

时间片轮转算法和优先级调度算法C语言模拟实现时间片轮转算法（Round Robin Scheduling）和优先级调度算法（Priority Scheduling）是操作系统中常用的两种进程调度算法。

下面将分别对这两种算法进行C语言模拟实现，并进行详细解释。

```c#include <stdio.h>#include <stdbool.h>#define MAX_PROC_NUM 10#define TIME_QUANTUM 2typedef struct Processint pid; // 进程ID} Process;void roundRobinScheduling(Process processes[], intnum_processes)for (int i = 0; i < num_processes; i++)} else}}}}int maiProcess processes[MAX_PROC_NUM];int num_processes;printf("Enter the number of processes: "); scanf("%d", &num_processes);for (int i = 0; i < num_processes; i++)printf("Process %d: ", i+1);processes[i].pid = i+1;}roundRobinScheduling(processes, num_processes); return 0;```优先级调度算法模拟实现：```c#include <stdio.h>#include <stdbool.h>#define MAX_PROC_NUM 10typedef struct Processint pid; // 进程IDint priority; // 优先级} Process;void priorityScheduling(Process processes[], int num_processes)int highest_priority = 0;int highest_priority_index;highest_priority = -1;for (int i = 0; i < num_processes; i++)highest_priority = processes[i].priority;highest_priority_index = i;}}if (highest_priority == -1)continue;}} else}}int maiProcess processes[MAX_PROC_NUM];int num_processes;printf("Enter the number of processes: ");scanf("%d", &num_processes);for (int i = 0; i < num_processes; i++)printf("Process %d:\n", i+1);printf("Burst Time: ");printf("Priority: ");scanf("%d", &processes[i].priority);processes[i].pid = i+1;}priorityScheduling(processes, num_processes);return 0;```以上是时间片轮转算法和优先级调度算法的C语言模拟实现。

实现模拟进程调度的算法：时间片轮转及短进程优先

操作系统课程设计报告时间：2011-12-26～2012-1-6地点：信息技术实验中心计算机科学与技术（或软件工程）专业xxx级xxx班xx号xxxxxxxx目录一课程设计的目的和意义………………………………………………………二进程调度算法模拟……………………………………………………………1 设计目的………………………………………………………………………2 设计要求………………………………………………………………………3 时间片轮转算法模拟…………………………………………………………4 先来先服务算法模拟…………………………………………………………三主存空间的回收与分配………………………………………………………1 设计目的………………………………………………………………………2 设计要求………………………………………………………………………3 模拟算法的实现………………………………………………………………四模拟DOS文件的建立和使用…………………………………………………1 设计目的………………………………………………………………………2 设计要求………………………………………………………………………3 模拟算法的实现………………………………………………………………五磁盘调度………………………………………………………………………1 设计目的………………………………………………………………………2 设计要求………………………………………………………………………3 模拟算法的实现………………………………………………………………六总结……………………………………………………………………………一、课程设计的目的和意义本次操作系统课程设计的主要任务是进行系统级的程序设计。

本课程设计是操作系统原理课程的延伸。

通过该课程设计，使学生更好地掌握操作系统各部分结构、实现机理和各种典型算法，加深对操作系统的设计和实现思路的理解，培养学生的系统设计和动手能力，学会分析和编写程序。

处理器调度时间片轮转法实验报告(C和C 含源代码)

for(i=0;i<num;i++)
{
printf("\n mp;p[i].name
,p[i].priority
,p[i].time
,p[i].state);
}
printf("********************************************\n");
printf("\n 进程执行完成\n");
%d
%d
%c\n"
,&p[i].name
,p[i].priority
,p[i].time
,p[i].state);
}
printf("********************************************\n");
printf(" 按任意键继续执行：\n");
getchar();//等待输入回车符
把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单
元记录轮到运行的进程。例如，当前轮到 P2 执行，则有：
标志单元 K2
K1
Q1
K2
2
1
R
PCB1
K2
Q2
K3
3
0
R
PCB2
K3
Q3
K4
1
0
R
PCB3
K4
Q4
K5
2
0
R
PCB4
K5
Q5
K1
4
0
R
PCB5
处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调
void run(PCB *p)//进程运行子程序 {

时间片轮转算法及优先级调度算法C语言模拟实现收藏

时间片轮转算法及优先级调度算法C语言模拟实现收藏时间片轮转算法是一种常见的CPU调度算法，通过将进程按照到达顺序放置在一个就绪队列中，并且给予每个进程相同的时间片，当进程用完时间片后，将其放到队列的尾部，轮流执行其他进程。

优先级调度算法是根据进程的优先级来决定下一个执行的进程。

下面是使用C语言模拟实现时间片轮转算法和优先级调度算法的代码：```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int remainingTime;} Process;int totalTurnaroundTime = 0;int totalWaitingTime = 0;//初始化每个进程的剩余执行时间for (int i = 0; i < numProcesses; i++)processes[i].remainingTime = processes[i].burstTime;}while (1)int allProcessesFinished = 1; // 标记所有进程是否执行完毕for (int i = 0; i < numProcesses; i++)if (processes[i].remainingTime > 0)allProcessesFinished = 0; // 还有未执行完毕的进程processes[i].remainingTime = 0;} else}printf("%s执行完毕，剩余时间：%d\n", processes[i].name, processes[i].remainingTime);}}if (allProcessesFinished)break; // 所有进程执行完毕，退出循环}}//计算平均周转时间和平均等待时间float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;float averageWaitingTime = (float)totalWaitingTime / numProcesses;printf("平均周转时间：%.2f\n", averageTurnaroundTime);printf("平均等待时间：%.2f\n", averageWaitingTime);int maiint numProcesses;printf("请输入进程数量：");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间和执行时间：", i+1);scanf("%s%d%d", processes[i].name, &processes[i].arrivalTime, &processes[i].burstTime);}printf("请输入时间片大小：");return 0;```优先级调度算法：```c#include <stdio.h>typedef structchar name[10];int arrivalTime;int burstTime;int priority;int waitingTime;int turnaroundTime;} Process;void runPriority(Process* processes, int numProcesses)int totalWaitingTime = 0;int totalTurnaroundTime = 0;//对进程按照到达时间进行排序for (int i = 0; i < numProcesses; i++)for (int j = 0; j < numProcesses-i-1; j++)if (processes[j].arrivalTime > processes[j+1].arrivalTime) Process temp = processes[j];processes[j] = processes[j+1];processes[j+1] = temp;}}}processes[0].waitingTime = 0;//计算每个进程的等待时间和周转时间for (int i = 1; i < numProcesses; i++)processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;totalWaitingTime += processes[i].waitingTime;totalTurnaroundTime += processes[i].turnaroundTime;}//计算平均等待时间和平均周转时间float averageWaitingTime = (float)totalWaitingTime / numProcesses;float averageTurnaroundTime = (float)totalTurnaroundTime / numProcesses;printf("平均等待时间：%.2f\n", averageWaitingTime);printf("平均周转时间：%.2f\n", averageTurnaroundTime);int maiint numProcesses;printf("请输入进程数量：");scanf("%d", &numProcesses);Process processes[numProcesses];for (int i = 0; i < numProcesses; i++)printf("请输入进程%d的名称、到达时间、执行时间和优先级：", i+1);scanf("%s%d%d%d", processes[i].name,&processes[i].arrivalTime, &processes[i].burstTime,&processes[i].priority);}runPriority(processes, numProcesses);return 0;```通过输入进程的信息，可以计算出使用时间片轮转算法和优先级调度算法的平均等待时间和平均周转时间，从而比较它们的效果。

操作系统时间片轮转算法与优先级调度算法

#include "stdio.h"#include "stdlib.h"#include "string.h"typedef struct node{char name[10]; /*进程标识符*/int prio; /*进程优先数*/int round; /*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count; /*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run; /*队列指针*/int N; /*进程数*//*将就绪队列中的第一个进程投入运行*/firstin(){run=ready; /*就绪队列头指针赋值给运行头指针*/run->state='R'; /*进程状态变为运行态*/ready=ready->next; /*就绪对列头指针后移到下一进程*/}/*标题输出函数*/void prt1(char a){if(toupper(a)=='P') /*优先数法*/printf(" name cputime needtime priority state\n");elseprintf(" name cputime needtime count round state\n"); }/*进程PCB输出*/void prt2(char a,PCB *q){if(toupper(a)=='P') /*优先数法的输出*/printf(" %-10s%-10d%-10d%-10d %c\n",q->name,q->cputime,q->needtime,q->prio,q->state);else/*轮转法的输出*/printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);}/*输出函数*/void prt(char algo){PCB *p;prt1(algo); /*输出标题*/if(run!=NULL) /*如果运行指针不空*/prt2(algo,run); /*输出当前正在运行的PCB*/p=ready; /*输出就绪队列PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}p=finish; /*输出完成队列的PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}p=ready;printf("就绪队列：");while(p!=NULL){printf("%s\t",p->name); p=p->next;}printf("\n");p=finish;printf("完成队列：");while(p!=NULL){printf("%s\t",p->name); p=p->next;}printf("\n");getch(); /*压任意键继续*/ }/*优先数的插入算法*/insert1(PCB *q){PCB *p1,*s,*r;int b;s=q; /*待插入的PCB指针*/p1=ready; /*就绪队列头指针*/r=p1; /*r做p1的前驱指针*/b=1;while((p1!=NULL)&&b) /*根据优先数确定插入位置*/if(p1->prio>=s->prio){r=p1;p1=p1->next;}elseb=0;if(r!=p1) /*如果条件成立说明插入在r与p1之间*/{r->next=s;s->next=p1;}else{s->next=p1; /*否如此插入在就绪队列的头*/ready=s;}}/*轮转法插入函数*/insert2(PCB *p2){tail->next=p2; /*将新的PCB插入在当前就绪队列的尾*/ tail=p2;p2->next=NULL;}/*优先数创建初始PCB信息*/void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; /*就绪队列头指针*/finish=NULL; /*完成队列头指针*/run=NULL; /*运行队列指针*/printf("Enter name and time of process\n"); /*输入进程标识和所需时间创建PCB*/for(i=1;i<=N;i++){p=malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';p->prio=50-time;if(ready!=NULL) /*就绪队列不空调用插入函数插入*/insert1(p);else{p->next=ready; /*创建就绪队列的第一个PCB*/ready=p;}}// clrscr();system("CLS");printf(" output of priority:\n");printf("************************************************\n"); prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';}/*轮转法创建进程PCB*/void create2(char alg){PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;printf("Enter name and time of round process\n");for(i=1;i<=N;i++){p=malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->count=0; /*计数器*/p->state='W';p->round=2; /*时间片*/if(ready!=NULL)insert2(p);else{p->next=ready;ready=p;tail=p;}}//clrscr();system("CLS");printf(" output of round\n");printf("************************************************\n"); prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';}/*优先数调度算法*/priority(char alg){while(run!=NULL) /*当运行队列不空时，有进程正在运行*/{run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/if(run->needtime==0) /*如所需时间为0将其插入完成队列*/{run->next=finish;finish=run;run->state='F'; /*置状态为完成态*/run=NULL; /*运行队列头指针为空*/if(ready!=NULL) /*如就绪队列不空*/firstin(); /*将就绪对列的第一个进程投入运行*/}else /*没有运行完同时优先数不是最大，如此将其变为就绪态插入到就绪队列*/if((ready!=NULL)&&(run->prio<ready->prio)){run->state='W';insert1(run);firstin(); /*将就绪队列的第一个进程投入运行*/}prt(alg); /*输出进程PCB信息*/}}/*时间片轮转法*/roundrun(char alg){while(run!=NULL){run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->count=run->count+1;if(run->needtime==0)/*运行完将其变为完成态，插入完成队列*/{run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)firstin(); /*就绪对列不空，将第一个进程投入运行*/}elseif(run->count==run->round) /*如果时间片到*/{run->count=0; /*计数器置0*/if(ready!=NULL) /*如就绪队列不空*/{run->state='W'; /*将进程插入到就绪队列中等待轮转*/ insert2(run);firstin(); /*将就绪对列的第一个进程投入运行*/}}prt(alg); /*输出进程信息*/}}/*主函数*/main(){char algo; /*算法标记*///clrscr();system("CLS");printf("type the algorithm:P/R(priority/roundrobin)\n");scanf("%c",&algo); /*输入字符确定算法*/ printf("Enter process number\n");scanf("%d",&N); /*输入进程数*/if(algo=='P'||algo=='p'){create1(algo); /*优先数法*/priority(algo);}elseif(algo=='R'||algo=='r'){create2(algo); /*轮转法*/roundrun(algo);}}。

操作系统进程调度算法模拟(c++)实验报告

南通大学计算机科学与技术学院操作系统课程设计报告书设计题目模拟实现进程调度中的先来先服务算法，短作业优先算法，时间片轮转算法，优先级调度算法专业班级计xxx学生姓名 xxxxx学号 161xxxxxxxx日期 2018.01.8-2018.01.12课程设计题目：模拟实现进程调度中的先来先服务算法，短作业优先算法，时间片轮转算法，优先级调度算法一、主要目的模拟实现进程调度中的先来先服务算法，短作业优先算法，时间片轮转算法，优先级调度算法二、设备与环境1.硬件设备：PC机一台2. 软件环境：Windows操作系统，vc6.0三、实验要求1.实验题目模拟实现进程调度中的先来先服务算法，短作业优先算法，时间片轮转算法，优先级调度算法2.数据结构及主要符号说明。

用两个数组分别表示进程的运行时间和优先级，数组大小定义为100，用以适应多种进程算法计算在各个算法模块函数中，所有的符号都是采用了同一种浮点型变量符号（如下所示）；float t=0;//保存周转时间和float r=0;//保存各进程周转时间float T;//用于保存平均周转时间float S=0;//用于保存带权周转时间和float s;//用于保存各程序带权周转时间float W;//用于保存平均带权周转时间特殊的：在所有算法里出现的“i”“j”均表示计数，在功能函数编写过程中，参数均是以a，b，c代替的其中c表示固定输入的进程数量，用以作为函数中循环跳出的标志；在时间片轮转算法中，用time表示时间片的大小，用m表示尚未完成的进程数；在时间片轮转算法中，定义了新的数组d[100]，用来保存相应的进程运行时间在循环过程中用以操作，避免因操作过程中数值变化无法进行后续操作四、程序流程图和源程序先来先服务算法源程序及流程图void First(float a[],int c)//先来先服务算法{float t=0;//保存周转时间和float r=0;//保存各进程周转时间float T;//用于保存平均周转时间float S=0;//用于保存带权周转时间和float s;//用于保存各程序带权周转时间float W;//用于保存平均带权周转时间int i;//计数for(i=1;i<=c;i++)//先来先服务算法具体实现{r+=a[i];//每个进程周转时间s=r/a[i];//每个进程加权周转时间t+=r;//总周转时间S+=s;//总加权周转时间}T=(float)t/c;//计算平均周转时间W=(float)S/c;//计算平均加权周转时间/****************输出******************/cout<<"先来先服务算法平均周转时间："<<T<<'\n';cout<<"先来先服务算法平均带权周转时间:"<<W<<'\n';}短作业优先算法计流程图void Short(float a[],int c)//短作业优先算法{float t=0;//保存周转时间和float r=0;//保存各进程周转时间float T;//用于保存平均周转时间float S=0;//用于保存带权周转时间和float s;//用于保存各程序带权周转时间float W;//用于保存平均带权周转时间int b[100];int i,j;//计数for(i=1;i<=c;i++)b[i]=a[i];for(i=1;i<c;i++)//对进程按照作业运行时间进行排序（冒泡） {for(j=1;j<=c-i;j++)if(b[j]>=b[j+1]){float m=b[j];b[j]=b[j+1];b[j+1]=m;}}for(i=1;i<=c;i++)//根据排序顺序实行短作业优先算法{r+=b[i];s=(float)r/b[i];t+=r;S+=s;}/*平均周转时间及平均加权周转时间计算*/T=(float)t/c;W=(float)S/c;/*************计算结果输出************/cout<<"短作业优先算法平均周转时间："<<T<<'\n';cout<<"短作业优先算法平均带权周转时间:"<<W<<'\n';}时间片轮转算法源程序及流程图void Time(float a[],int c)//时间片轮转算法{float time=1;//规定时间片的大小float t=0;//保存周转时间和float T;//用于保存平均周转时间float r=0;//保存各进程周转时间float S=0;//用于保存带权周转时间和float s;//用于保存各程序带权周转时间float W;//用于保存平均带权周转时间int i;//计数int m=c;//用于判定循环结束标准float d[100];for(i=1;i<=c;i++)//将待运行进程时间存入新的数组当中，便于之后的运算d[i]=a[i];cout<<"时间片轮转算法进程运行次序：";while(m>0)//时间片轮转，当所有进程执行完毕以后跳出{for(i=1;i<=c;i++)//每一个单次循环，每一个未完成进程分配一次时间片{if(d[i]>0)//进程完成与否的判断{cout<<i<<" ";r+=1;d[i]-=1;if(d[i]<=0)//进程若执行完毕，周转时间得出，加权周转时间得出，总时间得出{m--;s=r/a[i];S+=s;t+=r;}}}}cout<<endl;/***计算平均周转时间，平均加权周转时间***/T=t/c;W=S/c;/*********计算结果输出*********/cout<<"时间片轮转算法平均周转时间："<<T<<'\n';cout<<"时间片轮转算法平均带权周转时间:"<<W<<'\n';}优先级调度算法源程序及流程图void Precedence(float a[],float b[],int c)//优先级调度算法{float t=0;//保存周转时间和float r=0;//保存各进程周转时间float T;//用于保存平均周转时间float S=0;//用于保存带权周转时间和float s;//用于保存各程序带权周转时间float W;//用于保存平均带权周转时间int i,j;//计数for(i=1;i<=c;i++)//根据优先级确定进程执行顺序（冒泡排序） {for(j=1;j<=c-i;j++)if(a[j]<a[j+1]){float m=a[j];a[j]=a[j+1];a[j+1]=m;float n=b[j];b[j]=b[j+1];b[j+1]=n;}}for(i=1;i<=c;i++){r+=b[i];s=(float)r/b[i];t+=r;S+=s;}/*******计算及结果输出********/T=(float)t/c;W=(float)S/c;cout<<"优先级调度算法平均周转时间："<<T<<'\n';cout<<"优先级调度算法平均带权周转时间:"<<W<<'\n';}主函数源程序int main()//主函数{int i;//计数确定进程到来次序int n;//保存进程数量float Operation[100],Priority[100];//用于保存各个进程运行时间及优先级cout<<"请输入进程数：";cin>>n;cout<<"请依次输入各个进程运行时间及优先级:";for(i=1;i<=n;i++)cin>>Operation[i]>>Priority[i];system("cls");//清屏/*********按表格显示进程参数*********/cout<<"输入进程运行时间及优先级如下："<<endl;cout<<"进程号"<<'\t'<<"执行时间"<<'\t'<<"优先级"<<'\n';for(i=1;i<=n;i++)cout<<"job"<<i<<'\t'<<Operation[i]<<'\t'<<'\t'<<Priority[i]<<'\n';/*********调用函数********/First(Operation,n);cout<<endl;Short(Operation,n);cout<<endl;Time(Operation,n);cout<<endl;Precedence(Priority,Operation,n);return 0;}五、程序运行结果截图六、收获以及心得体会经过这次程序编写过程，我比较深刻的了解到了进程调度算法的具体实现思想，在编程过程中我发现，假使我在编写一个操作系统时，编写一段代码，绝对不能仅仅以实现某个具体的实验目标作为编程的最终结果，而不考虑这一点很可能会造成后续程序的混乱，数据的流失与改变。