Linux 进程编程核心：fork、wait 和 exec 深度解析

2025-10-11

在 Linux 系统中，进程是程序的一次执行过程，是操作系统进行资源分配和调度的基本单位。每个进程都有自己独立的地址空间、文件描述符、寄存器等资源，操作系统通过进程控制块（PCB，在 Linux 内核中用task_struct结构体表示）来管理进程的相关信息。

进程在操作系统中扮演着至关重要的角色，它是操作系统实现多任务处理的基础。通过进程，操作系统可以同时运行多个程序，提高系统的利用率和响应速度。例如，当我们在 Linux 系统中打开多个终端窗口，每个终端窗口都可以看作是一个独立的进程，它们可以同时执行不同的命令，互不干扰。

在进程编程中，fork、wait和exec是三个非常关键的函数，它们分别用于创建新进程、等待子进程结束和执行新的程序。接下来，我们将深入探讨这三个函数的用法和原理。

一、进程创建：fork函数解析

1. fork 函数基础

fork函数是 Linux 系统中用于创建新进程的系统调用，其定义在<unistd.h>头文件中，原型为pid_t fork(void);。这里的pid_t是一种数据类型，用来表示进程 ID。fork函数的功能非常强大，它会创建一个与调用进程（即父进程）几乎完全相同的新进程，这个新进程被称为子进程。

子进程会复制父进程的代码段、数据段、堆、栈等资源，拥有自己独立的进程 ID（PID），但与父进程共享一些资源，如打开的文件描述符。简单来说，就像是父进程克隆了一个自己，这个克隆体（子进程）有着与父进程相似的 “外貌”（资源），但又有自己独特的 “身份标识”（PID）。

2. fork 的返回值与执行逻辑

fork函数的一个独特之处在于它会返回两次，一次是在父进程中，一次是在子进程中。在父进程中，fork返回子进程的 PID；在子进程中，fork返回 0。如果fork函数执行失败，它会返回 - 1，并设置errno来指示错误原因。这种不同的返回值为区分父子进程提供了依据，就像是给父子进程分别发放了不同的 “通行证”，让它们可以在后续的代码中走不同的路径。

下面通过一段简单的 C 代码来展示fork函数的返回值和执行逻辑：

复制

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() { pid_t pid; // 调用fork函数创建子进程 pid = fork(); // 判断fork的返回值 if (pid < 0) { // fork失败 perror("fork error"); exit(EXIT_FAILURE); } else if (pid == 0) { // 子进程 printf("I am the child process, my pid is %d, my parents pid is %d\n", getpid(), getppid()); } else { // 父进程 printf("I am the parent process, my pid is %d, and my childs pid is %d\n", getpid(), pid); } return 0; }1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.

在这段代码中，首先调用fork函数创建子进程。然后根据fork的返回值判断当前是父进程还是子进程。如果返回值小于 0，说明fork失败，输出错误信息并退出程序；如果返回值为 0，说明是子进程，输出子进程的 PID 和父进程的 PID；如果返回值大于 0，说明是父进程，输出父进程的 PID 和子进程的 PID。

运行这段代码，你会看到类似如下的输出：

复制

I am the parent process, my pid is 12345, and my childs pid is 12346 I am the child process, my pid is 12346, my parents pid is 123451.2.

从输出结果可以清晰地看到父子进程的 PID 以及它们的执行路径。

3. 写时复制机制

在早期的操作系统中，当使用fork创建子进程时，会直接将父进程的所有内存空间完整地复制给子进程，这在内存使用和性能上都存在很大的问题，尤其是对于大型程序来说，复制大量内存数据会消耗大量时间和内存资源。为了解决这个问题，Linux 引入了写时复制（Copy - On - Write，COW）技术。

写时复制的原理是，在fork创建子进程时，内核并不立即复制父进程的整个地址空间，而是让父进程和子进程共享同一个物理内存拷贝，同时将这些共享内存页标记为只读。只有当父子进程中的某一个试图对共享内存页进行写操作时，才会触发缺页异常，此时内核会为需要写入的进程创建该内存页的一个新副本，然后将新副本的权限设置为可写，进程再对新副本进行写操作。

例如，假设父进程有一个数据段，其中包含一个变量x，值为 10。在fork创建子进程后，父子进程共享这个数据段的物理内存页。当父进程或者子进程想要修改x的值时，就会触发写时复制机制。内核会为执行写操作的进程创建一个新的数据段内存页，将原内存页的数据复制到新页，然后在新页上进行写操作。这样，另一个进程的数据段仍然保持不变，实现了数据的独立修改。

写时复制机制带来了很多优势：一方面，它显著提高了fork操作的效率，因为不需要在创建子进程时立即复制大量内存数据，减少了创建子进程的时间开销；另一方面，它有效地节省了内存资源，尤其是在父子进程共享大量数据且大部分数据不需要修改的情况下，避免了不必要的内存复制。

二、进程等待：wait函数解析

1. wait 函数作用

在 Linux 进程编程中，wait函数是一个非常重要的函数，它用于父进程等待子进程结束。当父进程调用wait函数时，会发生以下事情：首先，父进程会被阻塞，暂停执行，直到它的一个子进程结束；然后，wait函数会回收子进程的资源，包括释放子进程占用的内存空间、关闭子进程打开的文件描述符等；最后，wait函数还会获取子进程的退出状态，让父进程了解子进程是如何结束的，比如是正常退出还是异常终止。

wait函数对于资源回收和避免僵尸进程的产生具有至关重要的意义。在 Linux 系统中，每个进程都占用一定的系统资源，如果父进程创建了子进程后，不等待子进程结束并回收其资源，子进程就会变成僵尸进程。僵尸进程虽然已经结束运行，但它的进程控制块（PCB）仍然保留在系统中，占用系统资源，长期积累会导致系统资源浪费和性能下降。通过wait函数，父进程可以及时回收子进程的资源，避免僵尸进程的出现，确保系统的稳定运行。

2. wait 函数原型与参数

wait函数的原型定义在<sys/types.h>和<sys/wait.h>头文件中，具体原型为pid_t wait(int *status);。其中，pid_t是一种数据类型，用于表示进程 ID；status是一个指向整数的指针，用于存储子进程的退出状态信息。

如果status为NULL，表示父进程不关心子进程的退出状态，只希望等待子进程结束并回收其资源。如果status不为NULL，wait函数会将子进程的退出状态信息存储在status指向的整数中。通过一些宏定义，可以从这个整数中解析出子进程的具体退出情况。常用的宏有：

WIFEXITED(status)：用于判断子进程是否正常退出，如果正常退出返回非零值。WEXITSTATUS(status)：当WIFEXITED(status)为真时，通过这个宏可以获取子进程正常退出时的返回值。WIFSIGNALED(status)：判断子进程是否是因为收到信号而异常终止，如果是返回非零值。WTERMSIG(status)：当WIFSIGNALED(status)为真时，通过这个宏可以获取导致子进程异常终止的信号编号。3. wait 函数应用示例

下面通过一段代码示例来展示wait函数的具体应用：

复制

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main() { pid_t pid; int status; // 创建子进程 pid = fork(); if (pid < 0) { perror("fork error"); exit(EXIT_FAILURE); } else if (pid == 0) { // 子进程 printf("I am the child process, my pid is %d\n", getpid()); sleep(2); // 模拟子进程执行一些任务 exit(3); // 子进程正常退出，返回值为3 } else { // 父进程 printf("I am the parent process, my pid is %d, and my childs pid is %d\n", getpid(), pid); // 等待子进程结束 wait(&status); if (WIFEXITED(status)) { printf("The child process exited normally, exit status is %d\n", WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { printf("The child process was terminated by a signal, signal number is %d\n", WTERMSIG(status)); } } return 0; }1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.

在这段代码中，首先使用fork函数创建子进程。子进程打印自己的 PID，然后睡眠 2 秒，最后以返回值 3 正常退出。父进程打印自己和子进程的 PID，然后调用wait函数等待子进程结束。当子进程结束后，wait函数返回，通过WIFEXITED和WIFSIGNALED宏判断子进程的退出状态，并打印相应信息。

运行这段代码，你会看到类似如下的输出：

复制

I am the parent process, my pid is 12345, and my childs pid is 12346 I am the child process, my pid is 12346 The child process exited normally, exit status is 31.2.3.

从输出结果可以清晰地看到父子进程的执行过程以及子进程的退出状态。

4. waitpid 函数拓展

waitpid函数是wait函数的扩展，它提供了更灵活的等待方式。waitpid函数的原型为pid_t waitpid(pid_t pid, int *status, int options); 。与wait函数相比，waitpid函数有以下几个特点：

可以指定等待的子进程：pid参数用于指定要等待的子进程的 PID 。当pid > 0时，等待进程 ID 等于pid的子进程；当pid = -1时，等待任意子进程，此时waitpid与wait功能相同；当pid = 0时，等待和当前调用waitpid函数的进程同一个进程组的所有子进程；当pid < -1时，等待指定进程组内的任意子进程，其中pid的绝对值表示进程组的 ID 。可以选择是否阻塞等待：options参数用于控制waitpid的行为，常用的选项有WNOHANG（非阻塞模式）。当设置WNOHANG选项时，如果没有子进程结束，waitpid函数会立即返回 0，而不是阻塞等待；如果有子进程结束，则返回该子进程的 PID 。可以处理更多子进程状态：除了可以获取子进程的正常退出和异常终止状态外，waitpid函数还可以通过WUNTRACED选项报告被跟踪的子进程（即使它们尚未停止），通过WCONTINUED选项报告被继续执行的子进程（即被SIGCONT信号继续执行）。

waitpid函数在一些复杂的场景中非常有用。例如，当父进程需要同时管理多个子进程，并且希望在不阻塞的情况下获取子进程的状态时，可以使用waitpid函数的非阻塞模式。通过循环调用waitpid函数，并设置WNOHANG选项，父进程可以在等待子进程结束的同时继续执行其他任务。

下面是一个使用waitpid函数非阻塞等待子进程的示例代码：

复制

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main() { pid_t pid; int status; // 创建子进程 pid = fork(); if (pid < 0) { perror("fork error"); exit(EXIT_FAILURE); } else if (pid == 0) { // 子进程 printf("I am the child process, my pid is %d\n", getpid()); sleep(5); // 模拟子进程执行一些任务 exit(3); // 子进程正常退出，返回值为3 } else { // 父进程 printf("I am the parent process, my pid is %d, and my childs pid is %d\n", getpid(), pid); // 非阻塞等待子进程结束 while (1) { pid_t ret = waitpid(pid, &status, WNOHANG); if (ret == 0) { // 没有子进程结束，继续执行其他任务 printf("The child process is still running, I can do other things\n"); sleep(1); } else if (ret == pid) { // 子进程结束 if (WIFEXITED(status)) { printf("The child process exited normally, exit status is %d\n", WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { printf("The child process was terminated by a signal, signal number is %d\n", WTERMSIG(status)); } break; } else { // 错误情况 perror("waitpid error"); break; } } } return 0; }1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.

在这个示例中，父进程使用waitpid函数并设置WNOHANG选项非阻塞地等待子进程结束。在等待过程中，父进程可以继续执行其他任务，每隔 1 秒打印一次提示信息。当子进程结束后，waitpid函数返回子进程的 PID，父进程获取子进程的退出状态并打印相应信息。运行这段代码，你会看到父进程在等待子进程的同时还能执行其他任务，充分展示了waitpid函数的灵活性。

三、程序替换：exec函数解析

1. exec 函数族概述

在 Linux 进程编程中，当我们需要让一个进程去执行另一个不同的程序时，就会用到exec函数族。exec函数族的功能是用一个新的程序替换当前进程的正文段、数据段、堆段和栈段，使得当前进程从新程序的入口点开始执行。简单来说，就像是把进程原本运行的程序 “替换” 成了另一个程序，就如同给一个机器人换上了全新的 “大脑”（程序），让它执行新的任务。

需要注意的是，exec函数族并不会创建新的进程，进程的 PID 在执行exec前后保持不变。这意味着，虽然进程执行的程序发生了变化，但它在系统中的 “身份标识”（PID）并没有改变。例如，当我们在终端中输入ls命令时，shell 进程会调用fork创建一个子进程，然后子进程调用exec函数族中的某个函数，将自身替换为ls程序的执行，此时子进程的 PID 并没有改变，只是它开始执行ls程序的代码。

2. exec 函数原型与参数

exec函数族包含多个函数，它们的原型和功能相似，但在参数传递和查找可执行文件的方式上有所不同。常用的exec函数原型如下：

复制

#include <unistd.h> // 使用参数列表传递参数，在指定路径查找可执行文件 int execl(const char *path, const char *arg, ...); // 使用参数列表传递参数，在PATH环境变量指定路径查找可执行文件 int execlp(const char *file, const char *arg, ...); // 使用参数列表传递参数，在指定路径查找可执行文件，并可指定新的环境变量 int execle(const char *path, const char *arg, ..., char *const envp[]); // 使用参数数组传递参数，在指定路径查找可执行文件 int execv(const char *path, char *const argv[]); // 使用参数数组传递参数，在PATH环境变量指定路径查找可执行文件 int execvp(const char *file, char *const argv[]); // 使用参数数组传递参数，在PATH环境变量指定路径查找可执行文件，并可指定新的环境变量 int execvpe(const char *file, char *const argv[], char *const envp[]);1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.

这些函数的参数说明如下：

path：指定要执行的可执行文件的完整路径，例如/bin/ls 。file：如果参数中包含/，则视为路径并在指定路径下查找可执行文件；否则将在PATH环境变量指定的路径中查找可执行文件，例如ls 。arg：指定传递给可执行文件的一系列参数，以可变参数列表的形式传递，一般第一个参数为可执行文件的名称，且最后一个参数必须是NULL，用于表示参数列表的结束。例如，execl("/bin/ls", "ls", "-l", NULL)，其中"ls"是可执行文件的名称，"-l"是传递给ls命令的参数，NULL表示参数列表结束。argv：指定传递给可执行文件的一系列参数，以参数数组的形式传递，数组的最后一个元素必须是NULL，用于表示参数数组的结束。例如，char *argv[] = {"ls", "-l", NULL}; execv("/bin/ls", argv); 。envp：指定新进程的环境变量，是一个指向字符指针数组的指针，数组中的每个元素都是一个环境变量字符串，格式为"变量名=值"，最后一个元素必须是NULL，用于表示环境变量数组的结束。如果不使用该参数，新进程将继承调用进程的环境变量。例如，char *envp[] = {"HELLO=world", "USER=root", NULL}; execle("/bin/echo", "echo", "$HELLO", (char *)NULL, envp); 。3. exec 函数应用示例

下面通过一个具体的代码示例来展示exec函数的使用：

复制

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() { pid_t pid; // 创建子进程 pid = fork(); if (pid < 0) { perror("fork error"); exit(EXIT_FAILURE); } else if (pid == 0) { // 子进程 // 使用execlp函数执行ls命令，列出当前目录下的文件 // 第一个参数"ls"表示在PATH环境变量中查找ls程序 // 第二个参数"ls"是传递给ls程序的参数，一般第一个参数是程序名本身 // 第三个参数"-l"是ls命令的参数，用于以长格式列出文件 // 最后一个参数NULL表示参数列表结束 if (execlp("ls", "ls", "-l", NULL) == -1) { perror("execlp error"); exit(EXIT_FAILURE); } } else { // 父进程 wait(NULL); // 等待子进程结束 printf("Child process has finished.\n"); } return 0; }1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.

在这段代码中，首先使用fork函数创建一个子进程。在子进程中，调用execlp函数执行ls -l命令，用于列出当前目录下的文件。execlp函数会在PATH环境变量指定的路径中查找ls程序，并将"ls"、"-l"作为参数传递给ls程序。如果execlp函数执行失败，会打印错误信息并退出子进程。父进程调用wait函数等待子进程结束，然后打印提示信息。运行这段代码，你会看到子进程执行ls -l命令的输出结果，展示了当前目录下文件的详细信息。

四、fork、wait 和 exec 三者之间的协同

1. 常见应用场景

在实际的 Linux 编程中，fork、wait和exec这三个函数通常会协同工作，共同完成各种复杂的任务。在 Shell 脚本的实现中，当用户在终端输入一条命令，比如ls -l，Shell 进程会首先调用fork创建一个子进程。这个子进程继承了 Shell 进程的大部分资源，包括打开的文件描述符等。然后子进程调用exec函数族中的某个函数，比如execlp，将自身替换为ls程序的执行。

此时，子进程开始执行ls程序的代码，根据传入的参数-l以长格式列出当前目录下的文件。而父进程（即 Shell 进程）则调用wait函数等待子进程结束。当子进程执行完ls命令后，父进程从wait函数返回，继续等待用户输入下一条命令。通过这样的协同工作，Shell 能够实现对用户输入命令的解析和执行。

在服务器程序中，比如一个简单的 Web 服务器，fork、wait和exec的协同也起着关键作用。当服务器接收到一个客户端的连接请求时，主进程会调用fork创建一个子进程来处理这个连接。子进程调用exec函数族执行处理客户端请求的程序，比如一个 CGI 脚本或者一个专门的处理程序。

在这个过程中，主进程可以继续监听其他客户端的连接请求，而子进程负责处理当前客户端的具体请求。当子进程处理完请求后，主进程通过wait函数回收子进程的资源，确保系统资源的有效利用。通过这种方式，Web 服务器能够同时处理多个客户端的请求，提高了服务器的并发处理能力。

2. 代码实战

下面给出一个完整的代码示例，展示fork、wait和exec的协同工作流程：

复制

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main() { pid_t pid; int status; // 创建子进程 pid = fork(); if (pid < 0) { perror("fork error"); exit(EXIT_FAILURE); } else if (pid == 0) { // 子进程 char *argv[] = {"ls", "-l", NULL}; // 使用execvp函数执行ls -l命令 if (execvp("ls", argv) == -1) { perror("execvp error"); exit(EXIT_FAILURE); } } else { // 父进程 printf("I am the parent process, my pid is %d, and my childs pid is %d\n", getpid(), pid); // 等待子进程结束 wait(&status); if (WIFEXITED(status)) { printf("The child process exited normally, exit status is %d\n", WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { printf("The child process was terminated by a signal, signal number is %d\n", WTERMSIG(status)); } } return 0; }1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.

代码执行过程如下：

首先，主进程调用fork函数创建子进程。在子进程中，fork返回 0，然后子进程创建一个包含ls和-l的参数数组argv 。接着调用execvp函数，execvp会在PATH环境变量指定的路径中查找ls程序，并使用argv作为参数执行ls -l命令。如果execvp执行成功，子进程的代码段、数据段、堆段和栈段会被ls程序替换，开始执行ls程序的代码，输出当前目录下文件的详细信息。如果execvp执行失败，会打印错误信息并退出子进程。在父进程中，fork返回子进程的 PID，父进程打印自己和子进程的 PID 。然后调用wait函数等待子进程结束。当子进程结束后，wait函数返回，父进程通过WIFEXITED和WIFSIGNALED宏判断子进程的退出状态，并打印相应信息。

通过这个代码示例，我们可以清晰地看到fork、wait和exec是如何协同工作的。fork用于创建子进程，为执行新程序提供载体；exec用于将子进程替换为新的程序执行；wait用于父进程等待子进程结束并回收其资源，确保系统资源的有效管理。

THE END

警惕“银狐”木马，群传染群

<<上一篇

供应链金融数字化转型迈入发展快车道，安全风险如何防范？

下一篇>>