13、多进程并发服务器：使用 fork() 创建子进程处理多个客户端连接

说实话，单进程的服务器就像只有一个收银员的超市——来了第二个客户就得排队等着。这在生产环境里根本没法用。我早年刚接触网络编程时，就天真地写过一个单进程回显服务器，结果同事一测试，连开三个客户端，第三个直接超时了。嗯，从那以后我就明白了：并发，是服务器的基础素养。

这一章，我们来聊聊最经典的并发模型——多进程。用 fork() 为每个客户端创建一个子进程，各管各的，互不干扰。简单、粗暴、有效。

13.1 多进程模型的核心思想

说白了，就是主进程负责监听和接受连接。每来一个客户端，主进程就 fork() 出一个子进程，把新连接的套接字交给子进程去处理。子进程处理完就退出，主进程继续等下一个。

你想想看，这就像一家餐厅：老板（主进程）在门口迎客，每来一桌客人，就喊一个服务员（子进程）过来：「这桌你负责，伺候好了。」服务员领走客人，全程服务，直到客人离开。老板则继续在门口等下一波客人。

13.2 代码实现：一个多进程回显服务器

直接上代码。我个人习惯把核心逻辑拆成三步：创建套接字、绑定监听、循环 accept + fork。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <signal.h>

#define PORT 8888
#define BUFFER_SIZE 1024

// 处理僵尸进程的信号处理函数
void sigchld_handler(int sig) {
    while (waitpid(-1, NULL, WNOHANG) > 0);
}

int main() {
    int server_fd, client_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[BUFFER_SIZE];

    // 1. 创建套接字
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        exit(1);
    }

    // 设置端口复用，避免重启时 "Address already in use"
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 2. 绑定地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        exit(1);
    }

    // 3. 监听
    if (listen(server_fd, 10) < 0) {
        perror("listen");
        close(server_fd);
        exit(1);
    }

    printf("服务器已启动，监听端口 %d...\n", PORT);

    // 4. 注册 SIGCHLD 信号处理，防止僵尸进程
    signal(SIGCHLD, sigchld_handler);

    // 5. 主循环：接受连接 + fork
    while (1) {
        client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
        if (client_fd < 0) {
            perror("accept");
            continue;
        }

        // 打印客户端信息
        char client_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, INET_ADDRSTRLEN);
        printf("新客户端连接：%s:%d\n", client_ip, ntohs(client_addr.sin_port));

        // fork 创建子进程
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork");
            close(client_fd);
            continue;
        }

        if (pid == 0) {
            // 子进程：处理客户端
            close(server_fd);  // 子进程不需要监听套接字

            ssize_t n;
            while ((n = read(client_fd, buffer, sizeof(buffer) - 1)) > 0) {
                buffer[n] = '\0';
                printf("子进程 %d 收到：%s", getpid(), buffer);
                write(client_fd, buffer, n);  // 回显
            }

            printf("子进程 %d：客户端断开\n", getpid());
            close(client_fd);
            exit(0);  // 子进程退出
        } else {
            // 父进程：关闭客户端套接字，继续 accept
            close(client_fd);
        }
    }

    close(server_fd);
    return 0;
}

13.3 代码详解：每一步都别踩坑

这段代码我写过不下几十遍，但每次写还是会注意几个细节。这里挑重点说。

13.3.1 端口复用

SO_REUSEADDR 这个选项，我建议你每次都加上。为什么？因为服务器崩溃或重启时，端口可能还处于 TIME_WAIT 状态，不加这个选项，bind() 会直接报错。我曾经在调试时被这个坑过，明明程序退出了，端口却被占着，气得我直接重启虚拟机。

13.3.2 子进程要关闭监听套接字

注意看子进程里的 close(server_fd)。子进程从父进程那里复制了 server_fd，但它不需要监听，所以必须关掉。否则，父进程的监听套接字引用计数不会降为 0，导致资源泄漏。

13.3.3 父进程要关闭客户端套接字

反过来，父进程在 fork() 之后，要立即 close(client_fd)。因为父进程不负责和客户端通信，留着这个文件描述符只会占用资源。而且，如果不关，子进程退出后，客户端的连接可能不会被正确关闭。

13.3.4 处理僵尸进程

子进程退出时，会变成僵尸进程，直到父进程调用 wait() 或 waitpid() 回收。如果不处理，系统里的僵尸进程会越来越多，最终耗尽进程表。

我这里的做法是注册 SIGCHLD 信号处理函数，在信号处理里用 waitpid() 配合 WNOHANG 一次性回收所有已退出的子进程。这样既不会阻塞主循环，也不会漏掉子进程。

13.4 多进程模型的优缺点

任何技术都有两面性。多进程模型虽然简单，但也不是银弹。

优点	缺点
编程模型简单，容易理解	进程创建开销大，频繁 fork 性能下降
进程间完全隔离，一个崩溃不影响其他	进程间通信（IPC）复杂，共享数据困难
可以利用多核 CPU，真正并行处理	系统资源占用高，每个进程都有独立地址空间
适合 CPU 密集型任务	不适合大量短连接场景（如 HTTP 短连接）

我个人觉得，多进程模型最适合的场景是：连接数不多（几十到几百个），但每个连接的处理时间较长，且需要高稳定性。比如游戏服务器、文件传输服务器等。

13.5 核心逻辑流程图

下面这张图，把整个流程串了一遍。你可以对照着代码看，会更清晰。

13.6 避坑指南：我踩过的几个雷

多进程服务器写起来不难，但坑不少。我把自己踩过的几个雷列出来，你遇到了可以少走弯路。

• 文件描述符泄漏： 我曾经在子进程里忘了关 server_fd，结果跑了几天后，服务器突然报 "Too many open files"。排查了半天才发现，每个子进程都占着一个监听套接字，系统上限被撑爆了。
• 僵尸进程堆积： 早期我偷懒没处理 SIGCHLD，结果测试时开了 100 个客户端，结束后用 ps aux 一看，满屏的 <defunct>。嗯，从那以后我再也不敢忽略信号处理了。
• 惊群问题： 多进程模型下，如果多个子进程同时 accept 同一个监听套接字，会出现惊群现象——所有子进程都被唤醒，但只有一个能抢到连接。Linux 内核后来优化了这个问题，但在老版本上还是会有性能损耗。
• 共享状态问题： 子进程复制了父进程的内存空间，但之后各自独立。如果你想让多个子进程共享某个计数器或缓存，就得用共享内存或消息队列。我有个项目就因为这个，把简单的计数器改成了 mmap 共享内存，折腾了一整天。

好了，这一章就到这里。代码你可以直接拿去用，但建议自己动手敲一遍。只有亲手踩过坑，才能真正记住这些细节。

---

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