操作系统中的优先级调度和轮转调度

最新推荐文章于 2024-04-23 07:20:05 发布
最新推荐文章于 2024-04-23 07:20:05 发布
阅读量1.5k 收藏 15
点赞数 2
分类专栏： 学习 文章标签： 链表 算法 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/louiseyy/article/details/105489702
版权

在遭受了大概前后三个下午的折磨之后，我决定把这个痛苦的经历的结果记录下来，于是有了我的第一篇CSDN的博客。

优先级调度和轮转调度的c语言实现

先简述一下实现的过程吧

就是用结构体代表一个个的进程，然后通过链表来实现调度过程中的排序

其实优先级调度就是从那么多个进程里面选出一个优先级最高的进程放入CPU中运行，运行完一个时间片后更改此进程相应的变量，再把优先级减8，最后判断此进程是否完成，然后把此进程放到相应队列的队尾。

轮转调度和优先级调度十分相似，只是它的结构体中的变量和优先级调度不一样，然后把选择最高优先级改成选择就绪队列中的第一个进程就可以了。

所以其实拿到其中的一个代码就再稍微改一下就可以得到两种不同的调度方法了，所以不要像我一开始还打算写两个完全不一样的……

好了话不多说，直接进入代码解析好了

优先级调度的重点代码解析
  1. 先新建一些可以用的指针
struct PCB *Move=head->next;
struct PCB *Max_Pri=head->next;
struct PCB *Tail;    //尾指针 
struct PCB *hT;
  1. 然后利用指针遍历选出就绪队列中优先级最高的进程
while(Move!=NULL){
      if(Max_Pri->priority_number < Move->priority_number){
          Max_Pri = Move;
      }                        
      Move = Move->next;
  }
  1. 改变选中进程的某些属性（已运行时间+1，优先级-8，再判断此进程是否完成，如果完成把状态改为0，如果未完成则把状态改为1）
Max_Pri->used_time += Time_film;    
Max_Pri->priority_number -= 8;
if(Max_Pri->used_time == Max_Pri->need_time){	
      Max_Pri->process_state = 0;
      count++;
}
else{
      Max_Pri->process_state = 1;
}
  printf("进程 %d 被调度: \n",Max_Pri->process_name);
  1. 调用print函数（自定义的）输出此时的就绪队列和已完成队列
printf("        就绪队列：\n");
print(head);    //输出就绪队列
printf("        已完成队列：\n");
print(h);    //输出已完成队列
printf("\n");
  1. 把之前选中的优先级最高的进程从就绪队列里面取出来
Move = Max_Pri->cre;        
Move->next = Max_Pri->next;
if(Move->next != NULL){
 	Move = Max_Pri->next;
 	Move->cre = Max_Pri->cre;    
}
  1. 取出来后再判断一下进程是否已完成，如果已完成则放入已完成队列的队尾并把状态改成0（已完成），如果没有完成则放入就绪队列的队尾并把状态改回-1（就绪）
 if(Max_Pri->process_state !=0){
 	printf("进程 %d 未完成，进入就绪队列 \n\n",Max_Pri->process_name);
     Move = head;
     while( Move->next!=NULL ){    //当被调出进程未完成时将其插入就绪队列尾部 
         Move = Move->next; 
     }
     Tail = Move;
     Max_Pri->cre = Tail;
     Max_Pri->next = NULL;
     Tail->next = Max_Pri;
     
 }else{
 	printf("进程 %d 已完成，进入已完成队列 \n\n",Max_Pri->process_name);
 	Move =h;
 	while(Move->next!=NULL){
 		Move = Move->next;
 	}
 	hT = Move;
 	Max_Pri->cre = hT;
 	Max_Pri->next = NULL;
 	hT->next = Max_Pri;
 
 }
  if(Max_Pri->process_state !=0){
 	Max_Pri->process_state = -1;
 }else{
 	Max_Pri->process_state = 0;
 }
  1. 判断是否所有的进程都已经执行完毕，如果没有，则跳过if此段代码，重新调用此函数，进入循环
if(count == N){    //所有进程执行完毕 
  	printf("        就绪队列：\n");
      print(head);    //输出就绪队列
      printf("        已完成队列：\n");
      print(h);    //输出已完成队列
      printf("\n");
      printf("        所有进程执行完毕！");
      return;
  }
  //****************************循环调用 
  Process_scheduling(head,h);//此函数的函数名
}

其余的代码就基本上看一遍就能懂的了，所以就不解析了，试着自己分析分析吧。
关于轮转调度的也是，只是在前两个步骤有一点小小的变动，看一看就能明白，所以就直接贴代码了

优先级调度完整代码
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define Time_film 1    //时间片

int count = 0;    //统计进程完成个数 
int N;//进程个数 

void print(struct PCB *head);

struct PCB{
  int process_name;    //进程名 
  int priority_number;    //优先数,随机产生 
  int arrive_time;    //到达时间,为进程的创建时间 
  int need_time;    //需要运行的时间 
  int used_time;    //已用CPU的时间,初始值为0 
  int process_state;    //进程状态,1表示运行,0表示完成,-1表示就绪,初始值为-1 
  struct PCB *cre;    //前驱指针域
  struct PCB *next;    //后驱指针域
};

void Process_scheduling(struct PCB *head,struct PCB *h){
  //****************************
  struct PCB *Move=head->next;
  struct PCB *Max_Pri=head->next;
  struct PCB *Tail;    //尾指针 
  struct PCB *hT;
  //****************************//寻找最高优先级进程 
  while(Move!=NULL){
      if(Max_Pri->priority_number < Move->priority_number){
          Max_Pri = Move;
      }                        
      Move = Move->next;
  }
  
  //****************************改变选中进程的属性
  Max_Pri->used_time += Time_film;    
  Max_Pri->priority_number -= 8;
  if(Max_Pri->used_time == Max_Pri->need_time){	
      Max_Pri->process_state = 0;
      count++;
  }
  else{
      Max_Pri->process_state = 1;
  }
  printf("进程 %d 被调度: \n",Max_Pri->process_name);
  //*****************************输出此时的两个队列 
  printf("        就绪队列：\n");
  print(head);    //输出就绪队列
  printf("        已完成队列：\n");
  print(h);    //输出已完成队列
  printf("\n");
  
  //****************************//将最高优先级进程提出来
  Move = Max_Pri->cre;        
  Move->next = Max_Pri->next;
  if(Move->next != NULL){
      Move = Max_Pri->next;
      Move->cre = Max_Pri->cre;    
  }
  //*****************************把拿出来的相应的进程放入队列
  
  if(Max_Pri->process_state !=0){
  	printf("进程 %d 未完成，进入就绪队列 \n\n",Max_Pri->process_name);
      Move = head;
      while( Move->next!=NULL ){    //当被调出进程未完成时将其插入就绪队列尾部 
          Move = Move->next; 
      }
      Tail = Move;
      Max_Pri->cre = Tail;
      Max_Pri->next = NULL;
      Tail->next = Max_Pri;
      
  }else{
  	printf("进程 %d 已完成，进入已完成队列 \n\n",Max_Pri->process_name);
  	Move =h;
  	while(Move->next!=NULL){
  		Move = Move->next;
  	}
  	hT = Move;
  	Max_Pri->cre = hT;
  	Max_Pri->next = NULL;
  	hT->next = Max_Pri;
  
  }
 //********************************再把状态改回去 
  
  if(Max_Pri->process_state !=0){
  	Max_Pri->process_state = -1;
  }else{
  	Max_Pri->process_state = 0;
  }
   
  if(count == N){    //所有进程执行完毕 
  	printf("        就绪队列：\n");
      print(head);    //输出就绪队列
      printf("        已完成队列：\n");
      print(h);    //输出已完成队列
      printf("\n");
      printf("        所有进程执行完毕！");
      return;
  }
  //****************************循环调用 
  Process_scheduling(head,h);
}

void print(struct PCB *head){    //输出队列函数 
  if(head->next == NULL){
      printf("队列为空\n");
      return;
  }
  printf("进程号 已占用cpu时间 所需时间 优先级 状态\n");
  struct PCB *fry = head->next;
  while(fry != NULL){
      printf(" %d           ",fry->process_name);
      printf("%d           ",fry->used_time);
      printf("%d      ",fry->need_time-fry->used_time);
      printf("%d    ",fry->priority_number);
      if(fry->process_state == -1){
      	printf("%s","W"); 
  	}else if(fry->process_state == 1){
  		printf("%s","R");
  	}else{
  		printf("%s","F");
  	}
      printf("\n");
      fry = fry->next;    
  }
  printf("\n"); 
}

int main(){
  printf("---------优先级调度---------\n"); 
  printf("输入进程数：\n");
  scanf("%d",&N);
  	
  struct PCB *head;    //头指针
  struct PCB Pro[N+1];    //创建 N+1 个进程
  struct PCB *h;
  struct PCB q[N+1];
  h = &q[0];
  head = &Pro[0];

  printf("请输入%d个进程号以及运行时间：\n",N);
  for(int j=1;j<=N;j++){
  	scanf("%d %d",&Pro[j].process_name,&Pro[j].need_time);
  } 
  //****************************
  //设置进程参数
  Pro[0].process_name = 0;
  Pro[0].cre = NULL;
  Pro[0].next = &Pro[1];
  Pro[0].priority_number = 0;
  int i=0;
  for(i=1;i<=N;i++){
      Pro[i].priority_number = 100-Pro[i].need_time;
      Pro[i].arrive_time = 0;
      Pro[i].used_time = 0;
      Pro[i].process_state = -1;
  }
  for(i=1;i<=N;i++){    //形成双向队列
      if( i == N ){
          Pro[i].cre = &Pro[i-1];
          Pro[i].next = NULL;
          break;
      }
      Pro[i].cre = &Pro[i-1];
      Pro[i].next = &Pro[i+1];
  }
  //****************************
  
  printf("        进程初始状态: \n");
  print(head);    //输出初始队列状态
  
  Process_scheduling(head,h);    //调用进程调度函数(最高优先级)
  
  return 0;
}
轮转调度完整代码
#include<iostream>
#include<string>
#include <string.h>

int currentTime = 0;//当前时间
int number = 0;

//using namespace std;
struct pcb {
  int pName;//进程名
  struct pcb *next;//指向下一个进程
  struct pcb *cre;//指向上一个进程 
  int arriveTime;//到达时间
  int serviceTime;//总共需要运行的时间 
  int estimatedRunningtime;//还需要的运行时间
  int usedtime;//++ 
  int state;//进程的状态
  int filmtime;//时间片的长度 
  int flag; //计算运行了多少次 
};


void printing(struct pcb *p){
  if(p->next == NULL){
  	printf("队列为空\n");
      return;
  }
  printf("进程号 已占用CPU时间 所需时间 计数 时间片长度 状态\n");
  struct pcb *fry = new struct pcb;
  fry = p->next;
  while(fry != NULL){
  	printf("  %d          ",fry->pName);
      printf("%d          ",fry->usedtime);
      printf("%d      ",fry->estimatedRunningtime);
      printf("%d        ",fry->flag );
      printf("%d      ",fry->filmtime );
      if(fry->state == -1){
      	printf("%s","W"); 
  	}else if(fry->state == 1){
  		printf("%s","R");
  	}else{
  		printf("%s","F");
  	}
      
      printf("\n");
      fry = fry->next;

  }
}


void runProcess(struct pcb *p, struct pcb *h,int n) {//运行进程
  //*******************************************每次都是取队头 
  struct pcb *q = p;
  struct pcb *m = p->next;
  struct pcb *Tail;    //未完成的进程的尾指针 
  struct pcb *hT;//完成的进程的尾指针++ 
  //********************************************改变选中进程的属性
  m->estimatedRunningtime-=m->filmtime;
  m->usedtime+=m->filmtime;
  m->flag+=1;
  currentTime+=m->filmtime;
  if(m->usedtime>=m->serviceTime){
  	m->state = 0;
  	m->estimatedRunningtime = 0;
  	m->usedtime = m->serviceTime;
  	number++;		
  } else{
  	m->state = 1; 
  }
  printf("进程 %d 被调度: \n",m->pName);
  //************************************输出此时的两个队列 
  printf("        就绪队列：\n");
  printing(p);
  printf("        已完成队列：\n");
  printing(h);
  printf("\n\n");
  //*******************************************把进程拿出来
  q = m->cre;
  q->next = m->next;
  if(q->next != NULL){
      q = m->next;
  	q->cre =m->cre;
  }
  //********************************************把拿出来的相应的进程放入队列
  if(m->state != 0){
 		printf("进程 %d 未完成，进入就绪队列 \n\n",m->pName );
     	q = p;
     	while( q->next!=NULL ){ 
         	q = q->next; 
     	}
     	Tail = q;
     	m->cre = Tail;
     	m->next = NULL;
     	Tail->next = m;
 	}else{
  	printf("进程 %d 已完成，进入已完成队列 \n",m->pName );
  	q = h;
 		while(q->next!=NULL){
 			q = q->next;
  	}
  	hT = q;
  	m->cre = hT;
 		m->next = NULL;
 		hT->next = m;    	
  }		
  
  //************************************再把状态改回去 
  if(m->state !=0){
  	m->state = -1;
  }else{
  	m->state = 0;
  }
  
  if(number == n){    //所有进程执行完毕 ++
  	printf("        就绪队列：\n");
      printing(p);    //输出就绪队列
      printf("        已完成队列：\n");
      printing(h);    //输出已完成队列
      printf("\n");
  	printf("------所有进程执行完毕！------\n");
      return;
 	}
  runProcess(p,h,n);

}



int main() {
  printf("---------轮转调度---------\n");
  struct pcb *p;
  struct pcb *h;
  int n;
  printf("输入进程数：\n");
  scanf("%d",&n);
  struct pcb q[n+1];
  h = &q[0];
  q[0].pName = 0;
  q[0].cre = NULL;
  
  struct pcb Pro[n+1];    //创建 N+1 个进程-----就绪状态队列   
  p = &Pro[0];    
  printf("请输入%d个进程号以及运行时间：\n",n);
  for(int j=1;j<=n;j++){
  	scanf("%d %d",&Pro[j].pName,&Pro[j].serviceTime);
  } 

  for(int i=0;i<=n;i++){
      if(i==0){
          Pro[i].pName = 0;
          Pro[i].cre = NULL;
          Pro[i].next = &Pro[i+1];
          continue;
      }
      Pro[i].arriveTime=0;
      Pro[i].filmtime=2;
      Pro[i].estimatedRunningtime=Pro[i].serviceTime;
      Pro[i].state = -1;
      Pro[i].usedtime = 0;
      Pro[i].flag = 0;
  }
  for(int i=1;i<=n;i++){    //形成双向队列
      if( i == n ){
          Pro[i].cre = &Pro[i-1];
          Pro[i].next = NULL;
          break;
      }
      Pro[i].cre = &Pro[i-1];
      Pro[i].next = &Pro[i+1];
  }
  
  printf("        进程初始状态: \n");
  printing(p);    //输出初始队列状态
  printf("\n");
  
  runProcess(p,h,n);
  return 0;
}

最后得说明一下我的代码是根据一个博主的代码再经过自己的修改得到的，在这里贴一下源代码的出处：https://www.cnblogs.com/chiweiming/p/9028002.html
如果有写的不清楚或者写的不对的地方的欢迎留言交流噢

louiseyy
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Qt的操作系统实验一CPU调度：优先级调度&时间片轮转调度
10-31
利用Qt平台基于C++语言和可视化ui界面编写算法，实现动态CPU调度模拟系统。
优先调度算法和循环轮转调度算法
06-11
优先调度算法和循环轮转调度算法。java语言编写，非DOS界面，有窗口界面
操作系统进程调度C++源文件
05-28
优先级调度&轮转法的进程调度模拟器C++源文件，用于大学操作系统课程实验的代码参考。
十、调度算法----时间片轮转、优先级调度、多级反馈队列
zhaozhiwei314的博客
02-06 853
一、知识总览 二、时间片轮转法 注意： 如果时间片太大，使得每个进程都可以在一个时间片内完成，则时间片轮转调度算法退化为先来先服务调度算法，并且会增大进程的响应时间，因此时间片不能太大。 另一方面，进程调度、切换是有时间代价的（保存、恢复运行环境），因此如果时间片太小，会导致进程切换过于频繁，系统会花大量的时间来处理进程直接的切换，从而导致实际用于进程执行的时间比例减少。可见时间片也不能太小（一般来说，设计时间片时要让切换进程的开销占比不超过1%）。 三、优先级调度算法 1.非抢占式的优先级调度算法
优先级算法和时间轮转算法
11-28
模拟进程调度优先级算法和时间轮转算法。。无bug，可支持模拟100个进程同时测试。。，内有代码注释说明
【操作系统】-- 时间片轮转调度算法、优先级调度算法、多级反馈队列调度算法
热门推荐
张修宇的博客
06-04 1万+
公平地、轮流地为各个进程服务，让每个进程在一定时间间隔内都可以得到响应。按照各进程到达就绪队列的顺序，轮流让各个进程执行一个时间片，若进程未在一个时间片内执行完，则会剥夺处理机，将进程重新放到就绪队列队尾重新排队。用于进程调度抢占式算法不会优点：公平，响应快，适用于分时操作系统。缺点：由于高频率的进程切换，因此有一定的开销，不区分任务的紧急程度。根据任务的紧急程度来决定处理顺序。每个 作业/进程 有各自的优先级，调度时选择优先级最高的 作业/进程。可用于作业调度，也可用于进程调度，还可以用于I/O调度。抢占
操作系统实验一：CPU调度（优先级调度、时间片轮转调度）
m0_62816530的博客
10-31 2243
操作系统实验一，采用优先级调度算法和时间片轮转调度算法实现进程的动态添加、挂起、解挂、调度信息公示
操作系统进程调度算法——先来先服务、时间片轮转、优先级调度算法
weixin_57130368的博客
02-28 1万+
先来先服务调度算法、时间片轮转调度算法、优先级调度算法
优先级的时间片轮转算法（操作系统实验）
梦之马
11-21 1万+
实验题目： 基于优先数的时间片轮转调度算法调度处理器一、实验目的 在采用多道程序设计的系统中，同时处于就绪态的进程往往有多个，当就绪态的进程数大于处理器的个数时，就需按照某种策略进行分配处理器。本次设计模拟在单处理器情况下采用基于优先数的时间片轮转调度算法进行处理器调度，加深了解处理器调度工作过程。
实验3
weixin_30235225的博客
05-28 292
1.目的和要求 1.1.实验目的 用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。 1.2.实验要求 设计一个有 N个进程并发执行的进程调度模拟程序。 进程调度算法：采用最高优先级优先的调度算法（即把处理机分配给优先级最高的进程）和先来先服务（若优先级相同）算法。 (1). 每个进程有一个进程控制块（PCB）表示。进程控制块包含如下信息：进程名...
优先级调度和轮转调度算法
05-08
优先级调度 和 轮转调度算法的介绍，含相关测试数据
操作系统-进程调度算法.zip
12-25
操作系统进程调度算法 先进先出FIFO、最高优先级HPF（非抢占式）、时间片轮转算法RR 输入：进程序列文件，其中存储的是一系列要执行的进程， 每个进程包括 四个数据项： 进程id 号、 进程状态(1 就绪 2 等待 3 运行) 、所需时间 、优先数(0 级 最高) 输出: 进程执行序列 和等待时间 平均等待时间
广州大学操作系统课设-设计一个按照优先级调度算法实现处理机调度的程序 含报告
06-19
广州大学操作系统课设-设计一个按照优先级调度算法实现处理机调度的程序 含报告 题目一：设计一个按照时间片轮转法实现处理机调度的程序 虽然该文内容的是题目二，但是题目一和题目二也就调度方式不一样，其他都是完全相同的，也可以作为参考。 题目二：设计一个按照优先级调度算法实现处理机调度的程序 优先级调度算法实现处理机调度的程序设计提示如下：
【Leetcode】2007. 从双倍数组中还原原数组
weixin_43627638的博客
04-19 305
一个整数数组original可以转变成一个数组changed，转变方式为将original中每个元素加入数组中，然后将所有元素。给你一个数组changed，如果change是数组，那么请你返回original数组，否则请返回空数组。original的元素可以以顺序返回。
135. 分发糖果
最新发布
yinhua405的博客
04-23 789
//和前一个不相等。你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。///和前一个不相等。///和前一个不相等。///和前一个不相等。请你给每个孩子分发糖果，计算并返回需要准备的。
算法刷题-16
qq_45773834的博客
04-21 629
学习来源： leetcode，牛客 https://programmercarl.com https://www.yuque.com/taxing-qarr6/hxitgt/dedugmp09knerdi1
DFS与回溯专题：路径总和问题
孤舟一叶～的博客
04-19 782
对二叉树进行dfs搜索，递归计算每条路径的节点值之和，当某个节点的左右子节点都为空时，说明已经搜索完成某一条路径，将它与目标值进行比较，若相等，则为true。路径恢复： 向上回溯前，需要将当前节点从路径 list 中删除，即执行list.remove(list.size() - 1)。为什么要写list_all.add(new ArrayList(list))，而不是list_all.add(list)？注意：解释里面的sum.add(path)就是list_all.add(list)
算法矩阵提速原理
fanged的专栏
04-22 335
其实就我来看，计算机懂个P的高等数学，什么线性代数，概率，微积分，对于计算机来说都没有意义，没有意义，没有意义。但是在实践中，很多算法一旦上了矩阵，就跟开了外挂一样，速度飞快，这个又是什么原因呢？这里又要说说图形，音视频的数据的一些特点了，这些数据就是矩阵运算的最好示范，现在的CPU架构中，为了加速这些运算，所以进行了很多特别的优化，比如超线程，SIMD等等。简而言之，在现在的CPU体系中，使用矩阵运算，可以更贴近现在的架构，比如Cache的结构，SIMD的指令集以及一些其它指令集。所以会觉得速度很快。
牛客NC233 加起来和为目标值的组合(四)【中等 DFS C++、Java、Go、PHP】
weixin_37991016的博客
04-22 187
代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可。* @param nums int整型一维数组。* @param target int整型。* @return int整型。
时间片轮转算法和优先级调度算法
04-26
时间片轮转算法和优先级调度算法都是操作系统中常用的进程调度算法。时间片轮转算法是将CPU的使用时间分为若干个时间片，每个进程在一个时间片内得到一定的时间来使用CPU，当时间片用完后，操作系统会剥夺当前进程的CPU使用权并将其放回就绪队列的队尾，然后调度下一个等待CPU使用的进程运行。 优先级调度算法是根据进程的优先级来进行调度。进程优先级越高，越容易被调度。操作系统会根据每个进程的优先级和当前系统负载情况选择一个优先级最高的进程运行，如果多个进程的优先级相同，则按照时间片轮转算法的方式进行调度。 这两种算法各有优缺点，时间片轮转算法能保证每个任务都有机会获得CPU执行时间，但可能导致一些低优先级的进程长时间无法得到执行；优先级调度算法能保证高优先级进程优先执行，但可能会导致低优先级的进程饥饿现象。因此，操作系统通常采用两种算法的结合方式进行进程调度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值