内容总览

linux: 进程管理思维导图

一、起源:进程管理解决的问题

1.1 单道批处理的局限

早期计算机一次只能运行一个程序。CPU 执行程序期间遇到 IO(如读写磁盘)时处于空闲等待状态,IO 完成前 CPU 无法执行其他任务,整体利用率低。

1.2 多道程序并发的需求

为提高资源利用率,内存中同时加载多个程序。CPU 与 IO 设备可并行工作:某个程序等待 IO 时,CPU 切换执行另一个程序。多个程序共享 CPU、内存、IO 等资源,需要:

  1. 内存隔离:不同程序的代码与数据互不干扰
  2. 调度决策:CPU 在就绪程序间分配执行权
  3. 资源分配:文件、网络等资源按程序分配与回收

1.3 资源竞争与一致性

多个程序同时访问文件、网络、内存等共享资源,若无协调机制,可能产生数据错乱、死锁、重复执行等问题。需要统一的抽象层管理这些并发实体。

1.4 进程概念的诞生

进程作为"程序运行的实例",承载资源分配与调度的基本单位。每个进程拥有独立的虚拟地址空间,防止相互越界访问。操作系统通过进程管理,实现多道程序的安全、有序、高效运行。

二、原理:进程管理如何工作

2.1 进程与程序

  1. 程序
    • 磁盘上的静态实体,包含可执行代码、数据、资源清单
    • 一个程序可被多次加载,对应多个进程实例
  2. 进程
    • 程序运行时的动态实体,存在生命周期(创建、执行、终止)

    • 内核分配独立 PCB(进程控制块)与虚拟地址空间

  3. 关系
    • 程序是进程的蓝本,进程是程序的运行态实例

    • 同一程序(如 nginx)可同时存在多个进程,各自独立

2.2 进程的组成

2.2.1 PCB(进程控制块 task_struct)

内核中的数据结构,存储进程全部元数据:

  1. 标识信息:PID(进程号)、PPID(父进程号)、UID/GID
  2. 状态信息:运行态、阻塞态、停止态、僵尸态等
  3. 调度信息:优先级、nice 值、调度策略、累计 CPU 时间
  4. 资源信息:内存占用、打开文件描述符表、信号处理表
  5. 关系信息:父进程指针、子进程链表、进程组与会话指针

2.2.2 虚拟地址空间

每个进程拥有独立虚拟地址,由内核页表映射到物理内存,典型布局(从低到高):

  1. 代码段(.text):只读可执行的机器指令
  2. 数据段:已初始化的全局变量与静态变量
  3. BSS 段:未初始化的全局变量(程序加载时清零)
  4. 堆:动态分配内存(malloc/new 申请,从低向高增长)
  5. 文件映射区:共享库、mmap 映射文件
  6. 栈:函数调用栈、局部变量(从高向低增长)
  7. 内核空间(32 位典型 0xC0000000 以上):内核代码与数据,所有进程共享映射

2.2.3 文件描述符表

每个进程维护一张打开文件的索引表:

  1. 表项编号:0(标准输入)、1(标准输出)、2(标准错误)
  2. 表项内容:指向内核全局文件表,再指向 inode 与偏移
  3. 继承与复制:子进程 fork 后共享父进程的文件表(引用计数增加)

2.3 进程状态与转换

状态 STAT 字符 含义 触发
运行/就绪 R CPU 上执行或就绪队列中等待调度 创建后、被调度器选中、阻塞事件到达
可中断睡眠 S 等待事件,可被信号唤醒 read/write 阻塞、sleep、等待条件变量
不可中断睡眠 D 等待事件,不响应信号,强制 kill 无效 磁盘 IO 同步等待、内核底层锁等待
停止态 T / t 被信号暂停或调试器暂停 SIGSTOP、SIGTSTP(Ctrl+Z)、ptrace 断点
僵尸态 Z 进程已退出,父进程未调用 wait 回收 PCB 子进程 exit 后父进程缺失 wait/waitpid
死亡态 X 父进程 wait 回收完毕,PCB 释放 wait 完成

状态转换核心:

  1. 就绪 → 运行:调度器选中,分配 CPU
  2. 运行 → 阻塞:系统调用进入 IO 或等待事件
  3. 阻塞 → 就绪:事件到达或信号中断
  4. 运行 → 就绪:时间片耗尽或被高优先级抢占

2.4 进程调度

2.4.1 调度器职责

内核调度器根据策略,从就绪队列选择下一个上 CPU 的进程。调度决策平衡三个目标:

  1. 响应速度:交互式任务(桌面)低延迟
  2. 吞吐量:批处理任务高 CPU 利用率
  3. 公平性:各进程按权重分配 CPU 时间

2.4.2 CFS 完全公平调度

Linux 默认调度算法(针对普通进程 SCHED_NORMAL):

  1. 核心思想:给每个进程分配"虚拟运行时间"(vruntime),vruntime 越小越优先被调度
  2. 数据结构:红黑树(rbtree)组织就绪进程,按 vruntime 排序,O(log n) 取最小
  3. 权重与 nice:nice 值(-20 ~ 19)映射为权重,权重越高 vruntime 增长越慢,分配 CPU 越多
  4. 调度周期:CFS 在一个调度周期内保证每个就绪进程至少运行一次

2.4.3 实时调度策略

策略 说明
SCHED_FIFO 先进先出实时调度,无时间片,高优先级抢占低优先级
SCHED_RR 轮转实时调度,同优先级按时间片轮转

2.4.4 nice 与优先级

  1. nice:用户态可见的优先级调整(-20 最高,19 最低)
  2. 普通进程 nice 转换为 static_prio,决定 CFS 权重
  3. renice 命令可调整已运行进程的 nice

2.5 进程间关系

2.5.1 父子关系

  1. 创建(fork)
    • 子进程复制父进程 PCB、虚拟地址空间、文件描述符表

    • 写时复制(COW):父子共享物理页,任一写入时才复制新页

  2. 执行(exec)
    • 加载新程序覆盖当前进程地址空间,PID 不变
  3. 退出与回收
    • 子进程 exit 后发出 SIGCHLD 信号给父进程

    • 父进程通过 wait/waitpid 读取退出状态并释放子进程 PCB

    • 父进程未 wait 且子进程已退出 → 僵尸进程

    • 父进程先退出 → 子进程被 init(systemd PID 1)收养 → 孤儿进程

2.5.2 进程组

  1. 多个进程的集合,标识为 PGID(通常取组内第一个进程 PID)
  2. 信号可按进程组批量发送(kill 负数 PID)
  3. shell 中一条管道命令的所有进程同属一个进程组

2.5.3 会话

  1. 多个进程组的集合,标识为 SID
  2. 通常由用户登录 shell 创建,对应一个终端会话
  3. 会话首进程创建后绑定控制终端,shell 退出时会话内前台进程收到 SIGHUP

2.5.4 守护进程(daemon)

  1. 脱离控制终端、后台常驻运行的进程
  2. 特征:父进程为 init / systemd、无控制终端、工作目录通常为 /、标准输入输出重定向到 /dev/null
  3. systemd 服务单元管理的多数后台服务属于守护进程

2.6 信号机制

信号是内核向进程发送的异步事件通知。进程可注册信号处理函数,或按默认行为处理(终止、忽略、停止)。

2.6.1 常见信号

信号 编号 默认行为 场景
SIGKILL 9 终止 强制杀死,不可忽略/捕获/阻塞
SIGTERM 15 终止 请求优雅退出,可捕获清理
SIGINT 2 终止 终端 Ctrl+C
SIGHUP 1 终止 终端断开,常用于守护进程重载配置
SIGSTOP 19 停止 暂停进程,不可忽略/捕获
SIGTSTP 20 停止 终端 Ctrl+Z 暂停(可捕获)
SIGSEGV 11 终止+core dump 非法内存访问(段错误)
SIGCHLD 17 忽略 子进程退出通知父进程
SIGABRT 6 终止+core dump abort() 主动崩溃

2.6.2 信号的生命周期

  1. 产生:内核或 kill 系统调用生成信号
  2. 未决:信号暂存 PCB 未决信号集,等待进程处理
  3. 递送:进程从内核态返回用户态时检查未决信号集,执行处理
  4. 阻塞:进程可设置信号屏蔽字,对应信号保持未决直到解除阻塞

SIGKILL 与 SIGSTOP 不可被捕获、阻塞、忽略。

2.7 线程

线程是进程内的轻量级执行单元,用于在同一地址空间内实现并发。

  1. 共享资源(同进程的线程间)
    • 地址空间:代码段、数据段、堆、mmap 映射

    • 文件描述符表、信号处理表、用户与组、进程组与会话

  2. 私有资源
    • 线程栈、寄存器上下文、线程局部存储(TLS)、信号屏蔽字
  3. Linux 实现
    • 内核以 task_struct 统一表示进程与线程,线程又称"轻量级进程(LWP)"

    • clone 系统调用指定共享标志创建线程(共享地址空间、文件表等)

    • 用户态库 pthread 封装内核 clone,提供 POSIX 线程接口

  4. 调度
    • 线程与进程由同一 CFS 调度器管理,内核不区分两者

    • 单进程多线程可并行利用多核 CPU

2.8 进程间通信(IPC)

方式 方向/结构 效率 适用场景
匿名管道 pipe 单向字节流,父子进程共享 中 亲缘进程简单数据传输(如 shell 管道)
命名管道 FIFO 单向字节流,路径可见 中 无亲缘关系进程间文件式传输
消息队列 mq 内核维护结构化消息,按类型/优先级存取 中 多生产者多消费者、按消息类型解耦
共享内存 shm/mmap 同一块物理内存映射到多进程地址空间 高(无内核拷贝) 大数据量高速传输,需外部同步
信号量 sem 内核维护计数器,PV 操作实现互斥与同步 中 共享内存/临界区的互斥与条件同步
Unix 域套接字 双向字节流/数据报,类似网络 Socket 中高 本机进程间可靠双向通信(systemd journald ↔ journalctl 即此类)
信号 signal 异步事件、无附加数据 高 控制流通知(退出、暂停、事件到达)

注:共享内存 + 信号量是高性能 IPC 组合;Unix 域套接字是通用易编程的组合。

2.9 cgroups 资源限制

cgroups(控制组)将进程组织为层级树,每层可限制对应组的资源用量。

  1. 子系统(资源控制器)
子系统 限制项
cpu CPU 使用比例、带宽(CFS 带宽、实时带宽)
cpuset 绑定可用 CPU 核与内存节点
memory 内存限额、OOM 触发、统计
blkio 块设备 IO 读写速率、权重
pids 组内可创建进程/线程总数上限
freezer 批量冻结/解冻组内全部进程
  1. 层级与挂载
    • cgroups v1:各子系统独立挂载于 /sys/fs/cgroup/<子系统>/

    • cgroups v2:统一层级,单挂载点 /sys/fs/cgroup/,子系统按进程按需启用

  2. 与 systemd 的对应
    • service / scope / slice 单元对应 cgroup 目录

    • systemctl set-property 设置资源限制(如 CPUQuota、MemoryMax)

    • systemd-cgls 查看 cgroup 进程树,systemd-cgtop 查看资源占用

2.10 cgroup v2 资源限制实操

2.9 给出子系统的分类与挂载位置,本节展开 v1 与 v2 的层级差异、统一层级下的接口写法、通过 systemd 落地限制并验证的方法,以及 PSI、delegation 与容器场景中的对应关系。

2.10.1 v1 与 v2 的层级差异

维度 cgroup v1 cgroup v2
层级结构 每个子系统一棵独立树,同一进程可处于不同子系统的不同组 单一统一层级树,同一进程在同一时刻只属于一个组
挂载点 每个子系统一个挂载目录,如 /sys/fs/cgroup/memory/ 单一挂载点 /sys/fs/cgroup/
控制器启用 挂载子系统即启用 由父组通过 cgroup.subtree_control 逐级启用,可用列表见 cgroup.controllers
组内进程约束 允许一个组同时包含进程与子组 默认遵守无内部进程约束,仅叶子组可存放进程(根组除外)
接口命名 memory.limit_in_bytes、blkio.throttle.* 等,各子系统自成体系 memory.max、io.max、cpu.max 等统一命名
事件与统计 分散在各子系统目录 memory.events、cgroup.events、cpu.stat 等集中提供
委托能力 基本不支持 支持把子树控制权委托给非特权进程(见 2.10.8)

v1 的按子系统分树允许同一进程同时受多个控制器约束,但难以表达统一的层级归属,容易在限额与统计上产生歧义;v2 以单一树配合逐级启用控制器解决该问题,代价是组内进程位置受到约束。

2.10.2 v2 主要接口的语义与写法

接口文件 含义 写入示例
cpu.weight CPU 相对权重,取值 1~10000,默认 100,仅在 CPU 争用时按比例分配 echo 200 > cpu.weight
cpu.max CPU 带宽上限,格式为"配额 周期"(微秒),默认 max 100000 echo "50000 100000" > cpu.max
cpu.weight.nice 以 nice 值(-20~19)表达的权重 echo 5 > cpu.weight.nice
cpuset.cpus / cpuset.mems 绑定可使用的 CPU 与 NUMA 内存节点 echo 0-3 > cpuset.cpus
memory.max 内存硬上限,触达后在该组内触发 OOM echo 2G > memory.max
memory.high 内存软上限,超出后限速回收并累计事件,不直接触发 OOM echo 1500M > memory.high
memory.low / memory.min 保护性下限,系统回收时优先保留该组用量 echo 512M > memory.low
memory.swap.max 该组可使用的 swap 上限 echo 0 > memory.swap.max
memory.current / memory.peak 当前用量与峰值用量(峰值需较新内核) cat memory.current
memory.events 事件计数:low、high、max、oom、oom_kill 等 cat memory.events
pids.max / pids.current 组内进程与线程数上限、当前数量 echo 512 > pids.max
io.max 设备级 I/O 上限,格式为"设备 rbps= wbps= riops= wiops=" echo "8:0 rbps=10485760 wbps=10485760" > io.max
io.latency 目标延迟保护,格式为"设备 target=微秒",该组延迟超标时限制其他组 echo "8:0 target=10000" > io.latency
io.weight 块设备 I/O 权重,取值 1~10000 echo "8:0 200" > io.weight
cgroup.procs / cgroup.threads 组内进程 PID / 线程 TID,写入即把该进程或线程迁入该组 echo PID > cgroup.procs

写法的两个共同点:

  1. 两个数值类接口(cpu.max、io.max)以空格或等号分隔的参数写入,单个值不足以表达完整语义
  2. io.max 与 io.latency 以"主设备号:次设备号"标识设备,可用 lsblk 的 MAJ:MIN 列确认

memory.max 与 memory.high 的取舍:memory.high 让内核提前限速回收,进程仍可继续运行,适合作为第一道防线;memory.max 触发 OOM 杀死组内进程,作为兜底。两者同时设置时,应使用 memory.high 略低于 memory.max 以留出回收余地。

2.10.3 手工创建子组与设置限制

# 0. 确认系统使用 cgroup v2
mount | grep cgroup2
# 1. 建立子组,并让父组把控制器授权给子组
mkdir -p /sys/fs/cgroup/demo
cat /sys/fs/cgroup/cgroup.controllers
echo "+cpu +memory +io +pids" > /sys/fs/cgroup/cgroup.subtree_control
# 2. 设置各类限制
echo 200 > /sys/fs/cgroup/demo/cpu.weight
echo "50000 100000" > /sys/fs/cgroup/demo/cpu.max
echo 1G > /sys/fs/cgroup/demo/memory.max
echo 800M > /sys/fs/cgroup/demo/memory.high
echo 0 > /sys/fs/cgroup/demo/memory.swap.max
echo 256 > /sys/fs/cgroup/demo/pids.max
echo "8:0 rbps=10485760 wbps=10485760" > /sys/fs/cgroup/demo/io.max
# 3. 把进程迁入该组,其后续子进程自动继承
echo <PID> > /sys/fs/cgroup/demo/cgroup.procs
# 4. 复核
cat /proc/<PID>/cgroup
cat /sys/fs/cgroup/demo/memory.current /sys/fs/cgroup/demo/pids.current
cat /sys/fs/cgroup/demo/memory.events /sys/fs/cgroup/demo/cpu.stat

说明:向 cgroup.procs 写入 PID 后,该进程及其此后创建的子进程都归该组管理,已在运行的其他线程不随之迁移(需写 cgroup.threads)。父组未启用的控制器,在子组下表现为接口文件不存在或写入报错。

坑点:向 cgroup.subtree_control 启用控制器前,父组自身不能存在进程,否则写入会因无内部进程约束失败;手工在 /sys/fs/cgroup 根下创建的目录不会被 systemd 持久化,重启后消失,长期使用应通过单元配置或专门的资源管理组件落盘。

2.10.4 通过 systemd 单元配置资源限制

systemd 把每个 service、scope 单元映射为 cgroup,用单元属性即可完成同样的限制,且随单元持久化。

单元属性 对应 v2 接口 说明
CPUQuota= cpu.max 跨全部 CPU 的总配额,50% 相当于半个核
CPUWeight= / CPUShares= cpu.weight 相对权重,仅在争用时有意义
AllowedCPUs= / AllowedMemoryNodes= cpuset.cpus / cpuset.mems 绑定 CPU 与 NUMA 节点
MemoryMax= / MemoryHigh= memory.max / memory.high 内存硬上限与软上限
MemorySwapMax= memory.swap.max 该单元可使用的 swap 上限
IOWeight= io.weight 块设备 I/O 权重
IOReadBandwidthMax= / IOWriteBandwidthMax= io.max 设备级带宽上限,写法为"设备 速率"
TasksMax= pids.max 单元内进程与线程总数上限
# 方式一:直接写入属性,生成 drop-in 文件,重启后保留
systemctl set-property nginx.service CPUQuota=150% MemoryMax=2G IOWeight=200 TasksMax=512

# 方式二:编辑单元 drop-in
systemctl edit nginx.service
[Service]
CPUQuota=150%
CPUWeight=200
MemoryMax=2G
MemoryHigh=1800M
MemorySwapMax=0
IOWeight=200
TasksMax=512
sudo systemctl daemon-reload
sudo systemctl restart nginx.service

# 验证配置值与 cgroup 实际值
systemctl show nginx.service -p CPUQuotaPerSecUSec,MemoryMax,MemoryHigh,TasksMax,IOWeight
cat /sys/fs/cgroup/system.slice/nginx.service/cpu.max
cat /sys/fs/cgroup/system.slice/nginx.service/memory.max
cat /sys/fs/cgroup/system.slice/nginx.service/pids.max
cat /sys/fs/cgroup/system.slice/nginx.service/cpu.stat

说明:CPUQuotaPerSecUSec 是 CPUQuota 的换算结果(微秒/秒),与 /sys/fs/cgroup 下 cpu.max 的配额字段一致;单元所属路径由单元类型决定,系统服务位于 system.slice 下,用户单元位于 user.slice 下,可用 systemctl status 的输出或 /proc/PID/cgroup 核对。

坑点:CPUQuota 是总量而不是每核配额,设置 CPUQuota=100% 只能使用一个核的计算能力;MemoryMax 触达后在该单元内触发 OOM,不会影响整机其他单元;只修改单元文件而不执行 daemon-reload 并重启服务时,限制不会应用到已在运行的进程。

2.10.5 手工观察方法

systemd-cgls                       # 树形展示 cgroup 层级与组内进程
systemd-cgtop                      # 按组显示 CPU、内存与 IO 占用
systemctl status nginx.service     # 状态输出中包含所属 cgroup 路径
cat /proc/<PID>/cgroup             # 进程所属组路径,v2 下只有一行 0::/
cat /sys/fs/cgroup/cgroup.controllers
cat /sys/fs/cgroup/<路径>/memory.stat

说明:/proc/PID/cgroup 在 v2 下只有一行(层级号 0),在 v1 下每个子系统一行,可据此判断系统使用的版本。memory.stat 提供 anon、file、slab、pgfault、pgmajfault、workingset 等细分项,用于区分限额是被匿名内存、文件页还是内核对象占用。

2.10.6 PSI 压力指标

PSI(Pressure Stall Information)把资源竞争量化为"任务被阻塞的时间占比",比使用率更能反映业务受影响的程度,cgroup v2 与内核同时提供该数据。

文件 提供行
/proc/pressure/cpu 只有 some 行
/proc/pressure/memory some 行与 full 行
/proc/pressure/io some 行与 full 行
  1. some:在该资源上至少有一个任务被阻塞的时间占比,反映"部分任务受影响"
  2. full:该资源上所有可运行任务都被阻塞的时间占比,反映"整体停摆"
  3. cpu 只有 some 行,因为 CPU 被占用时总有其他任务可以获得执行
  4. 每行包含 avg10、avg60、avg300 三个窗口的平均占比与 total 累计停顿微秒数
cat /proc/pressure/cpu
cat /proc/pressure/memory
cat /proc/pressure/io
cat /sys/fs/cgroup/<路径>/memory.pressure
cat /sys/fs/cgroup/<路径>/io.pressure
watch -n 1 cat /proc/pressure/io

用途:判断延迟瓶颈来自哪类资源。io 的 full 行持续升高表示全部任务都在等待 I/O;memory 的 some 行升高并伴随 memory.high 事件计数增长,表示该组进入限速回收。full 行占比与业务 P99 延迟的相关性通常高于 CPU 使用率,适合作为限流与扩容的判断依据。

2.10.7 容器场景中的 cgroup

  1. 容器由一组命名空间加一个 cgroup 子树构成,Docker、containerd 等运行时默认使用 cgroup v2,限额最终落在该子树的接口文件上
  2. docker run 的 --cpus、--memory、--pids-limit、--blkio-weight 分别对应 cpu.max、memory.max、pids.max 与 io.weight;docker stats 读取的即为 cgroup 计数
  3. 使用 systemd cgroup 驱动时,容器对应的路径形如 /sys/fs/cgroup/system.slice/docker-<容器ID>.scope/,使用 cgroupfs 驱动时位于 /sys/fs/cgroup/<容器ID>/ 下
  4. Kubernetes 中 kubelet 通过 CRI 设置 Pod 级与容器级 cgroup:limits.cpu 落到 cpu.max,requests.cpu 落到 cpu.weight,limits.memory 落到 memory.max,requests.memory 落到 memory.low
  5. QoS 类别由 requests 与 limits 的关系决定:Guaranteed 二者相等,Burstable 二者不等,BestEffort 均未设置且权重最低
# 宿主机查看某容器的 cgroup 与限额
systemctl status docker-<容器ID>.scope
cat /sys/fs/cgroup/system.slice/docker-<容器ID>.scope/memory.max
cat /sys/fs/cgroup/system.slice/docker-<容器ID>.scope/memory.events
cat /sys/fs/cgroup/system.slice/docker-<容器ID>.scope/cpu.max
docker inspect --format '{{.HostConfig.Memory}} {{.HostConfig.NanoCpus}}' <容器名>

坑点:容器内读取 /proc/meminfo 与 /proc/cpuinfo 在部分运行时下仍是宿主机数据,判断是否受限应以容器内的 cgroup 接口文件与应用是否收到 OOM 为准;容器内进程数为 1 号进程及其子进程,pids.max 触达后表现为 fork 失败而非直接 OOM。

2.10.8 delegation(委托)

  1. 含义:把某个子树的控制器启用权与子组创建权交给非特权进程,由该进程自行划分子组,父层不再逐级代为配置
  2. 前提:父组的 cgroup.subtree_control 已启用对应控制器,子树的 cgroup.procs 属主为被委托的用户
  3. 适用场景:运行库自身需要按进程组细分资源,如容器运行时、批处理调度器、语言运行时;普通服务只需固定限额时使用 2.10.4 的单元属性即可,不必委托
  4. systemd 中的对应属性为 Delegate=,容器运行时单元与用户管理器单元默认启用
[Service]
Delegate=yes
TasksMax=infinity
systemctl show user@1000.service -p Delegate,TasksMax
systemctl show docker.service -p Delegate
systemctl status user@1000.service

说明:Delegate=yes 之后 systemd 不再管理该单元内部子组的划分,单元内部的资源细分由服务自身负责;委托时通常需要把 TasksMax 设为 infinity 或足够大的值,否则子组内进程数受 pids.max 约束。

坑点:委托后若服务自身未写入 cgroup.subtree_control 与 cgroup.procs,限制不会自动生效,表现为设置成功但资源使用不受控;排查时应先确认单元内的子组结构与属主,再检查服务是否按预期接管。

内存维度的限额语义见linux: 内存管理的 cgroups 内存限制章节;单元属性、依赖与启动排障见同目录linux: systemd 介绍与使用。

三、实现:进程管理命令与排查

3.1 进程查看

3.1.1 ps

按自定义格式输出进程快照,常用组合:

# BSD 风格:查看所有进程(用户、PID、CPU、内存、VSZ、RSS、TTY、STAT、START、TIME、COMMAND)
ps aux

# UNIX 风格:显示完整层次(PPID、PGID、SID、优先级、NI、进程状态)
ps -ef
ps -eF                  # -F 附加 C、SZ、RSS、PSR 字段
ps -eo pid,ppid,stat,cmd,%cpu,%mem --sort=-%cpu   # 自定义字段按 CPU 降序

# 查看指定 PID 详情
ps -fp PID
ps -Lfp PID             # -L 显示线程(LWP 列)

STAT 列含义:

- R 运行、S 可中断睡眠、D 不可中断睡眠、T 停止、Z 僵尸、X 死亡

- s 会话首进程、l 多线程、+ 前台进程组、N 低 nice、< 高 nice

3.1.2 top / htop

实时交互式查看进程与系统指标:

top                     # 默认按 CPU 降序刷新
top -u 用户名           # 仅查看某用户进程
top -p PID1,PID2        # 仅查看指定 PID
top -H -p PID           # -H 按线程显示

top 常用交互键:

- 1 切换显示多核 CPU 占用

- M / P / T 分别按内存、CPU、累计时间排序

- k 发送信号(杀进程)

- r 调整 nice

- f 选择显示列

- q 退出

htop 是增强版,支持鼠标、颜色、树状显示。

3.1.3 pstree / pgrep / pidof

# 树状显示进程层级
pstree -p                 # -p 显示 PID
pstree -apU user          # -a 显示参数,-u 显示用户切换

# 按名称/属性查询 PID
pgrep -f 关键字            # 按命令行匹配(含参数)
pgrep -u 用户 -a 进程名    # -a 同时显示命令行
pgrep -x 精确进程名

# 按名称查询 PID,多个则空格分隔
pidof nginx

3.2 进程控制

3.2.1 kill / killall / pkill

# 向 PID 发信号(默认 SIGTERM=15)
kill PID
kill -TERM PID            # 与默认相同
kill -9 PID               # 强制杀死 SIGKILL
kill -HUP PID             # 重载配置(按约定)
kill -s 信号名 PID        # 用信号名或编号

# 按进程组杀(负号)
kill -TERM -PGID

# 按名称批量
killall 进程名            # 按精确名称
killall -u 用户 进程名
pkill -f 关键字           # 按命令行模糊匹配
pkill -U 用户 -TERM 进程名

注:SIGKILL(9)不可被捕获,进程无机会清理;优先使用 SIGTERM 让进程优雅退出。

3.2.2 nice / renice

# 启动时指定 nice
nice -n 10 命令           # 以 nice=10 启动,优先级降低
nice -n -5 命令           # 需 root,提高优先级

# 调整已运行进程
renice -n 10 -p PID
renice -n -5 -u 用户      # 批量调整该用户所有进程

3.2.3 nohup

# 忽略 SIGHUP,后台运行,输出重定向到 nohup.out
nohup ./myapp &
nohup ./myapp > myapp.log 2>&1 &

nohup 仅处理 SIGHUP,不处理终端关闭后的其他问题;systemd 服务单元是更规范的后台运行方式。

3.3 终端作业控制

# 启动后台作业
./longjob &

# 查看当前 shell 作业
jobs -l                   # -l 显示 PID

# 前台 ↔ 后台
Ctrl+Z                    # 前台作业暂停到停止态 T
bg %作业号                # 暂停的作业转为后台运行 S
fg %作业号                # 作业拉回前台 R

# 后台作业直接终止
kill %作业号

作业号以 % 前缀,如 %1、%2;退出 shell 前后台作业仍在运行时,shell 会告警。

3.4 /proc 文件系统

/proc 是内核暴露的虚拟文件系统,无磁盘占用,读取时动态生成。进程级信息位于 /proc//。

路径 内容
/proc/PID/status 名称、PID、PPID、UID、状态、内存、线程数
/proc/PID/cmdline 启动命令行(以 \0 分隔,用 strings 查看)
/proc/PID/cwd 当前工作目录符号链接
/proc/PID/exe 可执行文件符号链接(可恢复执行程序路径)
/proc/PID/fd/ 打开文件描述符目录,每一项是符号链接指向实际文件/socket
/proc/PID/maps 虚拟地址空间映射(代码、堆、栈、库)
/proc/PID/limits 资源软硬限制(ulimit 对应)
/proc/PID/environ 启动环境变量(\0 分隔)
/proc/PID/task/ 每个线程一个子目录

全局系统信息:/proc/cpuinfo、/proc/meminfo、/proc/loadavg、/proc/stat、/proc/net/。

3.5 常见问题排查

3.5.1 CPU 占用高

  1. 定位进程
top -b -n 1 | head -30    # 一次性取 top 前 30 行
ps -eo pid,user,%cpu,cmd --sort=-%cpu | head
  1. 定位线程
top -H -p PID             # 按线程排序,定位占用高的线程 TID
printf '%x\n' TID        # 十进制 TID 转十六进制(配合 jstack/gdb 使用)
  1. 调用栈分析
# 多次采样 perf 分析热点函数
perf top -p PID
perf record -g -p PID -- sleep 5
perf report

# gdb 附加查看调用栈
gdb -p PID -ex bt -ex detach

3.5.2 内存占用高

  1. 定位进程
ps -eo pid,user,rss,vsz,%mem,cmd --sort=-rss | head
top                                     # M 按内存排序
  1. 细分内存
cat /proc/PID/status                    # VmRSS/VmData/VmStk 查看分布
cat /proc/PID/smaps                    # 每段映射的 PSS/RSS,PSS 适用于共享库均摊统计
pmap -x PID                             # 与 smaps 类似,命令行汇总
  1. 泄漏分析
    • 观察 RSS 长期单调增长,不随业务下降 → 疑似泄漏

    • 使用 valgrind、AddressSanitizer 启动程序定位分配未释放点

3.5.3 僵尸进程(Z)

  1. 识别
ps aux | awk '$8 ~ /Z/ {print}'
ps -eo pid,ppid,stat,cmd | awk '$3 == "Z"'
  1. 处理
    • 僵尸进程 PCB 由父进程缺失 wait 导致,无法直接 kill 回收

    • 向父进程发 SIGCHLD 触发 wait(父进程正常处理信号时有效)

    • kill 父进程后僵尸被 init/systemd 收养并回收(父进程重启或为普通守护进程时可行)

    • 修复应用代码,确保 fork 后父进程 wait/waitpid,或忽略 SIGCHLD 显式设置 SA_NOCLDWAIT

3.5.4 D 状态进程(不可中断睡眠)

  1. 识别
    • ps STAT 列为 D;kill -9 无效果
  2. 常见原因
    • 同步磁盘 IO 阻塞(NFS 挂载断连、存储阵列故障、密集 fsync)

    • 内核底层锁等待

  3. 排查
cat /proc/PID/stack                     # 查看内核栈,定位阻塞在哪个内核函数
cat /proc/PID/wchan                     # 阻塞的内核函数名简写
iostat -x 1 观察 IO 等待 %util
dmesg 查看磁盘/NFS 报错
  1. 处理
    • 修复 IO 通道故障(磁盘、NFS、RAID)后进程通常自恢复

    • 挂起 NFS share 时,恢复网络或强制卸载挂载点

3.5.5 OOM Killer 杀死进程

  1. 识别
dmesg -T | grep -i 'out of memory\|Killed process'
journalctl -k --grep=oom -S today
  1. OOM 机制
    • 内存耗尽+swap 耗尽时,内核按 badness 分数选进程杀死

    • 分数由 RSS、子进程总内存、oom_score_adj、运行时长等综合计算

  2. 调整策略
    • /proc/PID/oom_score_adj 设为 -1000 让该进程豁免(-1000 完全豁免)

    • 增加物理内存或 swap(swap 延迟 OOM,代价是性能)

    • 用 cgroups memory 子系统限制高消耗服务的硬上限

3.5.6 孤儿进程

父进程先退出导致子进程被 init/systemd 收养(PPID=1)。

  1. 识别:ps 中 PPID=1 且非 systemd 自带服务的进程
  2. 处理:孤儿进程本身正常运行,无危害;需确认退出顺序是否符合预期

3.6 资源限制(ulimit 与 prlimit)

ulimit 控制 shell 启动的子进程资源上限,分软限制(可改,上限为硬限制)与硬限制(root 才可提高)。

常用项:

项 含义
-n 65535 打开文件描述符最大数
-u 65535 用户可创建进程/线程数上限
-m unlimited 最大常驻集(RSS)(现代内核多忽略)
-v unlimited 最大虚拟内存
-s 8192 每个线程栈大小(KB)
-c unlimited core dump 文件大小(0 关闭)
ulimit -a                 # 查看当前 shell 所有限制
ulimit -n                 # 仅查看 -n
ulimit -n 65535           # 临时修改当前 shell 软限制

永久修改写入 /etc/security/limits.conf(pam_limits 会话时生效):

* soft nofile 65535
* hard nofile 65535
root soft nofile 1048576
root hard nofile 1048576

systemd 服务的资源限制不读取 limits.conf,需在单元文件 [Service] 段中配置 LimitNOFILE=65535 等,或执行 systemctl set-property nginx.service LimitNOFILE=65535。

四、总结

  • 进程是资源分配与调度的基本单位,由 PCB、虚拟地址空间与文件描述符表组成

  • 起源于多道程序并发的需求,解决单道批处理 CPU 利用率低、资源竞争等问题

  • 原理涵盖状态转换、CFS 调度、父子进程关系、信号、线程、IPC、cgroups 资源限制

  • 实现覆盖进程查看与控制命令、终端作业控制、/proc 虚拟文件系统与常见问题(CPU/内存/僵尸/D 状态/OOM)排查

  • 进程管理与 systemd 服务管理天然关联:守护进程、cgroups 资源控制、信号发送均由 systemd 单元承载