实时调度算法_实时调度rms算法 - CSDN
精华内容
参与话题
  • 实时调度算法

    千次阅读 2018-09-29 15:32:35
    实时调度算法的分类 根据实时任务性质分类 硬实时调度算法:即任务必须在确定的时间内完成 软实时调度算法:即大部分任务必须在确定的时间内完成 根据调度方式分类 关于抢占式和非抢占式的定义这里不讲解 非抢占...

    必要的名词解释

    开始截止时间:某个任务必须在某个时间之前开始执行

    实时调度算法的分类

    根据实时任务性质分类
    • 硬实时调度算法:即任务必须在确定的时间内完成
    • 软实时调度算法:即大部分任务必须在确定的时间内完成
    根据调度方式分类
    关于抢占式和非抢占式的定义这里不讲解
    
    • 非抢占式
    • 抢占式

    最早截止时间优先算法

    EDF(Earliest DeadLine First)
    这个算法的含义就是,谁完成任务的截止时间早,谁就先执行。好比我们在排队买票的时
    候,经常出现有人说,不好意思,我赶时间让我先。
    

    EDF在非抢占式调度方式的应用

    我们通过一个例子来讲解(t 是时间轴)

    在这里插入图片描述

    1. 首先任务 1 先到达并且执行任务
    2. 在任务 1 执行的过程中,任务 2,3 到达。也就是任务 1 执行完时,有任务 2,3 等待被执行
    3. 比较任务 2,3 的截止时间,也就是最上面的开始截止时间,可得到,任务 3 先执行
    4. 同样的分析方式,可以得出任务 4 先于任务 2 执行
    5. 所以执行顺序是 1,3,4,2

    EDF在抢占式调度方式的应用

    我们通过一个例子来讲解

    在这里插入图片描述

    首先,该图的二,三行是为了说明常用的优先级调度不能适用于实时系统,这里不细说,可以不用管,我们直接观察第一行和最后一行。

    1. 在 t = 0 时,A1 和 B1 同时到达。此时比较二者的截止时间(最后期限),可以看出 A1 的截止时间早,所以 A1 先运行。

    2. A1 执行 10ms 后因为 A2 还没有到,所以不存在比较,直接切换 B1 执行。

    3. 当 B1 执行了 10ms 后,A2 到达,比较二者的截止时间,A2 先于 B1。所以A2 抢占处理机,B1 中断。

    4. 此后的调度方式按照上面的分析即可完成

      EDF 在抢占式和非抢占式的区别就是,抢占式就是,当新任务 A 来到的时
      候,如果 A 的截止时间比正在执行的任务 B 的截止时间提前,那么就中断 
      B ,抢夺处理机控制权,转而运行 A。
      

    最低松弛度优先算法

    LLF(Least Laxity First)
    这个算法的思想就是,根据任务的紧急程度判断。任务越紧急,松弛度就越低,优先级就越高
    

    松弛度 = 必须完成的时间 - 本身运行时间 - 当前时间

    先举一个下例子。比如此时时间轴为 0ms,任务 A 和 B 同时到达,需要确定先执行哪个任务。

    任务 A 需要在 200ms 这个时刻(或之前)完成,而 A 本身要运行 100ms。所以 A 的松弛度就是 200 - 100 - 0 = 100ms。

    此时还有一个任务 B ,必须在 400ms 时刻(或者之前)完成,本身需要运行 150ms,所以松弛度为 400 - 150 - 0 = 250

    所以,松弛度低(任务越紧急)先执行。

    下面给出一个测试,如果大家掌握了上面的思想就可以轻松完成
    

    假如一个实时系统中有两个周期性实时任务 A 和 B,任务 A 每 20ms 运行一次,一次运行 10ms 。

    任务 B 每 50ms 运行一次,一次运行 25ms。

    通过观察下图,画出 A 和 B 在 LLF 算法下的调度时间轴图。

    在这里插入图片描述

    下面给出答案
    在这里插入图片描述

    完!

    展开全文
  • 深入理解处理机调度算法,了解硬实时概念,掌握周期性实时任务调度算法EDF(Earliest Deadline First)和RMS(Rate Monotonic Scheduling)的可调度条件,并能在可调度情况下给出具体调度结果。 (二)实验内容 在...

    (一)实验目的
    深入理解处理机调度算法,了解硬实时概念,掌握周期性实时任务调度算法EDF(Earliest Deadline First)和RMS(Rate Monotonic Scheduling)的可调度条件,并能在可调度情况下给出具体调度结果。
    (二)实验内容
    在Linux环境中采用用户级线程模拟实现EDF和RMS两种实时调度算法。给定一组实时任务,按照EDF算法和RMS算法分别判断是否可调度,在可调度的情况下,创建一组用户级线程,分别代表各个实时任务,并按算法确定的调度次序安排各个线程运行,运行时在终端上画出其Gantt图。为避免图形绘制冲淡算法,Gantt图可用字符表示。 (三)实验准备
    EDF算法和RMS算法的可调度条件及调度原则。。
    在Linux环境中创建用户级线程的函数。
    EDF为可抢先式调度算法,其调度条件为sum(Ci/Ti)£1;RMS算法为不可抢先调度算法,其调度条件为sum(Ci/Ti)£n(exp(ln(2)/n)-1)。
    创建用户级线程的库函数为:
    int pthread_create (pthread_t *THREAD,
    pthread_attr_t * ATTR, void * (*START_ROUTINE)
    (void ), void ARG
    pthread_create(tid,NULL,func,arg);
    其中第一个参数是pthread_t型的指针,用于保存线程id;第二个参数是pthread_attr_t的指针,用于说明要创建的线程的属性,NULL表示使用缺省属性;第三个参数指明了线程的入口,是一个只有一个(void *)参数的函数;第四个参数是传给线程入口函数的参数
    (四)实验设计
    实时任务用task数据结构描述,设计四个函数:select_proc()用于实现调度算法,被选中任务执行proc(),在没有可执行任务时执行idle(),主函数mian()初始化相关数据,创建实时任务并对任务进行调度。
    为模拟调度算法,给每个线程设置一个等待锁,暂不运行的任务等待在相应的锁变量上。主线程按调度算法唤醒一个子线程,被选中线程执行一个时间单位,然后将控制权交给主线程判断是否需要重新调度。

    实验代码:

    #include "math.h"
    #include "sched.h"
    #include "pthread.h"
    #include "stdlib.h"
    #include "semaphore.h" 
    #include "stdio.h"
    typedef struct{  //实时任务描述
        char task_id;
        int call_num;  //任务发生次数
     int ci;  // Ci
        int ti;  //Ti 
        int ci_left;
        int ti_left; 
        int flag;  //任务是否活跃,0否,2是
        int arg;  //参数
        pthread_t th;  //任务对应线程
    }task;
    void proc(int* args);
    void* idle();
    int select_proc();
    int task_num = 0;
    int idle_num = 0;
    int alg;  //所选算法,1 for EDF,2 for RMS
    int curr_proc=-1;
    int demo_time = 100;  //演示时间
    task* tasks;
    pthread_mutex_t proc_wait[100];
    pthread_mutex_t main_wait, idle_wait;
    float sum=0;
    pthread_t idle_proc;
    int main(int argc,char** argv)
    {   
        pthread_mutex_init(&main_wait,NULL);
        pthread_mutex_lock(&main_wait);  //下次执行lock等待
        pthread_mutex_init(&idle_wait,NULL);
        pthread_mutex_lock(&idle_wait);  //下次执行lock等待
        printf("Please input number of real time tasks:\n");
        scanf("%d",&task_num);
        tasks = (task*)malloc(task_num*sizeof(task));
        int i;
    for(i=0;i<task_num;i++)
    {
            pthread_mutex_init(&proc_wait[i],NULL);
            pthread_mutex_lock(&proc_wait[i]);
        }
    for(i=0;i<task_num;i++)
    {
            printf("Please input task id, followed by Ci and Ti:\n");
        getchar();
            scanf("%c,%d,%d,",&tasks[i].task_id,&tasks[i].ci,&tasks[i].ti);
            tasks[i].ci_left=tasks[i].ci;
            tasks[i].ti_left=tasks[i].ti;
            tasks[i].flag=2;
            tasks[i].arg=i;
            tasks[i].call_num=1; 
            sum=sum+(float)tasks[i].ci/(float)tasks[i].ti; 
        }
        printf("Please input algorithm, 1 for EDF, 2 for RMS:");
        getchar();
        scanf("%d",&alg);
        printf("Please input demo time:");
        scanf("%d",&demo_time);
        double r=1;  //EDF算法
        if(alg==2)
        {  //RMS算法
            r=((double)task_num)*(exp(log(2)/(double)task_num)-1);
            printf("r is %lf\n",r);
        }
        if(sum>r)
        {  //不可调度
            printf("(sum=%lf > r=%lf) ,not schedulable!\n",sum,r);
            exit(2);
        }
    
        pthread_create(&idle_proc,NULL,(void*)idle,NULL); //创建闲逛线程
        for(i=0;i<task_num;i++)  //创建实时任务线程
            pthread_create(&tasks[i].th,NULL,(void*)proc,&tasks[i].arg);
        for(i=0;i<demo_time;i++)
        {
             int j; 
             if((curr_proc=select_proc(alg))!=-1)
             {  //按调度算法选线程
                 pthread_mutex_unlock(&proc_wait[curr_proc]);  //唤醒
                 pthread_mutex_lock(&main_wait);  //主线程等待
              }
              else
              {   //无可运行任务,选择闲逛线程
                  pthread_mutex_unlock(&idle_wait);  
                  pthread_mutex_lock(&main_wait);
              }
             for(j=0;j<task_num;j++)
              {  //Ti--,为0时开始下一周期
                  if(--tasks[j].ti_left==0)
                  {
                      tasks[j].ti_left=tasks[j].ti;
                      tasks[j].ci_left=tasks[j].ci;
                      pthread_create(&tasks[j].th,NULL,(void*)proc,&tasks[j].arg);
                      tasks[j].flag=2;
                  }
             }
        }
        printf("\n");
        sleep(10); 
    };
    
    void proc(int* args)
    {
        while(tasks[*args].ci_left>0)
        {
            pthread_mutex_lock(&proc_wait[*args]);  //等待被调度
            if(idle_num!=0)
    {
                printf("idle(%d)",idle_num);
    idle_num=0;
            }
            printf("%c%d",tasks[*args].task_id,tasks[*args].call_num);
            tasks[*args].ci_left--;  //执行一个时间单位
            if(tasks[*args].ci_left==0)
            {
                printf("(%d)",tasks[*args].ci);
                tasks[*args].flag=0;
                tasks[*args].call_num++;
            }
            pthread_mutex_unlock(&main_wait); //唤醒主线程
        }
    };
    void* idle()
    {
         while(1)
          {
            pthread_mutex_lock(&idle_wait);  //等待被调度
            printf("->");  //空耗一个时间单位
            idle_num++;
            pthread_mutex_unlock(&main_wait);  //唤醒主控线程
        }
    };
    int select_proc(int alg)
    {
        int j;
        int temp1,temp2;
        temp1=10000;
        temp2=-1;
        if((alg==2)&&(curr_proc!=-1)&&(tasks[curr_proc].flag!=0))
            return curr_proc; 
    
          for(j=0;j<task_num;j++)
          {
            if(tasks[j].flag==2)
              {
                switch(alg)
                  {
                    case 1:    //EDF算法
                         if(temp1>tasks[j].ci_left)
                            {
                               temp1=tasks[j].ci_left;
                                temp2=j;
                        }
                    case 2:    //RMS算法
                       if(temp1>tasks[j].ti)
                              {
                            temp1=tasks[j].ti;
                            temp2=j;
                        }
                   }
                 }
             }
                return temp2;
    }
    

    编译:gcc -lpthread -lm test_scheduler.c -o scheduler.out
    运行:./ scheduler.out
    /算法EDF结果/
    这里写图片描述
    /算法RMS结果/
    这里写图片描述

    展开全文
  • 【操作系统】实时调度

    万次阅读 2016-12-03 15:56:24
    实现实时调度的基本条件 提供必要的调度信息(就绪时间、开始截止时间和完成截止时间、处理时间、资源要求、优先级) 系统处理能力强。在实时系统中,若处理机的处理能力不够强,则有可能因处理机忙不过来而致使某些...

    实现实时调度的基本条件

    • 提供必要的调度信息(就绪时间、开始截止时间和完成截止时间、处理时间、资源要求、优先级)
    • 系统处理能力强。在实时系统中,若处理机的处理能力不够强,则有可能因处理机忙不过来而致使某些实时任务不能得到及时处理。
    • 采用抢占式的调度机制
    • 具有快速切换机制

    实时调度的 CPU 处理能力

    单处理机:

    m: 实时任务数目,ci: 每次处理时间,pi: 周期时间

    公式

    例如:有 6 个硬实时任务,周期时间都是 50 ms,每次的处理时间为 10 ms,则系统是不可调度的。

    多处理机:(N: 处理机数目)

    公式

    实时调度算法的分类

    按实时任务性质(即对时间约束的强弱程度)

    • 硬实时调度:必须满足任务截止期要求,错过后果严重。
    • 软实时调度算法:期望满足任务截止期要求,错过可容
      忍。

    按调度方式

    非抢占式调度算法

    • 非抢占式轮转调度算法:用于工业生产的群控系统中。
    • 非抢占式优先调度算法:用于有一定时间要求的实时控制系统之中。

    抢占式调度算法 (按抢占发生的时间)

    • 基于时钟中断抢占的优先权调度算法
    • 立即抢占的优先权调度算法

    抢占式调度算法

    图像

    最早截止时间优先算法

    算法是根据任务的开始截止时间和完成截止时间来确定任务的优先级。截止时间越早,其优先级越高。就绪队列中任务按其截止时间排列,队首任务先分配处理机。

    非抢占式调度方式用于非周期实时任务
    抢占式调度方式用于周期实时任务

    非抢占式调度方式用于非周期实时任务

    图解

    抢占式调度方式用于周期实时任务

    有两个周期性任务,任务 A 的周期时间为 20ms,每个周期处理时间为 10ms;任务 B 的周期时间为 50ms,每个周期处理时间为 25ms。两个任务的到达时间,最后期限和执行时间如下图:

    图示

    固定优先级调度(A 有较高优先级)

    图示

    图示

    固定优先级调度(B 有较高优先级)

    例子

    最早截止完成时间优先算法

    图示

    图示

    图示

    最低松弛度优先算法

    最低松弛度优先算法(LLF,Least Laxity First)
    低松弛 = 高紧急

    算法是根据任务紧急(或松弛)的程度,来确定任务的优先级。任务的紧急度越高,其优先级越高,并使之优先执行。

    算法采用抢占调度方式,可用于调度具有完成截止时间的周期性实时任务。

    松弛度 = 必须完成时间 - 本身剩余运行时间 - 当前时间

    例如:

    在一个实时系统中,有两个周期性实时任务 A 和 B,任务 A 要求每 20ms 执行一次,执行时间为 10ms;任务B 只要求每 50ms 执行,执行时间为 25ms。试按最低松弛度优先算法进行调度。

    图示

    动图示例

    优先级倒置

    优先级倒置现象
    高优先级进程(或线程)被低优先级进程(或线程)延迟或阻塞。

    例如:有三个完全独立的进程 Task A、Task B 和 TaskC,Task A 的优先级最高,Task B 次之,Task C 最低。Task A 和 Task C 共享同一个临界资源 X。

    图解

    根据优先级原则,高优先级进程优先执行。但此例中Task A 和 Task C 共享同一个临界资源,出现了不合理的现象。

    高优先级进程 Task A 因低优先进程 Task C 被阻塞,又因为低优先进程 Task B 的存在延长了被阻塞的时间。

    优先级倒置的解决方法

    Priority Ceiling

    进程 Task C 在进入临界区后,Task C 所占用的处理机就不允许被抢占。这种情况下,Task C 具有最高优先级(Priority Ceiling) 。

    如果系统中的临界区都较短且不多,该方法是可行的。反之,如果 Task C 临界区非常长,则高优先级进程Task A 仍会等待很长的时间,其效果无法令人满意。

    图示

    Priority Inheritance

    当高优先级进程 Task A 要进入临界区使用临界资源 X时,如果已经有一个低优先级进程 Task C 正在使用该资源,可以采用优先级继(Priority Inheritance)的方法。

    此时一方面 Task A 被阻塞,另一方面由 Task C 继承Task A 的优先级,并一直保持到 Task C 退出临界区。

    图示

    展开全文
  • 几种常见的调度算法

    万次阅读 多人点赞 2018-11-18 16:58:34
    1、调度方式和调度算法的若干准则 1)面向用户的准则:周转时间短(CPU执行用时Ts、周转时间T=Ts+Tw、带权周转时间W= T/Ts)、响应时间快、均衡性、截止时间的保证、优先权准则 2)面向系统的准则:系统吞吐量高、...

    一、处理机调度相关基本概念

    1、调度方式和调度算法的若干准则
    1)面向用户的准则:周转时间短(CPU执行用时Ts、周转时间T=Ts+Tw、带权周转时间W= T/Ts)、响应时间快、均衡性、截止时间的保证、优先权准则
    2)面向系统的准则:系统吞吐量高、处理机利用率好、各类资源的平衡利用
    3)批处理系统为照顾为数众多的短作业,应采用短作业优先的调度算法;分时系统为保证系统具有合理的响应时间,应采用轮转法进行调度

    二、常用调度算法

    1、先来先服务调度算法FCFS
    (1)按照作业提交,或进程变为就绪状态的先后次序分派CPU;
    (2)新作业只有当当前作业或进程执行完或阻塞才获得CPU运行
    (3)被唤醒的作业或进程不立即恢复执行,通常等到当前作业或进程出让CPU。(所以,默认即是非抢占方式)
    (4)有利于CPU繁忙型的作业,而不利于I/O繁忙的作业(进程)。
    在这里插入图片描述

    2、短作业(进程)优先调度算法SJF(非抢占)/SPF(抢占)
    (1)平均周转时间、平均带权周转时间都有明显改善。SJF/SPF调度算法能有效的降低作业的平均等待时间,提高系统吞吐量。
    (2)未考虑作业的紧迫程度,因而不能保证紧迫性作业(进程)的及时处理、对长作业的不利、作业(进程)的长短含主观因素,不一定能真正做到短作业优先。
    在这里插入图片描述

    3、高优先权优先调度算法HPF
    (1)两种方式:非抢占式优先权算法、抢占式优先权算法(关键点:新作业产生时)
    (2)类型:静态优先权:创建进程时确定,整个运行期间保持不变。动态优先权:创建进程时赋予的优先权可随进程的推进或随其等待时间的增加而改变。
    (3)高响应比优先调度算法HRRN
    HRRN为每个作业引入动态优先权,使作业的优先级随着等待时间的增加而以速率a提高:优先权 =(等待时间+要求服务时间)/要求服务时间= 响应时间 / 要求服务时间。
    什么时候计算各进程的响应比优先权?(作业完成时、新作业产生时(抢占、非抢占)、时间片完成时、进程阻塞时)
    在这里插入图片描述

    4、基于时间片的轮转调度算法RR
    (1)时间片轮转算法
    过程:1、排成一个队列。2、每次调度时将CPU分派给队首进程。3、时间片结束时,发生时钟中断。4、暂停当前进程的执行,将其送到就绪队列的末尾,并通过上下文切换执行当前就绪的队首进程。
    说明:1、进程阻塞情况发生时,未用完时间片也要出让CPU。2、能够及时响应,但没有考虑作业长短等问题。3、系统的处理能力和系统的负载状态影响时间片长度。
    (2)多级反馈队列算法FB
    过程:1、准备调度:先将它放入第一个队列的末尾,按FCFS原则排队等待调度。2、IF时间片内完成,便可准备撤离系统。3、IF时间片内未能完成,调度程序便将该进程转入第二队列的末尾等待再次被调度执行。4、当第一队列中的进程都执行完,系统再按FCFS原则调度第二队列。在第二队列的稍放长些的时间片内仍未完成,再依次将它放入第三队列。5、依次降到第n队列后,在第n队列中便采取按时间片轮转的方式运行。

    说明:1、设置多个就绪队列,各队列有不同的优先级,优先级从第一个队列依次降低。2、赋予各队列进程执行时间片大小不同, 优先权越高,时间片越短。3、仅当优先权高的队列(如第一队列)空闲时,调度程序才调度第二队列中的进程运行。4、高优先级抢占时,被抢占的进程放回原就绪队列末尾。

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • 实时调度及相关算法

    2020-04-08 22:15:26
    实时调度及相关算法 实时系统是那些时间因素非常关键的系统。例如,计算机的一个或多个外设发出信号,计算机必须在一段固定时间内作出适当的反应。一些实例是:医院里特护病房的监控系统、飞行器中的自动驾驶仪以及...
  • 调度算法的介绍及优缺点

    千次阅读 2018-07-19 15:55:52
    调度算法是根据系统的资源分配策略所规定的资源分配算法。有的调度算法适用于作业调度,有的适用于进程调度,有的两者都适用。   先了解几个术语  到达时间、服务时间、开始时间  完成时间、等待时间  周转...
  • 操作系统调度算法(详解)

    千次阅读 2019-04-06 16:45:32
    调度类型: 长程调度:决定加入到待执行的进程池当中 中程调度:决定加入到哪一部分或全部在主存中进程的集合中 短程调度:决定哪一个可用进程将被处理器执行 I/O调度:决定哪一个进程挂起的I/O请求将被可用的I/...
  • 常用实时调度算法

    千次阅读 2018-06-13 12:20:51
    实现实时调度的基本条件提供必要的调度信息(就绪时间、开始截止时间和完成截止时间、处理时间、资源要求、优先级)系统处理能力强。在实时系统中,若处理机的处理能力不够强,则有可能因处理机忙不过来而致使某些...
  • Xen的调度算法主要负责对各个客户虚拟机进行CPU时间片的分配,从而使 得硬件资源在各个客户虚拟机之间合理分配。在客户虚拟机启动之初,Xen会配 置其的CPU个数,这里的CPU称之为虚拟处理器,即VCPU。Xen的虚拟机...
  • linux内核中提供了两种实时调度策略:SCHED_FIFO和SCHED_RR,其中RR是带有...linux的实时调度算法提供了一种软实时工作方式。实时优先级范围从0到MAX_RT_PRIO减一。默认情况下,MAX_RT_PRIO为100,所以默认的实时优先级
  • SMP硬实时调度算法

    千次阅读 2017-04-25 17:42:55
    SMP硬实时调度算法
  • 算法中被选中任务每运行一个时间单位便将控制权交给主线程。再判断是否需要切换实时任务。实际上不需这样频繁的时钟中断。 故改进成。只在需要重新调度任务时才返回主控线程。且统计出线程切换次数(主线程切换不...
  • 实时调度算法之EDF算法

    千次阅读 2019-11-17 08:51:23
    算法要求在系统中保持一个实时任务就绪队列,该队列按各任务截止时间的早晚排序;当然,具有最早截止时间的任务排在队列的最前面。调度程序在选择任务时,总是选择就绪队列中的第一个任务,为之分配处理机,使之...
  • 实验二 处理机调度——实时调度算法EDF和RMS   一、实验目的 深入理解处理机调度算法,了解硬实时概念,掌握周期性实时任务调度算法EDF(Earliest Deadline First)和RMS(Rate Monotonic Scheduling)的可调度...
  • 2.4 调度当计算机系统是多道...在操作系统中,完成选择工作的这一部分称为调度程序(scheduler),该程序使用的算法称为调度算法(scheduling algorithm)。尽管有一些不同,但许多适用于进程调度的处理方法也同样...
  • linux实时任务调度算法分析

    千次阅读 2011-12-27 23:31:27
    鉴于最近有关cpu占有率的一些问题涉及到linux内核的调度算法,有必要进行了解。因此,写了这篇文章。linux常见的任务有两种,实时任务与非实时任务。实时任务的调度算法是大家都非常熟悉的优先级抢占或优先级抢占加...
  • 常用调度算法总结

    万次阅读 2013-08-10 19:26:13
    常用调度算法总结 分类: 操作系统 2013-08-10 17:59 71人阅读 评论(0) 收藏 举报 目录(?)[+] 先来先服务队列最短优先优先队列高优先权优先调度算法 优先权调度算法的类型高响应比优先调度...
  • 嵌入式实时操作系统任务调度算法

    千次阅读 2016-06-12 22:14:49
    任务调度
  • RMS,EDF,LLF实时调度算法

    千次阅读 2019-10-27 20:38:01
    RMS算法根据任务的周期长短分配优先级高低(属于静态优先级分配,优先级不会再改变了) EDF算法根据任务的截止期的早晚分配优先级的高低...总结:RMS算法是静态优先级中最优的实时调度算法。EDF和LLF是动态优先级中...
  • 例如,在批处理系统、分时系统和实时系统中,通常都采用不同的调度方式和算法。选择调度方式和算法的准则,有的是面向用户的,有的是面向系统的。在系统学习这些知识之前,可以先看一个生活中常见的故事。 用打开...
1 2 3 4 5 ... 20
收藏数 196,282
精华内容 78,512
关键字:

实时调度算法