Linux进程创建机制：fork与exec原理详解(学习笔记)

2026-03-30

为什么Linux的进程不能自己创建进程？

当你启动一个应用程序时，背后可能涉及多个进程的协同工作。例如 Electron 应用（如 Discord）采用多进程架构，后台会启动多个进程相互通信。

但你是否想过：一个进程 P1 想要创建新进程 P2，需要做什么？

内存隔离铁律

现代操作系统有一个核心原则：每个用户进程都被限制在操作系统分配的特定内存区域内。这个区域称为进程的地址空间（Address Space）。

┌─────────────────────────────────────┐
│           进程 P1 的地址空间          │
│  ┌─────────────────────────────┐   │
│  │         代码段              │   │
│  ├─────────────────────────────┤   │
│  │         数据段              │   │
│  ├─────────────────────────────┤   │
│  │         堆                  │   │
│  ├─────────────────────────────┤   │
│  │         栈                  │   │
│  └─────────────────────────────┘   │
│                                     │
│  ← P1 无法访问此区域 →               │
│                                     │
│  ┌─────────────────────────────┐   │
│  │      其他进程的地址空间      │   │
│  └─────────────────────────────┘   │
└─────────────────────────────────────┘

关键问题：虽然 P1 可以把 P2 的可执行文件从磁盘读入自己的内存，但 P1 无法将该代码放置到其地址空间之外的不同内存区域。即使那块内存当前没有被任何其他进程使用。

这意味着：

进程无法完全靠自己创建一个全新的进程
进程创建必须在内核态完成，不能完全在用户空间处理

系统调用：用户空间与内核空间的桥梁

什么是系统调用（System Call）？

系统调用是操作系统提供的 API，允许用户进程请求执行它们自身不被允许执行的操作。

系统调用的特点：

在用户空间被调用
在内核空间执行
通常以 C/C++ 函数的形式暴露

系统调用可以处理的操作：

硬件访问：从磁盘读取文件、将字符写入屏幕
操作系统服务：检索系统信息、进程间通信、进程管理

用户空间                    内核空间
┌──────────┐               ┌──────────┐
│  用户程序 │ ──系统调用──→ │  操作系统 │
│          │ ←──返回值──── │   内核    │
└──────────┘               └──────────┘

Windows vs Unix/Linux 的不兼容性

每个操作系统都有自己的设计理念，这导致不兼容的 API：

Windows：CreateProcess()
Unix/Linux：fork() + exec()

Windows 的进程创建方式

CreateProcess() 系统调用

Windows 提供了一个专门用于创建新进程的系统调用：

// Windows 的进程创建方式
BOOL CreateProcessA(
    LPCSTR lpApplicationName,    // 可执行文件的完整路径
    LPSTR lpCommandLine,         // 命令行参数字符串
    // ... 其他参数
);

参数说明

参数	作用
`lpApplicationName`	要运行程序的可执行文件完整路径，操作系统据此在磁盘上找到并加载程序
`lpCommandLine`	完整的命令行字符串，包括传递给新进程的任何参数

CreateProcess() 的工作流程

操作系统在磁盘上找到指定的可执行文件
为新进程分配一块空闲的内存区域
将可执行代码加载到那块内存
执行所有必要步骤，将进程插入调度器
传递命令行字符串，使新进程可以解析启动参数

直观理解

Windows 的方式很直观：

告诉操作系统："用这个可执行文件创建一个新进程"
操作系统完成所有工作

Unix/Linux 的进程创建方式

Unix/Linux 的方式看起来很奇怪：fork() 没有任何参数，而 exec() 才是加载可执行文件的系统调用。

两种系统调用的组合

系统调用	参数	作用
`fork()`	无参数	克隆调用它的进程
`exec()`	有参数	替换调用进程内当前运行的程序

核心设计理念：

在 Unix/Linux 系统上，创建新进程的唯一方法就是克隆现有进程。

fork() 详解：克隆整个进程

fork() 的行为

当操作系统收到 fork() 请求时，它会克隆调用它的进程：

┌─────────────────────────────────────────────────┐
│                  fork() 调用                     │
└─────────────────────────────────────────────────┘
                        │
          ┌─────────────┴─────────────┐
          ▼                           ▼
   ┌─────────────┐            ┌─────────────┐
   │   父进程     │            │   子进程     │
   │ (原进程)     │            │ (克隆体)     │
   └─────────────┘            └─────────────┘

被克隆的内容

被克隆的内容	说明
整个地址空间	代码段、数据段、栈、堆
进程上下文	包括 CPU 状态（寄存器、程序计数器等）

几乎所有内容都被复制，但有一个例外

❌ 进程 ID 不被复制（必须保持唯一）

代码示例：观察 fork() 的行为

#include <stdio.h>
#include <unistd.h>

int main() {
    int i = 0;
    
    // 第一个循环：fork 之前
    for (i = 0; i < 5; i++) {
        printf("%d\n", i);
        sleep(1);
    }
    
    // 调用 fork
    pid_t pid = fork();
    
    // 第二个循环：fork 之后
    for (i = 0; i < 5; i++) {
        printf("[PID %d] %d\n", getpid(), i);
        sleep(1);
    }
    
    return 0;
}

运行结果分析

观察点：调用 fork() 之前，行为正常；调用之后，输出变成了两份。

原因：子进程继承了父进程的 CPU 状态，包括在 fork 被调用那一刻的程序计数器。因此，父进程和子进程都会从 fork() 调用之后的下一条指令开始继续执行。

fork() 调用点
     │
     ├──→ 父进程：继续执行，程序计数器指向下一条指令
     │
     └──→ 子进程：也继续执行，程序计数器指向同一位置（不是程序开头！）

fork() 的返回值

调用者	fork() 返回值
父进程	新创建的子进程的 PID（正整数）
子进程	0
调用失败	-1

这是区分父进程和子进程的关键！

fork() 炸弹示例：连续调用 fork()

fork();
fork();
fork();

执行分析：

初始: 1 个进程
  │
  ├─fork()→ 2 个进程
  │            │
  │            ├─fork()→ 2 个进程 (共 4 个)
  │            │
  │            └─fork()→ 2 个进程 (共 4 个)
  │
  └─fork()→ 2 个进程
               │
               ├─fork()→ 2 个进程 (共 4 个)
               │
               └─fork()→ 2 个进程 (共 4 个)

最终: 8 个进程

运行结果：消息被打印了 8 次，每个进程每秒打印一次。

安全警告：这种模式被称为"fork 炸弹"，恶意使用会导致系统资源耗尽。现代系统通常通过 ulimit 限制单个用户可创建的进程数来防御此类攻击。

exec() 详解：替换当前程序

exec() 族函数

Unix/Linux 提供了一个 exec() 族函数，其中一个变体是 execv()：

int execv(const char *path, char *const argv[]);

参数说明

参数	作用
`path`	要运行的可执行文件的路径
`argv`	C 字符串指针数组，定义传递给新程序的命令行参数

execv() 的实际意义

execv() 用于将一个进程正在执行的程序替换为另一个程序。

命令行到系统调用的转换

终端命令：

program arg1 arg2 arg3

对应的系统调用：

char *args[] = {"program", "arg1", "arg2", "arg3", NULL};
execv("/path/to/program", args);

execv() 到底做了什么？

重要：execv() 不会创建新进程！它会：

在磁盘上定位指定的可执行文件
彻底重置调用进程：
- 栈被重置
- 堆被清空
- 代码段和数据段的内容被丢弃
- CPU 状态被重置
将新的可执行文件加载到内存
程序计数器被重置，指向新程序的第一条指令
参数列表加载到特定内存段，供新程序访问

调用 execv() 之前:
┌─────────────────────────────────────┐
│  进程正在执行: 程序 A                │
│  程序计数器 → 程序 A的第N条指令      │
└─────────────────────────────────────┘
                  │
                  │ execv("chrome", args)
                  ▼
┌─────────────────────────────────────┐
│  进程仍然存在，但正在执行: 程序 B     │
│  程序计数器 → 程序 B的第一条指令      │
└─────────────────────────────────────┘

代码示例：观察 execv() 的行为

#include <stdio.h>
#include <unistd.h>

int main() {
    printf("Before execv: This is the original program.\n");
    
    char *args[] = {"google-chrome", "--new-window", "https://example.com", NULL};
    execv("/usr/bin/google-chrome", args);
    
    // 这行永远不会执行！
    printf("After execv: This will never be printed.\n");
    
    return 0;
}

运行结果

Before execv: This is the original program.
[程序变成 Google Chrome]
[最后那条 printf 永远不会被执行]

原因：一旦 execv() 成功执行，当前程序被完全替换，执行永远不会到达调用之后的任何代码。

fork() + exec()：Unix/Linux 的标准模式

核心问题

fork() 克隆进程，但不知道要运行什么程序
exec() 运行程序，但不创建新进程

解决方案：fork-exec 模式

如果一个进程先调用 fork()，让操作系统克隆它，然后只有克隆出来的进程调用 exec() 用目标程序替换自己，而原进程继续运行，会怎么样？

这就是 Unix/Linux 上进程创建的标准模式！

完整的工作流程

1. 父进程调用 fork()
       │
       ▼
2. 操作系统克隆父进程，创建子进程
       │
       ├──────────────────┬──────────────────┐
       ▼                  ▼                  │
   ┌─────────┐       ┌─────────┐             │
   │  父进程  │       │  子进程  │             │
   │ (保持不变)│       │ (将改变) │             │
   └─────────┘       └─────────┘             │
       │                  │                  │
       │                  ▼                  │
       │           ┌─────────────┐           │
       │           │ 调用 exec()  │           │
       │           │ 替换为新程序 │           │
       │           └─────────────┘           │
       │                  │                  │
       ▼                  ▼                  │
   ┌─────────┐       ┌─────────┐             │
   │ 继续执行 │       │ 执行新程序│             │
   │ 原程序   │       │          │             │
   └─────────┘       └─────────┘             │

完整代码示例

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

int main() {
    printf("Parent process PID: %d\n", getpid());
    
    pid_t pid = fork();
    
    if (pid < 0) {
        // fork 失败
        perror("fork failed");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程：执行新程序
        printf("Child process PID: %d, Parent PID: %d\n", getpid(), getppid());
        
        char *args[] = {"ls", "-l", NULL};
        execv("/bin/ls", args);
        
        // execv 成功则不会执行到这里
        perror("execv failed");
        exit(EXIT_FAILURE);
    } else {
        // 父进程：等待子进程结束
        printf("Parent waiting for child %d\n", pid);
        int status;
        waitpid(pid, &status, 0);
        
        if (WIFEXITED(status)) {
            printf("Child process %d exited with status %d\n", pid, WEXITSTATUS(status));
        }
    }
    
    return 0;
}

为什么这样设计？

Unix/Linux 采用 fork-exec 模式的核心优势：

灵活的环境配置：父进程在 fork() 之前可以：
- 配置环境变量（setenv()）
- 设置进程权限（setuid(), setgid()）
- 准备文件描述符/IO 重定向（dup2()）
- 设置资源限制（setrlimit()）
- 传递必要的上下文信息
管道和重定向的实现：Shell 中的管道（|）和重定向（>, <）正是利用了这一特性：
```
ls -l | grep txt > output.txt
```
Shell 在 fork() 后、exec() 前修改子进程的文件描述符，实现数据流的连接。
进程间通信的建立：父进程可以在 fork() 前创建管道、共享内存等 IPC 机制，子进程自动继承这些资源。

然后子进程继承这些配置，再通过 exec() 加载实际要运行的程序。

如何区分父进程与子进程

方法一：使用 fork() 的返回值

fork() 的返回值已经告诉我们是父进程还是子进程：

pid_t pid = fork();

if (pid > 0) {
    // 父进程：pid 是子进程的 ID
    printf("I am parent, child PID = %d\n", pid);
} else if (pid == 0) {
    // 子进程：pid 是 0
    printf("I am child, my PID = %d\n", getpid());
}

方法二：使用 getpid() 获取当前进程 ID

#include <unistd.h>

pid_t original_pid = getpid();

pid_t pid = fork();

pid_t current_pid = getpid();

if (current_pid == original_pid) {
    // 仍然是原始进程（父进程）
} else {
    // 这是子进程
}

条件分支的逻辑

fork();

if (pid != 0) {
    // 代码在父进程中运行
} else {
    // 代码在子进程中运行
}

fork() 调用点
     │
     ├──→ pid > 0：父进程执行 if 分支
     │
     └──→ pid = 0：子进程执行 else 分支

popen() 函数与 fork-exec 模式

popen() 是什么？

popen() 是一个符合 POSIX 标准的函数，用于生成新进程。但它不是系统调用。

popen() 的内部实现

从概念上讲，popen() 的实现如下：

FILE *popen(const char *command, const char *type) {
    // 1. 创建子进程
    pid_t pid = fork();
    
    if (pid == 0) {
        // 2. 子进程：执行命令
        execl("/bin/sh", "sh", "-c", command, NULL);
        _exit(127);  // exec 失败时退出
    }
    
    // 3. 父进程：返回文件指针
    // ... 处理管道的设置 ...
    
    return fp;
}

结论：popen() 在内部正是使用了 fork() + exec() 的模式。

进程树：追溯第一个进程

进程树的概念

在 Unix/Linux 系统上，所有用户进程都是由其他用户进程创建的。这意味着父进程也是由另一个进程创建的，形成一个进程树。

追溯根进程

pstree

或者

ps -ef

输出会显示类似：

systemd(1)─┬─sshd(1234)───sshd(5678)───bash(5679)───pstree(8901)
           ├─nginx(2345)───nginx(2346)
           └─...

根进程：从何而来？

所有用户进程都是由其他用户进程创建的，那第一个进程是怎么出现的？

答案：PID 为 1 的进程（通常是 systemd 或 init）是内核直接启动的。这是理解内核和操作系统界限的关键。

单个进程可以衍生出整个进程子系统，从而实现更宏大的目标。

回答开头的问题

当你启动 Discord 时：

你启动了一个可执行文件，它变成一个进程
这个进程的主要目的是衍生出多个协同工作的进程
这些进程让应用程序按我们熟悉的方式运行

常见陷阱与最佳实践

1. 僵尸进程（Zombie Process）

子进程结束后，如果父进程不调用 wait() 或 waitpid()，子进程会变成僵尸进程：

// 错误示例：不回收子进程
pid_t pid = fork();
if (pid == 0) {
    exit(0);  // 子进程退出
}
// 父进程继续运行，不调用 wait()
// 子进程变成僵尸进程 <defunct>

问题：

僵尸进程占用进程表项（PID）
大量累积会导致无法创建新进程
使用 ps aux 可以看到状态为 Z 的进程

解决方案：

// 正确做法：回收子进程
int status;
waitpid(pid, &status, 0);  // 阻塞等待
// 或
waitpid(pid, &status, WNOHANG);  // 非阻塞检查

2. 孤儿进程（Orphan Process）

父进程先于子进程结束，子进程会被 init（PID 1）收养：

pid_t pid = fork();
if (pid == 0) {
    sleep(10);  // 子进程睡眠
    printf("Parent PID: %d\n", getppid());  // 会显示 1
    exit(0);
}
// 父进程立即退出
exit(0);

特点：

init 进程会自动回收孤儿进程
通常不会造成资源泄漏问题
某些守护进程（daemon）故意利用这一特性

3. exec() 失败处理

exec() 成功后不会返回，如果返回说明调用失败：

// 错误示例：没有错误处理
if (fork() == 0) {
    execv("/bin/ls", args);
    // 如果 exec 失败，子进程会继续执行父进程的代码！
}

// 正确做法：必须处理失败情况
if (fork() == 0) {
    execv("/bin/ls", args);
    perror("execv failed");
    exit(EXIT_FAILURE);  // 确保子进程退出
}

4. 文件描述符泄漏

fork() 会复制所有打开的文件描述符：

int fd = open("file.txt", O_RDONLY);

pid_t pid = fork();
if (pid == 0) {
    // 子进程也有 fd 的副本
    // 如果不需要，应该关闭
    close(fd);
    execv("/bin/program", args);
}

最佳实践：

使用 O_CLOEXEC 标志：open("file.txt", O_RDONLY | O_CLOEXEC)
或使用 fcntl() 设置 FD_CLOEXEC 标志
exec() 时会自动关闭带有 CLOEXEC 标志的文件描述符

5. 信号处理

子进程继承父进程的信号处理器，但 exec() 会重置信号处理：

signal(SIGINT, custom_handler);  // 设置信号处理器

pid_t pid = fork();
if (pid == 0) {
    // 子进程继承了 custom_handler
    execv("/bin/program", args);
    // exec 成功后，SIGINT 恢复为默认处理
}

扩展阅读

写时复制（Copy-on-Write, COW）

早期 fork() 实现会完整复制父进程的内存，开销巨大。现代系统采用写时复制优化：

fork() 后父子进程共享相同的物理内存页
内存页被标记为只读
当任一进程尝试写入时，触发页错误（page fault）
操作系统复制该内存页，让两个进程各有一份

优势：

大幅减少 fork() 的开销
如果子进程立即调用 exec()，避免了不必要的内存复制

vfork() 系统调用

vfork() 是专门为 fork-exec 模式设计的优化版本：

pid_t pid = vfork();
if (pid == 0) {
    execv("/bin/program", args);
    _exit(1);  // 必须使用 _exit，不能用 exit
}

特点：

子进程直接使用父进程的地址空间（不复制）
父进程被挂起，直到子进程调用 exec() 或 _exit()
更高效，但更危险（子进程修改会影响父进程）

注意：现代系统有 COW 优化后，vfork() 的性能优势已不明显，不推荐使用。

clone() 系统调用

Linux 提供了更底层的 clone() 系统调用，可以精确控制父子进程共享哪些资源：

int clone(int (*fn)(void *), void *stack, int flags, void *arg);

可控制的资源：

CLONE_VM：共享内存空间
CLONE_FILES：共享文件描述符表
CLONE_SIGHAND：共享信号处理器
CLONE_THREAD：创建线程而非进程

关系：

fork() 是 clone() 的封装
pthread_create() 也是基于 clone() 实现的

posix_spawn() 函数族

POSIX 标准提供了 posix_spawn() 作为 fork-exec 的替代方案：

#include <spawn.h>

pid_t pid;
char *argv[] = {"ls", "-l", NULL};
posix_spawn(&pid, "/bin/ls", NULL, NULL, argv, environ);

优势：

一次调用完成进程创建
在某些系统上性能更好
更容易移植到不支持 fork() 的系统

总结对比

特性	Windows	Unix/Linux
系统调用	`CreateProcess()`	`fork()` + `exec()`
参数传递	单个命令行字符串	参数数组
进程创建方式	请求内核直接创建	先克隆自身，再替换程序
设计理念	一步到位	分两步：克隆 + 替换
父进程干预	可在参数中传递配置	可在 fork 前配置环境

fork-exec 模式的哲学

┌────────────────────────────────────────────────────────┐
│  Unix/Linux 的设计哲学                                  │
├────────────────────────────────────────────────────────┤
│                                                        │
│  fork() = "复制我"                                     │
│           ↓                                            │
│  操作系统：克隆整个进程上下文                            │
│           ↓                                            │
│  exec() = "变成这个程序"                                │
│           ↓                                            │
│  操作系统：丢弃旧程序，加载新程序                        │
│                                                        │
│  优势：父进程可以在 fork 前配置子进程的环境              │
│       （环境变量、权限、文件描述符等）                   │
│                                                        │
└────────────────────────────────────────────────────────┘

核心要点

Linux 的 fork-exec 模式虽然看起来"绕弯"，但提供了极大的灵活性：

分离关注点：进程创建（fork）和程序加载（exec）是两个独立的操作
灵活配置：在两步之间可以进行各种环境配置
Unix 哲学：提供简单、正交的工具，让它们可以灵活组合完成复杂任务
实际应用：Shell 的管道、重定向等功能都依赖这一机制