目录
- 一、引言
- 二、进程优先级是什么
- 三、为什么要有优先级
- [四、Linux 里优先级长什么样:PRI 与 NI](#四、Linux 里优先级长什么样:PRI 与 NI)
- [1. 先把优先级拎出来看](#1. 先把优先级拎出来看)
- [2. PRI 和 NI 的关系](#2. PRI 和 NI 的关系)
- [3. 魔鬼细节:这里的 old pri 到底是什么](#3. 魔鬼细节:这里的 old pri 到底是什么)
- [4. nice 的范围:为什么是 -20 到 19](#4. nice 的范围:为什么是 -20 到 19)
- [5. 为什么 nice 的范围不能随便改](#5. 为什么 nice 的范围不能随便改)
- [6. 查看和调整优先级:从 top 入手](#6. 查看和调整优先级:从 top 入手)
- 五、顺便把竞争、独立、并行、并发说清楚
- 六、进程切换:寄存器是共享的,数据是私有的
- 七、总结
一、引言
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) 调度算法。
感谢您看到这里,不知是否可以为博主留下一个点赞或评论呢?这对博主很有用,同时有问题或争论可以在评论区提出~感谢支持~





