
个人主页:发疯的技术鼠
❄️专栏传送门:《C语言》《数据结构》《C++》《算法》《Linux系统》
🌟Gitee 仓库:《C语言与数据结构与算法》《C++》
进程概念(三):优先级、切换与调度------一颗 CPU 如何"分身"
系列文章:Linux 系统编程 ·《进程概念》篇 · 第 3 篇 / 共 4 篇
本篇:进程优先级、竞争与独立、并行与并发、进程切换、Linux 2.6 O(1) 调度。
上一篇我们让进程"生"了出来,也看懂了它的各种状态。但还有一个问题没回答:
CPU 只有一个(或几个核),进程却有一大堆,凭什么每个进程都觉得自己在一直往前跑?
这一篇就讲这件事:优先级怎么排、时间片怎么切、上下文怎么存、调度器怎么在常数时间里挑出"下一个幸运儿"。
先讲个真事
你一边挂着音乐,一边编译一个几万行的项目,一边还在浏览器里开十几个标签页。
按常理,编译这种 CPU 密集型任务应该把 CPU 吃干抹净,音乐早该卡成电音了。但大多数时候,音乐照样流畅,网页也还能动。
这不是因为 CPU 真的"同时"在干所有事,而是因为操作系统在极短的时间尺度上,不停地把 CPU 从一个人手里抢过来,塞给下一个人。快到你完全感觉不到。
这套"抢来抢去"的规则,就是进程调度。
一、优先级:排队也有先后
1. 为什么要有优先级
CPU 资源是有限的,进程数目却可能很多,甚至只有一个 CPU。于是进程之间天然具有竞争性。
为了让"更重要的活"先干、让系统整体更合理,操作系统给每个进程安排了一个优先级(priority):CPU 资源分配的先后顺序。
- 优先级高的进程,有优先执行的权利;
- 合理配置优先级,可以改善系统性能;
- 在多核机器上,还可以把进程绑定到指定 CPU,把不重要的进程挪到某个核上,提升整体吞吐。
2. PRI 和 NI:两个容易混淆的数
在 Linux 里看进程优先级,绕不开两个字段:
- PRI :进程可被执行的优先级,值越小,越早被执行;
- NI :nice 值,进程优先级的修正数值。
它们的关系是:
text
PRI(new) = PRI(old) + nice
默认情况下,普通进程的 PRI 是 80,NI 是 0。nice 的取值范围是 -20 ~ 19,一共 40 个级别。
| nice 值 | 大致 PRI | 含义 | 谁可以设置 |
|---|---|---|---|
| -20 | 60 | 最"不客气",优先级最高 | 只有 root |
| 0 | 80 | 默认 | 所有人 |
| 10 | 90 | 比较"谦让" | 所有人 |
| 19 | 99 | 最"客气",优先级最低 | 所有人 |
为什么叫 nice?因为它衡量的是进程对别的进程有多"友好":nice 值越大,越愿意把 CPU 让给别人,自己的优先级就越低。
一定要记住:nice 不是优先级,它是优先级的修正值。就像"优惠券"不是"价格",但会影响你最终付多少钱。
3. 用 ps -l 看 PRI 和 NI
bash
ps -l
输出大概长这样:

重点看
PRI和NI两列:默认都是80和0。UID是执行者身份,PID是进程号,PPID是父进程号。
各字段含义:
| 字段 | 含义 |
|---|---|
UID |
执行者的身份(用户 ID) |
PID |
进程代号 |
PPID |
父进程代号 |
PRI |
可被执行的优先级,越小越早执行 |
NI |
nice 值,优先级的修正值 |
4. 修改优先级:top、nice、renice
方法一:top 里改
bash
top
# 进入后按 r → 输入进程 PID → 输入新的 nice 值



方法二:nice / renice 命令
bash
# 启动时指定 nice 值
nice -n 7 sleep 100 &
# 修改已运行进程的 nice 值
renice -n 5 -p <pid>


方法三:系统调用
c
#include <stdio.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <unistd.h>
int main(void)
{
int prio = getpriority(PRIO_PROCESS, 0);
printf("nice = %d\n", prio);
setpriority(PRIO_PROCESS, 0, 10); /* 把自己调"谦让"一点 */
printf("after set: %d\n", getpriority(PRIO_PROCESS, 0));
return 0;
}

注意:
getpriority出错时返回 -1,而 -1 本身也是合法的 nice 值。严谨的写法要先把errno清零,再判断返回值。初学阶段知道有这个坑就行。
权限规则:普通用户只能把自己的进程调得更"谦让"(nice 值增大),想把 nice 调成负数(提高优先级)需要 root 权限。否则人人都给自己 -20,优先级就形同虚设了。
5. 一个真实实验:nice -n 7 之后,NI 为什么是 19?

第一步
nice -n 7 sleep 100 &,ps -lp却看到PRI 99 / NI 19;第二步renice -n 5之后,才变成PRI 85 / NI 5。
很多人第一反应:不是 -n 7 吗,怎么 NI 是 19?
关键在两个字:相对 。nice -n N 的语义是在当前父进程 nice 的基础上加 N,不是"设置成 N":
text
新 nice = 当前ppid的 nice + N (结果会被限制在 -20 ~ 19)
从 renice 输出的那句 old priority 19 可以看出,执行完 nice -n 7 之后,这个进程的 nice 已经是 19------说明它继承的起点不低(可能是 12,12 + 7 = 19;也可能已经是 19,直接被上限截断)。总之它不是 7 ,因为 -n 不是绝对值。
而 renice -n 5 的语义是"设置成 5 "(绝对设置),所以 old 19 → new 5,ps 里立刻变成 NI 5 / PRI 85。
| 命令 | 语义 | 例子 |
|---|---|---|
nice -n 7 cmd |
在当前ppid的 nice 上 加 7,超过 19 截断 | 12 → 19;19 → 19 |
renice -n 5 -p PID |
把 nice 设为 5 | 19 → 5 |
在默认情况下 PRI = 80 + nice,所以图中两次的结果正好是:
text
NI 19 → PRI 99
NI 5 → PRI 85
💡 顺带说明:在普通的
nice = 0的 shell 里执行nice -n 7 sleep 100 &,ps会看到NI 7 / PRI 87。这张图里之所以是 19,是因为这个 shell 之前的 nice 已经被调高过------正好演示了"相对调整"的坑。想确认某个进程的 nice 和 PRI,最方便的是:
bashps -o pid,ni,pri,stat,cmd -p <pid>记住口诀:
nice是"再加多少",renice是"改成多少"。
二、竞争、独立、并行、并发
这四个词经常被混着用,但在操作系统里各有明确含义。
1. 四个概念
- 竞争性:系统进程数目众多,CPU 资源只有少量甚至 1 个,进程之间必然竞争资源。为了高效、合理地竞争,才有了优先级。
- 独立性:多进程运行需要独享各种资源,进程之间互不干扰。一个进程崩了,不应该把另一个进程的数据改掉。
- 并行(parallel) :多个进程在多个 CPU 上同时运行。
- 并发(concurrent) :多个进程在一个 CPU 上交替运行,在一段时间内让多个进程都得到推进。### 2. 咖啡机比喻
先看一张特别形象的图::

上面是并发 :一台咖啡机,两条队伍轮流用,一段时间内两杯咖啡都在推进;下面是并行:两台咖啡机,两条队伍各做各的,真正同时进行。
用表格对比:
| 对比项 | 并发 | 并行 |
|---|---|---|
| CPU 数量 | 一个 | 多个 |
| 运行方式 | 交替执行 | 同时执行 |
| 微观上 | 同一时刻只有一个进程在跑 | 同一时刻多个进程在跑 |
| 宏观上 | 一段时间内都推进了 | 真正的一起推进 |
| 关键条件 | 时间片 + 切换 | 多核 / 多处理器 |
一句话:并发是"轮流坐庄",并行是"各开一桌"。单核机器上你能看到并发,看不到真正的并行。
三、进程切换:CPU 的"存档"和"读档"
1. 上下文是什么
CPU 里的寄存器只有一份,但每个进程都觉得自己在独占 CPU。进程被切走时,它算到一半的数据放哪?答案是:上下文(context)。
上下文切换,实际含义是任务切换,或者说是 CPU 寄存器切换。当多任务内核决定运行另一个任务时::
- 保存当前任务的当前状态,也就是 CPU 寄存器中的全部内容;
- 把这些内容保存到该任务自己的堆栈(或 PCB)中;
- 把下一个将要运行的任务的当前状况,从它的栈里重新装入 CPU 寄存器;
- 开始下一个任务的运行。
这一过程就叫 context switch。

CPU 里的寄存器只有一份,但上下文可以有多份,分别对应不同进程。进程 A 被切下来时带走自己的上下文,下次回来再按原样恢复,就能接着之前的逻辑继续跑。
打个比方:你在打游戏,临时要出门,先存档 ;回来之后读档,角色还站在原地、血条还是满的。上下文切换就是操作系统的存档/读档,只不过它一秒钟要存几十上百次。
2. 时间片:什么时候切
当代计算机都是分时操作系统。每个进程都有自己合适的时间片(其实就是一个计数器)。时间片一到,进程就被操作系统从 CPU 上"剥离"下来,换下一个。
text
进程 A 跑 10ms → 时间片用完 → 保存 A 的上下文
→ 选中进程 B → 恢复 B 的上下文 → B 跑 10ms → ......
所以"同时运行"的真相是:
text
宏观:A、B、C 都在推进
微观:CPU 在 A、B、C 之间极速切换
3. 切换是有代价的
上下文切换不是免费的:
- 要保存/恢复大量寄存器;
- 切换后 CPU 缓存、TLB 可能失效,需要重新预热;
- 切换太频繁,CPU 大量时间花在"换人"而不是"干活"上。
所以调度器要在"响应快"和"开销小"之间找平衡:时间片太短,切换开销大;时间片太长,交互卡顿。
四、Linux 2.6 的 O(1) 调度
1. 目标:不管多少进程,挑人都是常数时间
早期的调度器在进程很多时,选下一个进程的代价会随进程数增长。Linux 2.6 引入了 O(1) 调度器:无论系统里有多少进程,选出一个最合适的进程,时间复杂度都是常数。
它的核心数据结构是每个 CPU 一个 runqueue(运行队列):

每个 CPU 一个 runqueue;
active指向活动队列,expired指向过期队列;每个队列都是一个prio_array,里面有nr_active、bitmap[5]和queue[140]。
2. prio_array:140 个队列 + 一张位图
prio_array 里有三个关键成员:
| 成员 | 含义 |
|---|---|
nr_active |
当前队列里有多少个可运行进程 |
bitmap[5] |
5 个 32 位整数,共 160 个 bit,用 140 个 bit 标记"哪个优先级的队列非空" |
queue[140] |
140 个链表头,下标就是优先级;相同优先级的进程按 FIFO 排队 |
优先级范围是:
- 实时优先级:0 ~ 99(普通进程不关心);
- 普通优先级:100 ~ 139,正好对应 nice 值 -20 ~ 19。
queue[140] 的每个元素就是一个进程队列,数组下标就是优先级。调度时从下标 0 开始找第一个非空队列,找到的就是当前最高优先级的进程。
但"从 0 开始遍历 140 个队列"虽然也是常数,还是不够快。于是有了 bitmap[5]:

每个 bit 对应一个优先级队列是否非空。找"最高优先级"就变成了"找第一个为 1 的 bit",用位运算几条指令就能完成,真正做到 O(1)。
3. 活动队列与过期队列
只有 queue[140] 还不够,因为时间片会耗尽。O(1) 调度器用了两个数组:
- 活动队列(active):时间片还没用完的进程,按优先级放在这里;
- 过期队列(expired):时间片已经耗尽的进程,按优先级放在这里。
调度规则:
- 从活动队列里按优先级挑一个进程运行;
- 时间片用完,把它移到过期队列;
- 活动队列空了,把
active和expired两个指针交换; - 过期队列里的进程重新计算时间片,又变成一批"满血"的活动进程。
这样就不需要每次都遍历所有进程重新算时间片,交换一下指针即可,代价是常数。
4. 一张图串起来
text
新进程 → 活动队列 queue[优先级]
↓ 调度
CPU 运行
↓ 时间片耗尽
过期队列 queue[优先级]
↓ 活动队列空了,交换指针
重新计算时间片,回到活动队列
5. 重要提醒:O(1) 是"历史算法"
O(1) 调度器是 Linux 2.6 时代的经典设计,也是理解"用数据结构把调度变快"的绝佳案例。但现代 Linux 已经不用它了:
- 2.6.23 起,默认调度器换成 CFS(完全公平调度);
- 6.6 起,CFS 又被 EEVDF 取代。
所以面试时别张口就说"Linux 用 O(1) 调度"。更准确的说法是:O(1) 是 Linux 2.6 的历史实现,现代内核用 CFS/EEVDF,但"活动/过期队列 + 位图"的思想仍然值得学习。
五、把这一章串起来
现在回看一个进程的一生:
fork()创建,进入就绪队列(R);- 调度器按优先级挑中它,上 CPU 运行;
- 时间片用完,保存上下文,回到就绪队列;
- 等 IO 时进入
S/D,事件到了被唤醒,回到就绪队列; - 收到
SIGSTOP进入T,SIGCONT恢复; exit()退出,如果父进程没回收,变成Z;- 父进程
wait或父进程退出后被 1 号进程回收,彻底消失。
这一圈下来,优先级决定它排队的顺序,时间片决定它跑多久,上下文切换保证它每次回来都能接着跑,调度器决定下一个是谁。
常见问题 FAQ
Q1:nice 值越大,优先级越高还是越低?
越低。nice 越大越"谦让",PRI 越大,越晚被执行。想让进程更优先,要把 nice 调小(负值),这需要 root 权限。
Q2:PRI 和 NI 是一回事吗?
不是。PRI 是最终优先级,NI 是修正值。关系是 PRI(new) = PRI(old) + nice。
Q3:为什么负 nice 需要 root?
否则每个进程都可以把自己调到最高优先级,优先级机制就失效了。系统必须保证只有特权用户能"插队"。
Q4:并行和并发到底怎么区分?
并行需要多个 CPU 同时执行;并发是单 CPU 交替执行。单核上只有并发,多核上两者都可能有。
Q5:上下文切换为什么有开销?
保存/恢复寄存器本身要时间,切换后缓存和 TLB 可能失效,需要重新加载。切换越频繁,花在"换人"上的时间越多。
Q6:O(1) 调度器现在还能用吗?
不能,现代内核已经换成 CFS/EEVDF。O(1) 是理解调度思想的历史案例,不是当前实现。
小结
- 优先级 :PRI 越小越优先;nice 是修正值,范围 -20 ~ 19;
PRI(new) = PRI(old) + nice。 - 查看与修改 :
ps -l看 PRI/NI,top按r改,nice/renice命令,getpriority/setpriority函数。 - 竞争、独立、并行、并发:CPU 少进程多 → 竞争;资源独享 → 独立;多 CPU 同时 → 并行;单 CPU 交替 → 并发。
- 进程切换:保存寄存器上下文到 PCB/栈,恢复下一个进程的上下文;时间片到期触发切换。
- O(1) 调度 :每个 CPU 一个 runqueue,
prio_array用queue[140]+bitmap[5]+ active/expired 双队列,把"选下一个"做到常数时间;现代内核已换成 CFS/EEVDF。
下一篇是本系列的最后一篇,也是很多人的"劝退点":环境变量和虚拟地址空间。我们会回答两个经典问题------为什么 ls 能直接运行、你的 hello 却要 ./hello?为什么 fork 之后父子打印同一个地址,值却不一样?