操作系统 / 系统课时

比较进程与线程并发模型

比较进程与线程并发模型

阻塞式服务器常把每个连接交给一个子进程或线程处理,让单个连接的阻塞不再卡住整个服务。本节用同一份程序实现并比较两种模型,观察它们在地址空间、文件描述符、同步成本和连接规模上的差异。

学习目标

  • 实现“一连接一进程”和“一连接一线程”两种阻塞并发服务器。
  • 从地址空间、调度、同步与资源占用角度解释两种模型的核心差异。
  • 判断何时阻塞并发仍足够简单可靠,何时应转向事件驱动模型。

两种模型到底隔离了什么

fork() 创建子进程后,父子进程拥有独立的虚拟地址空间;初始内存通常依赖写时复制,不会立刻把全部物理页复制一遍。已打开的文件描述符会被继承,因此父进程在把已连接 socket 交给子进程后,应关闭自己那份描述符。

线程则共享同一进程的地址空间和文件描述符表。创建线程通常比创建进程轻,但共享堆、全局变量和连接对象也意味着竞态条件更容易出现;多个线程修改同一状态时,需要互斥锁、原子操作或其他同步机制。

多进程与多线程阻塞并发模型对比

用一个程序切换 process 与 thread 模式

下面的程序固定接收两个客户端连接,process 模式对每个连接执行一次 fork(),thread 模式则创建一个 POSIX 线程。为了让差异直接可见,服务端把自己的进程 ID 和线程 ID 写进响应。

将代码保存为 blocking_server.c:

c
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static void serve_one(int fd, int thread_mode) {
    char buf[128];
    ssize_t n = recv(fd, buf, sizeof(buf) - 1, 0);
    if (n <= 0) {
        return;
    }
    buf[n] = '\0';

    char out[256];
    if (thread_mode) {
        snprintf(out, sizeof(out), "model=thread pid=%ld tid=%lu echo=%s",
                 (long)getpid(), (unsigned long)pthread_self(), buf);
    } else {
        snprintf(out, sizeof(out), "model=process pid=%ld echo=%s",
                 (long)getpid(), buf);
    }
    send(fd, out, strlen(out), 0);
}

static void *thread_worker(void *arg) {
    int fd = *(int *)arg;
    serve_one(fd, 1);
    close(fd);
    return NULL;
}

int main(int argc, char **argv) {
    if (argc != 3 || (strcmp(argv[1], "process") != 0 &&
                      strcmp(argv[1], "thread") != 0)) {
        fprintf(stderr, "usage: %s process|thread PORT\n", argv[0]);
        return 2;
    }

    int thread_mode = strcmp(argv[1], "thread") == 0;
    int port = atoi(argv[2]);

    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd < 0) {
        perror("socket");
        return 1;
    }

    int yes = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));

    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    addr.sin_port = htons((unsigned short)port);

    if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0 ||
        listen(listen_fd, 16) < 0) {
        perror("bind/listen");
        close(listen_fd);
        return 1;
    }

    printf("listening mode=%s port=%d\n", argv[1], port);
    fflush(stdout);

    pthread_t tids[2];
    int client_fds[2];

    for (int i = 0; i < 2; ++i) {
        int client_fd = accept(listen_fd, NULL, NULL);
        if (client_fd < 0) {
            perror("accept");
            close(listen_fd);
            return 1;
        }

        if (thread_mode) {
            client_fds[i] = client_fd;
            int rc = pthread_create(&tids[i], NULL, thread_worker, &client_fds[i]);
            if (rc != 0) {
                fprintf(stderr, "pthread_create: %s\n", strerror(rc));
                close(client_fd);
                close(listen_fd);
                return 1;
            }
        } else {
            pid_t pid = fork();
            if (pid == 0) {
                close(listen_fd);
                serve_one(client_fd, 0);
                close(client_fd);
                _exit(0);
            }
            if (pid < 0) {
                perror("fork");
                close(client_fd);
                close(listen_fd);
                return 1;
            }
            close(client_fd);
        }
    }

    if (thread_mode) {
        pthread_join(tids[0], NULL);
        pthread_join(tids[1], NULL);
    } else {
        wait(NULL);
        wait(NULL);
    }

    close(listen_fd);
    return 0;
}

客户端并发发起两个连接。将下面内容保存为 client.py:

python
import socket
from concurrent.futures import ThreadPoolExecutor

def call(message: str) -> str:
    with socket.create_connection(("127.0.0.1", 19090)) as sock:
        sock.sendall(message.encode())
        chunks = []
        while chunk := sock.recv(256):
            chunks.append(chunk)
        return b"".join(chunks).decode()

with ThreadPoolExecutor(max_workers=2) as pool:
    results = list(pool.map(call, ["alpha", "beta"]))

for line in results:
    print(line)

先编译,再分别运行两种模式:

bash
cc -Wall -Wextra -O2 -pthread blocking_server.c -o blocking_server

./blocking_server process 19090 >process.log 2>&1 &
SERVER_PID=$!
sleep 0.2
python3 client.py
wait "$SERVER_PID"
cat process.log

./blocking_server thread 19090 >thread.log 2>&1 &
SERVER_PID=$!
sleep 0.2
python3 client.py
wait "$SERVER_PID"
cat thread.log

rm -f blocking_server process.log thread.log

预期输出如下,实际 PID/TID 会不同,因此用 <ID> 表示:

text
model=process pid=<ID> echo=alpha
model=process pid=<ID> echo=beta
listening mode=process port=19090
model=thread pid=<ID> tid=<ID> echo=alpha
model=thread pid=<ID> tid=<ID> echo=beta
listening mode=thread port=19090

关键观察点不是 ID 的具体数值:process 两条响应来自两个不同 PID;thread 两条响应的 PID 相同,而 TID 不同。示例中的 sleep 0.2 仅用于演示启动顺序,真实服务应使用就绪探针或重试机制。

调度、内存与同步的实际代价

多进程的优势是故障和内存写入天然隔离:一个子进程破坏自己的堆,通常不会直接改坏另一个连接处理器的内存。代价是进程对象、页表与 IPC 管理更重;共享统计、缓存或限流状态时,需要共享内存、管道等额外机制。

多线程共享地址空间,传递连接对象和共享缓存更直接,单个工作线程的创建成本通常也更低。但共享状态必须设计同步边界;锁竞争、死锁或错误的 fd 所有权管理,会把“轻量”优势抵消掉。线程栈大小也会随着线程数累计占用虚拟地址空间和实际内存。

两种模型还有一个共同上限:每个活跃连接都绑定一个可调度执行单元。连接大量处于等待网络数据的状态时,系统仍要维护成百上千甚至更多任务、栈和调度元数据,频繁唤醒也会增加上下文切换。

怎样选择阻塞并发模型

连接数较小、每个请求逻辑较重、隔离优先级高时,多进程模型简单而稳健;需要共享内存中的缓存或业务对象、连接规模中等且同步关系可控时,多线程通常更合适。两者都适合把阻塞 API 直接映射到顺序业务代码。

当连接规模继续增大,而且大部分连接时间都花在等待 I/O 上,继续增加进程或线程会越来越不经济。这时应把“连接”和“执行单元”解耦,使用 epoll 等事件驱动机制,让少量线程管理大量非阻塞 socket;这正是阻塞并发模型的自然边界。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

比较进程与线程并发模型

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通