阻塞I/O模型：从最原始的Socket说起

说实话，很多做网络编程的朋友一上来就研究epoll、kqueue这些高级货，结果连最基础的阻塞模型都没吃透。我个人觉得，阻塞I/O就像学开车先学挂挡——虽然慢，但它是理解一切的基础。

这一章，我们就来聊聊阻塞式Socket到底是怎么工作的。我会带着你从Server端到Client端，把代码一行行拆开看，最后再聊聊这个模型到底痛在哪里。

阻塞式Socket的工作原理

阻塞I/O，说白了就是「等」。你调用一个函数，数据没到，线程就挂在那不动了。直到数据来了，函数才返回。

举个例子，你打电话叫外卖。你拿起电话拨号，对方接通后你说「我要一份宫保鸡丁」，然后你就拿着电话等。对方不说话，你也不挂，就这么干等着。这就是阻塞。

在Socket的世界里，阻塞发生在两个地方：

• accept() — 没有新连接时，线程阻塞
• recv() / read() — 没有数据可读时，线程阻塞

为什么会这样？因为默认情况下，Socket就是阻塞模式。你创建一个Socket，它天生就是阻塞的。除非你显式调用fcntl(sock, F_SETFL, O_NONBLOCK)把它变成非阻塞。

阻塞式Server实现

我记得刚入行时写第一个网络服务，就是阻塞式的。代码很简单，但坑不少。我们来看看一个典型的阻塞式Server长什么样：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int server_fd, client_fd;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
    
    // 1. 创建Socket
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // 2. 绑定地址和端口
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
    
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
    
    // 3. 开始监听
    if (listen(server_fd, 3) < 0) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }
    
    printf("Server listening on port %d\n", PORT);
    
    while (1) {
        // 4. 阻塞等待连接
        client_fd = accept(server_fd, (struct sockaddr *)&address, 
                          (socklen_t*)&addrlen);
        if (client_fd < 0) {
            perror("accept failed");
            continue;
        }
        
        printf("New connection accepted\n");
        
        // 5. 阻塞读取数据
        int valread = read(client_fd, buffer, BUFFER_SIZE);
        if (valread > 0) {
            printf("Received: %s\n", buffer);
            send(client_fd, "Hello from server", 17, 0);
        }
        
        // 6. 关闭连接
        close(client_fd);
        memset(buffer, 0, BUFFER_SIZE);
    }
    
    close(server_fd);
    return 0;
}

这段代码看起来挺规整的，对吧？但实际跑起来你会发现一个问题：它一次只能服务一个客户端。

你想想看，当accept()返回后，程序进入read()阻塞等待数据。这时候第二个客户端连上来，accept()根本不会被调用，因为线程还在read()里卡着呢。第二个客户端只能排队等着。

阻塞式Client实现

Client端相对简单一些，但同样有阻塞点。我们来看看：

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

#define PORT 8080

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char *hello = "Hello from client";
    char buffer[1024] = {0};
    
    // 1. 创建Socket
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        printf("Socket creation error\n");
        return -1;
    }
    
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    
    // 2. 转换IP地址
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        printf("Invalid address\n");
        return -1;
    }
    
    // 3. 阻塞等待连接建立
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("Connection failed\n");
        return -1;
    }
    
    // 4. 发送数据
    send(sock, hello, strlen(hello), 0);
    printf("Hello message sent\n");
    
    // 5. 阻塞等待响应
    int valread = read(sock, buffer, 1024);
    if (valread > 0) {
        printf("Server response: %s\n", buffer);
    }
    
    close(sock);
    return 0;
}

Client端的阻塞点主要在connect()和read()。如果Server没启动，connect()会一直等到超时。如果Server不回复，read()就永远卡在那。

阻塞I/O的痛点分析

好了，代码看完了。我们来聊聊这个模型到底哪里让人头疼。我总结了几个核心痛点：

痛点	具体表现	后果
线程阻塞	一个线程只能处理一个连接	并发能力极差
资源浪费	线程在等待时什么都不做	CPU空转，内存浪费
扩展困难	每个连接需要一个线程	C10K问题无法解决
响应延迟	前一个请求阻塞，后续请求排队	用户体验差
编程复杂	需要处理多线程同步	容易出bug

说白了，阻塞I/O最大的问题就是「一个线程只能干一件事」。你想想看，如果每个连接都需要一个线程，那10000个连接就需要10000个线程。线程切换的开销、内存的消耗、锁的竞争……这些都会把系统压垮。

为了让你更直观地理解阻塞I/O的工作流程，我画了一张图：

从这张图可以看得很清楚：当Server在处理Client 1的read()时，Client 2和Client 3只能排队等着。这就是阻塞模型最核心的问题——串行处理。

你可能会想：「那我用多线程不就行了？每个连接开一个线程。」没错，很多人就是这么干的。但线程不是免费的。每个线程需要分配栈空间（默认8MB），1000个线程就是8GB内存。而且线程切换的开销，在高并发场景下会吃掉大量CPU。