Linux 进程与线程深度解析：fork()、exec()、线程原理，一次彻底搞懂

一、进程是什么：不只是"一个程序"

教科书上那句“进程是程序的一次执行”，听起来总有点隔靴搔痒，不够透彻。

免费影视、动漫、音乐、游戏、小说资源长期稳定更新！ 👉 点此立即查看 👈

在内核的视角里，事情要具体得多。一个进程，本质上就是一个名为 task_struct 的结构体。你可以把它想象成一张记录了这个执行单元所有家当的“户口本”或“档案表”。里面都记了些什么呢？

• 进程 ID（pid）、父进程 ID（ppid）
• 虚拟内存映射（mm_struct）
• 打开的文件表（files_struct）
• 信号处理表、CPU 寄存器状态
• 调度信息（优先级、运行时间片）

┌─ task_struct ─────────────────┐
│  pid = 1234                   │
│  mm      → 虚拟内存空间       │
│  files   → 文件描述符表       │
│  signals → 信号处理           │
│  regs    → CPU寄存器状态      │
│  sched   → 调度信息           │
└───────────────────────────────┘

所以，一个更精确的定义是：进程 = task_struct + 独立的虚拟地址空间。这个组合，才构成了一个完整的、能够被调度和执行的实体。

二、fork()：最快的“复制粘贴”

创建新进程，最经典的方式就是 fork()。它的行为简单直接：把当前进程（父进程）复制一份，生成一个子进程。

pid_t pid = fork();
if (pid == 0) {
    // 子进程：pid == 0
    printf("我是子进程，PID=%d\n", getpid());
} else {
    // 父进程：pid == 子进程的PID
    printf("我是父进程，子进程PID=%d\n", pid);
}

这个设计很巧妙：fork() 会返回两次，在父进程里返回子进程的 PID，在子进程里则返回 0。通过判断返回值，父子进程就能轻松地走上不同的执行路径。

但这里立刻引出一个问题：如果父进程占用了 2GB 内存，fork() 一次就要复制 2GB 吗？那像 Nginx 这样启动几十个 worker 进程的服务，内存岂不是瞬间爆炸？

当然不会。这就用到了我们上一篇提到的核心技术：写时复制（Copy-On-Write，COW）。

fork() 之后，父子进程实际上共享同一批物理内存页，内核只是将这些页的页表项标记为“只读”。当任何一个进程试图去写这些共享页时，才会触发缺页中断，此时内核才真正地为这个进程复制它所写的那一页。这就是“谁写，谁复制”。

COW 的精妙之处在于极大优化了常见场景。比如 Shell 执行命令：fork() 出一个子进程后，子进程通常会立刻调用 exec() 来加载一个新程序（如 ls）。既然要彻底换掉地址空间，那么父进程原来的那些数据页，子进程一页都不需要真正复制。fork() 的主要开销，其实就变成了复制父进程的页表，这个代价要小得多。

三、exec()：换一套衣服继续跑

fork() 复制了父进程，但子进程往往并不想“子承父业”，而是要去执行一个全新的程序。这个“变身”的步骤，就由 exec() 家族函数来完成。

exec() 调用后，进程的虚拟地址空间会被完全重置——旧的代码段、数据段、堆栈都被清空，然后装载新程序的代码和数据。不过，进程的 PID 保持不变，已经打开的文件描述符（除非设置了 O_CLOEXEC 标志）也会被继承下来。

fork() + exec() 的组合，是 Shell 执行命令的标准模式，其流程如下图所示：

这解释了为什么你在 bash 里输入 ls，执行的是 /bin/ls 而不是 bash 自己。Bash 先 fork() 出一个自己的副本（子进程），然后这个子进程调用 exec() 把自己“替换”成 ls 程序。ls 执行完毕退出后，父进程 bash 继续运行，等待你的下一条命令。

用代码来简化表示就是这个过程：

pid_t pid = fork();
if (pid == 0) {
    // 子进程：替换成 ls
    execv("/bin/ls", argv);
    // exec 成功不会返回到这里
} else {
    // 父进程：等子进程结束
    waitpid(pid, NULL, 0);
}

四、进程 vs 线程：共享的边界在哪里？

“进程和线程的区别是什么？” 这是个经典的面试题。

最核心的答案在于共享资源的范围：线程是进程内部的执行单元，同一进程下的所有线程共享该进程的虚拟地址空间。

下面这张图清晰地展示了进程与线程在资源上的共享边界：

从图中可以一目了然：进程之间是完全隔离的，各自拥有独立的代码、堆、栈和文件描述符表。而同一进程内的多个线程，则共享代码段、堆、全局变量和文件描述符表，每个线程私有的只有自己的栈、寄存器和线程 ID。

正因为共享内存，线程间通信变得异常简单——直接读写同一块内存即可，无需借助管道、消息队列等进程间通信（IPC）机制。但这也带来了副作用：一个线程如果写坏了堆上的数据，整个进程内的所有线程都会受到影响。

五、Linux 线程的真相：它和进程是同一个东西

这一点可能出乎很多人的意料：在 Linux 内核中，并没有一个独立于进程的“线程”概念。 线程，本质上就是共享了特定资源的进程。

Linux 创建线程和创建进程，使用的是同一个底层系统调用——clone()。区别仅仅在于传入的标志位（flags）不同：

// 创建进程：fork() 内部调用 clone，大部分资源不共享
clone(fn, stack, SIGCHLD, arg);

// 创建线程：pthread_create() 内部调用 clone，共享地址空间等
clone(fn, stack,
      CLONE_VM        |  // 共享虚拟内存
      CLONE_FS        |  // 共享文件系统信息
      CLONE_FILES     |  // 共享文件描述符表
      CLONE_SIGHAND   |  // 共享信号处理器
      CLONE_THREAD,      // 同一线程组
      arg);

其中，CLONE_VM 标志是关键。有了它，父子“进程”将共享同一个 mm_struct（虚拟内存描述符），也就共享了整个地址空间——这，就是我们通常所说的“线程”。去掉这个标志，父子拥有独立的地址空间——这，就是标准的“进程”。

在内核看来，它们都是 task_struct，调度器对它们一视同仁。

这个设计带来一个重要推论：Linux 的线程切换和进程切换，在内核层面本质是一样的——都是保存和恢复一个 task_struct 的上下文。线程切换之所以更快，主要是因为共享了 mm_struct，不需要切换页表，从而避免了昂贵的 TLB 刷新操作。

六、进程状态：从创建到死亡

一个进程从被 fork() 出来开始，其生命周期会经历一系列状态变迁，如下图所示：

对这些状态需要稍作说明：

• RUNNABLE ⇄ RUNNING：这是进程最活跃的状态，在就绪和运行之间高频切换，完全由调度器掌控。
• INTERRUPTIBLE（S 状态）：最常见的睡眠状态。你用 ps 命令看到的大部分睡眠进程都在这里，它们可以被信号唤醒。
• UNINTERRUPTIBLE（D 状态）：进程在等待不可中断的 I/O（如某些磁盘操作）时进入此状态。此时连 kill -9 都无法杀死它。经典的案例就是 NFS 网络文件系统挂起导致的进程“卡死”。
• ZOMBIE（Z 状态）：进程“已死未葬”。它不占用内存，但仍占用着一个 PID 资源，需要父进程来“收尸”。

这里重点说一下僵尸进程（Zombie）。子进程退出后，它的 task_struct 并不会立即释放，而是会等待父进程调用 wait() 或 waitpid() 来收集其退出状态信息。如果父进程一直不调用 wait()，子进程就会一直保持僵尸状态。僵尸进程虽然不消耗内存，但会占用有限的 PID 资源，积累过多可能导致无法创建新进程。

处理僵尸进程，通常有两种做法：

// 方案一：忽略 SIGCHLD 信号，内核自动回收僵尸子进程
signal(SIGCHLD, SIG_IGN);

// 方案二：非阻塞地 wait，收割所有已退出的子进程
waitpid(-1, NULL, WNOHANG);

七、线程创建实战

#include 
#include 

int shared_counter = 0;   // 全局变量，所有线程共享

void *worker(void *arg) {
    int id = *(int *)arg;
    // 注意：多线程操作 shared_counter 需要加锁！
    shared_counter++;
    printf("线程 %d，shared_counter = %d\n", id, shared_counter);
    return NULL;
}

int main() {
    pthread_t tid[3];
    int ids[3] = {1, 2, 3};

    for (int i = 0; i < 3; i++)
        pthread_create(&tid[i], NULL, worker, &ids[i]);

    for (int i = 0; i < 3; i++)
        pthread_join(tid[i], NULL);  // 等待所有线程结束

    return 0;
}

编译时需要链接 pthread 库：gcc -o demo demo.c -lpthread。

八、高频面试题精析

Q：fork()之后父子进程谁先执行？
A：顺序是不确定的，完全由内核调度器决定。虽然在单 CPU 上，历史上父进程被设计为先继续运行的概率更高，但这并非绝对保证。编程时绝不能依赖执行顺序，必要时需使用同步机制。

Q：Linux 线程和进程切换的开销对比？
A：线程切换省去了切换页表和刷新 TLB 的开销（因为共享 mm_struct），因此通常比进程切换更快。但两者都涉及从用户态陷入内核态、保存和恢复寄存器上下文等操作。实际测试中，线程切换的速度大约是进程切换的 2 到 5 倍。

Q：fork()之后文件描述符怎么处理？
A：子进程会继承父进程所有打开的文件描述符（包括 socket），并且它们指向内核中同一个文件表项。这正是 Nginx 的 prefork 模型中，多个 worker 进程能够共享同一个监听套接字的基础。如果不想让子进程继承某个 fd，可以在打开文件时使用 O_CLOEXEC 标志，或者在 fork() 后、exec() 前手动关闭。

Q：什么是孤儿进程？和僵尸进程有什么区别？
A：孤儿进程是指父进程先于子进程退出，此时子进程会被内核的 init 进程（或 systemd）接管，由它负责后续的 wait()。孤儿进程本身无害。
僵尸进程则是子进程先退出，但父进程没有调用 wait() 来回收，导致子进程的 task_struct 无法释放，PID 被长期占用。僵尸进程积累会消耗系统 PID 资源，影响稳定性。

Q：多线程程序里fork()是安全的吗？
A：非常危险！fork() 在调用时，只会复制调用它的那个线程，其他线程在子进程中会“瞬间消失”。如果这些消失的线程正持有某个互斥锁，那么在子进程中，这把锁就永远无法被释放了，极易导致死锁。安全的做法是：要么在 fork() 后立即调用 exec()（前提是 fork() 时不持有任何锁），要么使用 pthread_atfork() 函数来注册 fork 前后的清理回调。

九、结语

从 fork() 到 exec()，从进程到线程，这一路梳理下来，我们看到的是 Linux 内核设计中的一个核心哲学：机制复用，通过标志位控制行为。

进程和线程在底层共享同一套 task_struct 机制，仅因 clone() 的标志位不同而呈现不同形态。写时复制（COW）让进程复制变得极其轻量，而 exec() 则赋予了进程彻底蜕变的能力。

理解这些底层机制，才能真正看懂 Nginx 的 prefork 模型为何高效，才能明白为何在多线程环境中调用 fork() 需要格外小心，也才能在面对相关面试问题时，做到条理清晰，直击本质。