目录
- 一、引言
- 二、内核是怎么"组织"进程的
- [1. 最朴素的双链表长什么样](#1. 最朴素的双链表长什么样)
- [2. 麻烦来了:只有成员地址,怎么找到它爹?](#2. 麻烦来了:只有成员地址,怎么找到它爹?)
- [3. 从成员反推整个结构体](#3. 从成员反推整个结构体)
- [4. 绕这么一圈,图什么?](#4. 绕这么一圈,图什么?)
- [三、runqueue:每个逻辑 CPU 都有一张排班表](#三、runqueue:每个逻辑 CPU 都有一张排班表)
- 四、活动数组:数组下标就是优先级
- [1. prio_array 的结构](#1. prio_array 的结构)
- [2. 挑一个最合适的进程](#2. 挑一个最合适的进程)
- [3. 位图怎么找第一个非空队列](#3. 位图怎么找第一个非空队列)
- 五、过期队列:时间片用完的人去哪儿
- [六、凭什么叫 O(1)](#六、凭什么叫 O(1))
- 七、后来调度器怎么变了
- 八、总结
一、引言
OK 大佬们好,我是戊本菌。
上篇用 ps -l 和 top 看了普通进程的 PRI、PR 和 NI,也看了内核怎么保存切换时的现场。那么调度器挑人时,手里到底拿着一张什么样的表?
咱们以 Linux v2.6.18 的 O(1) 调度器为例,先看任务怎么挂上链表,再看优先级怎么对应到队列下标,最后看时间片用完之后怎么换班。
二、内核是怎么"组织"进程的
1. 最朴素的双链表长什么样
学过数据结构的同学对双链表熟得不能再熟:
c
struct Node
{
int data;
struct Node *next;
struct Node *prev;
};
每个结点存自己的数据,再存前后两个指针。放进程也顺理成章------把 data 换成 task_struct 不就完事了?
c
struct Node
{
struct task_struct data; // 想这么干
struct Node *next;
struct Node *prev;
};
但事实并非如此,我们接着往下看:
内核采用的是侵入式链表。先用下面的简化代码看结点怎么嵌进去:
c
struct link
{
struct link *next;
struct link *prev;
};
struct task_struct
{
// ... 一大堆进程属性
struct link node; // 把这个"结点"嵌进来
// ...
};
insert_head(head, &(t->node));
也就是说,链表结点不是一个包含 task_struct 的壳,而是 task_struct 的一部分被塞进了链表里。
这种写法有一个正式的名字:侵入式链表(intrusive list)。它的意思是------链表这个数据结构,把自己的那部分"侵入"到了被管理的对象里面。
2. 麻烦来了:只有成员地址,怎么找到它爹?
看到这儿你会发现一个很别扭的点:链表里挂的是 struct link *,它指向的只是 task_struct 里那个小小的 node 成员。调度器手里只有一个 link 的地址,怎么反过来拿到整个 task_struct?
结构体和它的第一个成员从同一个位置开始。两者的指针类型不同,要比较地址,可以先转成 void *。后面的成员还要考虑对齐填充,偏移量用标准库的 offsetof 来算:
c
#include <stddef.h>
#include <stdio.h>
struct A {
int a;
int b;
int c;
double d;
};
void inspect_layout(void)
{
struct A obj;
int same_address = (void *)&obj == (void *)&obj.a;
size_t offset_c = offsetof(struct A, c);
printf("same address: %d\n", same_address);
printf("offset of c: %zu\n", offset_c);
}
这里 same_address 为真。offset_c 由编译器按当前平台的结构体布局算出,表示成员 c 到结构体起点的字节数。
3. 从成员反推整个结构体
拿到指向真实结构体成员的指针,再减去该成员的字节偏移量,就能找到结构体起点。Linux 把这一步封装成 container_of:
c
struct task_struct *task =
container_of(node, struct task_struct, run_list);
这里的 node 指向某个任务的 run_list 成员。Linux v2.6.18 的调度器用 list_entry 来做这一步,它把链表结点还原成对应的任务。给不同用途各嵌一个链表成员,同一个任务就能同时挂在不同的链表上。
4. 绕这么一圈,图什么?
答案就两条:
- 一个进程,我怎么获取当前进程的其他属性?------用"成员地址 - 偏移量"反推出结构体地址,之后想访问哪个字段都可以。
- 为什么要这么干? ------增加链式管理的扩展性,代码只需要维护一份。
想想看,如果每个被管理的结构体都自带一套链表代码,内核里就要维护几十套长得几乎一样的 insert、erase、find,改一个 bug 改几十遍。而侵入式链表把"链表能力"抽成一个 struct link,任何结构体只要嵌一个 link 成员,就立刻拥有了"被挂到链表上"的能力:一份链表代码,管理所有对象。
这也解释了一个常见的疑惑------为什么内核源码里到处都是 struct list_head *next, *prev。因为很多内核对象都复用了这种链表结构,甚至不同的结构体对象之间,也能用链表、二叉树、哈希表组织起来。
好,地基打完了。接下来到把这些链表真正用起来的地方。
三、runqueue:每个逻辑 CPU 都有一张排班表
先看一幅大图:runqueue(运行队列)。它是 Linux v2.6.18 调度器的核心数据结构。每个逻辑 CPU 的 runqueue 管理分给它的可运行任务,也记录当前正在运行的任务。
【核心特征】
- 一个逻辑 CPU 对应一个 runqueue 。如果有多个 CPU,就必须额外考虑进程个数的负载均衡问题------不然一个 CPU 排队排到天荒地老,另一个 CPU 闲到打哈欠。
- 每个 runqueue 维护着
nr_running,记录这个运行队列上的可运行任务数,包括正在运行的普通任务,以及curr(此刻正在跑的进程)、idle(没活干时切过去的空闲进程)。
精简一下,长这样:
c
struct rq {
spinlock_t lock;
unsigned long nr_running;
unsigned long long nr_switches;
struct task_struct *curr, *idle;
struct mm_struct *prev_mm;
struct prio_array *active, *expired, arrays[2];
int best_expired_prio;
/* SMP 相关的 cpu_load、sd、active_balance 等字段此处省略 */
};
curr和idle是"人",active、expired、arrays[2]是"队列"。剩下两个问题:
- 队列本身怎么装进程? ------
prio_array。- 为什么队列要两份? ------
active和expired的意义。
四、活动数组:数组下标就是优先级
1. prio_array 的结构
c
struct prio_array {
unsigned int nr_active;
DECLARE_BITMAP(bitmap, MAX_PRIO + 1); /* include 1 bit for delimiter */
struct list_head queue[MAX_PRIO];
};
MAX_PRIO 就是 140------上篇埋的那个伏笔,这里撞上了。
queue[140] 里,数组下标就是优先级。 相同动态优先级的任务挂到同一条链表。常规入队走队尾,选择时取队首。
至于为什么是 140 个格子:普通优先级区间占 100~139,前面的 0~99 为实时优先级保留,合起来正好 140 个位置。
nr_active 记录这个优先级数组里一共挂了多少个任务------这主要是为了回答一个很实际的问题:"如果队列里一个进程都没有呢?" 靠这个计数,调度器就知道"我这儿空了",不用在空队列上瞎转悠。
2. 挑一个最合适的进程
先想一个最直接的办法,逐个检查 queue[140]:
- 从 0 号下标开始遍历
queue[140];- 找到第一个非空队列,那必定是当前优先级最高的队列;
- 取该队列的第一个进程(FIFO 的队首),开始运行,调度完成。
📷 配图:选进程的三步流程示意(0 号格子往上扫 → 撞到第一个非空队列 → 取队首)
问题来了:最多检查 140 个队列,也是 O(1)。 调度频繁发生,内核用位图减少这一步的检查量。
3. 位图怎么找第一个非空队列
为了快速找到第一个非空队列,内核给 140 个队列各分一位,另外留一位作分隔标记。实现用的是 DECLARE_BITMAP(bitmap, MAX_PRIO + 1)。按 32 位的 unsigned long 来装,需要 5 个机器字。换成 64 位的 unsigned long,需要 3 个机器字。
入队时把对应位设为 1。出队时如果链表空了,再把对应位清成 0。挑任务时,sched_find_first_bit 找到最靠前的置位,调度器用这个位号查 queue[idx],再取队首。具体会检查几个机器字、用什么指令,由架构实现决定。
扫描的位数有固定上限。队伍排得再长,取到队首的步骤也一样。
五、过期队列:时间片用完的人去哪儿
想象一下,两个同优先级任务轮流跑,时间片耗尽后移到队尾,就能继续轮转。真正棘手的是另一种情形:只要更高优先级的任务一直留在活动队列,低优先级的任务就会一直等。
runqueue 为此准备了两份结构相同的优先级数组:
| 数组 | 调度器什么时候选它 |
|---|---|
活动数组 active |
当前从这里选任务 |
过期数组 expired |
等活动数组清空,交换身份后再从这里选 |
以 Linux v2.6.18 的普通任务为例,时间片用完时,内核先重算这个任务的动态优先级,再补上新时间片。通常把它放进 expired。交互任务满足条件时还能留在 active。
如果过期数组等待得太久,或者当前任务的静态优先级低于已记录的过期任务,内核就会让这个用完时间片的任务也转入 expired。best_expired_prio 参与的就是这里的饥饿判断。等 active 清空,调度器交换两个指针,再从新的 active 的位图找下一个任务。
换班时只换指针,已经补好的时间片跟着任务一起留在数组里。这个机制缓解了普通任务长时间等待的问题。实时任务按自己的调度规则处理。
六、凭什么叫 O(1)
| 动作 | 做什么 | 相对单个 runqueue 的任务数 |
|---|---|---|
| 常规入队 | 把任务挂到对应优先级的队尾,同时更新位图 | O(1) |
| 挑下一个任务 | 查固定范围的位图,再取对应链表的队首 | O(1) |
| 普通任务时间片耗尽 | 给当前任务补时间片,再按规则入队 | O(1) |
| 活动数组为空 | 交换两张数组的指针 | O(1) |
这里的 O(1) 讲的是单个运行队列上的这些操作。多核之间的负载均衡是另一段逻辑,实际调度耗时也会受到锁、缓存和迁移等因素影响。
七、后来调度器怎么变了
Linux 2.6.23 引入 CFS,普通任务的公平调度改用虚拟运行时间组织任务,经典实现用红黑树。Linux 从 6.6 开始向 EEVDF 过渡,在符合条件的任务中优先选虚拟截止时间最早的任务。这篇讲的双数组和优先级位图,以 Linux v2.6.18 为例。
八、总结
task_struct可以嵌入链表结点。知道结点的地址和偏移量,就能通过list_entry找回任务。- 每个逻辑 CPU 有自己的 runqueue。调度器用当前活动数组的位图找优先级最高的非空链表,再取队首。
- 普通任务的时间片耗尽后先补时间片,再决定放进哪张数组。活动数组用空以后,交换两张数组的指针。
- 位图范围固定,所以单个 runqueue 挑下一个任务的代价不会随队列里的任务数增长。
Linux v2.6.18 调度器源码 · Linux 内核的 CFS 文档 · Linux 内核的 EEVDF 文档
到这里,"进程为什么能并发地跑"这件事,从优先级到队列就全串起来了。
下一篇我们换个方向,从"进程怎么接收参数、怎么看到环境变量"讲起,然后一路摸到 程序地址空间 ------那里面有一个特别抓人的问题:**为什么父子进程里同一个变量,地址一样,值却不一样?**那两个地址得放回各自的虚拟地址空间里看。至于它们怎么映射到物理内存,下篇见。
以上是我自己啃这块内容之后的理解,每个结论我都尽量落到源码和结构体字段上。但个人的理解终归有局限,如果哪里讲偏了,还请各位大佬在评论区指出来,我改。
感谢您看到这里,不知是否可以为博主留下一个点赞或评论呢?这对博主很有用,同时有问题或争论可以在评论区提出~感谢支持~
完整代码与示例整理:代码仓库
https://gitee.com/jiang-bos-blog-post/learning-linux




