前言
在 Linux 上写并发程序,绕不开两条路线:一条是多进程 ,用 fork、exec、waitpid 这些 POSIX 原语把工作拆到彼此隔离的地址空间里;另一条是多线程 ,用 POSIX 线程或 C++11 的 std::thread,让多个执行流共享同一份内存。这两个模型经常被放在一起讲,但它们的语义差别很大,混着用的时候尤其容易出错。
常见的误解有三个。第一,以为 fork 之后父子进程共享变量------实际上 fork 复制的是地址空间,父子各自修改自己的副本,只有打开的文件描述符(更准确地说,是它指向的 open file description)是共享的。第二,以为多线程之间「自动」保持数据一致------共享内存加上没有同步的读写就是数据竞争(data race),按标准是未定义行为(undefined behavior, UB),不是「结果偶尔不对」这么轻。第三,以为线程一定比进程快------线程省掉了地址空间切换,但同步开销、缓存一致性、调试难度都要单独算账。
本文先讲 fork 和 std::thread 各自的机制与边界,再给一个把两者放在同一个程序里的完整例子:父进程用管道接收子进程的消息并回收它,随后启动若干线程做求和。例子只使用 Linux/POSIX 接口,编译时需要链接线程库。
一、进程:fork 到底复制了什么
fork 调用一次、返回两次。父进程里返回子进程的 PID,子进程里返回 0,失败返回 -1 并设置 errno。子进程从 fork 返回的那一行继续执行,和父进程走同一段代码,靠返回值分叉。
被复制的东西包括:地址空间(代码、数据、堆、栈)、文件描述符表、信号处理设置、当前工作目录、用户与组 ID。现代内核用写时复制(copy-on-write)实现地址空间的复制,fork 刚返回时父子指向同一批物理页,任何一方写入才触发复制。所以「复制了整个地址空间」在语义上成立,在成本上并不是立刻拷贝一遍。
文件描述符表被复制,但表项指向的 open file description 是共享的。这意味着父子进程对同一个管道写端调用 write,数据会追加到同一个流里,文件偏移也是共享的。这一点常被用来做父子协作,也常导致「以为各自独立」的错误。
fork 之后通常跟 exec,用新程序的映像替换当前进程。fork 加 exec 是 shell 启动命令的标准做法:先复制出一个进程,再在子进程里换上目标程序。
子进程结束后不会自动消失,要由父进程调用 wait 或 waitpid 回收,否则它变成僵尸进程(zombie),占着进程表项。父进程先于子进程退出时,子进程被 init 或 subreaper 收养。waitpid 的第二个参数带回状态,要用 WIFEXITED、WEXITSTATUS 这类宏解析,不能直接把状态当退出码。
还有一个容易忽略的限制:在多线程程序里调用 fork,子进程只保留调用 fork 的那个线程 。POSIX 规定,从 fork 返回到 exec 之间,子进程只能调用异步信号安全(async-signal-safe)的函数。malloc、printf、std::cout 都不在安全列表里------它们可能锁住一把在别的线程里已被持有、且再也不会释放的锁。所以子进程里应该用 write 写字节,用 _exit 退出,而不是 exit(后者会刷新并可能加锁 stdio 缓冲)。
二、线程:共享地址空间带来的自由与责任
std::thread 在 <thread> 中,C++11 起可用。创建一个线程就是把一个可调用对象交给它,线程开始执行后与创建者并发运行。同一进程内的线程共享地址空间、堆、全局变量、静态变量和文件描述符;每个线程有自己的栈、寄存器上下文和线程局部存储。
共享是效率的来源,也是错误的来源。两个线程同时对同一个 int 做非原子的读改写,就是数据竞争。标准对数据竞争的定义很明确:两个线程访问同一内存位置,至少一个是写,且没有同步关系。后果是 UB,编译器可以假设它不存在,从而做出让源代码看起来「不可能是这个结果」的优化。
保护共享数据的常规手段是互斥量。std::mutex 配 std::lock_guard 是最小组合:构造时加锁,析构时解锁,异常路径也能正确释放。需要中途解锁或配合条件变量时用 std::unique_lock。同时需要多把锁时,用 C++17 的 std::scoped_lock 一次锁住多个互斥量,避免两个线程以相反顺序加锁造成死锁。
线程对象的生命周期必须管理好。std::thread 析构时如果仍处于 joinable 状态,标准要求调用 std::terminate。所以每个线程要么 join()(等待结束),要么 detach()(分离,之后不能再 join)。分离的线程如果访问了已经销毁的对象,同样是 UB,所以 detach 要慎用,通常只在确认线程的生命周期不依赖调用者时使用。
三、怎么选:进程还是线程
| 维度 | 多进程 | 多线程 |
|---|
|------|------------|-------|
| 地址空间 | 各自独立,默认不共享 | 共享同一份 |
|------|-----------|---------------|
| 崩溃影响 | 通常只影响单个进程 | 一个线程崩溃会带走整个进程 |
|------|---------------|------------------|
| 创建成本 | 较高,涉及页表与描述符复制 | 较低,但仍有栈分配与内核对象开销 |
|------|----------------|---------------|
| 通信方式 | 管道、共享内存、套接字、信号 | 直接读写共享变量(需同步) |
|-------|---------|---------------|
| 同步复杂度 | 较低,边界清晰 | 较高,锁与生命周期都要小心 |
|------|-----------------|-----------|
| 调试难度 | 相对容易,可单独 attach | 较难,竞态难以复现 |
|------|------------------|------------------|
| 典型场景 | 服务隔离、崩溃恢复、调用外部程序 | 并行计算、I/O 复用、共享缓存 |
一个实用的判断是:需要故障隔离 或权限隔离 时用进程;需要频繁共享大量数据 时用线程。两者也可以组合,比如主进程管理多个工作进程,每个工作进程内部再用线程池。但要注意上面说的 fork 限制:不要在已经有线程的进程里随手 fork,除非子进程立刻 exec。
四、完整示例:管道 + 进程回收 + 线程求和
下面的程序先 fork,子进程往管道写一行消息后用 _exit 退出;父进程读管道、waitpid 回收,然后启动四个线程累加,用互斥量保护共享的累加变量。把 fork 放在创建线程之前,可以避开「多线程进程中 fork」的限制。
cpp
// 适用于 C++17,平台:Linux / POSIX
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
std::mutex g_mutex;
// 每个线程先算局部和,最后一次性并入共享结果,减少锁的持有时间
void worker(int id, long long& total) {
long long local = 0;
for (int i = 1; i <= 1000; ++i) {
local += static_cast<long long>(id) * i;
}
{
std::lock_guard<std::mutex> lock(g_mutex);
total += local;
std::cout << "thread " << id << " finished\n";
}
}
int main() {
int fds[2];
if (::pipe(fds) != 0) {
std::perror("pipe");
return 1;
}
pid_t pid = ::fork();
if (pid < 0) {
std::perror("fork");
return 1;
}
if (pid == 0) {
// 子进程:只调用 async-signal-safe 的 write/_exit
::close(fds[0]);
const char msg[] = "child: hello from a separate process\n";
ssize_t written = ::write(fds[1], msg, sizeof(msg) - 1);
(void)written;
::close(fds[1]);
::_exit(0);
}
// 父进程:关掉不用的写端,否则 read 等不到 EOF
::close(fds[1]);
char buf[128];
ssize_t n = ::read(fds[0], buf, sizeof(buf) - 1);
if (n > 0) {
buf[n] = '\0';
std::cout << "parent read: " << buf;
}
::close(fds[0]);
int status = 0;
if (::waitpid(pid, &status, 0) == pid && WIFEXITED(status)) {
std::cout << "child exit code: " << WEXITSTATUS(status) << '\n';
} else {
std::cout << "child did not exit normally\n";
}
long long total = 0;
std::vector<std::thread> pool;
pool.reserve(4);
for (int i = 1; i <= 4; ++i) {
pool.emplace_back(worker, i, std::ref(total));
}
for (std::thread& t : pool) {
t.join();
}
std::cout << "total = " << total << '\n';
return 0;
}
编译时需要开启线程支持,例如用 g++ -std=c++17 -pthread 并链接上面的源文件。这里不展示任何运行输出,因为本机没有编译环境;程序的行为应当按标准与 POSIX 语义推导。
几个关键点。std::ref(total) 是必要的:std::thread 的构造函数会按值衰减(decay-copy)实参,直接传 total 会复制一份,线程改的是副本。worker 的签名是 void(int, long long&),std::thread 支持任意可调用对象和任意参数个数,不要求 C 风格的 void* 形参。父进程必须关闭管道的写端,否则 read 会一直阻塞等待更多数据,因为内核看到还有写端打开。子进程用 _exit 而不是 exit,避免刷新从父进程继承来的缓冲、避免执行 atexit 处理器。
常见坑点
1. 忘记回收子进程
❌ fork() 之后父进程直接继续干活,从不 waitpid,子进程结束后留下僵尸。
✅ 记录 PID 并在合适位置 waitpid(pid, &status, 0);或者显式设置 SIGCHLD 的处理方式,但不要在信号处理器里做复杂工作。
2. 管道端没有全部关闭
❌ 父进程保留 fds[1] 不关,read(fds[0], ...) 永远等不到 EOF。
✅ 每一端只保留自己需要的描述符,用完立即 close;父子都要关掉不用的那一端。
3. 在多线程进程里 fork 后调用非异步信号安全的函数
❌ 子进程里执行 std::cout << "hi" 或 malloc,可能死锁在继承来的锁上。
✅ 子进程只调用 write、_exit、close 这类安全函数;需要复杂逻辑时先 exec 新程序。
4. 把栈上变量按值传给线程却以为在共享
❌ std::thread t(worker, total); 之后发现线程里的修改没有反映到外面。
✅ 明确用 std::ref(total) 传引用,或者传指针;同时确认被引用对象的生命周期覆盖线程的运行期。
5. 用 volatile 当同步手段
❌ volatile bool stop = false; 让线程轮询,认为另一个线程写 true 后一定能看到。
✅ 用 std::atomic<bool>,或者用互斥量加条件变量;volatile 不建立线程间的同步关系,也不阻止重排。
6. 线程对象析构前没有 join 或 detach
❌ 函数返回时局部的 std::thread 仍 joinable,程序调用 std::terminate。
✅ 所有路径上都 join();需要后台运行时才 detach(),并保证线程不访问已销毁的对象。
7. 用 exit 而不是 _exit 结束 fork 出的子进程
❌ 子进程调用 exit(0),刷新了继承的 stdio 缓冲,输出出现重复。
✅ fork 之后子进程用 _exit(0);只有确定没有共享缓冲问题时才用 exit。
8. 认为 fork 后父子共享普通变量
❌ 子进程修改全局变量,父进程读到的还是旧值,却以为出了 bug。
✅ 记住地址空间是复制的;需要共享数据就用共享内存(mmap 的 MAP_SHARED)或管道/套接字通信。
总结
| 主题 | 关键结论 |
|---|
|------------|---------------------------------------------|
| fork 的复制 | 地址空间写时复制,文件描述符表复制但 open file description 共享 |
|-------|-------------------------------------------------|
| 子进程回收 | 必须 wait/waitpid,否则产生僵尸;状态用 WIFEXITED 等宏解析 |
|------------|------------------------|
| 多线程 fork | 子进程只剩调用线程,只能调用异步信号安全函数 |
|------|-----------------------|
| 线程共享 | 共享地址空间与堆,独立栈;共享写入必须同步 |
|------|-------------------|
| 数据竞争 | 按标准是 UB,不是「结果不确定」 |
|--------|---------------------------------------------|
| 线程生命周期 | 析构前必须 join 或 detach,否则 std::terminate |
|------|-------------------|
| 选择依据 | 要隔离用进程,要频繁共享数据用线程 |
多进程和多线程不是互斥的选择,而是两种隔离粒度。把 fork 的复制语义、文件描述符的共享关系、线程的同步责任这三件事记清楚,剩下的就是按场景组合。示例代码展示的是结构,不是唯一写法;实际工程里还应加上错误处理、超时和退出协调。