C / C++ / 系统课时
阻塞 IO 为什么限制并发
阻塞 IO 为什么限制并发
阻塞 IO 的问题不是“程序一定很慢”,而是同一个执行线程一旦停在 accept、read 或 recv 上,就暂时不能处理其他文件描述符。本篇用一个可运行示例复现这种停顿,并说明 IO 多路复用解决的到底是哪一层问题。
学习目标
- 解释阻塞
accept、read、recv对当前线程执行流程的影响。 - 看懂一个连接如何让单线程服务器暂时忽略其他已就绪连接。
- 理解
select、poll、epoll一类机制为什么能提高单线程 IO 并发度。
阻塞发生在当前线程
监听 Socket 没有待接收连接时,阻塞 accept 会让调用线程休眠;已连接 Socket 没有数据时,阻塞 read 或 recv 也会让调用线程等待。等待期间通常不持续消耗 CPU,但该线程无法继续执行后面的业务逻辑。
这并不等于“整个操作系统只能处理一个连接”。内核仍可接收其他网络数据,进程也可以创建其他线程。真正受限制的是:一个按顺序写的阻塞线程,一次只能等待并处理当前那条执行路径。

一个连接怎样拖住同一线程
下面程序先让客户端 A 建立连接,但故意延迟发送;客户端 B 随后连接并立刻发送。服务器接受第一个连接后马上阻塞在 recv,因此直到 A 发来数据后,才有机会执行第二次 accept。
#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;
}编译并运行:
gcc -std=c11 -Wall -Wextra -O2 blocking_demo.c -o blocking_demo
./blocking_demo预期输出的关键顺序如下,客户端与服务器最前面的个别打印可能因进程调度互换,但 B 会在服务器第二次 accept 之前完成连接和发送:
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 的事件注册与非阻塞读写会更直接。