进程调度算法

于 2024-01-20 13:39:08 发布
阅读量600 收藏 9
点赞数 18
分类专栏： 算法与数据结构及其他 文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59994613/article/details/135691670
版权

文章目录

主要内容

一.进程调度算法

1.各调度算法思想

  1. 先来先服务算法（First Come, First Served，FCFS）：这是最简单的调度算法之一。进程按照它们进入就绪队列的顺序进行调度，首先进入队列的进程首先被执行。这意味着后来的进程必须等待前面的进程完成才能执行。

  2. 短作业优先调度算法（Shortest Job First，SJF）：这种算法会优先选择执行时间最短的进程。当一个新的进程进入就绪队列时，系统会比较它的执行时间与当前就绪队列中所有进程的执行时间，然后选择执行时间最短的进程来执行。

  3. 时间片轮转调度算法（Round Robin）：在这种算法中，每个进程被分配一个时间片，当时间片用完时，操作系统会将该进程移到就绪队列的末尾，然后选择下一个就绪队列中的进程来执行。这种方法确保了每个进程都有机会执行，并且避免了长时间的等待。

  4. 优先级调度算法（Priority Scheduling）：这种算法根据每个进程的优先级来决定执行顺序。较高优先级的进程会优先执行，而较低优先级的进程则会被推迟执行。这种算法可以是静态的（优先级在进程创建时确定）或者动态的（优先级可以随着时间变化）。
    在这里插入图片描述

这些调度算法各有优劣，适用于不同的场景和需求。选择适当的调度算法可以提高系统的性能和效率。

2.程序流程图

在这里插入图片描述

3.源代码

代码如下（示例）:
#include<bits/stdc++.h>
#include<windows.h>
using namespace std;
struct PCB
{
 int pid;//进程号
 char pname;//进程名
 double priority;//优先级
 int arrive;//到达时间
 int service;//服务时间
 int start;//开始时间
 int end;//结束时间
 int turnover;//周转时间
 double author_turnover;//带权周转时间
} pcb[5];

double fcfs_author,fcfs_turnover,sjf_author,sjf_turnover,hrrn_author,hrrn_turnover;
vector<PCB> fcfs;
vector<PCB> sjf;
vector<PCB> hrrn;

int cmp(PCB a,PCB b)//fcfs
{
 return a.arrive<b.arrive;
}

int cmp1(PCB a,PCB b)//sjf  排序，按service升序排序，如果service相等，则按arrive升序排序
{
 return (a.service<b.service)||(a.service==b.service&&a.arrive<b.arrive);
}

int cmp2(PCB p1, PCB p2) //hrrn 
{
 return (p1.priority > p2.priority) || (p1.priority==p2.priority && p1.arrive<p2.arrive);
}

void Compare()//打印算法对比 
{
 cout<<"先来先服务调度算法！"<<endl;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0;i<fcfs.size();i++)
 {
  cout<<"\t"<<fcfs[i].pname<<"\t\t"<<fcfs[i].arrive<<"\t\t"<<fcfs[i].service<<"\t\t"<<fcfs[i].end<<"\t\t"<<fcfs[i].turnover<<"\t\t";
  printf("%.2lf\n",fcfs[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",fcfs_turnover);
 printf("\t平均带权周转时间：%.2lf\n",fcfs_author);
 
 cout<<endl;
 cout<<endl;
 
 cout<<"短作业优先算法！"<<endl;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0;i<sjf.size();i++)
 {
  cout<<"\t"<<sjf[i].pname<<"\t\t"<<sjf[i].arrive<<"\t\t"<<sjf[i].service<<"\t\t"<<sjf[i].end<<"\t\t"<<sjf[i].turnover<<"\t\t";
  printf("%.2lf\n",sjf[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",sjf_turnover);
 printf("\t平均带权周转时间：%.2lf\n",sjf_author);
 
 cout<<endl;
 cout<<endl;
 
 cout<<"高响应比优先算法！"<<endl;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0;i<hrrn.size();i++)
 {
  cout<<"\t"<<hrrn[i].pname<<"\t\t"<<hrrn[i].arrive<<"\t\t"<<hrrn[i].service<<"\t\t"<<hrrn[i].end<<"\t\t"<<hrrn[i].turnover<<"\t\t";
  printf("%.2lf\n",hrrn[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",hrrn_turnover);
 printf("\t平均带权周转时间：%.2lf\n",hrrn_author);
 system("pause");
 system("cls");
}

void print()
{
 system("cls");
 cout<<"\n\n";
 cout<<"\t 进程名：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname;
 }
 cout<<endl;
 cout<<"\t到达时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].arrive;
 }
 cout<<endl;
 cout<<"\t服务时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].service;
 }
 cout<<endl;
 cout<<endl;
 system("pause");
 system("cls");
}

void FCFS()   //先来先服务
{

 system("cls");
 cout<<"先来先服务调度算法！"<<endl;
 //打印
 cout<<"\n\n";
 cout<<"\t 进程名：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname;
 }
 cout<<endl;
 cout<<"\t到达时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].arrive;
 }
 cout<<endl;
 cout<<"\t服务时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].service;
 }
 cout<<endl;
 cout<<endl;
 int finish = 0;//当前时间，初始化为0
 sort(pcb,pcb+5,cmp);
 int sum_turnover = 0;
 double sum_author_turnover = 0.0;
 for(int i=0; i<5; i++)
 {
  if(pcb[i].arrive>finish)
   pcb[i].end = pcb[i].arrive+pcb[i].service;
  else
   pcb[i].end = pcb[i].service+finish;
  finish = pcb[i].end;
  pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
  pcb[i].start = pcb[i].end-pcb[i].service;
  pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
  sum_turnover+=pcb[i].turnover;
  sum_author_turnover+=pcb[i].author_turnover;
  fcfs.push_back(pcb[i]);
 }

 //过程
 int cpu = 0;
 int f[5] = {0};//初始化为0，代表不占用
 while(1)
 {
  if(cpu==pcb[4].end)
  {
   cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
   break;
  }
  for(int i=0; i<5; i++)
  {
   if(pcb[i].arrive==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
   }
  }
  for(int i=0; i<5; i++)
  {
   if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
   {
    f[i]=1;//占用cpu
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    Sleep(pcb[i].service*100);
   }
   if(pcb[i].end==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    f[i]=0;//解除占用cpu
   }
  }
  cpu++;
 }

 //计算
 double avg_turnover = (double)sum_turnover/5;
 double avg_author_turnover = (double)sum_author_turnover/5;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
  printf("%.2lf\n",pcb[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",avg_turnover);
 fcfs_turnover=avg_turnover;
 printf("\t平均带权周转时间：%.2lf\n",avg_author_turnover);
 fcfs_author=avg_author_turnover;
 system("pause");
 system("cls");
}



void SJF()
{
 system("cls");
 cout<<"短作业优先调度算法！"<<endl;
 //打印
 cout<<"\n\n";
 cout<<"\t 进程名：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname;
 }
 cout<<endl;
 cout<<"\t到达时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].arrive;
 }
 cout<<endl;
 cout<<"\t服务时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].service;
 }
 cout<<endl;
 cout<<endl;

 int i,j=0,finish=0;//j为当前就绪队列的末尾指针 
 sort(pcb,pcb+5,cmp);//排序

// for(int i=0;i<5;i++)
//  cout<<pcb[i].pname; 测试排序是否正确
 int sum_turnover = 0;
 double sum_author_turnover = 0.0;
 for(int i=0; i<5; i++)
 {
  while(j<5&&pcb[j].arrive<=finish)//当有新的进程的进入时间小于当前时间，就加入就绪队列 
   j++;
  sort(pcb+i,pcb+j,cmp1); 
  if(pcb[i].arrive>finish)
   pcb[i].end = pcb[i].arrive+pcb[i].service;
  else
   pcb[i].end = pcb[i].service+finish;
  finish = pcb[i].end;
  pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
  pcb[i].start = pcb[i].end-pcb[i].service;
  pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
  sum_turnover+=pcb[i].turnover;
  sum_author_turnover+=pcb[i].author_turnover;
  sjf.push_back(pcb[i]);
 }
 
 //过程
 int cpu = 0;
 int f[5] = {0};//初始化为0，代表不占用
 while(1)
 {
  if(cpu==pcb[4].end)
  {
   cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
   break;
  }
  for(int i=0; i<5; i++)
  {
   if(pcb[i].arrive==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
   }
  }
  for(int i=0; i<5; i++)
  {
   if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
   {
    f[i]=1;//占用cpu
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    Sleep(pcb[i].service*100);
   }
   if(pcb[i].end==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    f[i]=0;//解除占用cpu
   }
  }
  cpu++;
 }
 
 
 //计算
 double avg_turnover = (double)sum_turnover/5;
 double avg_author_turnover = (double)sum_author_turnover/5;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
  printf("%.2lf\n",pcb[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",avg_turnover);
 sjf_turnover=avg_turnover;
 printf("\t平均带权周转时间：%.2lf\n",avg_author_turnover);
 sjf_author=avg_author_turnover;
 system("pause");
 system("cls");
}

void init()
{
 cout<<endl;
// for(int i=0;i<5;i++)
// {
//  pcb[i].pid = i;
//  cout<<"进程："<<i<<endl;
//  cout<<"进程名：";
//  cin>>pcb[i].pname;
//  cout<<"到达时间：";
//  cin>>pcb[i].arrive;
//  cout<<"服务时间：";
//  cin>>pcb[i].service;
//  cout<<endl;
// }
 pcb[0].pname='A';
 pcb[0].arrive=0;
 pcb[0].service=3;

 pcb[1].pname='B';
 pcb[1].arrive=4;
 pcb[1].service=6;

 pcb[2].pname='C';
 pcb[2].arrive=4;
 pcb[2].service=4;

 pcb[3].pname='D';
 pcb[3].arrive=6;
 pcb[3].service=5;

 pcb[4].pname='E';
 pcb[4].arrive=8;
 pcb[4].service=2;
 system("cls");
}

void menu()
{
 cout<<endl;
 cout<<endl;
 cout<<"\t   进程调度模拟程序"<<endl;
 cout<<endl;
 cout<<"\t1. 输入作业情况"<<endl;
 cout<<endl;
 cout<<"\t2. 显示作业情况"<<endl;
 cout<<endl;
 cout<<"\t3. 先来先服务算法"<<endl;
 cout<<endl;
 cout<<"\t4. 短作业优先算法"<<endl;
 cout<<endl;
 cout<<"\t5. 高响应比优先算法"<<endl;
 cout<<endl;
 cout<<"\t6. 算法结果对比"<<endl;
 cout<<endl;
 cout<<"\t0. 退出"<<endl;
 cout<<endl;
 cout<<"请输入选择:";
}

void HRRN()
{
 system("cls");
 cout<<"高响应比调度算法！"<<endl;
 //打印
 cout<<"\n\n";
 cout<<"\t 进程名：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname;
 }
 cout<<endl;
 cout<<"\t到达时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].arrive;
 }
 cout<<endl;
 cout<<"\t服务时间：";
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].service;
 }
 cout<<endl;
 cout<<endl;
 int sum_turnover = 0;
 double sum_author_turnover = 0.0;
 int j=0;
 int finish=0;
 sort(pcb, pcb+5, cmp);
 for(int i = 0; i < 5; i++)
 {
  while(j<5 && pcb[j].arrive <= finish)
   j++;
  for(int k = i; k < j; k++)
   pcb[k].priority = (finish-pcb[k].arrive+pcb[k].service) / pcb[k].service;
  sort(pcb+i, pcb+j, cmp2);

  if(pcb[i].arrive > finish)
   pcb[i].end = pcb[i].arrive + pcb[i].service;
  else
   pcb[i].end = finish + pcb[i].service;
  pcb[i].turnover = pcb[i].end - pcb[i].arrive;
  finish = pcb[i].end;
  pcb[i].start = pcb[i].end-pcb[i].service;
  pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
  sum_turnover+=pcb[i].turnover;
  sum_author_turnover+=pcb[i].author_turnover;
  hrrn.push_back(pcb[i]);
 }
 
 
 //过程
 int cpu = 0;
 int f[5] = {0};//初始化为0，代表不占用
 while(1)
 {
  if(cpu==pcb[4].end)
  {
   cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
   break;
  }
  for(int i=0; i<5; i++)
  {
   if(pcb[i].arrive==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
   }
  }
  for(int i=0; i<5; i++)
  {
   if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
   {
    f[i]=1;//占用cpu
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    Sleep(pcb[i].service*100);
   }
   if(pcb[i].end==cpu)
   {
    cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    f[i]=0;//解除占用cpu
   }
  }
  cpu++;
 }
 
 //计算
 double avg_turnover = (double)sum_turnover/5;
 double avg_author_turnover = (double)sum_author_turnover/5;
 cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
 for(int i=0; i<5; i++)
 {
  cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
  printf("%.2lf\n",pcb[i].author_turnover);
 }
 printf("\t平均周转时间：%.2lf\t",avg_turnover);
 hrrn_turnover=avg_turnover;
 printf("\t平均带权周转时间：%.2lf\n",avg_author_turnover);
 hrrn_author=avg_author_turnover;
 system("pause");
 system("cls");
}

int main()
{
 int flag=1;
 while(1)
 {
  menu();
  int sel;
  cin>>sel;
  switch(sel)
  {
   case 1:
    init();
    break;
   case 2:
    print();
    break;
   case 3:
    FCFS();
    break;
   case 4:
    SJF();
    break;
   case 5:
    HRRN();
    break;
   case 6:
    Compare();
    break;
   case 0:
    exit(0);
  }
 }
 return 0;
}

4.运行结果分析

展示及显示作业情况
在这里插入图片描述

5.先来先服务算法

在这里插入图片描述

6.短作业优先算法

在这里插入图片描述

7.高响应优先算法

在这里插入图片描述

8.算法结果对比

在这里插入图片描述

总结

以上是今天要讲的内容，练习了进程调度算法。

K要努力
关注
  • 18
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
操作系统进程调度算法
xy的博客
02-18 1万+
基本的操作系统进程调度算法包括先来先服务（first come first serve），时间片轮转（round robin），多级反馈轮转法（round robin with multiple feedback），优先级法（静态优先级法/动态优先级法），短作业优先法（shortest job first），最高响应比优先法（highest response_ratio next）。
进程的调度算法
honeyJ
03-23 1031
一、进程的调度进程调度方式是指当某一处进程正在处理机上执行时，若有某个更为重要或紧迫的进程需要处理，即有优先权更高的进程进入就绪队列，此时应如何分配处理机。这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。二、进程的调度算法1．先来先服务调度算法（FCFS）      先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于...
几个常用的操作系统进程调度算法
热门推荐
luyafei_89430的专栏
10-23 7万+
一、先来先服务和短作业(进程)优先调度算法 1．先来先服务调度算法 先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的
【操作系统】_7种进程调度算法
weixin_43916755的博客
04-27 2万+
书中一共描述了七种进程调度算法，为了学到这几种调度算法，后边做了几道练习题。 1. 先来先服务（FCFS）调度算法 先来先服务调度算法是最简单的调度方法。其基本原则是，按照进程进入就绪队列的先后次序进行选择。对于进程调度来说，一旦一个进程得到处理机，它就一直运行下去，直到该进程完成任务或者因等待某事件而不能继续运行，才会让出处理机。先来先服务调度算法属于非剥夺方式。 从表面上看，这个方法对于所有进程都是公平的，并且一个进程的等待时间是可以预先估计的。但是从另一方面来说，这个方法并非公平，因为当一个大进程先到
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
01-01
本文将深入探讨Java环境下实现的四种进程调度算法：先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)以及高响应比优先(HRN)。这些算法在多任务环境中用于决定哪个进程应该获得CPU的执行权，以达到资源分配的公平...
操作系统实验：时间片轮转RR进程调度算法.doc
05-11
时间片轮转RR进程调度算法 本文档对时间片轮转RR进程调度算法进行了详细的实现和分析。该算法是操作系统中的一种常用的进程调度算法，能够合理地分配CPU时间片，提高系统的效率和公平性。 一、需求分析 时间片...
表妹教你进程调度算法
帅枫的博客
11-22 1005
前言 进程调度算法也称 CPU 调度算法，当 CPU 空闲时，操作系统就从就绪队列中按照一定的算法选择某个就绪状态的进程，并给其分配 CPU。通常以下几种情况会发生进程的调度： 当进程从运行状态转到等待状态； 当进程从运行状态转到就绪状态； 当进程从等待状态转到就绪状态； 当进程从运行状态转到终止状态； 其中 1 和 4 称为非抢占式调度，2 和 3 称为抢占式调度。非抢占式调度就是当进程正在运行时，它就会一直运行，直到该进程完成或发生某个事件而被阻塞时，才会把 CPU 让给其他进程；抢占式调度就是进程
进程调度算法详解
smf12138的博客
11-15 2533
例如，如果一个工作不断放弃CPU去等待键盘输入，这是交互型进程的可能行为，MLFQ因此会让它保持高优先级，相反，如果一个工作长时间的占用CPU，MLFQ会降低其优先级，通过这种方式，MLFQ在进程运行过程中学习其行为，从而利用工作的历史来预测它未来的行为.A（黑色）在最低优先级队列执行（长时间运行的CPU密集型工作），B（灰色）在时间T = 100时到达，并被加入最高优先级队列，由于它的运行时间很短，经过两个时间片，在被移入最低优先级队列之前，B执行完毕，然后A继续运行.如果 B 是交互型工作，
常用的进程调度算法
越陌度阡
12-14 6179
进程调度是由操作系统的进程调度程序按照某种策略和算法从就绪态进程中为当前空闲的CPU选择要运⾏的新进程，常用的进程调度算法有以下几种： 1. 先来先服务调度算法 从就绪队列的队⾸选择最先到达的进程，为该进程分配CPU。下面通过一个例子来说明先来先服务算法。 已知：就续队列中有3个进程， 分别为P1、P2、P3，进入系统的时间分别为0、1、2，服务时间分别为24、3、3，求3个进程的系统......
「 操作系统 」聊聊进程调度算法
frozenpenguin的博客
04-08 4499
进程调度算法是操作系统中非常重要的一部分，它决定了操作系统中各个进程的执行顺序和时间片。在单核CPU下，任何时刻都只可能有一个程序在执行，比如正在计算1*2这个程序A，那么就不能运行1+…+n这个求和程序B，这个时候程序A处于执行状态，而程序B处于非执行状态。我们在任意时刻到底是执行哪个程序呢？我们运行的地铁列车，有指挥中心统一控制调度，到底由哪些地铁执行哪一天的任务，这是因为轨道等资源有限，不可能全放进去。类似到进程调度，CPU等硬件资源有限，也不可能全部一起执行。这就引出了我们的进程调度。
【操作系统-进程】进程的调度算法
最新发布
Mount256的博客
08-23 9275
【例】（2016 统考真题）某进程调度程序采用基于优先数（priority）的调度策略，即选择优先数最小的进程运行，进程创建时由用户指定一个 nice 作为静态优先数。【解】（1）由于采用了静态优先数，当就绪队列中总有优先数较小的进程时，优先数较大的进程一直没有机会运行，因而会出现饥饿现象。（1）若调度程序只将 nice 的值作为进程的优先数，即 priority = nice，则可能会出现饥饿现象，为什么?时间片轮转（RR）调度算法（时间片=2）时间片轮转（RR）调度算法（时间片=5）
操作系统进程调度算法流程图：先来先服务，短作业优先，优先权高者优先
04-03
暂不支持图片回答，以下为文字版解析。 先来先服务（FCFS）调度算法流程图： 1. 就绪队列中的进程按照进入队列的先后顺序排列； 2. 当前进程执行完毕或发生阻塞，将就绪队列中的下一个进程调度到CPU上执行。 短作业优先（SJF）调度算法流程图： 1. 就绪队列中的进程按照估计执行时间从小到大排序； 2. 当前进程执行完毕或发生阻塞，将就绪队列中的下一个执行时间最短的进程调度到CPU上执行。 优先权高者优先（Priority）调度算法流程图： 1. 就绪队列中的进程按照优先级从高到低排序； 2. 当前进程执行完毕或发生阻塞，将就绪队列中优先级最高的进程调度到CPU上执行。 注：以上流程图仅是简单的示意图，实际情况还要考虑多个进程同时就绪、进程抢占等因素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

K要努力

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值