目录
[查看信号 kill -l](#查看信号 kill -l)
[1. 必须包含头文件](#1. 必须包含头文件)
[2. 函数原型](#2. 函数原型)
[1. 必须包含头文件](#1. 必须包含头文件)
[2.exec 函数家族](#2.exec 函数家族)
[5.exec 前后的"保留"与"重置"](#5.exec 前后的“保留”与“重置”)
一、进程创建
博主在【进程】系列开篇就带大家初识了使用fork创建子进程,遗忘的小伙伴可以点击链接重新过一遍!
【Linux进程(一)】Linux 进程初探:操作系统如何管理进程?fork() 为什么返回两次?-CSDN博客
博主给大家提炼几个重要的知识点,然后关于进程创建部分就带过了。
1.fork基础
1.一次调用,两次返回
`fork()` 调用一次,但会在父进程和子进程中分别返回。通过返回值区分父子进程:返回 `0` 表示当前是子进程;返回大于 `0` 表示当前是父进程,返回值是子进程 PID;返回 `-1` 表示创建失败。子进程 PID 非零且唯一,因此用 `0` 表示子进程不会产生歧义。

2.COW原理
`fork` 后,父子进程拥有相同虚拟地址的独立地址空间。Linux 使用写时复制优化:**`fork` 时不一定立即复制物理内存;父子进程先共享物理页,并将页标记为只读;任一进程写入某页时,内核才为该进程复制该页。**好处是如果子进程只读或立即 `exec`,可以避免大量物理内存复制。

3.子进程继承和差异
子进程继承父进程的许多资源,但多为独立副本。继承的内容包括文件描述符、信号处理方式、环境变量、用户 ID 和组 ID 等进程属性。子进程特有的差异包括拥有新的 PID、PPID 指向创建它的父进程、地址空间是独立副本并通过写时复制实现、不继承父进程挂起的信号、不继承文件锁,定时器等状态会被重置。
总结
`fork` 的核心是一次调用、两次返回;通过写时复制实现高效的地址空间复制;子进程继承大量资源,但拥有独立 PID 和地址空间副本。
2.fork常规用法
1.父进程希望子进程复制自己,使父子进程同时执行不同的代码段。
2.创建一个子进程来执行一个不同的程序。常用写法:子进程从fork返回后,调用exec族函数。exec族函数在第四个话题"进程程序替会向大家介绍"会向大家介绍。
3.fork备份实验COW
父进程每五秒修改一次全局数组data里的内容,fork出子进程备份耗时十秒,父进程修改data就会触发写时拷贝,操作系统会给父进程开辟一段新的空间存放新的data数据,不会影响子进程读取修改前data里的数据进行备份。
cpp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <time.h>
#define NUM 10
int data[NUM] = {0};
void Backup()
{
pid_t id = fork();
if(id == 0)
{
// child
sleep(10);
int i = 0;
printf("Backup: ");
for(i = 0; i < NUM; i++)
{
printf("%d ", data[i]);
}
printf("\n");
exit(0); // 进程结束
}
}
void ChangeData()
{
int i = 0;
for(; i < NUM; i++)
{
data[i] = i + rand();
}
printf("origin data: ");
for(i = 0; i < NUM; i++)
{
printf("%d ", data[i]);
}
printf("\n");
}
int main()
{
srand(time(NULL));
while(1)
{
//修改
ChangeData();
//备份
Backup();
sleep(5);
}
}
实验现象:

二、进程终止
1.进程终止的三种情况
1.程序代码跑完了,运行结果正确。
2.程序代码跑完了,运行结果错误。
3.程序代码没有跑完,异常退出。
疑问:正常终止的进程,如何判断运行结果是否正确?
2.退出码
退出码(Exit Code / Exit Status) 是程序或命令结束时返回给操作系统/调用者的一个整数,用来表示执行结果状态。
退出码是进程留给父进程/调用者的"结果状态报告":0 表示成功,非 0 表示失败或异常。
用户可以使用**echo ¥?**查看上一个进程的退出码
?是一个变量,"?"里保存的是bash命令行上运行的最后一个退出进程的退出码。
3.如何进行进程的正常退出
方式一:main函数中使用return
1.其他函数调用return表示函数调用结束。
2.main函数调用return表示进程结束。
方式二:使用exit/_exit函数


与main函数使用return不同,无论子函数还是主函数调用exit,进程都会直接结束,不会执行后续代码。
测试代码:
cpp
#include <stdio.h>
#include <stdlib.h>
static void f(void) {
printf("[f] 进入 f\n");
exit(7);
printf("[f] exit 之后(不执行)\n");
}
int main(void) {
printf("[main] 开始\n");
f();
printf("[main] f() 之后(不执行)\n");
return 0;
}
运行结果:

exit和_exit的区别
exit 会走 C 库的正常退出流程(刷新 stdio 缓冲区、关闭流),而 _exit 直接进入内核终止进程,这些清理都不做。
测试代码:
cpp
int main()
{
printf("hahahahahaha ");
exit(0);
//_exit(0);
}
运行结果:
使用exit退出:

使用_exit退出:

4.进程如何异常退出
异常退出大多数是"被信号终止"
查看信号 kill -l
使用kill -l命令查看所有信号:

之前进程部分,我们接触过使用kill-9杀死一个进程。
常见信号:
SIGTERM (15) :最标准的终止请求 。
kill命令的默认信号。进程可以捕获它,从而有机会在退出前进行资源清理、保存状态等"体面"的收尾工作。SIGKILL (9) :强制终止,无法被捕获或忽略 。当进程对
SIGTERM无动于衷(例如卡死或忽略信号)时,这是"最后的手段"。由于它直接由内核执行,进程没有任何反应时间,也不会执行任何清理逻辑。SIGINT (2) :键盘中断 。由
Ctrl-C触发。它的意图是"打断"前台进程,通常也用于终止程序,但同样是可被捕获的,允许程序优雅退出。
结论
衡量一个进程运行结果是否可信,可以使用退出码和信号两个数字来表示,如果进程异常退出,退出码就失去意义了。
类比我们考试,考试考完了,成绩才有效。考试作弊被抓住了,考了多少分都无效!
三、进程等待
1.概念
进程等待指父进程阻塞或轮询,直到某个子进程状态改变并回收其退出信息。它是退出码和信号终止的接收端:子进程怎么死的,父进程通过等待获知并善后。
2.为什么必须等待
子进程终止后,内核不会立刻释放全部资源。退出码、终止信号、资源统计要保留在进程PCB里,等父进程来取。这个已死但未回收的状态就是僵尸进程。父进程调用 wait 或 waitpid 取走信息后,内核才真正释放进程表项。
不等待的后果有三条。子进程变僵尸,占用 PID 和进程表项。僵尸积累会耗尽 PID,无法再 fork。父进程先于子进程退出时,子进程被 init 或 systemd 收养,由它兜底回收。
3.wait
1. 必须包含头文件
cpp
#include <sys/wait.h>
#include <sys/types.h> // 通常也需要,为了 pid_t
2. 函数原型
cpp
pid_t wait(int *status);
3.参数说明
参数 :传入一个
int变量的地址(如&status),用于接收子进程的退出状态。如果不关心,传NULL。返回值 :成功返回被回收的子进程 PID;失败返回
-1。行为 :阻塞 。父进程会停在这里,直到任意一个子进程结束
4.父进程调用wait解决子进程的僵尸问题
代码样例:
cpp
int main()
{
pid_t id=fork();
if(id==0)
{
printf("我是一个子进程,我创建成功了,pid:%d\n",getpid());
exit(1);
}
if(id>0)
{
int status=0;
pid_t pid=wait(&status);
printf("wait成功,子进程pid:%d\n",pid);
printf("exitcode=%d\n",status);
}
return 0;
}
运行结果:

疑问:为什么我们设置的退出码是1,而打印出来的退出码是256,不符合预期?
5.关于status
status不能简单的当作整形来看待,可以当作位图来看待,具体细节如下图(只研究status低16
比特位):

所以我们退出码为1,status里存的其实是1000 0000也就是2^7=256。要获取预期中的退出码,应该使用**(status>>8)&&0xFF,** 如果要获取退出信号应该使用status&0x7F。
测试代码:
cpp
int main()
{
pid_t id=fork();
if(id==0)
{
printf("我是一个子进程,我创建成功了,pid:%d\n",getpid());
exit(1);
}
if(id>0)
{
int status=0;
pid_t pid=wait(&status);
//pid_t pid=waitpid(-1,&status,0);
printf("wait成功,子进程pid:%d\n",pid);
printf("exitcode=%d\n",(status>>8)&&0xff);
}
return 0;
}
运行结果(符合预期):

不过使用位运算获取进程结束的status太繁琐了,C标准库就给我们提供了宏:
6.WIFEXITED&&WEXITSTATUS
这两个宏是 <sys/wait.h> 里定义的一对"黄金搭档",必须配合使用,顺序不能颠倒。
WIFEXITED(status)
判断进程是否正常退出
定义:(((status) & 0x7f) == 0)
作用:检查 status 低 7 位(信号位)是否为 0。
返回真(非 0):子进程通过 exit() / return / _exit() 正常结束。
返回假(0):子进程被信号杀死(段错误、kill -9 等)。
WEXITSTATUS(status)
获取进程的退出码
定义:(((status) >> 8) & 0xff)
作用:取出 status 的 bit 8--15,即退出码。
有效前提:只有 WIFEXITED(status) 为真时才有意义。
返回值范围:0 ~ 255。
1.原则上保证父进程最后退出。
2.父进程通过wait等待子进程退出。
3.如果子进程不退出,父进程就一直阻塞在wait这一行代码,等待子进程死亡。
4.waitpid
1. 必须包含头文件
cpp
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
2.函数原型
cpp
pid_t waitpid(pid_t pid, int *status, int options);
3.参数说明
pid :指定要等哪个子进程。
大于 0:等 PID 为 pid 的特定子进程。
-1:等任意子进程(等价于 wait)。
0:等同进程组的任意子进程。
status:接收状态,解析方法同 wait(如 WIFEXITED、WEXITSTATUS 等)。
options :决定等待行为。填 0 表示阻塞等待(和 wait 一样,直到子进程结束)。
填 WNOHANG 表示非阻塞(如果子进程还没结束,立即返回 0,父进程可以继续干别的事)。
返回值 :成功时返回被回收的子进程 PID。
使用 WNOHANG 且子进程还在运行:返回 0。
出错(如没有子进程):返回 -1。
4.非阻塞等待
非阻塞等待就是指父进程在等待子进程退出时,采用非阻塞轮询的方式,若子进程没有退出,父进程在等待期间可以做其他的事情。
模拟样例:
cpp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
void PrintLog()
{
printf("我要打印日志!\n");
}
void SyncMySQL()
{
printf("我要访问数据库!\n");
}
void Download()
{
printf("我要下载核心数据\n");
}
typedef void(*task_t)();
task_t tasks[3] = {
PrintLog,
SyncMySQL,
Download
};
//////////////////////////////////////////////////////////////
int main()
{
printf("我是父进程, pid :%d, ppid : %d\n", getpid(), getppid());
pid_t id = fork();
if(id == 0)
{
//child
int cnt = 5;
while(cnt)
{
printf("我是子进程, pid :%d, ppid : %d, cnt: %d\n", getpid(), getppid(), cnt);
sleep(1);
cnt--;
}
exit(13);
}
while(1)
{
int status = 0;
pid_t rid = waitpid(id, &status, WNOHANG);
if(rid > 0)
{
if(WIFEXITED(status))
{
printf("子进程正常退出, 退出码: %d\n", WEXITSTATUS(status));
}
else
{
printf("进程出异常了,请注意!\n");
}
break;
}
else if(rid == 0)
{
sleep(1);
printf("子进程还没有退出,父进程轮询!\n");
for(int i = 0; i < 3; i++)
{
tasks[i]();
}
}
else{
printf("wait failed, who: %d, status: %d\n", rid, status);
break;
}
}
return 0;
}
运行结果:

四、进程程序替换
fork之后父子进程各自执行父进程代码中的一部分,但如果子进程想执行别的程序呢?这就引出了------进程程序替换。
1.替换原理
在不创建新进程的前提下 ,用磁盘上的一个新程序完全覆盖掉当前进程用户空间的代码段,数据段和堆栈。这里需要注意是覆盖掉的是进程的虚拟内存空间,而不是物理内存。
父进程使用fork创建子进程后,执行的是和父进程相同的程序,子进程往往要调用一个exec族函数来执行另一个新的程序。fork和exec族函数通常搭配使用。在子进程中调用exec族函数,由于进程具有独立性,替换子进程不会影响父进程。
验证程序替换不创建新进程:
cpp
#include<stdio.h>
#include<sys/wait.h>
#include<sys/types.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
pid_t id=fork();
if(id==0)
{
printf("我是子进程,pid:%d,ppid:%d\n",getpid(),getppid());
execlp("ls","ls","-l",NULL);
exit(1);
}
else if(id>0)
{
printf("子进程创建成功,pid:%d\n",id);
int status=0;
pid_t ret=waitpid(id,&status,0);
printf("wait成功,回收子进程pid:%d\n",ret);
}
return 0;
}
测试结果(符合预期)

2.exec函数
1.核心作用
exec 族函数的作用是:用一个新的程序(可执行文件)替换当前进程的代码段、数据段、堆和栈。替换完成后,进程的 PID 不变,但执行的代码变成了全新程序,并且从新程序的 main 函数开始执行。
2.exec 函数家族
exec 并不是一个函数,而是一组(6个)功能类似的函数,它们的区别在于参数传递方式、是否查找 PATH 环境变量、以及是否自定义环境变量。
execl:参数传递用列表(逗号分隔),不查 PATH,继承环境变量。
execlp:参数传递用列表,自动查 PATH,继承环境变量。
execle:参数传递用列表,不查 PATH,自定义环境变量。
execv:参数传递用字符串数组,不查 PATH,继承环境变量。
execvp:参数传递用字符串数组,自动查 PATH,继承环境变量。
execvpe:参数传递用字符串数组,自动查 PATH,自定义环境变量。
记忆口诀(后缀字母含义):
后缀 l (list):参数以逗号分隔的列表形式给出,最后必须以 NULL 结尾。
后缀 v (vector):参数以字符串数组(指针数组)形式给出,数组最后也必须以 NULL 结尾。
后缀 p (path):如果只给了文件名(如 "ls"),会自动去环境变量 PATH 里找。如果没有 p,就必须给全路径(如 "/bin/ls")。
后缀 e (environment):允许传入自定义的环境变量数组 envp。如果没有 e,新程序将继承当前进程的环境变量。
3.参数到底怎么传?
无论用列表还是数组,传递参数时务必记住两点:
第一点:第一个参数是程序名本身(习惯上跟路径的文件名一致,新程序的 argv0 就是它)。
第二点:参数列表必须以 NULL 结尾,告诉系统参数到此为止。
以执行 ls -l /home 为例:
用 execl 列表形式:execl("/bin/ls", "ls", "-l", "/home", (char *)NULL);
用 execv 数组形式:先定义数组 char *const argv\[\] = {"ls", "-l", "/home", NULL}; 然后调用 execv("/bin/ls", argv);
用 execlp 带 PATH 查找形式:execlp("ls", "ls", "-l", "/home", (char *)NULL);(不用写 /bin/)
4.返回值
如果 exec 执行成功,它永远不会返回!因为它的代码段已经被替换了,原来的 return 语句都不存在了。
只有执行失败时(比如文件找不到、没有执行权限),它才会返回 -1,并设置 errno。
因此,标准写法必须在 exec 后面加一句 perror 和 exit,例如:execl("/bin/ls", "ls", "-l", NULL); perror("exec failed"); exit(1);
5.exec 前后的"保留"与"重置"
当一个进程调用 exec 成功后,以下东西的状态是:
保留不变的:
PID 和 PPID(完全不创建新进程)。
进程的优先级(nice 值)。
当前工作目录。
打开的文件描述符(除了设置了 FD_CLOEXEC 标志的,默认全保留。这就是为什么 shell 重定向 ls > log.txt 可以生效,因为 shell 打开文件后 exec,文件描述符传给了 ls)。
环境变量(如果你用的是不带 e 的函数)。
被重置或替换的:
地址空间(代码、数据、堆、栈全部换成新程序的)。
信号处理函数(原本捕获的信号处理函数会被重置为默认行为,因为新程序的代码里没有那些函数了)。
内存中的映射(比如 mmap 的共享内存通常会解除映射)。
五、小结
这篇文章系统梳理了 Linux 进程控制的四大核心机制,以下是各部分的提炼:
一、进程创建
核心在于 fork 函数的"一次调用,两次返回"。为了提升效率,Linux 引入了写时复制(COW)技术,让父子进程在发生写操作或 exec 之前共享物理内存。子进程会继承父进程的大量资源,但拥有独立的 PID 和地址空间副本。
二、进程终止
进程共有三种终止情况:正常运行结束、运行结果错误、以及被信号异常终止。正常结束时,进程会向父进程返回退出码(0 表示成功,非 0 表示失败),可使用 echo $? 查看。退出方式上,main 函数 return 和 exit 会刷新缓冲区,而 _exit 会直接进入内核终止,不刷新缓冲区。异常退出通常是被信号(如 kill -9)终止,此时退出码失去意义,应以信号为准。
三、进程等待
子进程终止后如果父进程不进行回收,会产生僵尸进程并占用系统资源。父进程必须使用 wait 或 waitpid 回收子进程并获取退出信息。wait 拿到的 status 是一个位图:高 8 位是退出码,低 7 位是终止信号。应当使用 WIFEXITED 和 WEXITSTATUS 这对宏来解析,而不是直接比较数值。此外,通过 waitpid 配合 WNOHANG 选项,可以实现非阻塞轮询,让父进程在等待子进程退出的同时去执行其他任务。
四、进程程序替换
使用 exec 族函数可以在不创建新进程的前提下,用新程序完全覆盖当前进程的虚拟地址空间。子进程 exec 后,PID 保持不变,但代码和数据被彻底替换,这也是 fork 和 exec 经常搭配使用的原因。exec 成功后永远不会返回,只有失败时才返回 -1。共有 6 个 exec 函数,可通过后缀 l、v、p、e 区分参数传递方式、是否查找 PATH 以及是否自定义环境变量。exec 执行后,文件描述符、当前工作目录等会被保留,而信号处理函数、地址空间等会被重置
有了前面的基础,下一篇博主会带大家自己手搓一个迷你shell命令行解释器,创作不易,请大家一键三连,感谢大佬的支持,respect!