Linux 进程管理天花板！一篇吃透 “进程创建 - 终止 - 回收” 全流程，写时拷贝、非阻塞等待全揭秘
文 章 目 录
💻作 者 简 介：曾 与 你 一 样 迷 茫，现 以 经 验 助 你 入 门 Linux。
💡个 人 主 页：@笑口常开xpr 的 个 人 主 页
📚系 列 专 栏：Linux 探 索 之 旅：从 命 令 行 到 系 统 内 核
✨代 码 趣 语：当 waitpid 候 着 子 进 程 的 归 途，当 Z 态 的 “残 影” 待 清 扫，代 码 里 的 等 待 犹 如 持 灯 的 守 夜人 - - - 每 一 次 status 的 拆 解，都 是 为 回 收 “迷 路 的 碎 片”。
💪代 码 千 行，始 于 坚 持，每 日 敲 码，进 阶 编 程 之 路。
📦gitee 链 接：gitee
对 Linux 初 学 者 而 言，“进 程” 是 理 解 系 统 底 层 的 关 键，却 常 让 人 困 在 “只 会 用 命 令，不 懂 原 理” 的 阶 段。本 文 以 实 操 为 核 心，从 fork 函 数 切 入，拆 解 进 程 创 建（写 时 拷 贝）、终 止（3 种 场 景）、等 待（wait/waitpid 解 决 僵 尸 进 程），搭 配 代 码 与 截 图，帮 你 快 速 掌 握 进 程 管 理 核 心 逻 辑。
一、进 程 的 创 建
1、fork 函 数 初 识
在 linux 中 fork 函 数 是 非 常 重 要 的 函 数，它 从 已 存 在 进 程 中 创 建 一 个 新 进 程。新 进 程 为 子 进 程，而 原 进 程 为 父 进 程。
进 程 调 用 fork，当 控 制 转 移 到 内 核 中 的 fork 代 码 后，内 核 做：
- 分 配 新 的 内 存 块 和 内 核 数 据 结 构 给 子 进 程
- 将 父 进 程 部 分 数 据 结 构 内 容 拷 贝 至 子 进 程，页 表 代 码 和 数 据 可 以 是 完 全 一 样 的。
- 添 加 子 进 程 到 系 统 进 程 列 表 当 中
fork 返 回，开 始 调 度 器 调 度
#include<stdio.h> #include<unistd.h> #include<stdlib.h> int main(){printf("pid:%d Before!\n",getpid());fork();printf("pid:%d After!\n",getpid());return0;}
fork 之 前 父 进 程 独 立 执 行，fork 之 后，父 子 两 个 执 行 流 分 别 执 行。
注 意
fork 之 后，谁 先 执 行 完 全 由 调 度 器 决 定。
2、fork 函 数 返 回 值
子 进 程 返 回 0，父 进 程 返 回 的 是 子 进 程 的 pid。
3、写 时 拷 贝
父 子 代 码 共 享，父 子 再 不 写 入 时，数 据 也 是 共 享 的，当 任 意 一 方 试 图 写 入，便 以 写 时 拷 贝 的 方 式 各 自 一 份 副 本。
写 时 拷 贝 本 质 是 写 的 时 候 再 用，是 一 种 延 时 申 请，按 需 申 请。
具 体 见 下 图:
无 论 是 父 进 程 还 是 子 进 程，如 果 想 要 写 入，会 将 父 进 程 中 可 写 的 部 分 改 成 只 读，子 进 程 继 承 时 也 是 只 读 状 态，暂 时 是 只 读 状 态。针 对 这 种 情 况，操 作 系 统 不 做 异 常 处 理，如 果 想 要 写 入 数 据，会 将 页 表 对 应 的 区 域 重 新 映 射，然 后 进 行 写 时 拷 贝，这 样 就 能 访 问 原 来 可 写 的 区 域。
4、创 建 多 个 进 程
#include<unistd.h> #include<stdlib.h> #define N5voidRunChild(){ int cnt =5;while(cnt){printf("I am child:%d,ppid:%d\n",getpid(),getppid());sleep(1); cnt--;}} int main(){for(int i =0;i<N;i++){ pid_t id =fork();if(id==0){//子进程RunChild();exit(0);//终止子进程}}sleep(1000);return0;}
5 次 循 环 结 束 后，父 进 程 没 有 结 束，子 进 程 终 止 成 为 僵 尸 进 程。父 子 进 程 谁 先 运 行 由 调 度 器 决 定。
二、进 程 终 止
1、进 程 退 出 场 景
- 代 码 运 行 完 毕，结 果 正 确
- 代 码 运 行 完 毕，结 果 不 正 确
- 代 码 异 常 终 止
结 果 是 否 正 确 采 用 进 程 的 退 出 码 来 进 行 判 定。
2、进 程 常 见 退 出 方 法
成 功 只 有 1 种 可 能，但 失 败 有 多 个 理 由。
（1）正 常 终 止（可 以 通 过 echo $? 查 看 进 程 退 出 码）：
echo $?
表 示 最 近 一 次 进 程 退 出 时 的 退 出 码。可 以 通 过 观 察 退 出 码 来 判 断 进 程 是 否 正 常 结 束。
- 从 main 返 回
在 c 语 言 中，程 序 返 回 0 中 的 0 表 示 进 程 的 退 出 码，表 征 进 程 的 运 行 结 果 是 否 正 确，0->success。main 函 数 的 返 回 值 的 本 质 表 示 进 程 运 行 完 成 时 是 否 是 正 确 的 结 果，如 果 不 是，可 以 使 用 不 同 的 数 字 表 示 不 同 的 出 错 原 因。
进 程 中 父 进 程 会 关 心 程 序 的 运 行 情 况，用 户 可 以 根 据 错 误 码 来 找 出 程 序 中 的 错 误。
可 以 改 变 return 的 返 回 值
如 上 图 所 示，第 二 次 调 用 echo $? 返 回 值 成 为 0。当 第 2 次 输 出 时，程 序 变 成 了 echo 命 令，echo 上 次 执 行 是 正 确 的，所 以 退 出 码 为 0。
strerror
将 错 误 码 转 换 成 错 误 码 描 述。
示 例 1
系 统 提 供 的 错 误 码 和 错 误 码 描 述 是 有 对 应 关 系 的。错 误 码 用 来 表 征 错 误 原 因，错 误 码 描 述 展 现 更 详 细 的 错 误 信 息。
示 例 2
可 以 自 己 定 义 错 误 码。
errno
最 近 一 次 的 错 误 码。
示 例
3、代 码 异 常
本 质 可 能 就 是 代 码 没 有 跑 完。进 程 的 退 出 码 无 意 义，不 关 心 退 出 码 了。进 程 出 现 了 异 常，本 质 是 进 程 收 到 了 对 应 的 信 号。
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<string.h> #include<errno.h> int main(){ int* p =NULL;*p=100;return0;}
访 问 野 指 针，进 程 抛 出 异 常 显 示 段 错 误，对 应 第 11 号。
验 证
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<string.h> #include<errno.h> int main(){while(1){printf("Hello world,pid:%d\n",getpid());sleep(1);}return0;}
第 11 个 信 号 是 进 程 出 现 了 段 错 误。
4、echo
终 止 程 序 并 返 回 程 序 的 退 出 码 和 return 的 效 果 类 似。
5、exit 和 return 的 区 别
return
exit
exit 在 任 意 地 方 被 调 用，都 表 示 调 用 进 程 直 接 退 出，return 只 表 示 当 前 函 数 返 回，没 有 退 出 进 程。
6、_exit
终 止 进 程。
7、exit 和 _exit 的 区 别
exit
_exit
exit 在 结 束 之 后 还 做 了 以 下 工 作：
- 执 行 用 户 通 过 atexit 或 on_exit 定 义 的 清 理 函 数。
- 关 闭 所 有 打 开 的 流，所 有 的 缓 存 数 据 均 被 写 入。
- 调 用 _exit。
exit 是 库 函 数，_exit 是 系 统 调 用。
printf 函 数 先 把 数 据 写 入 缓 冲 区 中，合 适 的 时 候 进 行 刷 新。这 个 缓 冲 区 绝 对 不 在 内 核 中。如 上 图，如 果 缓 冲 区 在 内 核 中，exit 和 _exit 都 会 刷 新，但 实 际 _exit 没 有 刷 新 缓 冲 区。
三、进 程 等 待
1、必 要 性
- 子 进 程 退 出，父 进 程 如 果 不 管 不 顾，就 可 能 造 成 ‘僵 尸 进 程’ 的 问 题，进 而 造 成 内 存 泄 漏。
- 僵 尸 进 程 无 法 被 杀 死，需 要 通 过 进 程 等 待 来 杀 掉 它，进 而 解 决 内 存 泄 漏 问 题。
- 需 要 得 到 子 进 程 的 退 出 情 况，即 知 道 布 置 给 子 进 程 的 任 务 子 进 程 的 任 务 完 成 的 怎 么 样，是 可 以 选 择 的。
2、定 义
通 过 系 统 调 用 wait/waitpid，来 进 行 对 子 进 程 进 行 状 态 检 测 与 回 收 的 功 能。
3、回 收
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<string.h> #include<errno.h> int main(){ pid_t id =fork();if(id<0){perror("fork");return1;}elseif(id ==0){//子进程 int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);}exit(0);}else{//父进程 while(1){printf("I am father,pid:%d,ppid:%d\n",getpid(),getppid());sleep(1);}}return0;}
子 进 程 退 出 后 一 直 成 为 僵 尸 状 态。父 进 程 通 过 调 用 wait/waitpid 来 进 行 僵 尸 进 程 的 回 收 问 题。
4、wait
wait 是 系 统 调 用 接 口，等 待 进 程 直 到 进 程 的 状 态 发 生 改 变。
1 个 进 程
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/wait.h> #include<sys/types.h> int main(){ pid_t id =fork();if(id<0){perror("fork");return1;}elseif(id ==0){//子进程 int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);}exit(0);}else{//父进程 int cnt =10;while(cnt){printf("I am father,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);} pid_t ret =wait(NULL);if(ret == id){printf("wait success,ret:%d\n",ret);}}return0;}
当 父 进 程 的 循 环 结 束 之 后，子 进 程 被 回 收。
在 子 进 程 成 为 僵 尸 状 态 以 后，父 进 程 等 待 是 必 须 的。wait 等 待 任 意 一 个 子 进 程 退 出。
多 个 进 程
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/wait.h> #include<sys/types.h> #define N10voidRunChild(){ int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d\n",getpid(),getppid());sleep(1); cnt--;}} int main(){for(int i =0;i<N;i++){ pid_t id =fork();if(id==0){RunChild();exit(0);}printf("create child process:%d success\n",id);//只有父进程才会执行}sleep(10);//等待for(int i=0;i<N;i++){ pid_t id =wait(NULL);if(id >0){printf("wait %d success\n",id);}}sleep(5);return0;}
wait 当 任 意 一 个 子 进 程 退 出 的 时 候，wait 回 收 子 进 程。
如 果 任 意 一 个 子 进 程 不 退 出，父 进 程 默 认 在 wait 的 时 候，调 用 这 个 系 统 调 用 的 时 候，也 就 不 返 回，默 认 叫 做 阻 塞 状 态。
5、waitpid
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/wait.h> #include<sys/types.h> int main(){ pid_t id =fork();if(id<0){perror("fork");return1;}elseif(id ==0){//子进程 int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);}exit(0);}else{//父进程 int cnt =10;while(cnt){printf("I am father,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);} pid_t ret =waitpid(-1,NULL,0);if(ret == id){printf("wait success,ret:%d\n",ret);}}return0;}
当 waitpid 回 收 子 进 程 时 返 回 的 是 子 进 程 的 pid。
status
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/wait.h> #include<sys/types.h> int main(){ pid_t id =fork();if(id<0){perror("fork");return1;}elseif(id ==0){//子进程 int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);}exit(1);}else{//父进程 int cnt =10;while(cnt){printf("I am father,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);} int status =0; pid_t ret =waitpid(id,&status,0);if(ret == id){printf("wait success,ret:%d,status:%d\n",ret,status);}}return0;}
父 进 程 等 待，期 望 获 得 子 进 程 的 代 码 是 否 异 常，如 果 没 有 异 常 ，结 果 对 吗，不 对 是 因 为 什 么。
int 类 型 总 共 有 32 个 比 特 位，目 前 只 考 虑 低 16 位。
上 面 代 码 中，status 是 256 的 原 因 是 因 为 子 进 程 的 exit 为 1 即 退 出 码 为 1，00000000 00000000 00000001 00000000，化 为 十 进 制 就 是 2^8 为 256。
如 果 低 7 位 是 否 为 0，如 果 为 0 则 进 程 没 有 收 到 信 号，则 代 码 没 有 异 常。
上 面 的 代 码 中 如 果 status 为 全 局 变 量，因 为 父 子 进 程 具 有 独 立 性，父 进 程 无 法 得 到 子 进 程 的 数 据。父 进 程 要 拿 子 进 程 的 状 态 数 据，只 能 通 过 wait 等 系 统 调 用 来 得 到 子 进 程 的 代 码 和 数 据。
验 证
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/wait.h> #include<sys/types.h> int main(){ pid_t id =fork();if(id<0){perror("fork");return1;}elseif(id ==0){//子进程 int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);}exit(11);}else{//父进程 int cnt =10;while(cnt){printf("I am father,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);} int status =0; pid_t ret =waitpid(id,&status,0);if(ret == id){//0x7F 0111 1111printf("wait success,ret:%d,exit sig:%d,exit code:%d\n",ret,status&0x7F,(status>>8)&0xFF);}}return0;}
6、原 理
waitpid 是 操 作 系 统 提 供 的 接 口，子 进 程 退 出 时 会 将 接 收 的 信 号 以 及 main 函 数 的 返 回 值 返 回 到 status 中，父 进 程 通 过 waitpid 得 到 子 进 程 的 相 关 信 息 来 回 收 子 进 程。
父 进 程 在 等 待 时 只 能 等 待 自 己 的 子 进 程，不 能 等 待 其 余 进 程 ，否 则 会 等 待 失 败。
7、WIFEXITED 和 WEXITSTATUS
可 以 使 用 WIFEXITED 和 WEXITSTATUS 来 检 测 进 程 是 否 正 常 退 出。
1 个 进 程
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/wait.h> #include<sys/types.h> int main(){ pid_t id =fork();if(id<0){perror("fork");return1;}elseif(id ==0){//子进程 int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);}exit(11);}else{//父进程 int cnt =10;while(cnt){printf("I am father,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);} int status =0; pid_t ret =waitpid(id,&status,0);if(ret == id){//0x7F 0111 1111//printf("wait success,ret:%d,exit sig:%d,exit code:%d\n",ret,status&0x7F,(status>>8)&0xFF);if(WIFEXITED(status)){printf("process success,code exit:%d\n",WEXITSTATUS(status));}else{printf("process fail\n");}}}return0;}
多 个 进 程
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/wait.h> #include<sys/types.h> #define N10voidRunChild(){ int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d\n",getpid(),getppid());sleep(1); cnt--;}} int main(){for(int i =0;i<N;i++){ pid_t id =fork();if(id==0){RunChild();exit(i);}printf("create child process:%d success\n",id);//只有父进程才会执行}sleep(10);//等待for(int i=0;i<N;i++){//pid_t id = wait(NULL); int status =0; pid_t id =waitpid(-1,&status,0);if(id >0){printf("wait %d success,exit code:%d\n",id,WEXITSTATUS(status));}}sleep(5);return0;}
多 个 子 进 程 被 父 进 程 回 收。
Linux 的 进 程 也 是 一 棵 多 叉 树 结 构，父 进 程 只 对 直 系 的 子 进 程 直 接 负 责。
8、options
阻 塞 方 式，当 options 为 0 的 时 候 为 阻 塞 方 式。waitpid 会 导 致 父 进 程 进 入 阻 塞 状 态。
（1）WNOHANG
在 等 待 过 程 中 采 用 非 阻 塞 等 待。
（2）非 阻 塞 轮 询
非 阻 塞 轮 询 是 一 种 在 程 序 中 定 期 检 查 某 个 状 态 或 资 源 是 否 就 绪 的 机 制，其 核 心 特 点 是 不 会 阻 塞 当 前 程 序 的 执 行 流 程。
每 次 检 查 操 作 不 会 “卡 住” 程 序，如 果 目 标 未 就 绪，检 查 会 立 即 返 回，允 许 程 序 继 续 执 行 其 他 任 务，而 不 是 一 直 等 待 到 目 标 就绪。
（3）代 码 演 示
#include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<sys/wait.h> #include<sys/types.h> int main(){ pid_t id =fork();if(id<0){perror("fork");return1;}elseif(id ==0){//子进程 int cnt =5;while(cnt){printf("I am child,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt); cnt--;sleep(1);}exit(11);}else{ int status =0;while(1)//轮询{ pid_t ret =waitpid(id,&status,WNOHANG);//非阻塞if(ret >0){//0x7F 0111 1111//printf("wait success,ret:%d,exit sig:%d,exit code:%d\n",ret,status&0x7F,(status>>8)&0xFF);if(WIFEXITED(status)){printf("process success,code exit:%d\n",WEXITSTATUS(status));}else{printf("process fail\n");}break;}elseif(ret<0){printf("wait fail\n");break;}else{printf("子进程还没有退出,再等等...\n");}sleep(1);}}sleep(3);return0;}
注 意
在 while 循 环 中 必 须 添 加 sleep(1) 这 一 语 句。原 因 是，若 缺 少 这 个 睡 眠 操 作，程 序 会 进 入 无 间 断 的 轮 询 状 态，持 续 不 断 地 查 询 子 进 程 是 否 退 出。这 种 高 频 次 的 查 询 会 导 致 CPU 资 源 被 大 量 占 用，进 而 可 能 造 成 程 序 运 行 出 现 卡 顿 现 象。
通 过 进 程 等 待 可 以 保 证 父 进 程 是 多 进 程 当 中 最 后 一 个 退 出 的 进 程。
父 进 程 可 以 在 等 待 子 进 程 返 回 时 做 一 些 简 单 级 的 任 务。但 是 父 进 程 的 核 心 是 等 待 子 进 程 返 回，即 延 迟 回 收 子 进 程，统 一 回 收 子 进 程。
四、总 结
本 文 带 你 掌 握 了 fork 原 理、写 时 拷 贝、进 程 终 止 方 式，以 及 wait/waitpid 回 收 僵 尸 进 程 的 方 法 - - - 这 些 是 Linux 系 统 编 程 的 基 础，为 后 续 进 程 通 信、线 程 管 理 铺 路。建 议 多 实 操 修 改 代 码 加 深 理 解，关 注 专 栏，后 续 将 解 锁 更 多 Linux 底 层 内 容。
