您的位置：360文档中心› 时间片轮转算法和优先级调度算法-C语言模拟实现-收藏

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

合集下载

操作系统进程调度C语言代码

操作系统进程调度C语言代码

操作系统进程调度C语言代码操作系统是计算机系统中的重要组成部分，用于管理和控制计算机资源的分配和使用。

在操作系统中，进程调度是指将系统资源（如 CPU、内存、磁盘、网络等）分配给运行中的进程的过程。

进程调度是操作系统实现多任务、多用户和分时系统的关键。

进程调度的算法有多种。

最常见的是时间片轮转算法、优先级调度算法、最短进程优先算法和先到先服务算法等。

下面我们将介绍一下时间片轮转算法的 C 语言代码实现。

1. 时间片轮转算法时间片轮转算法是一种基于时间片的调度算法，它给每个进程分配一个时间片，当时间片用完后，系统将进程暂停，并将 CPU 分配给下一个进程。

时间片轮转算法可以让所有进程公平地使用 CPU 时间，并且可以避免进程饥饿的情况发生。

2. C 语言代码实现在 C 语言中，可以用结构体来表示一个进程，包括进程 ID、进程状态、优先级、到达时间和需要运行的时间片等属性。

下面是一个简单的进程结构体的定义：```struct Process processes[5];在实现时间片轮转算法之前，需要先实现一个进程调度函数，它的作用是找到就绪进程中优先级最高的进程，并返回它的位置。

下面是一个简单的进程调度函数：```int find_highest_priority_process(struct Process *processes, int n) {int highest_priority = -1;int highest_priority_index = -1;for (int i = 0; i < n; i++) {if (processes[i].state != 2 && processes[i].priority >highest_priority) {highest_priority = processes[i].priority;highest_priority_index = i;}}return highest_priority_index;}```在实现时间片轮转算法之前，需要先定义一些全局变量，包括就绪队列、当前时间、时间片大小和进程数量等。

时间片轮转算法和优先级调度算法

时间片轮转算法和优先级调度算法

时间片轮转算法和优先级调度算法-C语言模拟实现-收藏时间片轮转算法和优先级调度算法C语言模拟实现收藏一、目的和要求进程调度是处理机管理的核心内容。

本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。

二、实验内容1. 设计进程控制块PCB的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。

2. 编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3. 按要求输出结果。

二、提示和说明分别用两种调度算法对伍个进程进行调度。

每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH ），并假定初始状态为就绪状态。

（一）进程控制块结构如下：NAME ----- 进程标示符PRIO/ROUND ――进程优先数/进程每次轮转的时间片数（设为常数2）CPUTIME ――进程累计占用CPU的时间片数NEEDTIME ――进程到完成还需要的时间片数I STATE——进程状态NEXT ――链指针注：2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。

（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN ――当前运行进程指针READY ――就需队列头指针TAIL ――就需队列尾指针FINISH ――完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减1，CPU时间片数加1,进程还需要的时间片数减1。

在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2,进程还需要的时间片数减2,并退出CPU，排到就绪队列尾，等待下一次调度。

2. 程序的模块结构提示如下：整个程序可由主程序和如下7个过程组成：（1）INSERT1 ――在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；（2）INSERT2 ――在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；（3）FIRSTIN ――调度就绪队列的第一个进程投入运行；（4）PRINT ――显示每执行一次后所有进程的状态及有关信息。

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

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

进程调度算法时间片轮转法+优先级#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语言实现时间片轮转调度算法

用c语言实现时间片轮转调度算法

用c语言实现时间片轮转调度算法时间片轮转调度算法是一种常见的进程调度算法，其主要思想是将所有就绪进程按顺序排列，每个进程分配一个时间片，当时间片用尽后，进程被送到队列的末尾，然后下一个进程被执行。

本文将介绍如何使用C语言实现时间片轮转调度算法。

首先，我们需要定义进程控制块（PCB），包括进程的ID、状态、优先级和时间片等信息。

可以使用结构体来表示PCB，代码如下：```typedef struct PCB {int pid; // 进程IDint status; // 进程状态（就绪、运行、等待、结束） int priority; // 进程优先级int time_slice; // 时间片} PCB;```接下来，我们需要创建一个就绪队列和一个等待队列来存储所有进程。

可以使用链表来实现队列，代码如下：```typedef struct Node {PCB *pcb; // PCB指针struct Node *next; // 指向下一个节点的指针} Node;// 就绪队列Node *ready_queue = NULL;// 等待队列Node *wait_queue = NULL;```然后，我们需要编写一个函数来创建进程并添加到就绪队列中。

该函数接受进程的ID、优先级和时间片作为参数，并返回一个指向新进程PCB的指针。

代码如下：```PCB *create_process(int pid, int priority, int time_slice) {PCB *pcb = (PCB*)malloc(sizeof(PCB));pcb->pid = pid;pcb->status = 0; // 就绪状态pcb->priority = priority;pcb->time_slice = time_slice;// 将新进程添加到就绪队列末尾Node *p = (Node*)malloc(sizeof(Node));p->pcb = pcb;p->next = NULL;if (ready_queue == NULL) {ready_queue = p;} else {Node *q = ready_queue;while (q->next != NULL) {q = q->next;}q->next = p;}return pcb;}```接下来，我们需要编写一个函数来模拟时间片轮转调度算法。

四种进程调度算法 先到先服务,优先级,短作业优先,时间片轮转

四种进程调度算法 先到先服务,优先级,短作业优先,时间片轮转

#include"stdio.h"#define N 50int n;int sj;struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int yxj; //优先级int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];void input(Gzuo a[]){printf("请输入进程个数：");scanf("%d",&n);for(int i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sj);}void sjp(Gzuo a[],int sj)//时间片轮转调度{int i,j,min,time;float sum1,sum2;bool flag=true;/*printf("\t请输入进程数(0<n<=50):\t"); scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);printf("\n\n");printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sjp);while(sjp<=0){printf("n\t请重新输入：");scanf("%d",&sjp);}/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].st2;a[i].st2=a[i+1].st2;a[i+1].st2=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}time = a[0].dt;//printf("赋值后TIME值为：%d\n",time);min = 0;while(min<n){flag=true;for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt<=time)flag=false;}for(i=0;i<n;i++){if(a[i].st2 > 0 ){if(a[i].dt<=time){//printf("当前a[%d].st2值为：%d\n",i,a[i].st2);a[i].st2 = a[i].st2 - sj;//printf("运算后当前a[%d].st2值为：%d\n",i,a[i].st2); //printf("当前TIME值为：%d\n",time);time = time + sj;//printf("增加之后TIME值为：%d\n",time);if(a[i].st2<=0){a[i].wct = time + a[i].st2;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;min++;}}else if(flag)for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt>time){time = a[i].dt;break;}}}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("**************************************************************** *****\n");}void fcfs(Gzuo a[])//先到先服务调度{int i,j,min;float sum1,sum2;/*printf("\t请输入进程数(0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0)printf("n\t请重新输入："); scanf("%d",&n);}printf("\n\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void sjf(Gzuo a[])//短作业优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t"); scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}if(a[i].dt==a[i+1].dt&&a[i].st>a[i+1].st) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b=b+1;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].st>a[z+1].st){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt, a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void yxj(Gzuo a[])//优先级优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/* struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int yxj; //优先级int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间："); scanf("%d",&a[i].dt);printf("\t服务时间："); scanf("%d",&a[i].st);printf("\t优先级：");scanf("%d",&a[i].yxj);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min; min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}if(a[i].dt==a[i+1].dt&&a[i].yxj<a[i+1].yxj) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b++;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].yxj<a[z+1].yxj){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t优先级\t完成时间\t周转时间\t带权周转时间\n"); sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%d\t\t%.0f\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[i ].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void main(){ int n;input(a);printf("以下是先到先服务调度：");fcfs(a);printf("以下是短作业优先调度：");sjf(a);printf("以下是时间片轮转法：");sjp(a,sj);printf("以下是优先级优先调度：");yxj(a); }。

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

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

操作系统时间片轮转算法与优先级调度算法操作系统作为计算机的核心，需要负责管理和分配系统资源的功能。

其中，调度算法是操作系统中非常重要的一个功能，它决定了如何分配CPU时间，因此直接影响系统的性能和响应速度。

本文将介绍两种操作系统中常用的调度算法：时间片轮转算法和优先级调度算法。

时间片轮转算法时间片轮转算法（Round Robin）是一种基本的调度算法，它是多道程序设计中常用的一种算法。

在内存中同时存放多个进程，并根据每个进程的优先级轮流分配 CPU 时间，以保证每个进程都能得到一定的CPU时间片，从而保证操作系统的公平性和系统的稳定性。

基本思想时间片轮转算法的基本思想是：将每个进程分配相同长度的CPU时间片，一旦时间片用完，立即将该进程挂起，并将 CPU 分配给下一个进程。

这样就可以保证每个进程都有相同的机会获得 CPU 时间，避免了某个进程长时间霸占CPU而导致其他进程无法运行的情况。

算法流程时间片轮转算法的具体实现过程如下：1.将所有待运行的进程加入到就绪队列中；2.从就绪队列中取出第一个进程，将其运行指定时间片长度的时间；3.如果该进程在运行时间片结束之前自己退出，那么直接将其从就绪队列中取出，释放资源；4.如果该进程在运行时间片结束之前没有自己退出，那么将其挂起放到队列的尾部，然后将 CPU 分配给下一个进程，重复2-4步骤，直到所有进程执行完毕。

算法优点时间片轮转算法的优点如下：1.公平：每个进程都能得到相同长度的时间片，避免了某个进程长时间霸占CPU的情况，从而保证了每个进程都会运行；2.适用：时间片轮转算法适用于多任务并发的环境下，可以有效地避免死锁和饥饿现象；3.高效：时间片轮转算法可以保证 CPU 的高效利用，能够最大限度地提高 CPU 的性能。

算法缺点时间片轮转算法的缺点如下：1.精度问题：时间片长度不能太长，否则会导致某些进程长时间等待CPU时间片；2.资源浪费：如果一个进程只需要很短的时间就可以完成任务，但由于时间片的限制而占用CPU的时间，这就是一种资源浪费。

【精品】进程模拟调度时间片和优先级

【精品】进程模拟调度时间片和优先级

仲恺农业工程学院课程设计进程调度模拟算法实现（优先数算法和时间片算法）课程名称计算机系统开发综合训练（2）姓名杜松耀院(系）信息科学与技术学院专业班级计算机科学与技术121学号2指导教师史婷婷目录1需求分析............................................ 错误!未指定书签。

2概要设计............................................ 错误!未指定书签。

2.1实验原理....................................... 错误!未指定书签。

2。

2数据结构...................................... 错误!未指定书签。

2.3算法描述....................................... 错误!未指定书签。

2.4算法流程图..................................... 错误!未指定书签。

3详细设计............................................ 错误!未指定书签。

3.1源程序代码..................................... 错误!未指定书签。

4调试分析............................................ 错误!未指定书签。

5总结................................................ 错误!未指定书签。

1需求分析本实验完成的系统是进程调度模拟算法实现（优先数算法和时间片算法)，进程是操作系统中最基本、最重要的概念，是在多道程序系统出现后，为了刻画系统内部的动态状况、描述运行程序的活动规律而引进的新概念，所有多道程序设计操作系统程序设计操作系统都建立在进程的基础上。

进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。

优先级和时间片轮转调度

优先级和时间片轮转调度
}
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[])

c语言实现基于时间片轮转调度算法

c语言实现基于时间片轮转调度算法

c语言实现基于时间片轮转调度算法以下是基于时间片轮转调度算法的C语言实现示例：```c#include <stdio.h>#include <stdlib.h>typedef struct Process {int pid; // 进程IDint burstTime; // 执行时间int remainingTime; // 剩余执行时间int arrivalTime; // 到达时间int waitingTime; // 等待时间} Process;void timeSliceScheduling(Process processes[], int n, int timeSlice) {int currentTime = 0;int completedProcesses = 0;while (completedProcesses < n) {for (int i = 0; i < n; i++) {if (processes[i].remainingTime > 0) {int executionTime = (processes[i].remainingTime > timeSlice) ? timeSlice : processes[i].remainingTime;processes[i].remainingTime -= executionTime;currentTime += executionTime;if (processes[i].remainingTime == 0) {completedProcesses++;processes[i].waitingTime = currentTime - processes[i].arrivalTime - processes[i].burstTime;}}}}}void printWaitingTime(Process processes[], int n) { printf("Process\tWaiting Time\n");for (int i = 0; i < n; i++) {printf("%d\t%d\n", processes[i].pid, processes[i].waitingTime);}}int main() {int n, timeSlice;printf("Enter the number of processes: ");scanf("%d", &n);Process processes[n];printf("Enter the burst time and arrival time for each process:\n");for (int i = 0; i < n; i++) {processes[i].pid = i + 1;printf("Process %d: ", processes[i].pid);scanf("%d%d", &processes[i].burstTime,&processes[i].arrivalTime);processes[i].remainingTime = processes[i].burstTime;processes[i].waitingTime = 0;}printf("Enter the time slice: ");scanf("%d", &timeSlice);timeSliceScheduling(processes, n, timeSlice);printWaitingTime(processes, n);return 0;}```这个示例演示了如何使用时间片轮转调度算法计算进程的等待时间。

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

进程调度模拟设计——时间片轮转、优先级法 程序
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;

优先级 时间片轮转调度算法

优先级 时间片轮转调度算法

优先级调度算法和时间片轮转调度算法是两种不同的操作系统进程或任务调度算法。

下面我将分别解释这两种算法：
1. 优先级调度算法：
优先级调度算法是一种非抢占式的调度算法，在这种算法中，每个进程被赋予一个优先级，调度器总是选择优先级最高的进程来执行。

如果多个进程具有相同的优先级，则可以按照FCFS （先进先出）的方式进行调度。

这种算法的优点是简单且易于实现，但可能导致某些进程长时间得不到执行，因此公平性较差。

2. 时间片轮转调度算法：
时间片轮转调度算法是一种抢占式的调度算法，在这种算法中，每个进程被分配一个时间片，当进程在执行过程中用完时间片后，调度器将剥夺该进程的CPU并分配给下一个等待的进程。

如果一个进程在时间片用完之前阻塞或完成，调度器将进行特殊处理。

这种算法的优点是公平性较好，每个进程都有机会获得执行，但实现起来相对复杂。

优先级调度算法和时间片轮转调度算法各有优缺点，适用于不
同的场景。

在实际应用中，操作系统通常会根据具体需求选择适合的调度算法。

c语言做的时间片轮转算法

c语言做的时间片轮转算法
OutQueue(bq);
break;
case 3:
InitQueue(runq);
printf("当前执行队列中的进程有：\n");
OutQueue(runq);
break;
case 4: dispatch(rq,bq,runq);
break;
case 5: flag=0;
break;
default: printf("输入序号错误！\n");
}
printf("\n");
}
int IsEmpty(LinkQueue *Q)
{
if(Q->front==Q->rear)
return(TRUE);
else
return(FALSE);
}
LinkQueueNode * DeleteQueue(LinkQueue *Q)
{ LinkQueueNode *p;
break;
}
}
}
getchar();
switch(m)
{ case 1: InitQueue(rq);
BuildQueue(rq);
printf("当前就绪队列中的进程有：\n");
OutQueue(rq);
break;
case 2:
InitQueue(bq);
BuildQueue(bq);
printf("当前阻塞队列中的进程有：\n");
printf("1、创建就绪（ready）队列\n");
printf("2、创建阻塞队列（blocked）\n");
printf("3、创建执行队列（run）\n");

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

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

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）时间片轮转：●思想：公平、轮流为每个进程服务、每个进程在一定时间内得到相应●规则：按照到达就绪队列的顺序，轮流让各个进程执行一个时间片。

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

时间片轮转算法和优先级调度算法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语言模拟实现收藏

时间片轮转算法及优先级调度算法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语言实现)

基于优先级的时间片轮转调度算法(C语言实现)

1
队列![流程图.png](https://upload-images.jianshu.io/upload_images/13373683fc06e9117b622d3e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
1 typedef struct Link 2{
12 p = p->next;
13
14
}
}
1
removeFirst：将队列中第一个元素中的数据复制到给定参数中（用于返回），并删除
1 void removeFirst(Link *l, Block *b)
2{
3
Block *t;
4
5
// 空队列则直接返回
6
if (isEmpty(l))
7
{
8
return ;
11 }
12
13
14
// 若存在，则释放
15
if (p != NULL)
16
{
17
t->next = p->next;
1
18
free(p);
19
}
20 }
sortByArrivalTime：根据进程到达时间将队列排序（从小到大）
9
}
10
11
// t指向第二个Block，用于之后将队列接上
12 t = l->first->next->next;
13
14
// 将第一个Block中的内容复制到b中，用于返回
15
b->processID = l->first->next->processID;

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

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

#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;}。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

一、目的和要求进程调度是处理机管理的核心容。

本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。

二、实验容1.设计进程控制块PCB的结构，通常应包括如下信息：进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。

2.编写两种调度算法程序：优先数调度算法程序循环轮转调度算法程序3.按要求输出结果。

三、提示和说明分别用两种调度算法对伍个进程进行调度。

每个进程可有三种状态；执行状态（R UN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。

（一）进程控制块结构如下：NAME——进程标示符PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）CPUTIME——进程累计占用CPU的时间片数NEEDTIME——进程到完成还需要的时间片数STATE——进程状态NEXT——链指针注：1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。

（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：RUN——当前运行进程指针READY——就需队列头指针TAIL——就需队列尾指针FINISH——完成队列头指针（三）程序说明1. 在优先数算法中，进程优先数的初值设为：50-NEEDTIME每执行一次，优先数减1，CPU时间片数加1，进程还需要的时间片数减1。

在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。

2. 程序的模块结构提示如下：整个程序可由主程序和如下7个过程组成：（1）INSERT1——在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；（2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；（3）FIRSTIN——调度就绪队列的第一个进程投入运行；（4）PRINT——显示每执行一次后所有进程的状态及有关信息。

（5）CREATE——创建新进程，并将它的PCB插入就绪队列；（6）PRISCH——按优先数算法调度进程；（7）ROUNDSCH——按时间片轮转法调度进程。

主程序定义PCB结构和其他有关变量。

（四）运行和显示程序开始运行后，首先提示：请用户选择算法，输入进程名和相应的NEEDTIM E值。

每次显示结果均为如下5个字段：name cputime needtime priority state注：1．在state字段中，"R"代表执行态，"W"代表就绪（等待）态，"F"代表完成态。

2．应先显示"R"态的，再显示"W"态的，再显示"F"态的。

3．在"W"态中，以优先数高低或轮转顺序排队；在"F"态中，以完成先后顺序排队。

view plaincopy to clipboardprint?1./*2.操作系统实验之时间片轮转算法和优先级调度算法3.By Visual C++ 6.04.*/#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/int count; /*记录执行的次数*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高* /void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*/void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*/void RoundRun(); /*时间片轮转调度*/int main(void){char chose;printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("输入进程的调度方法：(P/R)\n");scanf("%c",&chose);switch(chose){case 'P':case 'p':PrioCreate();Priority();break;case 'R':case 'r':TimeCreate();RoundRun();break;default:break;}Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\n ");while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p ->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低* /{PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空，则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大，则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = ready;if(ready == NULL){ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->round = 0;tmp ->count = 0;InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 0;tmp ->round = 2; /*假设每个进程所分配的时间片是2*/tmp ->count = 0;InsertTime(tmp);}}void Priority() /*按照优先级调度，每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行* /{Output(); /*输出每次调度过程中各个节点的状态*/while(flag){run->prio -= 3; /*优先级减去三*/run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/{run ->state = 'F';run->count++; /*进程执行的次数加一*/InsertFinish(run);flag = 0;}else /*将进程状态置为W，入就绪队列*/{run->state = 'W';run->count++; /*进程执行的次数加一*/InsertTime(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/ {run->state = 'W';run->count = 0; /*计数器清零，为下次做准备*/ InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。

相关文档
最新文档