Linux内核架构浅谈25-Linux实时调度器：SCHED_RR与SCHED_FIFO策略实现

解析Linux实时调度的核心机制、优先级管理及两种调度策略的实现差异

一、实时调度的本质：确定性与低延迟

实时系统与普通系统的核心区别在于对响应时间的确定性要求。在工业控制、自动驾驶、机器人等场景中，任务必须在严格的时间窗口内完成，否则可能导致严重后果。Linux通过实时调度器（RT Scheduler）提供这种能力，其核心目标是：

确保高优先级实时任务优先获得CPU资源
提供可预测的任务响应时间
避免低优先级任务干扰高优先级任务

Linux实时调度器支持两种主要策略（定义于sched.h）：

SCHED_FIFO（先进先出实时调度）：同优先级任务按顺序执行，高优先级任务可抢占，任务一旦获得CPU将一直运行直到主动放弃或被更高优先级任务抢占
SCHED_RR（时间片轮转实时调度）：在SCHED_FIFO基础上为同优先级任务分配时间片，时间片耗尽后任务被放到队列末尾，确保同优先级任务公平轮转

与CFS的根本区别：实时调度器采用"优先级驱动"的抢占式调度，高优先级任务可无条件抢占低优先级任务（包括CFS管理的普通任务）；而CFS追求的是"比例公平"，不保证严格的响应时间。

二、实时优先级：严格的层级体系

Linux实时调度采用静态优先级机制，优先级范围为1（最低）到99（最高），数值越大优先级越高。这与普通进程的nice值（-20到19）形成鲜明对比：

实时进程优先级（1-99）> 普通进程优先级（100-139）
实时优先级具有严格的抢占关系：高优先级实时任务可立即抢占低优先级实时任务和普通任务
相同优先级的实时任务调度行为由具体策略（FIFO/RR）决定

2.1 优先级的内核表示

实时优先级存储在进程描述符task_struct中，核心成员包括：

复制代码

struct task_struct {
    // ... 其他成员 ...
    int prio;               // 当前有效优先级（实时优先级直接使用）
    int static_prio;        // 静态优先级（实时进程等于rt_priority）
    unsigned int rt_priority; // 实时优先级（1-99，0表示非实时进程）
    const struct sched_class *sched_class; // 调度类（rt_sched_class）
    struct sched_rt_entity rt; // 实时调度实体
    // ... 其他成员 ...
};

实时进程的sched_class指向rt_sched_class，使内核将其交给实时调度器管理。

2.2 优先级与调度类的映射

Linux内核通过"调度类"机制实现多调度策略共存，实时调度器对应rt_sched_class，其优先级高于普通进程的fair_sched_class：

复制代码

// 调度类优先级顺序（include/linux/sched.h）
extern const struct sched_class stop_sched_class;    // 最高（用于停止CPU）
extern const struct sched_class rt_sched_class;      // 实时调度类
extern const struct sched_class fair_sched_class;    // CFS调度类
extern const struct sched_class idle_sched_class;    // 最低（空闲进程）

调度时，内核按上述顺序检查各调度类，优先选择高优先级调度类中的就绪任务。

Linux调度类优先级层级stop_sched_classrt_sched_class (SCHED_FIFO/SCHED_RR)fair_sched_class (CFS)idle_sched_class最高优先级最低优先级

三、实时调度核心数据结构

实时调度器通过两个核心数据结构管理实时任务：sched_rt_entity（实时调度实体）和rt_rq（实时就绪队列）。

3.1 sched_rt_entity：实时任务的抽象

每个实时进程被抽象为sched_rt_entity，记录调度相关信息：

复制代码

struct sched_rt_entity {
    struct list_head run_list;     // 就绪队列链表节点
    unsigned long timeout;         // 超时时间（用于SCHED_RR时间片）
    unsigned int time_slice;       // 剩余时间片（SCHED_RR专用）
    int prio;                      // 实时优先级
    // ... 其他辅助成员 ...
};

关键成员解析：

run_list：用于将实体链接到对应优先级的就绪队列
time_slice：SCHED_RR任务的剩余时间片，默认值为DEF_TIMESLICE（100ms）
timeout：记录时间片到期时间，用于触发时间片轮转

3.2 rt_rq：实时就绪队列的管理中枢

rt_rq管理特定CPU上的实时任务，按优先级组织：

复制代码

struct rt_rq {
    struct list_head rt_active[MAX_RT_PRIO];  // 按优先级分组的就绪队列
    unsigned int rt_nr_running;               // 运行中的实时任务数量
    unsigned int highest_prio;                // 当前最高优先级
    // ... 其他辅助成员 ...
};

核心特性：

rt_active：数组大小为MAX_RT_PRIO（100），每个元素是对应优先级（0-99）的就绪任务链表
highest_prio：缓存当前最高优先级，避免每次调度时从0到99遍历查找
rt_nr_running：记录实时任务总数，用于快速判断是否有实时任务需要调度

示例：rt_rq的结构与任务组织

假设有三个实时任务：A（优先级30，SCHED_FIFO）、B（优先级50，SCHED_RR）、C（优先级50，SCHED_RR），其在rt_rq中的组织方式如下：

复制代码

struct rt_rq {
    rt_active = [
        // 0-29: 空链表
        30: [A],  // 优先级30的就绪队列（仅任务A）
        // 31-49: 空链表
        50: [B -> C],  // 优先级50的就绪队列（B和C按顺序排列）
        // 51-99: 空链表
    ],
    highest_prio = 50,  // 当前最高优先级为50
    rt_nr_running = 3   // 共3个实时任务
}

调度时，实时调度器会先处理优先级50的任务（B和C），再处理优先级30的任务A，体现了"优先级驱动"的核心原则。

四、SCHED_FIFO策略：先到先服务的实时调度

SCHED_FIFO（First-In-First-Out）是最简单的实时调度策略，其核心规则可概括为：

相同优先级的任务按就绪顺序排队，先就绪的任务先执行
任务一旦获得CPU，将持续运行直到以下情况之一发生：
- 主动放弃CPU（如调用sched_yield()或阻塞）
- 被更高优先级的实时任务抢占
- 任务终止
低优先级FIFO任务不能抢占高优先级FIFO任务

4.1 SCHED_FIFO的调度流程

SCHED_FIFO的核心调度逻辑在rt_sched_class的pick_next_task和enqueue_task方法中实现：

4.1.1 任务入队（enqueue_task_rt）

复制代码

static void enqueue_task_rt(struct rq *rq, struct task_struct *p, int wakeup) {
    struct sched_rt_entity *rt_se = &p->rt;
    struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
    int prio = p->prio;

    // 1. 将任务添加到对应优先级的就绪队列尾部
    list_add_tail(&rt_se->run_list, &rt_rq->rt_active[prio]);

    // 2. 更新最高优先级缓存
    if (prio < rt_rq->highest_prio) {
        rt_rq->highest_prio = prio;
    }

    // 3. 增加实时任务计数
    rt_rq->rt_nr_running++;
}

注：Linux内核中优先级数值越小表示优先级越高（与用户空间感知相反），因此prio < rt_rq->highest_prio表示新任务优先级更高。

4.1.2 选择下一个任务（pick_next_task_rt）

复制代码

static struct task_struct *pick_next_task_rt(struct rq *rq) {
    struct rt_rq *rt_rq = &rq->rt;
    struct sched_rt_entity *rt_se;
    struct task_struct *p;
    int prio;

    // 1. 从最高优先级开始查找就绪任务
    for (prio = rt_rq->highest_prio; prio < MAX_RT_PRIO; prio++) {
        if (!list_empty(&rt_rq->rt_active[prio])) {
            // 2. 取队列头部任务
            rt_se = list_first_entry(&rt_rq->rt_active[prio],
                                     struct sched_rt_entity, run_list);
            p = task_of(rt_se);
            // 3. 标记为当前运行任务
            rt_rq->curr = rt_se;
            return p;
        }
    }

    return NULL;  // 无实时任务就绪
}

4.2 SCHED_FIFO的抢占机制

当高优先级实时任务就绪时，内核会立即触发抢占。核心逻辑在try_to_wake_up中：

复制代码

static int try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags) {
    // ... 其他逻辑 ...

    // 如果被唤醒任务是实时任务且优先级高于当前任务
    if (p->sched_class == &rt_sched_class &&
        p->prio < current->prio) {
        // 触发立即抢占
        resched_curr(rq);
    }

    // ... 其他逻辑 ...
}

这种即时抢占确保高优先级实时任务的响应延迟最小化。

示例：SCHED_FIFO任务调度时序

假设有三个FIFO任务：T1（优先级80）、T2（优先级90）、T3（优先级80），调度过程如下：

初始状态：T1正在运行，T2和T3阻塞
t=10ms：T2被唤醒（优先级90 > T1的80），立即抢占T1，T2开始运行
t=20ms：T3被唤醒（优先级80 < T2的90），加入优先级80的就绪队列，不触发抢占
t=50ms：T2完成任务退出，调度器选择优先级80队列的T1继续运行
t=70ms ：T1主动调用sched_yield()，放弃CPU，T3从就绪队列头部取出并运行

时序表明：高优先级任务可立即抢占低优先级任务；同优先级任务按就绪顺序执行，需等待前序任务主动释放CPU。

五、SCHED_RR策略：时间片轮转的实时调度

SCHED_RR（Round-Robin）是对SCHED_FIFO的扩展，为相同优先级的任务引入时间片机制，解决了FIFO中同优先级任务可能饿死的问题。其核心规则是：

同优先级任务轮流执行，每个任务拥有固定时间片（默认100ms）
时间片耗尽时，任务被移至就绪队列尾部，等待下一轮调度
高优先级任务仍可随时抢占RR任务，行为与FIFO一致

5.1 SCHED_RR与SCHED_FIFO的核心差异

特性	SCHED_FIFO	SCHED_RR
时间片	无时间片限制，持续运行直到主动放弃	有时间片（默认100ms），超时后轮换
同优先级抢占	同优先级任务不能互相抢占	时间片耗尽后被同优先级任务抢占
适用场景	需要持续运行的任务（如控制环路）	同优先级任务需公平共享CPU的场景
实现复杂度	简单（仅维护就绪队列）	较复杂（需管理时间片和超时）

5.2 SCHED_RR的时间片管理

RR任务的时间片管理是其与FIFO的核心区别，主要通过以下机制实现：

5.2.1 时间片初始化

任务创建或被唤醒时，初始化时间片：

复制代码

static void sched_rt_init(struct task_struct *p) {
    struct sched_rt_entity *rt_se = &p->rt;

    // 非实时任务不初始化
    if (!rt_prio(p->prio))
        return;

    // SCHED_RR任务初始化时间片（默认100ms）
    if (p->policy == SCHED_RR) {
        rt_se->time_slice = DEF_TIMESLICE;
    } else {
        rt_se->time_slice = 0;  // FIFO任务无时间片
    }
}

5.2.2 时间片消耗与超时处理

内核定期（时钟中断）检查RR任务的时间片消耗：

复制代码

static void update_curr_rt(struct rq *rq) {
    struct rt_rq *rt_rq = &rq->rt;
    struct sched_rt_entity *curr = rt_rq->curr;
    u64 now = rq_clock(rq);
    u64 delta = now - curr->start_time;

    // 仅处理SCHED_RR任务
    if (curr->time_slice && task_of(curr)->policy == SCHED_RR) {
        // 消耗时间片（将纳秒转换为时间片单位）
        curr->time_slice -= delta / NSEC_PER_MSEC;

        // 时间片耗尽
        if (curr->time_slice <= 0) {
            // 重新设置时间片
            curr->time_slice = DEF_TIMESLICE;
            // 将任务移至就绪队列尾部
            requeue_task_rt(rq, task_of(curr), 0);
            // 触发重新调度
            resched_curr(rq);
        }
    }

    curr->start_time = now;
}

5.2.3 时间片轮转的触发

时间片耗尽后，requeue_task_rt将任务移至队列尾部，实现轮转：

复制代码

static void requeue_task_rt(struct rq *rq, struct task_struct *p, int head) {
    struct sched_rt_entity *rt_se = &p->rt;
    struct rt_rq *rt_rq = rt_rq_of_se(rt_se);

    // 从当前队列移除
    list_del(&rt_se->run_list);
    // 添加到队列尾部（实现轮转）
    list_add_tail(&rt_se->run_list, &rt_rq->rt_active[p->prio]);
}

示例：SCHED_RR任务调度时序

假设有两个RR任务：R1（优先级70）、R2（优先级70），时间片100ms，调度过程如下：

t=0ms：R1就绪并开始运行，时间片=100ms
t=100ms：R1时间片耗尽，被移至就绪队列尾部，R2从队列头部取出并运行，时间片=100ms
t=200ms：R2时间片耗尽，被移至就绪队列尾部，R1从队列头部取出并运行，时间片=100ms
t=250ms：R1主动阻塞（等待IO），剩余时间片保留，R2开始运行
t=300ms：R1被唤醒，加入就绪队列尾部，R2继续运行
t=300ms：R2时间片耗尽，R1从队列头部取出并运行（使用剩余时间片50ms）

可见，RR策略通过时间片确保同优先级任务公平共享CPU，且任务阻塞时会保留剩余时间片。

六、实时调度的用户空间接口与实践

用户空间通过标准系统调用配置实时调度策略和优先级，核心接口包括sched_setscheduler()和sched_setparam()。

6.1 设置实时调度策略的代码示例

复制代码

#include 
#include 
#include 
#include 

// 设置进程为SCHED_FIFO策略，优先级50
int set_fifo_scheduler(pid_t pid, int priority) {
    struct sched_param param;

    // 检查优先级范围（1-99）
    if (priority < 1 || priority > 99) {
        fprintf(stderr, "优先级必须在1-99之间\n");
        return -1;
    }

    param.sched_priority = priority;
    // 设置调度策略和参数
    if (sched_setscheduler(pid, SCHED_FIFO, ¶m) == -1) {
        perror("设置调度策略失败");
        return -1;
    }

    printf("进程%d已设置为SCHED_FIFO，优先级%d\n", pid, priority);
    return 0;
}

// 设置进程为SCHED_RR策略，优先级30
int set_rr_scheduler(pid_t pid, int priority) {
    struct sched_param param;

    if (priority < 1 || priority > 99) {
        fprintf(stderr, "优先级必须在1-99之间\n");
        return -1;
    }

    param.sched_priority = priority;
    if (sched_setscheduler(pid, SCHED_RR, ¶m) == -1) {
        perror("设置调度策略失败");
        return -1;
    }

    printf("进程%d已设置为SCHED_RR，优先级%d\n", pid, priority);
    return 0;
}

int main() {
    // 设置当前进程为SCHED_FIFO，优先级50
    set_fifo_scheduler(getpid(), 50);
    
    // 业务逻辑...
    while (1) {
        // 实时任务处理
    }

    return 0;
}

6.2 实时调度的权限与限制

使用实时调度策略需要注意：

权限要求 ：非root用户需要CAP_SYS_NICE能力才能设置实时优先级，可通过setcap命令赋予：
复制代码
```
sudo setcap cap_sys_nice+ep ./realtime_app
```
CPU时间限制 ：Linux通过RLIMIT_RTTIME限制实时进程的CPU使用时间（默认无限制），防止实时任务独占CPU导致系统无响应
优先级反转 ：低优先级实时任务持有高优先级任务需要的锁时，会导致高优先级任务阻塞。可通过pthread_mutexattr_setprotocol设置优先级继承协议解决

6.3 实时调度的性能监测工具

chrt：命令行工具查看/设置实时调度策略

复制代码

# 查看进程1234的调度策略
chrt -p 1234

# 将进程1234设置为SCHED_RR，优先级50
chrt -r -p 50 1234

ps：查看进程优先级

复制代码

ps -eo comm,pid,pri,rtprio,sched | grep -E "COMMAND|my_realtime_app"

trace-cmd：跟踪实时调度事件，分析调度延迟
复制代码
```
sudo trace-cmd record -e sched_switch
sudo trace-cmd report
```

七、总结

Linux实时调度器通过SCHED_FIFO和SCHED_RR策略为实时应用提供了确定性的调度能力，其核心要点包括：

实时进程采用1-99的静态优先级体系，优先级高于普通进程，支持严格的抢占机制
SCHED_FIFO策略适用于需要持续运行的任务，同优先级任务按顺序执行，无时间片限制
SCHED_RR策略为同优先级任务引入时间片轮转，确保公平共享CPU资源
实时调度器通过rt_rq按优先级组织就绪队列，通过sched_rt_entity跟踪任务状态
用户空间通过sched_setscheduler()等接口配置实时调度参数，需注意权限和优先级反转问题

理解实时调度器的工作原理，对于开发工业控制、自动驾驶等对时间敏感的应用至关重要。在实际使用中，需根据任务特性选择合适的调度策略，并通过工具监测和优化实时性能。