精华内容
下载资源
问答
  • 多级队列反馈调度算法

    千次阅读 2010-11-13 13:04:00
    void MultiDispatch() /*多级调度算法,每次执行一个时间片*/ {  int flag = 1;  ReadyQueue *point;  point = Head;  pop(point);  while(running != NULL)  {  if(Head ->LinkPCB!=NULL)  point = Head; ...

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>

    typedef struct processNode    /*进程节点信息*/
    {
     char name[20];      /*进程的名字*/
     int prio;       /*进程的优先级*/
     int round;       /*分配CPU的时间片*/
     int cputime;      /*CPU执行时间*/
     int needtime;      /*进程执行所需要的时间*/
     char state;       /*进程的状态,W——就绪态,R——执行态,F——完成态*/
     int count;       /*记录执行的次数*/
     struct processNode *next;   /*链表指针*/
    }PCB;
    typedef struct Queue     /*多级就绪队列节点信息*/
    {
     PCB *LinkPCB;      /*就绪队列中的进程队列指针*/
     int prio;       /*本就绪队列的优先级*/
     int round;       /*本就绪队列所分配的时间片*/
     struct Queue *next;     /*指向下一个就绪队列的链表指针*/
    }ReadyQueue;
    PCB *running=NULL,*finished=NULL;  /*定义三个队列,就绪队列,执行队列和完成队列*/
    ReadyQueue *Head = NULL; /*定义第一个就绪队列*/
    static ReadyQueue *ready=NULL;
    int num;        /*进程个数*/
    int ReadyNum;       /*就绪队列个数*/
    void Output();       /*进程信息输出函数*/
    void Insertfinished(PCB *in);   /*将进程插入到完成队列尾部*/
    void InsertReadyQueue(ReadyQueue *in); /*插入就绪队列,规定优先数越小,优先级越低*/
    void ReadyQueueInit();     /*创建就绪队列初始化函数*/
    void pop(ReadyQueue *queue);   /*取得某一个就绪队列中的队头进程*/
    void push(PCB *in,ReadyQueue *queue); /*将进程插入到就绪队列尾部*/
    void ProcessCreate();     /*进程创建函数*/
    void RoundRobin(ReadyQueue *timechip);  /*时间片轮转调度算法*/
    void MultiDispatch();     /*多级调度算法,每次执行一个时间片*/


    void Output()       /*进程信息输出函数*/
    {
     PCB *p = NULL; 
     
     p = ready->LinkPCB;
     if(p!=NULL)
      printf("就绪队列.../n");
     while(ready !=NULL)
     {
      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;
      }
      ready = ready->next;
      if(ready!=NULL)
       p = ready->LinkPCB;
     }

     p = finished;
     if(p!=NULL)
      printf("完成队列.../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;
     }
     printf("/n/n");
     p = running;
     if(p!= NULL)
      printf("运行队列.../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;
     }
    }
    void Insertfinished(PCB *in)   /*将进程插入到完成队列尾部*/
    {
     PCB *fst;
     fst = finished;

     if(finished == NULL)
     {
       in->next = finished;
       finished = in;
     }
     else
     {
       while(fst->next != NULL)
       {
        fst = fst->next;
       }
       in ->next = fst ->next;
       fst ->next = in;
     } 
     printf("the %s has finished!!!/n",in->name); 
     running = NULL;
     Output();
    }
    void InsertReadyQueue(ReadyQueue *in) /*创建就绪队列,规定优先数越小,优先级越低*/
    {
     ReadyQueue *fst,*nxt;
     fst = nxt = Head;

     if(Head == NULL)     /*如果没有队列,则为第一个元素*/
     {
       in->next = Head;
       Head = in;
     }
     else        /*查到合适的位置进行插入*/
     {
       if(in ->prio >= fst ->prio)  /*比第一个还要大,则插入到队头*/
       {
        in->next = Head;
        Head = in;
       
       }
       else
       {
        while(fst->next != NULL)   /*移动指针查找第一个比它小的元素的位置进行插入*/
        {
      nxt = fst;  
      fst = fst->next;
      if(in ->prio >= fst ->prio)
      {
       in ->next = fst;
       nxt ->next = in;
       return;
      }
        }
      
        if(fst ->next == NULL)   /*已经搜索到队尾,则其优先级数最小,将其插入到队尾即可*/
        {
      in ->next = fst ->next;
      fst ->next = in;
      return;
        }  
       }
     } 
    }
    void ReadyQueueInit()     /*创建就绪队列输入函数*/
    {
     ReadyQueue *tmp;
     int i=0, j=1;

     printf("输入就绪队列的个数:/n");
     scanf("%d",&ReadyNum);

     printf("输入每个就绪队列的CPU时间片:/n");
     for(i = 0;i < ReadyNum; i++)
     {
       if((tmp = (ReadyQueue *)malloc(sizeof(ReadyQueue)))==NULL)
       {
        perror("malloc failed!!!");
        exit(1);
       }
       printf("请输入就绪队列的时间片 : ");
       scanf("%d",&(tmp->round));  /*输入此就绪队列中给每个进程所分配的CPU时间片*/
       tmp ->prio = 50 - tmp->round;  /*设置其优先级,时间片越高,其优先级越低*/
       tmp ->LinkPCB = NULL;    /*初始化其连接的进程队列为空*/
       tmp ->next = NULL;
       InsertReadyQueue(tmp);   /*按照优先级从高到低,建立多个就绪队列*/
     }

     printf("**********Multiple ReadyQueue Information**********/n");
     ReadyQueue *rq = Head;
     
      while(rq != NULL){
       printf("第 %d 个就绪队列/n",j++);
       printf("优先级=%d/t 该就绪队列的时间片=%d/n",rq->prio,rq->round);
       rq = rq->next;
      } 
     
    }
    void pop(ReadyQueue *queue)    /*取得某一个就绪队列中的队头进程*/
    {
     running = queue ->LinkPCB;

     if(queue ->LinkPCB != NULL)
     {
       running ->state = 'R';
       queue ->LinkPCB = queue ->LinkPCB ->next;
       ready = queue;
       running ->next = NULL;  
     }
    }
    void push(PCB *in,ReadyQueue *queue) /*将进程插入到就绪队列尾部*/
    {
     PCB *fst;
     fst = queue->LinkPCB;

     if( queue->LinkPCB == NULL)
     {
       in->next =  queue->LinkPCB;
       queue->LinkPCB = in;
     }
     else
     {
       while(fst->next != NULL)
       {
        fst = fst->next;
       }
       in ->next = fst ->next;
       fst ->next = in;
     }

     printf("push the %s into Ready Queue!!!/n",in->name);
    }
    void ProcessCreate()     /*进程创建函数*/
    {
     PCB *tmp;
     int i,j=1,k;

     printf("**********输入进程的个数**********/n");
     scanf("%d",&num);

     for(i = 0;i < num; i++)
     {
       if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
       {
        perror("malloc failed!!!");
        exit(1);
       }
       k=j;
       printf("输入第%d个进程名字:/n",j++);
       scanf("%s",tmp->name);
       getchar();       /*吸收回车符号*/
       printf("输入第%d个进程需要的时间:/n",k);
       scanf("%d",&(tmp->needtime));
       tmp ->cputime = 0;
       tmp ->state ='W';
       tmp ->prio = 50 - tmp->needtime;  /*设置其优先级,需要的时间越多,优先级越低*/
       tmp ->round = Head ->round;
       tmp ->count = 0;
       push(tmp,Head);      /*按照优先级从高到低,插入到就绪队列*/
     }
     printf("***The first time ReadyQueue Information***/n");
       PCB *prq = Head->LinkPCB;  
       printf("进程名/t优先级/t轮数/tcpu时间/t需要时间/t进程状态/t计数器/n");
       while(prq != NULL)
       { 
        printf("%s/t%d/t%d/t%d/t%d/t/t%c/t/t%d/n",prq->name,prq->prio,prq->round,prq->cputime,prq->needtime,prq->state,prq->count); 
        prq = prq->next;
       }
    }
    void RoundRobin(ReadyQueue *timechip)   /*时间片轮转调度算法*/
    {

     int flag = 1;

     pop(timechip);
     while(running != NULL)
     {
       while(flag)
       {
        running->count++;
        running->cputime++;
        running->needtime--;
        if(running->needtime == 0)   /*进程执行完毕*/
        {
      running ->state = 'F';
      Insertfinished(running);
      flag = 0;
        }
        else if(running->count == timechip ->round)/*时间片用完*/
        {
      running->state = 'W';
      running->count = 0;     /*计数器清零,为下次做准备*/
      push(running,timechip);
      flag = 0;
        }
       }
       flag = 1;
       pop(timechip);
     }
    }
    void MultiDispatch()     /*多级调度算法,每次执行一个时间片*/
    {
     int flag = 1;
     ReadyQueue *point;
     point = Head;
     pop(point);
     while(running != NULL)
     {
        if(Head ->LinkPCB!=NULL)
         point = Head;
        while(flag)
        {
          running->count++;
          running->cputime++;
          running->needtime--;
          if(running->needtime == 0)   /*进程执行完毕*/
          {
        running ->state = 'F';
        Insertfinished(running);
        flag = 0;
          }
          else if(running->count == running->round)/*时间片用完*/
          {
         running->state = 'W';
         running->count = 0;     /*计数器清零,为下次做准备*/
         if(point ->next!=NULL)
         {
           running ->round = point->next ->round;/*设置其时间片是下一个就绪队列的时间片*/
           push(running,point->next);   /*将进程插入到下一个就绪队列中*/
           flag = 0;
           Output();
         }
         else
         {
           RoundRobin(point);     /*如果为最后一个就绪队列就调用时间片轮转算法*/
           break;
         }
        }      
       }
        flag = 1;
        if(point ->LinkPCB == NULL)   /*就绪队列指针下移,进入下一级就绪队列!!!*/
         point =point->next;
        if(point ->next ==NULL)
        {
          RoundRobin(point);
          break;
        }  
        pop(point);
     }
     
    }

    int main(void)
    {
     ReadyQueueInit();     /*创建就绪队列*/
     ProcessCreate();     /*创建就绪进程队列*/
     MultiDispatch();     /*算法开始*/ 
     return 0;
    }

     

    展开全文
  • 下面我们首先介绍,多级反馈队列调度算法 然后对前面介绍的各种调度算法进行比较 之后呢,我们简单讨论一下 在设计多处理器调度算法时所要考虑的几个问题 多级反馈队列调度算法 是 UNIX 的一个分支,BSD 5.3 版所...

    下面我们首先介绍,多级反馈队列调度算法 然后对前面介绍的各种调度算法进行比较 之后呢,我们简单讨论一下 在设计多处理器调度算法时所要考虑的几个问题 多级反馈队列调度算法 是 UNIX 的一个分支,BSD 5.3 版所采用的调度算法 它是在前面各种调度算法的基础之上 提出的一个综合的调度算法,是在考虑了各种 因素之后进行折中权衡的一个结果 下面我们介绍 一下多级反馈队列调度算法的基本思想 就绪队列设置成多个 其中第一级队列的优先级最高 依次从高到低,系统 给不同的就绪队列分配了长度不同的时间片 第一级队列优先级最高 但分配给它的时间片最小 随着队列优先级的不断降低 分配给队列的时间片就越大 比如说第一级队列分配给它一个单位的话 第二级队列就可以分配成两倍的时间片 那么第三级可以分配四倍的时间片,这就是 级别越低,时间片越大 在进行调度的时候 首先从优先级高的队列进行调度 如果第一级队列没有进程了 那么系统会从第二级队列进行调度,以此类推 每一个队列都是按照时间片轮转的方式进行调度 新创建的进程 就绪的时候呢都进入第一级队列 如果一个被调度上 CPU 的进程用完了时间片 而放弃了 CPU,那么它就进入下一集就绪队列 也就是说,它被降级了 那么如果一个被调度上 CPU 的进程 由于等待 I/O 而被阻塞,进入了等待队列 当等待的事件发生后,这个进程从等待队列 回到原来一级就绪队列。 那么这里头 我们可以根据不同的情况来设计不同的方案 以体现系统对这一类进程的 偏好程度,比如说 这个进程是回到原来一级就绪队列的队首呢 还是队尾?如果回到队首,说明系统对这类进程更加友好 另外,当这个进程再度被调度上 CPU 之后 是让它运行完剩余的时间片呢 还是重新给它分配一个完整的时间片让它去运行? 也体现了系统对这类进程的偏好程度 那么我们现在所看到的 多级反馈队列调度算法呢是一个非抢占式的 如果允许抢占呢 也就是说当有一个更高优先级的进程就绪的时候 可以抢占正在运行进程的 CPU 那么被抢占的进程呢 会回到原来一级就绪队列的末尾 当然也可以有不同的设计方案 比如说回到原来一级就绪队列的队首 当这个进程再度被调度上 CPU 时呢 可以运行完它刚才剩余的时间片 也可以重新给它一个完整的新的时间片让它运行 因此呢又派生出不同的设计方案 下面我们来看一下这张图 它反映了一个进程在 队列里头的一些迁移活动 当创建一个新的进程时 所有的进程都进入第一级队列 如果是 I/O 型的进程,那么它可能 被调度上 CPU 之后很短时间就去等待 I/O 当它从等待队列又回到就绪队列的时候 由于我们让它回到原来一级就绪队列,所以它呢优先级没有降低 被调度上 CPU 的机会很多。 但是对于 CPU 型的进程 它被调度上 CPU,用完了一个时间片之后 它就会回到下一级队列 那么如果每次都用完了它的时间片,它就会降级 可能一个 CPU 型的进程就慢慢降到了 优先级最低的这个队列里头,因此我们可以看到 通过这样一个调度算法 就可以慢慢地区分出来哪些进程是 CPU 型进程 哪些进程是 I/O 型进程,很显然 多级反馈队列调度算法对 I/O 型进程更偏好一点 对 CPU 型进程呢不太有利 但是呢它也做了一些弥补,比如说 优先级高的队列时间片短 而优先级低的队列时间片会很大 所以当低优先级的 CPU 型进程被调度上 CPU 之后,它可以运行更长的时间 那这里呢也是一种平衡的结果。 下面 我们对前面介绍的各种调度算法 做一下小结。 在占用 CPU 的方式上 先来先服务,短作业优先 最高响应比优先调度算法是非抢占式的调度策略 最短剩余时间优先 则是一个抢占式的调度策略,而时间片轮转 多级反馈队列调度算法 则是允许在时间片到的时候可以进行抢占 在追求调度算法指标上 我们来看一下短作业优先 最短剩余时间优先和最高响应比优先 这三个调度算法都可以带来比较高的吞吐量 而 时间片轮转调度算法 如果时间片很小,那么它的吞吐量就很低 先来先服务调度算法 还有多级反馈队列调度算法对吞吐量这个指标 并不强调,在响应时间方面 时间片轮转,短作业优先两个调度算法 对短的作业可以提供很快的响应时间 最短剩余时间优先 和最高响应比优先调度算法呢,也可以提供很好的响应时间 而对于先来先服务调度算法 当不同的进程 它们的时间有很大差别的时候,对于某些进程 它的响应时间会很慢,下面我们来看一下 调度算法本身所带来的开销 先来先服务和时间片轮转调度算法 因为实现比较简单,所以开销比较小 而其它四种调度算法它们的开销可能很大 比如说最高响应比优先调度算法 它要计算每一个进程的响应比 才能选择响应比最高的那个进程。 所以计算响应比需要花时间 多级反馈队列调度算法需要维护多个就绪队列,这也需要花时间 接着我们来看一下不同的调度算法 对进程的影响。 时间片轮转调度算法 公平地对待每一个进程。 最高响应比优先调度算法 则是在先就绪的进程和短进程之间做了一个很好的平衡 而来先来先服务调度算法 对长进程之后的短进程,或者是 I/O 型进程 是不利的。 那么最短作业优先 和最短剩余时间优先的调度算法对长进程不利 会导致长进程产生饥饿现象 多级反馈队列调度算法 对于 I/O 型进程是偏好的,也就是说对 I/O 型进程有利 而对 CPU 型进程不利 会导致 CPU 型进程产生饥饿 所以没有一种调度策略是完美的 也不可能有一种调度策略对各种类型的进程都能够照顾到 因此在设计调度策略的时候,我们应该 考虑综合性的因素,下面 我们简要介绍一下在设计多处理器调度算法时 需要考虑的几个问题 在设计多处理器调度算法时 我们不仅要决定选择哪一个进程执行 而且还要确定这个被选中的进程在哪一个 CPU 上执行 另外我们必须要考虑 进程在多个 CPU 之间迁移时所带来的高速缓存 TLB 失效的开销 如果一个进程 之前在 CPU1 上执行,后来又被调度到了 CPU2 上执行 那么高速缓存 TLB 失效就会增加 而如果这个进程每次都被指定到 同一个 CPU 上执行,那么就会减少各种 失效。 因此 应该尽可能地使进程总在同一个 CPU 上执行 另外 呢,我们还应该考虑到一个负载均衡的问题 因为有多个 CPU,那么不可能让某些 CPU 非常地忙碌 而其它 CPU 很空闲,所以 我们要通过调度使得 所有的 CPU 都保持忙碌,那么这就 是一个负载均衡的问题

    展开全文
  • 多级反馈队列调度算法是一种CPU处理机调度算法,UNIX操作系统采取的便是这种调度算法多级反馈队列调度算法即能使高优先级的作业得到响应又能使短作业(进程)迅速完成。(对比一下FCFS与高优先响应比调度算法的缺陷)...

    多级反馈队列调度算法是一种CPU处理机调度算法,UNIX操作系统采取的便是这种调度算法。

    多级反馈队列调度算法即能使高优先级的作业得到响应又能使短作业(进程)迅速完成。(对比一下FCFS与高优先响应比调度算法的缺陷)。

    多级(假设为N级)反馈队列调度算法可以如下原理:

    1、设有N个队列(Q1,Q2….QN),其中各个队列对于处理机的优先级是不一样的,也就是说位于各个队列中的作业(进程)的优先级也是不一样的。一般来说,优先级Priority(Q1) > Priority(Q2) > … > Priority(QN)。怎么讲,位于Q1中的任何一个作业(进程)都要比Q2中的任何一个作业(进程)相对于CPU的优先级要高(也就是说,Q1中的作业一定要比Q2中的作业先被处理机调度),依次类推其它的队列。

    2、对于某个特定的队列来说,里面是遵循时间片轮转法。也就是说,位于队列Q2中有N个作业,它们的运行时间是通过Q2这个队列所设定的时间片来确定的(为了便于理解,我们也可以认为特定队列中的作业的优先级是按照FCFS来调度的)。

    3、各个队列的时间片是一样的吗?不一样,这就是该算法设计的精妙之处。各个队列的时间片是随着优先级的增加而减少的,也就是说,优先级越高的队列中它的时间片就越短。同时,为了便于那些超大作业的完成,最后一个队列QN(优先级最低的队列)的时间片一般很大(不需要考虑这个问题)。

    多级反馈队列调度算法描述:

    1、进程在进入待调度的队列等待时,首先进入优先级最高的Q1等待。

    2、首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程,则调度次优先级队列中的进程。例如:Q1,Q2,Q3三个队列,只有在Q1中没有进程等待时才去调度Q2,同理,只有Q1,Q2都为空时才会去调度Q3。

    3、对于同一个队列中的各个进程,按照时间片轮转法调度。比如Q1队列的时间片为N,那么Q1中的作业在经历了N个时间片后若还没有完成,则进入Q2队列等待,若Q2的时间片用完后作业还不能完成,一直进入下一级队列,直至完成。

    4、在低优先级的队列中的进程在运行时,又有新到达的作业,那么在运行完这个时间片后,CPU马上分配给新到达的作业(抢占式)。

    我们来看一下该算法是如何运作的:

    假设系统中有3个反馈队列Q1,Q2,Q3,时间片分别为2,4,8。

    现在有3个作业J1,J2,J3分别在时间 0 ,1,3时刻到达。而它们所需要的CPU时间分别是3,2,1个时间片。

    1、时刻0 J1到达。于是进入到队列1 , 运行1个时间片 , 时间片还未到,此时J2到达。

    2、时刻1 J2到达。 由于时间片仍然由J1掌控,于是等待。 J1在运行了1个时间片后,已经完成了在Q1中的2个时间片的限制,于是J1置于Q2等待被调度。现在处理机分配给J2。

    3、时刻2 J1进入Q2等待调度,J2获得CPU开始运行。

    4、时刻3 J3到达,由于J2的时间片未到,故J3在Q1等待调度,J1也在Q2等待调度。

    5、时刻4 J2处理完成,由于J3,J1都在等待调度,但是J3所在的队列比J1所在的队列的优先级要高,于是J3被调度,J1继续在Q2等待。

    6、时刻5 J3经过1个时间片,完成。

    7、时刻6 由于Q1已经空闲,于是开始调度Q2中的作业,则J1得到处理器开始运行。

    8、时刻7 J1再经过一个时间片,完成了任务。于是整个调度过程结束。

    从上面的例子看,在多级反馈队列中,后进的作业不一定慢完成。

    展开全文
  • 多级反馈队列调度算法多级反馈队列调度算法多级反馈队列调度算法多级反馈队列调度算法多级反馈队列调度算法多级反馈队列调度算法多级反馈队列调度算法多级反馈队列调度算法
  • 通常在使用多级队列调度算法时,进程进入系统时被永久地分配到某个队列。例如,如果前台和后台进程分别具有单独队列,那么进程并不从一个队列移到另一个队列,这是因为进程不会改变前台或后台的性质。这种设置的优点...

    通常在使用多级队列调度算法时,进程进入系统时被永久地分配到某个队列。例如,如果前台和后台进程分别具有单独队列,那么进程并不从一个队列移到另一个队列,这是因为进程不会改变前台或后台的性质。这种设置的优点是调度开销低,缺点是不够灵活。

    相反,多级反馈队列(multievel feedback queue)调度算法允许进程在队列之间迁移。这种想法是,根据不同CPU执行的特点来区分进程。如果进程使用过多的CPU时间,那么它会被移到更低的优先级队列。这种方案将I/O密集型和交互进程放在更高优先级队列上。 此外,在较低优先级队列中等待过长的进程会被移到更高优先级队列。这种形式的优化可阻止饥饿的发生。

    71f5188f353e7cfac03dc806ba547a0b.gif

    多级反馈队列

    例如,一个多级反馈队列的调度程序有三个队列,从02(如上图)。调度程序首先执行队列0内的所有进程。只有当队列0为空时,它才能执行队列1内的进程。类似地,只有队列01都为空时,队列2的进程才能执行。到达队列1的进程会抢占队列2的进程。同样,到达队列0的进程会抢占队列1的进程。

    每个进程在进入就绪队列后,就被添加到队列 0 内。队列 0 内的每个进程都有 8ms 的时间片。如果一个进程不能在这一时间片内完成,那么它就被移到队列1的尾部。如果队列0为空,队列 1 头部的进程会得到一个16ms 的时间片。如果它不能完成,那么将被抢占,并添加到队列2。只有当队列 01 为空时,队列 2 内的进程才可根据FCFS来运行。这种调度算法将给那些 CPU 执行不超过 8ms 的进程最高优先级。这类进程可以很快得到 CPU,完成 CPU 执行,并且处理下个 I/O 执行。
    所需超过 8ms 但不超过 24ms 的进程也会很快得以服务,但是它们的优先级要低一点。长进程会自动沉入队列2,队列01不用的CPU周期按 FCFS 顺序来服务。

    算法思想: 对其他调度算法的折中权衡。

    算法规则:

    a.设置多级就绪队列,各级队列优先级从高到低,时间片从小到大。

    b. 新进程到达时先进入第1级队列,按FCFS原则排队等待被分配时间片,若用完时间片进程还未结束,则进程进入下一级队列队尾。如果此时已经是在最下级的队列,则重新放回该队列队尾。

    c. 只有第k级队列为空时,才会为k+1级队头的进程分配时间片

    用于作业/进程调度: 用于进程调度

    是否可抢占? 抢占式算法

    优缺点: 对各类型进程相对公平(FCFS的优点);每个新到达的进程都可以很快就得到响应(RR优点);短进程只用较少的时间就可完成(SPF优点);不必实现估计进程的运行时间;可灵活地调整对各类进程的偏好程度,比如CPU密集型进程、I/O密集型进程(拓展:可以将因I/O而阻塞的进程重新放回原队列,这样I/O型进程就可以保持较高优先)

    是否会导致饥饿:

    通常,多级反馈队列调度程序可由下列参数来定义:

    1. 队列数量。
    2. 每个队列的调度算法。
    3. 用以确定何时升级到更高优先级队列的方法。
    4. 用以确定何时降级到更低优先级队列的方法。
    5. 用以确定进程在需要服务时将会进入哪个队列的方法。

    多级反馈队列调度程序的定义使其成为最通用的CPU调度算法。通过配置,它能适应所设计的特定系统。但是,由于需要一些方法来选择参数以定义最佳的调度程序,所以它也是最复杂的算法。

    展开全文
  • 计算机操作系统多级反馈队列算法\多级反馈队列调度算法的相关算法。
  • 多级反馈队列调度算法是目前操作系统调度算法中被公认的一种较好的调度算法。它可以满足各种类型进程的需要,既能使高优先级的作业得到响应又能使短作业(进程)迅速完成。基本概念多级反馈队列调度算法是一种根据先来...
  • 多级队列反馈调度算法用C语言模拟
  • 多级反馈队列算法 Multilevel Feedback Queue, MFQ 基于可剥夺的动态优先级调度策略 当一个进程第一次进入系统时它被放置在优先级最高的就绪队列 当它第一次执行后并返回就绪状态时它被放置到次优先级的就绪队列中在...
  • 通常在使用多级队列调度算法时,进程进入系统时被永久地分配到某个队列。例如,如果前台和后台进程分别具有单独队列,那么进程并不从一个队列移到另一个队列,这是因为进程不会改变前台或后台的性质。这种设置的优点...
  • C语言实现多级反馈队列调度算法-计算机操作系统实验。C语言实现多级反馈队列调度算法-计算机操作系统实验。
  • 在进程容易分成不同组的情况下,可以有另一类调度算法。例如,进程通常分为前台进程(foreground process)(或交互进程)和后台进程(background process)(或... 多级队列(multilevel queue)调度算法将就绪队列分成多个...
  • 多级反馈队列调度算法可以如下原理: 1、设有N个队列(Q1,Q2…QN),其中各个队列对于处理机的优先级是不一样的,也就是说位于各个队列中的作业(进程)的优先级也是不一样的。一般来说,优先级Priority(Q1) > ...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼【问题描述】多级反馈队列调度算法是操作系统中CPU处理机调度算法之一,该算法既能使高优先级的进程(任务)得到响应又能使短进程(任务)迅速完成。UNIX操作系统便采取这种...
  • 实验课程:操作系统实验名称:进程调度的设计与实现(综合实验)第一部分实验内容1.实验目标1、综合应用下列知识...3、加深理解多级反馈队列进程调度算法。2.实验任务1、用一种熟悉的语言,如C、PASCAL或C++等,编制...
  • 本文件是对操作系统进程多级反馈队列调度算法的设计与实现,算法以txt的形式输入输出,其中包含设计报告
  • package ...import java.util.*;/** * @Class MSFQS * @Description 多级反馈队列调度算法 * @Author Naren * @Date 2020/5/30 10:46 * @Version 1.0 */public class MSFQS {/*三个队列*/private st...
  • 报文离开队列的时间、顺序,以及各个队列之间报文离开的相互关系由队列调度算法决定。华为交换机设备的每个端口上都有 8 个下行队列,称为CQ(Class Queue)队列,也叫 端口队列(Port-queue),在交换机内部与前文...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 462
精华内容 184
关键字:

多级队列反馈调度算法