C / C++ / 系统课时

阻塞 IO 为什么限制并发

阻塞 IO 为什么限制并发

阻塞 IO 的问题不是“程序一定很慢”,而是同一个执行线程一旦停在 accept、read 或 recv 上,就暂时不能处理其他文件描述符。本篇用一个可运行示例复现这种停顿,并说明 IO 多路复用解决的到底是哪一层问题。

学习目标

  • 解释阻塞 accept、read、recv 对当前线程执行流程的影响。
  • 看懂一个连接如何让单线程服务器暂时忽略其他已就绪连接。
  • 理解 select、poll、epoll 一类机制为什么能提高单线程 IO 并发度。

阻塞发生在当前线程

监听 Socket 没有待接收连接时,阻塞 accept 会让调用线程休眠;已连接 Socket 没有数据时,阻塞 read 或 recv 也会让调用线程等待。等待期间通常不持续消耗 CPU,但该线程无法继续执行后面的业务逻辑。

这并不等于“整个操作系统只能处理一个连接”。内核仍可接收其他网络数据,进程也可以创建其他线程。真正受限制的是:一个按顺序写的阻塞线程,一次只能等待并处理当前那条执行路径。

单线程阻塞 IO 与 IO 多路复用的处理差异

一个连接怎样拖住同一线程

下面程序先让客户端 A 建立连接,但故意延迟发送;客户端 B 随后连接并立刻发送。服务器接受第一个连接后马上阻塞在 recv,因此直到 A 发来数据后,才有机会执行第二次 accept。

c
#define _POSIX_C_SOURCE 200809L

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

#define DEMO_PORT 9091

static void die(const char *message) {
    perror(message);
    exit(EXIT_FAILURE);
}

static void sleep_ms(long milliseconds) {
    struct timespec ts = {
        .tv_sec = milliseconds / 1000,
        .tv_nsec = (milliseconds % 1000) * 1000000L
    };
    nanosleep(&ts, NULL);
}

static struct sockaddr_in loopback_addr(void) {
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(DEMO_PORT);

    if (inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) != 1) {
        fprintf(stderr, "inet_pton failed\n");
        exit(EXIT_FAILURE);
    }
    return addr;
}

static void run_client(const char *name, long delay_before_send_ms) {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd == -1) {
        die("socket");
    }

    struct sockaddr_in server = loopback_addr();
    if (connect(fd, (struct sockaddr *)&server, sizeof(server)) == -1) {
        die("connect");
    }

    printf("client %s: connected\n", name);
    sleep_ms(delay_before_send_ms);

    if (send(fd, name, strlen(name), 0) == -1) {
        die("send");
    }
    printf("client %s: sent\n", name);

    close(fd);
    _exit(EXIT_SUCCESS);
}

int main(void) {
    setvbuf(stdout, NULL, _IONBF, 0);

    int listener = socket(AF_INET, SOCK_STREAM, 0);
    if (listener == -1) {
        die("socket");
    }

    int yes = 1;
    if (setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1) {
        die("setsockopt");
    }

    struct sockaddr_in local = loopback_addr();
    if (bind(listener, (struct sockaddr *)&local, sizeof(local)) == -1) {
        die("bind");
    }
    if (listen(listener, 8) == -1) {
        die("listen");
    }

    pid_t a = fork();
    if (a == -1) {
        die("fork");
    }
    if (a == 0) {
        close(listener);
        run_client("A", 1500);
    }

    pid_t b = fork();
    if (b == -1) {
        die("fork");
    }
    if (b == 0) {
        close(listener);
        sleep_ms(300);
        run_client("B", 0);
    }

    int first = accept(listener, NULL, NULL);
    if (first == -1) {
        die("accept");
    }

    puts("server: accepted first connection");
    puts("server: recv(first) is blocking");

    char buffer[16];
    ssize_t n = recv(first, buffer, sizeof(buffer) - 1, 0);
    if (n == -1) {
        die("recv");
    }
    buffer[n] = '\0';
    printf("server: first recv returned: %s\n", buffer);
    close(first);

    puts("server: only now calls accept(second)");
    int second = accept(listener, NULL, NULL);
    if (second == -1) {
        die("accept");
    }

    n = recv(second, buffer, sizeof(buffer) - 1, 0);
    if (n == -1) {
        die("recv");
    }
    buffer[n] = '\0';
    printf("server: second recv returned: %s\n", buffer);

    close(second);
    close(listener);
    waitpid(a, NULL, 0);
    waitpid(b, NULL, 0);
    return EXIT_SUCCESS;
}

编译并运行:

bash
gcc -std=c11 -Wall -Wextra -O2 blocking_demo.c -o blocking_demo
./blocking_demo

预期输出的关键顺序如下,客户端与服务器最前面的个别打印可能因进程调度互换,但 B 会在服务器第二次 accept 之前完成连接和发送:

text
client A: connected
server: accepted first connection
server: recv(first) is blocking
client B: connected
client B: sent
client A: sent
server: first recv returned: A
server: only now calls accept(second)
server: second recv returned: B

这里最容易误解的一点是:客户端 B 的 connect 可以成功,因为内核可以把已完成握手的连接放进监听队列;B 的数据也可以先进入内核缓冲区。但应用线程还停在 recv(first),所以它暂时没有执行第二次 accept,更谈不上读取 B。

IO 多路复用改变了什么

select、poll 和 Linux 的 epoll 都允许一个线程同时等待多个文件描述符的“就绪事件”。线程不再先选中某个连接并盲目阻塞,而是先问内核:监听 Socket、连接 A、连接 B 中,哪些现在可以读或可以接受新连接?

典型事件循环会重复三件事:等待一组 fd 就绪、取出就绪项、对这些项执行短小的 accept、recv 或业务处理。这样,一个暂时没有数据的连接不会独占整个线程的等待位置。

并发提升不等于并行计算

IO 多路复用提高的是一个线程管理许多 IO 等待对象的能力。它不会让单个线程同时执行多个 CPU 密集任务,也不会自动把耗时业务拆到多个核心。

如果每个连接的计算很重,常见做法是把网络事件循环与工作线程或进程池组合;如果主要瓶颈是大量连接的等待时间,多路复用就能显著减少“一个线程被一个空闲连接占住”的浪费。理解这个边界后,再学习 poll 或 epoll 的事件注册与非阻塞读写会更直接。

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

目录与阅读设置

阅读设置

17

记录一个想法

阻塞 IO 为什么限制并发

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

登录哪都通