在前两篇笔记中，我们了解了进程的基本概念、状态管理以及进程的内存管理，其中提到“父进程创建子进程”的核心操作，而实现这一操作的核心系统调用，就是 fork()。fork 是 Linux 系统编程中最基础、最核心的函数之一，被誉为进程界的“分身魔法”——它能让一个进程（父进程）“复制”出一个完全相同的分身（子进程），二者拥有独立的进程ID，却共享初始的内存资源，是实现进程并发、服务器多连接处理的基础。本节课将从 fork 的基本概念、核心原理、使用方法、底层机制（写时复制），到常见问题与实操案例，全面详解 fork 函数，帮大家彻底掌握其用法与本质。

一、fork 函数的基本概念

fork（英文意为“分叉”）函数的核心功能是创建一个新的子进程，这个子进程是父进程的“副本”——从内存数据、代码段、文件描述符，到进程上下文（程序计数器、寄存器状态等），初始状态下与父进程完全一致。但从 fork 调用成功的那一刻起，父子进程就成为两个独立的个体，拥有各自独立的 PID 和 PCB（进程控制块），内核会分别调度它们执行，互不干扰。

（一）fork 函数的声明与头文件

fork 是 Linux 系统调用，需包含对应的头文件才能使用，其函数声明如下：

#include <unistd.h>  // 核心头文件
#include <sys/types.h> // 用于 pid_t 类型定义

pid_t fork(void); // 无参数，返回值为 pid_t 类型（本质是 int）

关键说明：

返回值类型pid_t：是 Linux 中用于表示进程 ID 的专用类型，本质是 32 位整数，对应进程的 PID（正数）、0 或 -1（错误标识）。

无参数：fork 不需要传递任何参数，因为它会自动复制父进程的所有可继承资源，无需手动指定复制内容，体现了“完整复制”的特性。

（二）fork 的返回值（核心重点）

fork 函数的特殊之处在于：一次调用，两次返回——调用 fork 后，父进程和子进程会分别从 fork 函数的返回处继续执行，但返回值不同，这是区分父子进程的核心依据。返回值分为三种情况，也是面试高频考点，具体如下表所示：

返回值	所属进程	含义与说明
正数（>0）	父进程	返回值为子进程的 PID。父进程通过这个返回值，可唯一标识子进程，进而对其进行管理（如等待子进程退出、终止子进程等）。
0	子进程	表示子进程创建成功。子进程无需通过返回值获取自身 PID（可通过 getpid() 函数获取），也无需获取父进程 PID（可通过 getppid() 函数获取）。
-1	父进程（子进程未创建）	表示 fork 调用失败。常见失败原因：系统进程数达到上限、内存不足（或 swap 空间不足），此时会设置 errno 标识错误类型。

核心误区：很多初学者会误以为“fork 调用后，子进程从 main 函数开始执行”，这是错误的。实际上，子进程会从 fork 函数的返回处开始执行，与父进程执行相同的代码，但因为返回值不同，会进入不同的执行分支。

二、fork 的核心原理：子进程的创建过程

当父进程调用 fork() 后，内核会执行一系列操作创建子进程，整个过程可分为 4 个核心步骤，结合上一篇笔记的内存管理知识，能更清晰理解其本质：

1. 分配新的 PCB（进程控制块）：内核会为子进程分配一个全新的 task_struct 结构（即 PCB），用于存储子进程的 PID、PPID、进程状态、内存信息、文件描述符等核心信息，其中 PPID 会设置为父进程的 PID，确保进程树关系正确。

2. 复制父进程的页表（写时复制预处理）：子进程会复制父进程的虚拟内存页表，使得子进程的虚拟地址空间与父进程完全一致，但内核不会立即复制物理内存数据，而是采用“写时复制（Copy-On-Write, COW）”技术优化性能——将父子进程共享的物理内存页标记为只读，避免不必要的内存复制。

3. 继承父进程的核心资源：子进程会继承父进程的大部分资源，包括但不限于：

   1. 内存资源：代码段、数据段、堆、栈的虚拟地址映射（初始共享物理内存，触发写操作时才复制）；

   2. 文件描述符：子进程继承父进程的所有打开文件，文件描述符表相同，引用计数增加，父子进程共享同一文件的偏移指针；

   3. 其他资源：进程组 ID、会话 ID、环境变量、信号处理设置（除 SIGCHLD 信号会重置为默认方式外）。

4. 设置进程状态并调度：内核将子进程的状态设置为就绪态，加入就绪队列，等待 CPU 调度；同时，父进程继续从 fork 返回处执行（返回子进程 PID），子进程被调度后，也从 fork 返回处执行（返回 0）。

补充说明：fork 的底层实现实际是通过内核函数 do_fork() 完成的，该函数调用 copy_process() 复制父进程信息，最终完成子进程的创建与初始化，整个过程对用户态程序透明。

三、关键机制：写时复制（COW）与 fork 的性能优化

在早期的 Linux 系统中，fork 会直接复制父进程的全部物理内存数据，这种方式存在两个严重问题：一是复制大内存进程时，速度极慢，耗时久；二是如果子进程创建后立即执行 exec() 函数（加载新程序），那么之前复制的内存数据完全无用，造成严重的内存浪费。

为解决这一问题，现代 Linux 系统采用写时复制（Copy-On-Write, COW）技术，这也是 fork 高效运行的核心，其核心思想是：父子进程初始共享所有物理内存页，仅当任一进程尝试修改内存数据时，才复制该内存页的副本，实现内存的按需复制。

（一）写时复制的具体流程

1. fork 调用瞬间（零复制）：父子进程的虚拟地址空间完全一致，页表也完全相同，所有物理内存页被标记为“只读”，并维护一个引用计数（表示当前有多少进程共享该页），此时没有任何物理内存数据被复制，fork 调用几乎瞬间完成。

2. 只读访问时（仍共享）：如果父子进程仅读取内存数据（如访问代码段、未修改的全局变量），不会触发任何复制操作，仍然共享同一个物理内存页，节省内存资源。

3. 写操作时（触发复制）：当父进程或子进程尝试修改某块内存数据时，CPU 会检测到“尝试写入只读页”的异常，触发页故障（page fault），内核会执行以下操作：

   1. 为修改方分配一个新的物理内存页；

   2. 将原只读页的内容复制到新页中；

   3. 更新修改方的页表，将虚拟地址映射到新的物理页，并将新页标记为“可写”；

   4. 减少原只读页的引用计数，若引用计数为 0，则内核可回收该页。

（二）写时复制的优势与应用场景

优势：极大提升 fork 的执行效率，减少内存占用。对于创建后立即执行 exec() 的子进程（如 shell 执行命令时），几乎不会触发任何内存复制，仅复制页表，大幅节省时间和内存。

典型应用场景：服务器编程中，父进程接收客户端连接后，fork 子进程处理该连接，父进程继续等待新连接，子进程处理完连接后退出，这种场景下写时复制能显著提升服务器的并发处理能力。

四、fork 的基础使用示例（实操重点）

结合代码示例，理解 fork 的调用方式、返回值区分，以及父子进程的执行逻辑，这是掌握 fork 的关键。以下示例均可在 Linux 环境中直接编译运行（使用 gcc 编译）。

示例 1：基础用法——区分父子进程，查看 PID 与 PPID

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    pid_t pid; // 存储 fork 的返回值
    printf("===== 程序开始执行 =====\n");
    printf("当前进程（fork前）PID：%d\n", getpid()); // getpid() 获取自身 PID

    // 调用 fork 创建子进程
    pid = fork();

    // 检查 fork 是否失败
    if (pid == -1) {
        perror("fork 调用失败"); // perror 打印具体错误信息
        exit(1); // 退出程序，返回错误码 1
    }

    // 子进程：fork 返回 0
    else if (pid == 0) {
        printf("我是子进程，我的 PID：%d，我的父进程 PID：%d\n", getpid(), getppid());
        sleep(2); // 模拟子进程执行任务（休眠 2 秒）
        printf("子进程执行完毕，即将退出\n");
    }

    // 父进程：fork 返回子进程 PID（正数）
    else {
        printf("我是父进程，我的 PID：%d，我创建的子进程 PID：%d\n", getpid(), pid);
        wait(NULL); // 父进程等待子进程退出，避免子进程成为僵尸进程
        printf("父进程：子进程已退出，我也即将退出\n");
    }

    printf("进程 %d 执行结束\n", getpid());
    return 0;
}

运行步骤与结果说明：

1. 编译：gcc fork_basic.c -o fork_basic；

2. 运行：./fork_basic；

3. 预期结果（PID 为随机值，仅作参考）： ===== 程序开始执行 ===== 当前进程（fork前）PID：12345 我是父进程，我的 PID：12345，我创建的子进程 PID：12346 我是子进程，我的 PID：12346，我的父进程 PID：12345 子进程执行完毕，即将退出 进程 12346 执行结束 父进程：子进程已退出，我也即将退出 进程 12345 执行结束

4. 关键解读：fork 调用前，只有一个进程执行；fork 调用后，父子进程并行执行（执行顺序由内核调度决定，可能父进程先执行，也可能子进程先执行）；父进程通过 wait(NULL) 等待子进程退出，避免子进程成为僵尸进程。

示例 2：进阶用法——父子进程修改内存数据（验证写时复制）

通过修改全局变量，验证写时复制机制——初始时父子进程共享全局变量，修改后各自拥有独立的副本，互不影响。

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>

int global_var = 10; // 全局变量，初始值为 10

int main() {
    pid_t pid = fork();

    if (pid == -1) {
        perror("fork 失败");
        return 1;
    }

    // 子进程：修改全局变量
    if (pid == 0) {
        printf("子进程：修改前 global_var = %d\n", global_var);
        global_var = 20; // 触发写时复制
        printf("子进程：修改后 global_var = %d（子进程独立副本）\n", global_var);
    }

    // 父进程：读取全局变量，不修改
    else {
        sleep(1); // 等待子进程完成修改，确保观察到差异
        printf("父进程：global_var = %d（未修改，保持原值）\n", global_var);
    }

    return 0;
}

预期结果：

子进程：修改前 global_var = 10
子进程：修改后 global_var = 20（子进程独立副本）
父进程：global_var = 10（未修改，保持原值）

解读：子进程修改全局变量时，触发写时复制，内核为子进程分配新的物理内存页，复制原变量内容并修改，父进程的全局变量仍保持原值，证明父子进程的内存空间在修改后相互独立。

五、fork 的常见问题与注意事项

使用 fork 时，容易出现僵尸进程、父子进程执行顺序混乱、资源泄漏等问题，以下是最常见的问题及解决方案，也是实操中必须注意的点。

（一）问题 1：子进程成为僵尸进程

僵尸进程（Z 状态）是子进程执行完毕后，父进程未调用 wait() 或 waitpid() 函数回收其 PCB 资源导致的。如果父进程长期不回收，子进程会一直残留 PID，耗尽系统 PID 资源。

解决方案：

1. 父进程主动调用 wait(NULL)：等待任意子进程退出，回收其资源（如示例 1 所示），但会阻塞父进程，直到子进程退出。

2. 父进程调用 waitpid(pid, NULL, 0)：指定等待某个特定 PID 的子进程，更灵活，可避免阻塞（通过设置选项 WNOHANG 实现非阻塞等待）。

3. 父进程先于子进程退出：此时子进程会被 init 进程（PID=1）接管，init 进程会自动回收子进程资源，不会产生僵尸进程。

（二）问题 2：父子进程的执行顺序不确定

fork 调用后，父子进程处于就绪态，由内核调度器决定哪个进程先获得 CPU 时间片，执行顺序不确定，可能导致程序运行结果不一致（如依赖顺序的操作会出错）。

解决方案：通过 sleep() 函数设置延迟（如示例 2 中父进程 sleep(1)），或使用信号量、管道等进程间通信机制，控制父子进程的执行顺序。

（三）问题 3：fork 失败的常见原因及排查

fork 返回 -1 时，常见失败原因及排查方法：

1. 系统进程数达到上限：执行 ulimit -u 查看当前用户允许创建的最大进程数，若已达到上限，可通过 ulimit -u 10240（临时生效）调整。

2. 内存或 swap 空间不足：执行 free -h 查看内存和 swap 使用情况，若 swap 已用尽，需释放内存或扩大 swap 分区。

（四）其他注意事项

fork 后，父子进程共享文件描述符，但各自拥有独立的文件偏移指针，修改偏移指针会相互影响（如父子进程同时写入同一个文件，需注意同步）。

子进程会继承父进程的信号处理方式，但 SIGCHLD 信号（子进程退出时发送给父进程）会被重置为默认处理方式（忽略）。

避免在循环中频繁调用 fork，否则会快速创建大量进程，耗尽系统资源，导致系统卡顿甚至崩溃。

六、fork 与 vfork 的区别（补充知识点）

除了 fork，Linux 还提供 vfork() 函数，用于创建子进程，二者功能类似，但底层实现和使用场景有明显区别，vfork 更侧重于“高效创建子进程后立即执行 exec()”的场景，具体区别如下表所示：

对比维度	fork()	vfork()
内存共享机制	采用写时复制，初始共享物理内存，修改时复制	父子进程共享所有内存空间（包括栈），无写时复制
执行顺序	父子进程并行执行，顺序由内核调度	子进程先执行，父进程阻塞，直到子进程调用 exec() 或 _exit()
安全性	安全，父子进程内存独立，修改数据互不影响	不安全，子进程修改内存会直接影响父进程，易导致父进程崩溃
使用场景	通用场景，适合子进程需要修改内存数据的情况	仅适合子进程创建后立即执行 exec() 的场景（如 shell 命令执行）
兼容性	兼容性好，是推荐使用的方式	兼容性差，部分系统已弃用，不推荐使用

注意：官方推荐优先使用 fork()，避免使用 vfork()，因为 vfork() 的内存共享机制存在安全隐患，且在现代 Linux 系统中，fork() 结合写时复制的效率已接近 vfork()。

七、实操案例（巩固练习）

结合上述知识点，通过以下案例巩固 fork 的使用，覆盖核心场景：

1. 案例 1：创建多个子进程。编写程序，让父进程 fork 3 个子进程，每个子进程输出自己的 PID 和父进程 PID，父进程等待所有子进程退出后再退出。

2. 案例 2：排查僵尸进程。编写程序，父进程 fork 子进程后，不调用 wait()，执行 ps aux | grep 子进程PID，观察子进程是否处于 Z 状态，再修改程序，添加 wait() 函数，验证僵尸进程是否被回收。

3. 案例 3：验证写时复制。修改示例 2 的代码，让父进程和子进程分别修改全局变量和局部变量，观察二者的修改是否相互影响，加深对写时复制的理解。

八、总结

本节课重点讲解了 fork 函数的核心知识点，核心要点总结如下：

fork 的核心功能：创建子进程，子进程是父进程的副本，一次调用、两次返回，通过返回值区分父子进程。

底层机制：子进程创建时采用写时复制（COW）技术，初始共享物理内存，修改时才复制，提升效率、节省内存。

核心用法：通过 fork() 调用创建子进程，结合 getpid()、getppid() 获取进程 ID，通过 wait()/waitpid() 回收子进程资源，避免僵尸进程。

常见问题：僵尸进程、执行顺序不确定、fork 失败，需掌握对应的解决方案。

fork 是 Linux 进程编程的基础，也是后续学习进程通信、守护进程、服务器并发编程的前提。建议多在 Linux 环境中编写代码、运行测试，观察父子进程的执行逻辑和内存变化，彻底理解 fork 的本质。下一篇笔记，我们将讲解进程间通信的核心方式，进一步拓展进程相关的知识点。

转载自CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/2402_88401748/article/details/160089830