03-优先级与调度


个人主页:发疯的技术鼠

❄️专栏传送门:《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,最方便的是:

bash 复制代码
ps -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 寄存器切换。当多任务内核决定运行另一个任务时::

  1. 保存当前任务的当前状态,也就是 CPU 寄存器中的全部内容;
  2. 把这些内容保存到该任务自己的堆栈(或 PCB)中;
  3. 把下一个将要运行的任务的当前状况,从它的栈里重新装入 CPU 寄存器;
  4. 开始下一个任务的运行。

这一过程就叫 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):时间片已经耗尽的进程,按优先级放在这里。

调度规则:

  1. 从活动队列里按优先级挑一个进程运行;
  2. 时间片用完,把它移到过期队列;
  3. 活动队列空了,把 active 和 expired 两个指针交换;
  4. 过期队列里的进程重新计算时间片,又变成一批"满血"的活动进程。

这样就不需要每次都遍历所有进程重新算时间片,交换一下指针即可,代价是常数。

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,但"活动/过期队列 + 位图"的思想仍然值得学习。

五、把这一章串起来

现在回看一个进程的一生:

  1. fork() 创建,进入就绪队列(R);
  2. 调度器按优先级挑中它,上 CPU 运行;
  3. 时间片用完,保存上下文,回到就绪队列;
  4. 等 IO 时进入 S/D,事件到了被唤醒,回到就绪队列;
  5. 收到 SIGSTOP 进入 T,SIGCONT 恢复;
  6. exit() 退出,如果父进程没回收,变成 Z;
  7. 父进程 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 之后父子打印同一个地址,值却不一样?

上一篇:进程概念(二):进程是什么------PCB、pid、fork 与进程状态 ·

下一篇:进程概念(四):环境变量与虚拟地址空间

相关推荐
无足鸟ICT2 小时前
【RHCA+】sosreport(收集诊断文档)
linux·运维·服务器
GeW2 小时前
世界目光聚焦中国:底层技术、Linux、数据库的破局逻辑
linux·数据库
星恒随风4 小时前
MySQL 从零入门(十):MVCC、Undo Log 与 Read View 详解——InnoDB 如何实现事务隔离?
linux·数据库·笔记·sql·mysql
瑞雪兆丰年兮5 小时前
Linux零基础快速入门-第二章 Linux基础命令
linux·运维·服务器
咋的啥名都用不了呢~7 小时前
Linux项目部署6(安装Elasticsearch)
linux
无奈笑天下8 小时前
银河麒麟桌面上USB打印机无法打印问题标准处理流程
linux·运维·网络协议
15Moonlight9 小时前
Linux 网络(11):IO 多路转接(select /poll/epoll)
linux·网络
wno70411 小时前
CentOS下FTP服务搭建
linux·运维·centos
15Moonlight11 小时前
Linux网络(12):Reactor 模式
linux·网络