23、多线程与fork：当fork遇上线程

说实话，多线程和fork的组合，是我在系统编程中踩过最深的坑之一。记得我刚接触Linux多线程编程那会儿，总觉得fork和线程就像油和水——强行混在一起，迟早要出问题。后来在实际项目中，我确实因为这个问题导致过一个线上服务莫名其妙地死锁，排查了整整两天才找到根因。

今天我们就来聊聊这个话题。它不复杂，但细节很多。你想想看，一个进程里跑着好几个线程，突然调了个fork()，新进程里到底有几个线程？锁的状态是什么样的？文件描述符怎么继承？这些问题，搞不清楚就会出大乱子。

fork在线程环境中的行为

先看最核心的问题：在多线程程序中调用fork，新进程里只有调用fork的那个线程。其他线程全部消失，就像从来没存在过一样。

为什么会这样？因为fork的设计初衷是复制整个进程，但线程是轻量级进程，内核在实现fork时只复制调用线程的上下文。其他线程的资源（栈、寄存器状态）虽然还在内存里，但新进程里没有对应的线程来管理它们了。

来看个例子：

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* thread_func(void* arg) {
    pthread_mutex_lock(&mutex);
    printf("子线程拿到了锁，开始睡觉...\n");
    sleep(5);  // 模拟长时间持有锁
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);
    
    // 确保子线程先拿到锁
    sleep(1);
    
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        printf("子进程尝试拿锁...\n");
        pthread_mutex_lock(&mutex);  // 这里会死锁！
        printf("子进程拿到了锁\n");
        pthread_mutex_unlock(&mutex);
        exit(0);
    }
    
    pthread_join(tid, NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

这段代码跑起来，子进程会卡死在pthread_mutex_lock上。为什么？因为子进程里只有main线程，而锁是被那个不存在的子线程持有的。说白了，这把锁永远没人能释放了。

pthread_atfork的使用

那有没有办法解决这个问题？有的。POSIX提供了pthread_atfork函数，它允许你在fork前后注册回调函数，用来处理锁的状态。

int pthread_atfork(void (*prepare)(void), 
                   void (*parent)(void), 
                   void (*child)(void));

三个参数分别是：

• prepare：在fork之前调用，通常用来获取所有锁
• parent：在fork之后、父进程中调用，用来释放prepare中获取的锁
• child：在fork之后、子进程中调用，同样用来释放prepare中获取的锁

我个人的习惯是，在程序初始化时就注册好pthread_atfork。这样后续不管在哪里调用fork，都能保证锁的状态是干净的。

改进后的代码：

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void prepare_handler() {
    printf("prepare: 获取所有锁\n");
    pthread_mutex_lock(&mutex);
}

void parent_handler() {
    printf("parent: 释放锁\n");
    pthread_mutex_unlock(&mutex);
}

void child_handler() {
    printf("child: 释放锁\n");
    pthread_mutex_unlock(&mutex);
}

void* thread_func(void* arg) {
    // 子线程啥也不干，就等着
    sleep(3);
    return NULL;
}

int main() {
    // 注册fork处理器
    pthread_atfork(prepare_handler, parent_handler, child_handler);
    
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);
    
    sleep(1);
    
    pid_t pid = fork();
    if (pid == 0) {
        printf("子进程可以正常使用锁了\n");
        pthread_mutex_lock(&mutex);
        printf("子进程拿到了锁\n");
        pthread_mutex_unlock(&mutex);
        exit(0);
    }
    
    pthread_join(tid, NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

fork与线程的混合使用注意事项

我在项目中总结了几条铁律，分享给你：

1. 能不混用就别混用。多线程程序里需要创建子进程？考虑用pthread_create代替fork，或者用线程池。
2. 如果非要用fork，在fork之后立即调用exec。exec会重置进程地址空间，所有锁、线程状态都会被清掉，一了百了。
3. 不要在信号处理器里调用fork。信号处理器本身就在一个不确定的上下文中运行，再搞个fork，后果不可预测。
4. 注意文件描述符的继承。子进程会继承父进程的所有文件描述符，包括那些被其他线程打开的。如果多个线程同时操作同一个文件描述符，会出现竞争。

我曾经在一个网络服务器项目里遇到过这样的问题：主线程监听连接，工作线程处理请求。某个版本里我加了个fork来创建日志子进程，结果工作线程正在写的日志文件描述符被复制到了子进程里，导致日志文件被两个进程同时写，内容全乱了。嗯，从那以后我再也不敢在复杂线程环境里随便fork了。

多线程进程的exec行为

exec系列函数（execl、execv、execle、execve等）会完全替换当前进程的地址空间。这意味着：

• 所有线程都被销毁（只剩下调用exec的那个线程）
• 所有锁、条件变量、线程局部存储都被清空
• 信号处理器恢复为默认
• 内存映射、共享内存区域被卸载

说白了，exec之后，你得到了一个全新的进程。之前的多线程状态全部归零。

但有几个东西会保留：

• 进程ID（PID）不变
• 打开的文件描述符（除非设置了FD_CLOEXEC）
• 进程当前工作目录
• 环境变量

所以，我的建议是：在调用exec之前，确保所有线程都已经退出，或者至少没有持有任何锁。最稳妥的做法是，只在主线程里调用exec，并且确保其他线程已经join或者detach了。

知识体系总览

下面这张图总结了多线程与fork的核心关系，我把它画成了流程图，方便你理解：

这张图把整个知识脉络串起来了。从父进程fork出子进程，子进程面临锁和文件描述符的问题，再到pthread_atfork和exec两种解决方案，一目了然。

最后总结一句：多线程 + fork = 麻烦。能不用就不用，实在要用，记得用pthread_atfork兜底，或者fork后立即exec。这是我在无数次踩坑后得出的血泪教训。

---

公众号:蓝海资料掘金营，微信deep3321