操作系统笔记之进程调用API中的getpid、fork、wait、exec补充

code review!

—— 杭州 2024-03-17 夜

1.getpid()

getpid() 是一个在 Unix-like 系统（比如 Linux 和 macOS）中常用的系统调用函数，它用于获取当前进程的进程标识符（Process ID，简称 PID）。该函数定义在 <unistd.h> 头文件中，属于 POSIX 标准的一部分。

每个运行中的进程都有一个唯一的 PID，这是一个非负整数。这个标识符可以用于控制进程，比如发送信号给进程来终止它或者查询进程的状态。

函数原型

getpid() 函数的原型如下：

#include <unistd.h>pid_t getpid(void);

这里 pid_t 通常是 int 类型的别名，用于表示进程 ID。

返回值

getpid() 函数返回调用进程的 PID。因为每个进程都有一个唯一的 PID，并且 getpid() 不会失败，所以它没有失败的返回值。

示例代码

以下是一个简单的示例，演示了如何在 C 程序中调用 getpid() 函数：

#include <stdio.h>
#include <unistd.h>int main() {pid_t pid = getpid(); // 调用 getpid() 获取当前进程的 PIDprintf("The Process ID (PID) is: %d\n", pid);return 0;
}

当你编译并运行这个程序时，它会输出当前进程的 PID。

应用场景

getpid() 在多种情况下可能会被使用：

• 日志记录：在进行系统日志记录时，记录当前进程的 PID 可以帮助在出现问题时追踪到具体的进程。
• 进程管理：脚本或程序可能需要知道其自身的 PID，以便于创建锁文件，防止多个实例同时运行。
• 调试：在调试多进程程序时，知道不同进程的 PID 可以帮助区分它们的输出或行为。
• 信号处理：发送信号给特定进程时需要知道其 PID。

注意事项

• 在 Unix-like 系统中，PID 1 通常是初始化进程（init 或 systemd），它是所有其他用户空间进程的祖先。
• PID 是一个有限资源，在长时间运行的系统中可能会耗尽。不过，系统会在 PID 耗尽时回收和重用旧的、不再使用的 PID。
• 在多线程程序中，所有线程共享同一个 PID，因为它们运行在同一个进程上下文中。如果你需要获取线程的唯一标识符，应该使用 pthread_self() 或其他相关函数。

2.fork()

fork() 是一个用于创建进程的系统调用。理解 fork() 的关键是要知道它会创建一个与原始（父）进程几乎完全相同的新进程（子进程）。让我们用一个更详细的方式来说明这个过程：

1. 调用 fork(): 当一个进程（我们称之为父进程）执行到 fork() 系统调用时，它会请求操作系统创建一个新的进程。

2. 创建子进程: 操作系统会复制父进程的整个状态到子进程中。这意味着子进程将获得父进程数据段、代码段和堆栈的副本。在许多操作系统中，这种复制是通过写时复制（Copy-on-Write, COW）机制实现的，以提高效率。实际的内存页只有在其中一个进程尝试写入时才会被复制。

3. 区分父子进程: fork() 调用在父进程中返回子进程的 PID，在子进程中返回 0。这是父进程和子进程的代码可以区分两个进程的关键所在。

4. 独立执行: 一旦 fork() 完成，两个进程（父进程和子进程）都将从 fork() 调用之后的指令开始独立执行。这两个进程有各自独立的地址空间，所以一个进程对内存的改变不会影响另一个进程。

5. 资源共享: 子进程会继承父进程的文件描述符。这些文件描述符指向相同的文件表项，意味着父子进程可以共享打开的文件等资源。

6. 独立生命周期: 子进程有自己的生命周期，它可以独立于父进程执行，也可以执行不同的代码。通常，子进程会调用 exec() 系列函数来替换自己的内存空间，包括代码和数据，以运行一个新的程序。

简单的 fork() 示例

让我们看一个 fork() 的示例，以便更好地理解这个过程：

运行：

代码

#include <stdio.h>
#include <unistd.h>int main() {printf("Before fork()\n");pid_t pid = fork();if (pid == -1) {// fork失败perror("fork");return 1;} else if (pid > 0) {// 父进程printf("I am the parent process. My PID is %d and my child's PID is %d.\n", getpid(), pid);} else {// 子进程printf("I am the child process. My PID is %d.\n", getpid());}printf("This is the end of the process with PID %d.\n", getpid());return 0;
}

在这个程序中，我们首先打印 “Before fork()”，然后调用 fork()。在 fork() 之后，我们有两个独立的进程：父进程和子进程。每个进程都会执行相应的 if 分支，并且都会打印 “This is the end of the process with PID …”。因此，你会看到 “Before fork()” 只打印一次，而 “This is the end of the process with PID …” 会打印两次，一次用父进程的 PID，一次用子进程的 PID。

3.wait()

wait() 系统调用在 UNIX 和类 UNIX 操作系统中用于使一个父进程等待其子进程结束或改变状态。当子进程结束或停止时，父进程可以通过 wait() 系统调用来收集子进程的退出状态信息。这是一种进程间通信的方式，也是父进程管理子进程生命周期的一种方法。

功能

wait() 提供以下功能：

• 收集子进程状态: 父进程可以获取子进程的终止状态，例如子进程的退出代码。
• 回收资源: 当子进程结束时，操作系统会保留一些资源（如进程描述符和统计信息），直到父进程通过 wait() 调用释放。这一步骤被称为 “回收” 子进程。
• 同步: wait() 可以用来确保父进程在子进程结束之前不会继续执行，实现父子进程间的同步。

使用方法

wait() 调用通常在父进程中这样使用：

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>int main() {pid_t pid = fork();if (pid == -1) {// fork失败perror("fork");return 1;} else if (pid > 0) {// 父进程int status;waitpid(pid, &status, 0); // 父进程等待子进程结束if (WIFEXITED(status)) {printf("Child exited with status %d\n", WEXITSTATUS(status));}} else {// 子进程// 执行一些工作..._exit(42); // 子进程结束，返回42作为退出状态}return 0;
}

参数和返回值

wait() 函数的原型如下：

pid_t wait(int *status);

• status: 这是一个指向整数的指针，用于存储子进程的退出状态。通过宏（比如 WIFEXITED 和 WEXITSTATUS）可以分析这个状态值。
• 返回值: 返回子进程的 PID，或在错误时返回 -1。

状态宏

wait() 通过 status 参数传递的状态值可以用下列宏进行分析：

• WIFEXITED(status): 如果子进程正常结束，则此宏返回真（非0值）。
• WEXITSTATUS(status): 如果 WIFEXITED 非零，返回子进程的退出状态（即 main() 的返回值或 _exit 的参数）。
• WIFSIGNALED(status): 如果子进程因为信号而结束，则此宏返回真。
• WTERMSIG(status): 如果 WIFSIGNALED 非零，返回导致子进程终止的信号编号。
• WIFSTOPPED(status): 如果子进程处于停止状态，则此宏返回真。
• WSTOPSIG(status): 如果 WIFSTOPPED 非零，返回导致子进程停止的信号编号。

注意事项

• 如果父进程没有调用 wait()，而子进程已经结束，子进程将变成僵尸进程（Zombie），直到其父进程结束或为其调用 wait()。
• 如果父进程结束而子进程仍在运行，子进程将被 init 进程（PID 为 1）收养，init 将负责调用 wait() 收集状态信息。

wait() 还有几个相关函数，如 waitpid()、waitid() 和 wait3()/wait4()，它们提供了更多控制选项，比如非阻塞等待或等待特定的子进程。

4.exec()

当你运行一个程序时，操作系统为该程序创建了一个进程。每个进程都有自己的内存空间，其中包含了运行程序所需的指令和数据。exec() 系统调用的功能是在一个已经存在的进程中启动一个新的程序。这意味着 exec() 实际上是用一个全新的程序来替换当前进程的内存空间内容。

exec() 是一组函数，不仅仅只有一个。这组函数包括 execl(), execv(), execlp(), execvp(), execle(), execve() 等。这些函数的区别在于它们如何接收参数（比如直接传递参数列表或是通过数组传递参数），以及它们是否搜索系统的 PATH 环境变量来找到可执行文件。

以下是 exec() 函数族中一个函数的典型用法：

#include <stdio.h>
#include <unistd.h>int main() {char *args[] = {"/bin/ls", "-l", NULL}; // 定义了要执行的命令和参数列表execv("/bin/ls", args); // 使用 execv 来执行/bin/ls程序// 如果execv执行成功，以下的代码不会被执行，// 因为当前进程的内存已经被ls程序替换。perror("execv"); // 如果 execv 失败，则打印错误消息return 1;
}

在这个例子中，execv() 被用来在当前进程中运行 /bin/ls 命令。如果 execv() 成功执行，当前的程序（这个示例中的 C 程序）就会停止运行，因为它的内存空间被 ls 命令的代码和数据所替换。因此，程序中 execv() 调用之后的代码（在这里是 perror() 和 return 1）不会被执行。

如果 execv() 调用失败了（比如，如果 /bin/ls 不是一个有效的可执行文件），则 execv() 会返回 -1，并且 errno 会被设置为描述错误的代码。在这种情况下，perror() 会被执行，它会根据 errno 的值打印一条错误消息。

通常，exec() 调用与 fork() 调用一起使用，这样可以先通过 fork() 创建一个新的子进程，然后在子进程中使用 exec() 来替换为另一个程序。父进程可以继续执行其他任务，或者等待子进程完成。

5.通常，exec() 调用与 fork() 调用一起使用，为什么?

fork() 的作用

• 创建进程: fork() 创建了一个新的子进程，这个子进程几乎是父进程的完整副本。它有自己的进程ID，并且复制了父进程的内存布局。
• 独立运行: 一旦 fork() 成功，你就有了两个几乎相同的进程：一个父进程和一个子进程。

exec() 的作用

• 替换程序: exec() 家族的函数用于在一个进程中启动一个新程序。它替换当前进程的内存空间，包括代码和数据。
• 执行新任务: exec() 通常在 fork() 创建的子进程中调用，以确保子进程执行的是与父进程不同的新任务。

fork() 和 exec() 一起使用的原因

• 保护父进程: 如果只使用 exec()，你将失去当前正在运行的程序，因为它会被新程序替换。fork() 允许父进程继续运行，同时子进程可以去执行新任务。
• 执行并发任务: 使用 fork() 和 exec()，你可以让父进程和子进程同时（并发地）执行不同的任务。

实例

想象你有一个程序，就像一个简单的命令行界面。用户输入一个命令，比如 ls：

1. 程序调用 fork() 创建一个新的子进程。
2. 子进程使用 exec() 来执行 ls 命令。
3. 父进程等待子进程执行完毕。

在这个过程中：

• 如果没有 fork()，原有的程序就会停止运行来执行 ls。
• 如果只有 fork() 而没有 exec()，子进程将会做和父进程完全相同的事情，这不是我们想要的。

结合使用 fork() 和 exec() 允许父进程继续运行自己的代码，而子进程则运行一个全新的程序。这是多任务操作系统中常见的操作，它允许系统同时处理多个任务。

6.fork() 和 exec() 一起使用时，子进程的调用会返回吗?

在 fork() 和 exec() 被一起使用时，子进程的行为取决于 exec() 调用是否成功：

1. 如果 exec() 调用成功：

   • 子进程的 exec() 调用不会返回，因为子进程的原始程序代码已经被新程序替换。子进程从此开始执行新程序的代码，之前的执行上下文（包括调用 exec() 的代码）不复存在。
   • 子进程将继续作为新程序运行，直到该程序结束或遇到错误。

2. 如果 exec() 调用失败：

   • 子进程中的 exec() 调用会返回 -1，并且 errno 会被设置为描述错误的代码。在这种情况下，子进程通常会执行一些错误处理的代码，例如打印出错信息，并且随后通常会立即退出。
   • 子进程在 exec() 调用失败后通常会调用 exit() 或 _exit() 函数来结束自身，因为子进程的正常逻辑是执行另一个程序，如果这一步骤失败了，通常就没有理由继续执行原来的程序代码了。

简而言之，如果 exec() 成功，子进程不会返回到原程序代码；如果 exec()失败，子进程会返回一个错误，而且通常会紧接着退出。父进程可以通过 wait() 或 waitpid()调用来监测子进程的退出状态，以了解子进程是正常结束还是遇到了错误。