进程(三)进程优先级:谁先上 CPU

目录

一、引言

OK 大佬们好,我是戊本菌。

上一篇我们把进程的状态挨个儿捋了一遍:R 运行、S 睡眠、D 磁盘休眠、T 停止、Z 僵尸,顺带还认识了孤儿进程和僵尸进程的危害。当时留了一个尾巴------一个进程从 CPU 上被剥离下来,它的"上下文"去哪儿了?

这一篇我们接着往下走,把"剥离"这件事讲清楚。不过在讲上下文之前,得先回答一个更现实的问题:系统里那么多进程,CPU 只有一个,凭什么先跑你?

想象一下食堂打饭的窗口就一个,队伍却排到了门口。谁先打上饭,很显然是"队伍顺序"决定的;那进程的"队伍顺序"是谁定的、按什么定的?这就是本文要聊的进程优先级。

依旧三步走:是什么 → 为什么 → 怎么设计的。

二、进程优先级是什么

我们要学习一个新的东西,依旧对"它是什么"先进行发问。

不过这个问题得先排除一个干扰项,因为初学的时候特别容易把两件事混在一起:

【概念】

  • 权限 :解决的是"能不能"。你能不能用 root 身份 kill 掉别人的进程,你能不能打开 /etc/shadow,这叫权限。
  • 优先级 :解决的是"先不先"。大家都能跑,但 CPU 就那么一颗,谁先上车、谁后上车。

所以优先级的前提,是"已经能了"。进程在已经能够获得某种资源的前提下,得到该资源的先后顺序------这一句话就是优先级的定义。

【核心特征】

  • 优先级是"竞争"的产物,没有竞争就没有优先级。一个进程独占整个 CPU,它压根不需要优先级。
  • 优先级只影响先后 ,不影响能不能。

【举例】

还是车间那个比方:一群工人都能上手开机床(这是权限,你进了厂、有工牌),但机床只有一台,于是车间主任掏出排班表------今天谁先上、谁后上(这就是优先级)。工人不会因为排在后面就被开除,他只是晚一点开工。

所以"要不要讲优先级",问的其实是"资源够不够分"。资源足够,谁也不需要排队;资源不够,就必须有人决定顺序。

三、为什么要有优先级

顺着上面那句话往下问:资源什么时候会不够?

答案是几乎一直都不够。想想你电脑上同时跑着浏览器、音乐、终端、编译器,鼠标还能丝滑地动,这背后其实是一堆进程在抢同一颗 CPU 的执行时间。进程数目远大于 CPU 数目 (很多机器干脆只有一颗逻辑核),于是进程之间天然就带上了竞争性。

有了竞争,就必须有一套分配资源的标准,否则谁先谁后全靠运气,系统表现会像吃了炫迈一样------完全不可控。这套标准,就是优先级:决定进程获得某种资源的先后顺序。

反过来说,如果所有进程优先级相同,会怎么样?

会变成"先来后到"。先来的进程一旦不主动让出 CPU(比如死循环),后面的进程就只能干等,交互性直接崩盘------你敲一个字母,光标半分钟后才动。所以操作系统必须能区分"这个进程很急"和"这个进程可以等",把 CPU 先给急的那位。

四、Linux 里优先级长什么样:PRI 与 NI

1. 先把优先级拎出来看

在终端里敲下 ps -l:

关注这几列:

列 含义
UID 代表执行者的身份
PID 代表这个进程的代号
PPID 代表这个进程是由哪个进程发展衍生而来的,即父进程的代号
PRI 代表这个进程可被执行的优先级,其值越小越早被执行
NI 代表这个进程的 nice 值,即优先级的修正数值

我们可以看见,默认情况下 PRI 是 80、NI 是 0。这就是"普通优先级"的模样。

2. PRI 和 NI 的关系

PRI 比较好理解,就是进程的优先级------通俗点说就是程序被 CPU 执行的先后顺序,值越小优先级越高。

那 NI 是干什么的?

NI 就是我们说的 nice 值,它本身不是优先级,而是优先级的修正数据。两句话概括:

复制代码
PRI(new) = PRI(old) + nice
  • nice 为负,PRI 变小,进程更容易被优先执行;
  • nice 为正,PRI 变大,进程更"谦让",让别人先跑。

这也是为什么它叫 nice------你越 nice,越把机会让给别人。所以我猜在座各位的 nice 值应该都很小吧【狗头】。

所以,调整进程优先级,在 Linux 下就是调整进程的 nice 值。

这里要强调一点:nice 值和优先级不是一个概念,nice 只是优先级的变化量。把这两个混着用,后面算 PRI 的时候一定会懵。

3. 魔鬼细节:这里的 old pri 到底是什么

上面那个公式看着简单,但有个坑:PRI(old) 到底是什么?

如果 PRI(old) 指的是"上一次算出来的 PRI",那就有意思了------你已经把 nice 从 0 调到 10,PRI 变成 90;再想把 nice 调成 -10,公式会算成 90 - 10 = 80,而不是 80 - 10 = 70。越调越偏,调几次就彻底失控了。

所以这里的 PRI(old) 永远是原始优先级,也就是那个固定的 80。不管你怎么折腾 nice,每次都拿 80 做基准去加。这样 nice 和 PRI 才是严格一一对应的,调得回来。

所以注意"PRI(old) 是固定值"。

4. nice 的范围:为什么是 -20 到 19

nice 的取值范围是 -20 到 19,一共 40 个级别 。代入 80 的基准,PRI 就落在 60, 99 这个区间里。

也就是说,你 top 里把 nice 怎么按都按不出 200------范围是硬限制的。

【知识点补充】

如果你翻到内核源码,可能还会看到另一种说法:

  • 普通优先级:100 ~ 139
  • 实时优先级:0 ~ 99(不关心)

第一眼看是不是觉得跟 60, 99 对不上?其实两套数字说的是同一个东西的两种画法 :内核里的 prio 是 0~139 连续编号,普通优先级占 100~139;ps 显示的时候把这些整体平移了一下,把普通优先级的起点画在 80 上。所以 60 和 100 说的都是 nice=-20 的那一端,只不过一个是 ps 视角,一个是内核源码视角。

顺带记住这个数字:MAX_PRIO 就是 140。本文后面还会再撞见它一次。

5. 为什么 nice 的范围不能随便改

这就引出了下一个问题:为什么是 -20 到 19?凭什么不能是 -1000 到 1000?

因为分时操作系统要给每个进程相对公平、公正的调度策略 ,让不同的进程都能在一段时间内得到 CPU 资源。若允许你把 nice 拉到 -1000,那个进程就会霸占 CPU,剩下的进程全在等------饿死(这个词后面讲调度队列还会再出现一次)。

换个说法:改优先级这件事本身不应该是一个高频动作。你今天让 A 先跑,明天让 B 先跑,这叫调度;你一秒钟改一万次优先级,这叫添乱。范围有限,本质上是在说"优先级是用来微调的,不是用来重写规则的"。

当然,也不是所有系统都这么"讲道理"。实时操作系统里,优先级可能直接决定生死,该抢占就抢占,没有任何商量的余地------那是另一套思路,本文就不展开阐述了。

6. 查看和调整优先级:从 top 入手

查看和调整优先级,最直观的入口是 top,而且顺序是先看、再改:

bash 复制代码
top
# 进去之后按 "r" -> 输入进程 PID -> 输入 nice 值

使用如下指令创建一个sleep进程

通过ps指令查看进程pid

接着输入top进入top界面

top 上半屏是进程列表,最上面那几列里就有我们要的两个:PR 是优先级,NI 是 nice 值------跟前面 ps -l 里的 PRI、NI 是同一回事,只是列名短了一截。

这里密密麻麻的很多数据,但是不用怕,我们单取我们所需要的,还记得上面查看的pid(1499526)吗?

这里我们就使用到了,使用top -p <pid>指令

我们就进入了只有这一个进程的top界面

按**r** 之后

top 顶上会先问 PID to renice [default: ...]

把要改的进程号敲进去(这里我们已经通过 -p <pid>默认选好了进程),按下回车,接着问 Renice PID to value (default 0):

这里输 10 就是 nice=10,输 -10 就是 nice=-10(负号别漏 ,漏了就成了往"谦让"的方向调)。回车之后,那一行的 NI 当场变,PR 跟着一起动。

关注点:

这里我们输入10后出现如此提示,是为什么呢?

这里我们可以通过ps -o pid,user,ni,pri,cmd -p <PID>

指令查看当前进程属于谁,我们这里这个进程属于root所以我们无权修改其nice值

接下来总结:

在 top 里改的好处是看得见 :改之前这一行的 PR、NI 长什么样,改完立刻能对比,不用来回切命令。坏处也很明显------它是全屏交互界面,没法写进脚本,也没法一条命令批量改。

所以光靠 top 撑不住一整套需求,它边上还站着另外两条路:nice、renice,再往下是系统函数。

(1)nice:启动的时候就把 nice 定好

第一条路,命令还没跑起来,先把 nice 定死:

bash 复制代码
nice -n 10 sleep 1000 &

nice 本身不是"改"进程,而是"以某个 nice 值启动后面的命令",-n 10 就是 nice=10。末尾的 & 是让它挂到后台,好腾出手来看它。

顺带记一个小东西:丢到后台时 shell 会把 PID 直接打出来([1] 1848400),用 $! 也能取到,比 ps | grep 省事得多。

然后看它一眼:

NI = 10,PRI = 90。80 + 10 = 90,丝滑。

这就是"启动时就定好"的样子:一次生效,后面不用再管它。

(2)renice:改已经跑起来的进程

进程已经在跑了,nice 就派不上用场了(它是用来启动命令的),这时候换 renice:

这里我们用pid为1848400的进程举例

-p 后面跟 PID,-n 19 是新的 nice 值。执行完它会回一句:

注意它说的是 priority ,指的其实是 nice 值(也就是 ps 里的 NI 列),别跟 PRI 搞混了

80 加 19 是 99,正好顶到正方向的边界。

(3)往负方向调:先过权限这一关

接着把 nice 往负方向按,调到 -20:

普通用户跑到这里,会直接吃一个闭门羹:

这不是命令写错了,是权限在拦:普通用户只能把 nice 往大调 (让自己更谦让、更靠后),往小调 (往前抢)必须 root 。加个 sudo 就过得去:

这样就能修改成功啦~

这也就是"权限"和"优先级"这对亲戚在现实里的一次照面------权限管能不能 ,优先级管先不先。

(4)系统函数:getpriority / setpriority

最后一条是系统函数。nice、renice 这俩命令,底下调的其实就是这一对:

c 复制代码
#include <sys/time.h>
#include <sys/resource.h>
int getpriority(int which, int who);            // 取优先级
int setpriority(int which, int who, int prio);  // 设优先级

which 传 PRIO_PROCESS、who 传 0,指的就是"我自己"。写个小程序自己改自己,顺便验一验 PRI 是不是老老实实等于 80 + nice:

写入vim

c 复制代码
#include <stdio.h>
#include <unistd.h>
#include <sys/resource.h>

/* nice 只是修正值,ps 里的 PRI 才是优先级,两者差一个固定的 80 */
void show(const char *tag)
{
    int nice = getpriority(PRIO_PROCESS, 0);   /* who 传 0:我自己 */
    printf("%-8s nice = %3d   PRI = 80 + nice = %d\n", tag, nice, 80 + nice);
}

void try(int n)
{
    printf("-- 想把 nice 改成 %d\n", n);
    if (setpriority(PRIO_PROCESS, 0, n) == -1)
        perror("   setpriority 失败");   /* 普通用户往负方向调,走这里 */
    else
        show("   改完");
}

int main(void)
{
    printf("我是进程 %d\n", getpid());
    show("刚启动");

    try(10);
    try(19);
    try(-10);
    try(-20);

    return 0;
}

编译、跑:

普通用户跑,后两步(往负方向)会被权限拦下来,屏幕上只会留下 setpriority 失败: Permission denied,nice 停在 19 不动。加上 sudo 再跑一遍,就没有什么问题了。

这里有个值得盯一眼的地方:99 减 10 得到的是 70,不是 89 。如果 PRI(old) 指的是"上一次算出来的 PRI",这里就该是 89,然后越调越偏;实际能干净地回到 70,说明基准永远是那个固定的 80------第 3 小节那个"魔鬼细节",被这四行输出钉死了。

至此以上,进程优先级的基本盘就讲完了。

五、顺便把竞争、独立、并行、并发说清楚

优先级不是凭空长出来的,它长在"竞争"这两个字上。所以这几个概念必须一起过。

概念 含义 关键词
竞争性 系统进程数目众多,而 CPU 资源只有少量甚至 1 个,进程之间具有竞争属性 抢
独立性 多进程运行,需要独享各种资源,运行期间互不干扰 隔离
并行 多个进程在多个 CPU 下分别、同时运行 真·同时
并发 多个进程在一个 CPU 下通过进程切换,在一段时间内都得以推进 看起来同时

一句话区分并行和并发:并行是"真的两个人同时在干",并发是"一个人左右横跳,看起来像两个人在干"。

那"左右横跳"是怎么跳的?靠时间片。当代计算机都是分时操作系统,每个进程都有属于自己的时间片(本质就是个计数器),时间片一到,进程就被操作系统从 CPU 上剥离下来。

六、进程切换:寄存器是共享的,数据是私有的

这里有一个特别反直觉、但想通了就很爽的点:

寄存器是共享的,但寄存器里面的数据,本质上是进程私有的。

为什么?因为寄存器是 CPU 的零件,全世界就这么一套,谁来都往上写。那进程 A 刚刚算到一半、结果还在 rax 里,进程 B 上来了,rax 被覆盖成 B 的值------A 再回来时,是不是就失忆了?

所以必须有人替它把现场存下来。这就是上下文切换(Context Switch) ,也叫任务切换或 CPU 寄存器切换:当多任务内核决定运行另外一个任务时,它先保存正在运行任务的当前状态------也就是 CPU 寄存器中的全部内容------这些内容被保存在任务自己的堆栈中;入栈完成后,再把下一个将要运行任务的当前状况从它自己的栈里重新装入 CPU 寄存器,并开始下一个任务的运行。

这一套"寄存器现场",就是进程上下文。 它既不是进程的代码,也不是进程的数据,而是"进程跑到哪儿了"的快照。

所以回到上一篇那句话:进程从 CPU 上被剥离下来,剥离的是"使用 CPU 的权利",留下的是"上下文"。CPU 只有一个,但每个进程都认为自己独占了一颗 CPU------这就是并发给进程(也给人)制造的幻觉。

时间片 + 上下文切换 = 并发的实现方式。

七、总结

  • 优先级解决"先不先",权限解决"能不能";优先级是资源竞争下的产物,没有竞争就不需要它。
  • Linux 下调优先级,调的是 nice (-20 ~ 19,共 40 个级别),真正生效的公式是 PRI(new) = PRI(old) + nice,而 PRI(old) 永远是那个固定的 80 基准,否则越调越偏。
  • 代入 80 基准,PRI 落在 60, 99 ;ps 视角的 80 对应内核视角的 120,MAX_PRIO 是 140。
  • nice 范围被卡死,是因为分时系统要保证"一段时间内每个进程都能拿到 CPU",而且改优先级不该是高频动作。
  • 改 nice 有 nice、renice、top 里按 r 三个入口,系统函数是 getpriority / setpriority;普通用户只能往"谦让"的方向调。
  • 并行 是多颗 CPU 真的同时跑,并发 是一颗 CPU 靠时间片 + 进程切换制造出的假象;切换时保存和恢复的,就是进程上下文。

到这里,优先级算是讲完了。但它还留着一个问题没回答:**系统里那么多进程,内核到底用什么结构把它们排好队?**优先级这个数字,又是怎么变成"第几个格子"的?

下一篇我们就钻进去看 Linux 2.6 的 runqueue :为什么每个 CPU 都有一张排班表、queue[140] 的下标为什么就是优先级、140 个格子怎么用 5 个整型变成一条位运算指令,以及那一手"活动队列换过期队列"是怎么做到连饿死都防住的------O(1) 调度算法。

感谢您看到这里,不知是否可以为博主留下一个点赞或评论呢?这对博主很有用,同时有问题或争论可以在评论区提出~感谢支持~

相关推荐
aningx1 小时前
Arch 系用 greetd 实现开机自动进 Plasma Wayland,注销自动回桌面
linux
江无行者2 小时前
Linux 服务器 top 命令详解
linux
嵌入式 Linux手记4 小时前
一块内存,三种解释:union 的真实用法
linux·c语言·驱动开发·嵌入式
星恒随风4 小时前
MySQL 从零入门(九):事务管理详解——ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别
linux·服务器·数据库·笔记·mysql
草莓熊Lotso5 小时前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构
星恒随风5 小时前
MySQL 从零入门(十一):视图与用户权限管理详解
linux·服务器·数据库·笔记·mysql
江华森7 小时前
从零开始:智能运维概念与Linux环境准备完全指南
linux·运维
努力写代码的熊大8 小时前
Linux 个人复盘博客 · 第六篇 Linux 进程间五种通信:匿名管道、命名管道、共享内存、消息队列与信号量
linux·经验分享·笔记
橙橙子2308 小时前
Linux----libevent
linux·运维·服务器