线程/CPU调度策略、调度类、优先级

Linux 下线程/CPU调度策略

1. Linux 常见调度策略大盘点

在 Linux 中,线程调度策略主要分为两派:普通调度 和 实时调度。

  • SCHED_NORMAL (或 SCHED_OTHER): 这是绝大多数程序默认的调度策略。它由完全公平调度器 (CFS - Completely Fair Scheduler) 接管。核心思想是“按权重(nice 值)分配 CPU 运行时间比例”,不追求绝对的优先级,而是追求全局的公平性和整体的吞吐量。它虽然根据 NICE 值分配 CPU 运行时间,但不是按照优先级先后分配,而是根据优先级划分份额比例。
  • SCHED_FIFO (First-In, First-Out): 实时策略。顾名思义,先到先得,且不可抢占。只要一个 SCHED_FIFO 线程拿到 CPU,除非它主动阻塞(比如等 I/O、拿锁)、主动让出 (sched_yield),或者被更高优先级的实时线程抢占,否则它会一直霸占 CPU 跑到死。
  • SCHED_RR (Round-Robin): 带有时间片的实时策略。同优先级 的 SCHED_RR 线程之间会分配时间片,大家轮流跑。但请注意,它的优先级依然碾压所有 SCHED_NORMAL 的普通线程。

2. Linux 中的多重调度策略机制

Linux 中不仅同时存在多种调度策略,而且它们是按照严格的层级结构协同工作的。

Linux 内核为了满足不同类型程序的需求(例如对延迟极度敏感的底层硬件控制,以及对吞吐量要求很高的后台下载任务),引入了调度类 (Scheduling Class) 的模块化概念。每种调度策略都归属于特定的调度类,而这些调度类在内核中具有绝对的 优先级顺序。

内核在每次决定“下一个该让哪个进程运行”时,会按照以下优先级从高到低依次遍历各个调度类。只要高优先级的调度类中有就绪的进程,CPU 就会立刻执行它,只有当高优先级队列完全为空时,才会把 CPU 交给低优先级的调度类。

1. Stop 调度类 (stop_sched_class)

  • 优先级: 最高(不可被抢占,高于所有普通与实时任务)。
  • 作用: 这是内核内部使用的机制,处理极特殊的内核紧急控制任务,如 CPU 热插拔(Hotplug)、RCU 停机同步、内核死锁检测迁移等,没有对外暴露给用户的调度策略。
  • 策略: 单核串行执行,运行完即释放,用户态不可见。

2. Deadline 调度类 (dl_sched_class)

  • 对应策略: SCHED_DEADLINE(基于硬实时、最早截止时间优先算法 EDF)。
  • 核心参数: 每个任务指定三个参数 \((Runtime, Deadline, Period)\)——保证在每个周期 \(Period\) 内,至少在 \(Deadline\) 之前获得 \(Runtime\) 的 CPU 时间。
  • 场景: 航空电子、工业控制、超低延迟硬实时音视频流水线。

3. Real-Time 实时调度类 (rt_sched_class)

  • 对应策略: SCHED_FIFO(先进先出直到主动让出/阻塞)与 SCHED_RR(同优先级带固定时间片的轮转)。
  • 优先级范围: 静态优先级 0~99(数值越大/用户态看越大,优先级越高)。
  • 机制: 它们的优先级永远压制普通进程,只要就绪队列里有 RT 任务,普通任务就必须让步;同优先级按 FIFO 或 RR 执行。

4. Fair 公平调度类 (fair_sched_class)

  • 对应策略: SCHED_NORMAL(即 SCHED_OTHER,绝大多数常规进程)、SCHED_BATCH(吞吐型后台批处理)。你电脑里 99% 的软件都在这个调度类中排队。
  • 核心机制:
    • 内核 6.6 之前: 基于红黑树维护 \(vruntime\) 的 CFS(Completely Fair Scheduler)。
    • 内核 6.6+: 引入 EEVDF(Earliest Eligible Virtual Deadline First),用虚拟截止时间解决 CFS 在低延迟/轻负载唤醒时的响应抖动问题。
  • 权重调节: 用户态通过 nice 值(-20 到 19)映射权重。

5. Idle 调度类 (idle_sched_class)

  • 对应策略: SCHED_IDLE。
  • 优先级: 最低。
  • 机制: 当系统中没有任何上述类别的任务需要运行时触发。负责执行内核每核自带的 swapper(Idle 进程),将 CPU 置于省电休眠状态(如执行 HLT 指令或进入 ACPI C-states)。

3. 实时线程带来的灾难性风险

如果普通业务直接乱用 SCHED_FIFO 或 SCHED_RR,最直接的风险就是 系统假死(饿死普通线程)。

假设你写了一个 SCHED_FIFO 的线程,里面不小心混入了一个没有阻塞调用的死循环(比如疯狂自旋检查某个变量)。那么这颗 CPU 核心将彻底被这个线程独占。系统的守护进程、垃圾回收、甚至是你的 SSH 终端进程(它们通常是普通的 SCHED_OTHER)统统拿不到时间片,被活活“饿死”。如果多核都被这种线程占满,整台机器就会直接失联,只能拔电源硬重启。

但 Linux 内核为了避免“只能拔电源硬重启”,其实在系统层面内置了保命兜底机制,并且在工程架构上也有标准的防御方案:

1. 内核自带的保命绳:RT Throttle(实时带宽限制)

内核默认开启了实时带宽限制,防止 RT 线程 100% 独占 CPU:

  • 核心参数:
    • /proc/sys/kernel/sched_rt_period_us(默认 1000000 μs,即 1 秒)
    • /proc/sys/kernel/sched_rt_runtime_us(默认 950000 μs,即 0.95 秒)
  • 运行机制: 即使你的 SCHED_FIFO 线程进入纯自旋死循环,它在 1 秒周期内最多也只能跑 0.95 秒,剩下的 50ms(5%)强制让给普通任务(SCHED_OTHER)。
  • 实际体验: 机器不会彻底“死透”,但 SSH 响应会变得极度卡顿(每秒仅有 50ms 窗口处理非实时逻辑),通常足够熟练的运维挤进去 kill -9。如果有人作死把 sched_rt_runtime_us 改成了 -1,那确实只能拔电源。

2. 用户态权限壁垒:Capability

普通无特权进程无法随意提权为实时任务:

  • 需要 CAP_SYS_NICE 能力,或者在 /etc/security/limits.conf 中显式配置 rtprio 上限。
  • 普通业务如果使用普通用户运行,调用 sched_setscheduler() 会直接返回 EPERM 报错。

3. 生产环境的防御避坑指南

如果业务确实有超低延迟诉求(如高频交易、核心音频采集)必须使用 RT 调度,通常遵循以下工程规范:

  • 核心隔离(CPU Affinity): 用 taskset 或 cpuset 将实时进程绑定在特定核(如 Core 2-3),严格保留 Core 0 给内核中断和 SSH/系统守护进程。
  • 硬件 Watchdog: 配合内核看门狗(softlockup_panic、NMI watchdog),如果单个 CPU 持续被锁死且无法响应时钟中断,直接触发机器自动重启转储 dump,而不是无限挂起。
  • 优先考虑 SCHED_DEADLINE: 新项目如果追求实时性,优先使用 SCHED_DEADLINE。它自带严格的 (runtime, period) 硬限制,一旦任务跑满配额会被内核主动限流(Throttle),天然杜绝死循环占满 CPU 的风险。

4. 经典神坑:线程优先级反转 (Priority Inversion)

这是并发编程里最著名的惨案之一(当年火星探路者号就栽在这上面)。

假设系统里有三个线程:高优先级 (H)、中优先级 (M)、低优先级 (L)。

  1. L 拿到了一把互斥锁 (Mutex),正在慢慢吞吞地执行临界区代码。
  2. 此时 H 被唤醒,它也需要这把锁,所以只能挂起等待 L 释放。
  3. 灾难来了:此时不需要锁的 M 变为了可运行状态。因为 M 优先级高于 L,OS 调度器让 M 抢占了 L 的 CPU。

结果: M 愉快地跑着,L 没 CPU 跑不了(自然也释放不了锁),导致最核心的 H 被一个毫无关联的 M 活活卡死。高优先级线程反而受制于中优先级线程,这就是 优先级反转。

5. 优先级反转的缓解与 Mutex 协议

既然聊到了这,就必须得说说底层的互斥锁协议了。为了破局,业界主要有两套经典的 Mutex 协议:

  • 优先级继承协议 (Priority Inheritance - PI): 这是最常用的动态解决方案。当 OS 发现高优先级线程 (H) 正在等待低优先级线程 (L) 持有的锁时,会 临时将 L 的优先级提升至 H 的优先级。这样 L 就不会被 M 抢占了,它能以 H 的优先级飞速执行完临界区,把锁交出来,然后立刻被打回原形(恢复低优先级)。
    • 实现提示: 在 C/C++ 的 POSIX 线程库中,你可以在初始化互斥锁时,通过 pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT) 来显式开启这个功能。
  • 优先级天花板协议 (Priority Ceiling Protocol): 这是一种静态解决方案。给 Mutex 本身设定一个“天花板优先级”(即所有可能访问该锁的线程的最高优先级)。只要任何线程拿到了这把锁,它的优先级就立刻飙升到天花板级别,直到释放锁。

6. 实际业务中为何避开实时调度?

在做底层系统开发或高性能网络框架时,大家对实时调度通常敬而远之,原因很现实:

  1. 爆炸半径太大: 像前面说的,应用层的一个低级逻辑 Bug,能直接把整个内核态和系统拖死,容错率极低。
  2. CFS 已经足够强大: 对于 99.9% 的后端服务,Linux 默认的 CFS 配合 nice 值微调,延迟毛刺已经被控制在非常小的范围内了。为了追求那零点几毫秒的极限响应而引入实时调度的风险,ROI (投资回报率) 极低。
  3. 伪需求与硬核门槛: 真正的“硬实时 (Hard Real-time)”(比如导弹控制、车机系统)不仅需要应用层策略,还需要打过 补丁的 Linux 内核甚至专用的 RTOS。在普通 Linux 服务器上开个 只是“软实时”,不仅无法保证绝对的微秒级截止时间,反而会扰乱现有的系统平衡。

补充1:CFS 中的 Nice 值与权重计算机制

在 Linux 的完全公平调度器 (CFS) 中,nice 值本身不是通过公式动态计算出来的,而是进程的一个静态配置属性(由系统默认赋予或用户手动设置)。CFS 真正“计算”的核心,是如何将 nice 值转换为权重 (Weight),并以此来推算 CPU 时间比例和虚拟运行时间 (vruntime)。

具体的过程分为以下几个核心维度:

1. Nice 值的基本设定

进程的 nice 值范围是 -20 到 19(共 40 个级别):

  • 默认值为 0。
  • 值越小,优先级越高(值越小,越不 NICE,需要得到的照顾就越多,优先级就越高)。

2. 从 Nice 值到权重 (Weight) 的映射

CFS 并不直接使用 nice 绝对值来分配时间,而是将其映射为“权重”。内核设计的数学原则是:nice 值每相差 1,进程所获得的 CPU 时间份额应该相差约 10%。

为了达到这个效果,相邻 nice 值的权重比例被设定为大约 1.25。基准点是 nice = 0,其对应的权重被固定定义为 1024(即系统宏定义的 NICE_0_LOAD)。

近似的权重换算公式为:

\[Weight \approx \frac{1024}{1.25^{nice}} \]

内核实际实现:为了极致的性能,Linux 内核并不会在调度时做复杂的浮点或次幂运算,而是预先算好了一个包含 40 个元素的常量数组(sched_prio_to_weight),直接通过 O(1) 的时间复杂度查表。例如:

  • nice = 0 → Weight = 1024
  • nice = 1 → Weight = 820
  • nice = -1 → Weight = 1277

3. 基于权重计算 CPU 时间比例

当多个进程在同一个 CPU 的就绪队列(Runqueue)中排队时,CFS 会在一个预设的“调度周期”内,根据权重按比例切分物理时间片。

计算公式如下:

\[\text{分配的物理时间} = \text{调度周期} \times \frac{\text{进程自身权重}}{\text{就绪队列所有进程权重之总和}} \]

举个直观的例子: 假设 CPU 队列里只有两个进程,A (nice = 0, weight = 1024) 和 B (nice = 1, weight = 820)。

  • A 获得的 CPU 时间比例:1024/(1024+820)≈55.5%
  • B 获得的 CPU 时间比例:820/(1024+820)≈44.5% A 比 B 多获得了约 10% 的 CPU 时间,精准兑现了内核的设计目标。

4. 驱动调度的引擎:虚拟运行时间 (vruntime)

CFS 调度时不关心绝对优先级,它的唯一准则是:永远挑选当前 vruntime(虚拟运行时间)最小的进程投入运行。

vruntime 是进程实际执行的物理时间经过“权重缩放”后的时间。计算公式为:

\[\Delta vruntime = \Delta actual\_runtime \times \frac{1024}{\text{进程自身权重}} \]

这个巧妙的公式导致了以下结果:

  • 对于 nice = 0 的进程(权重 1024):公式的分式恒为 1,虚拟时间流逝速度等于真实时间流逝速度。
  • 对于高优先级进程(如 nice = -20,权重极大):公式的分式极小,vruntime 增长得非常缓慢。因此它能在红黑树的左下角停留更久,获得极其频繁的调度机会。
  • 对于低优先级进程(如 nice = 19,权重极小):公式的分式极大,稍微运行一下,vruntime 就会暴涨。因此它会迅速失去 CPU 使用权,被调度器推迟执行。

补充2:NORMAL 调度不是赢家通吃

这是一个非常敏锐的直觉!在日常沟通甚至 top 命令的显示中,我们确实经常把 nice 值称为“优先级”(Priority)。但从操作系统内核的设计哲学来看,SCHED_NORMAL(由 CFS 实现)本质上绝不是传统的优先级调度,而是“比例份额调度”(Proportional Share Scheduling)。

我们可以通过以下三个核心差异,来彻底划清它们的界限:

1. 核心法则:赢家通吃 vs. 按权分饼

  • 真正的优先级调度(如 SCHED_FIFO / SCHED_RR):奉行的是绝对的抢占与压制。只要高优先级的线程处于就绪状态,低优先级的线程连 1 毫秒的 CPU 都拿不到。这叫“赢家通吃”。
  • CFS 的“伪优先级”:奉行的是和平分饼。nice 值仅仅代表切蛋糕的“权重比例”。哪怕是一个 nice = 19(优先级最低)的后台任务,面对一个 nice = -20(优先级最高)且跑满 CPU 的狂暴死循环,前者依然能分到属于自己的一丝 CPU 时间。在 CFS 的世界里,没有绝对的封杀,只有份额的多与少。

2. 调度的驱动力:直接排队 vs. 计算“委屈值”

  • 优先级调度:调度器直接看标签。优先级高的直接安排到队列最前面执行。
  • CFS 调度:调度器在挑人的时候,根本不看你的 nice 值是多少。它只看谁的 vruntime(虚拟运行时间)最小——也就是看谁受到的“委屈”最多。nice 值的作用仅仅是改变你累积 vruntime 的速度。高权重线程的 vruntime 涨得慢,所以能频繁地被选中;低权重线程涨得快,稍微跑一下就要去红黑树的右侧(冷板凳)排队了。

3. 终极底线:是否允许“饿死” (Starvation)

这是两者在计算机科学分类上的根本分水岭。

  • 真正的优先级调度天然允许饥饿。如果在系统中滥用实时调度,高优先级任务一旦陷入密集计算,低优先级任务就会被活活饿死,甚至导致整个操作系统的管理组件失去响应。
  • CFS 的名字叫“完全公平”,它的底线就是绝对不允许任何普通线程被饿死。只要还在 SCHED_NORMAL 策略里,每个线程在系统设定的调度延迟周期内,都必定会分到一个属于自己的时间片(哪怕只有几毫秒)。

总结来说: 传统的优先级调度是在回答“谁先跑,谁后跑”的问题; 而 SCHED_NORMAL 的本质是在回答“在这 100 毫秒内,你占百分之几,我占百分之几”的问题。

补充3:SCHED_RR 中不同优先级的调度真相:没有跨优先级的“轮流”

这是一个非常常见且直觉上容易产生的误解。在 Linux 的 SCHED_RR(以及 SCHED_FIFO)实时策略中,不同优先级的线程之间,绝对不会分配或共享时间片。

实时调度类的核心法则是绝对的优先级压制。时间片机制仅仅是为了解决“优先级完全相同的多个实时线程”之间的公平性问题。

具体机制可以分为以下三个维度来理解:

1. 跨优先级:绝对的抢占与压制

在 Linux 的实时调度器(RT Scheduler)中,实时优先级共有 99 个级别(1 到 99,数值越大优先级越高)。

如果系统里同时存在两个 SCHED_RR 线程:线程 A(优先级 90)和线程 B(优先级 89)。

  • 只要线程 A 处于就绪状态或正在运行,线程 B 将连 1 毫秒的 CPU 时间都得不到。
  • 线程 A 的时间片耗尽后,调度器只会去检查有没有其他优先级同为 90 的线程。如果没有,线程 A 会立刻获得一个新的时间片继续运行。
  • 只有当线程 A 主动休眠(例如等待 I/O、调用 sleep 或等待锁)导致它离开就绪队列时,线程 B 才有机会运行。

2. 同优先级:时间片轮转机制

只有当多个 SCHED_RR 线程具有完全相同的优先级(例如线程 X、Y、Z 都是优先级 50)时,时间片才会发挥作用。

  • 调度器会为该优先级维护一个队列。
  • 线程 X 运行,直到它主动阻塞,或者它的时间片耗尽。
  • 如果 X 的时间片耗尽,调度器会强行剥夺它的 CPU,把它放到“优先级 50 队列”的最末尾,并让队列头部的线程 Y 开始运行。
  • 这就是 Round-Robin(轮询)名字的由来,它只在“同级”内部生效。

3. RR 时间片的长度是怎么决定的?

与您之前了解的 CFS (SCHED_NORMAL) 完全不同,CFS 的时间片是根据 nice 权重动态计算出来的比例;而 SCHED_RR 的时间片是一个固定的系统级配置常量。

  • 它与线程的绝对优先级高低无关(优先级 99 和优先级 1 的线程,其时间片长度是一样的)。
  • 在现代 Linux 内核中,这个默认的时间片长度通常是 100 毫秒 (100ms)。
  • 系统管理员可以通过读取或修改 /proc/sys/kernel/sched_rr_timeslice_ms 文件来全局调整这个值。
posted @ 2026-10-11 23:26  光風霽月  阅读(29)  评论(0)    收藏  举报