第5章 TCP回射服务器与客户端

课程目录第5章 TCP回射服务器与客户端

TCP回射服务器与客户端：理解阻塞I/O模型

大家好，我是你们的老朋友。今天我们来聊聊TCP回射服务器与客户端。说实话，这个题目听起来有点学术，但说白了，它就是网络编程里的"Hello World"。你想想看，一个客户端发什么，服务器就原封不动地回什么——就这么简单。

但别小看它。我当年刚入行时，就是靠这个例子真正理解了socket编程的底层逻辑。嗯，咱们一步步来。

什么是回射服务器？

回射服务器（Echo Server）的核心逻辑就一句话：收到什么，就返回什么。客户端发送一段数据，服务器读取后立即写回。整个过程是典型的请求-响应模式。

我个人习惯把这种模型叫做"乒乓模型"——你打过来，我打回去。虽然简单，但它完美展示了TCP通信的完整生命周期：连接建立、数据收发、连接关闭。

核心要点：回射服务器是理解阻塞I/O的最佳入门案例。没有之一。

阻塞I/O模型

阻塞I/O，说白了就是"等"。当程序调用read()或recv()时，如果数据还没到，线程就挂在那里，直到数据来了才继续往下走。

为什么会这样？因为操作系统就是这么设计的。你想想看，如果数据没到就返回，那程序就得不停地轮询——CPU就白烧了。阻塞I/O让CPU能去干别的事，等数据到了再通知你。

我在项目中遇到过一个问题：一个新手同事写了个服务器，用了非阻塞模式加忙等待，结果CPU直接飙到100%。我一看代码就笑了——这就是典型的"为了不阻塞而阻塞了CPU"。

我的建议：初学者先吃透阻塞I/O。非阻塞、多路复用那些，都是在这个基础上做的优化。基础不牢，地动山摇。

服务器端实现

服务器端的流程，我总结为四步走：

创建socket —— 拿到一个文件描述符
绑定地址 —— 告诉系统"我在这等着"
监听连接 —— 开始排队接客
接受连接并处理 —— 来一个处理一个

来看代码：

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

#define PORT 8888
#define BUFFER_SIZE 1024

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];
    ssize_t n;

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

    // 2. 绑定地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(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, 5) < 0) {
        perror("listen");
        close(server_fd);
        exit(1);
    }

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

    // 4. 接受连接并处理
    while (1) {
        client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
        if (client_fd < 0) {
            perror("accept");
            continue;
        }

        printf("新客户端连接: %s:%d\n",
               inet_ntoa(client_addr.sin_addr),
               ntohs(client_addr.sin_port));

        // 回射处理
        while ((n = read(client_fd, buffer, BUFFER_SIZE)) > 0) {
            write(client_fd, buffer, n);
        }

        printf("客户端断开连接\n");
        close(client_fd);
    }

    close(server_fd);
    return 0;
}

注意：这段代码是单线程的，一次只能处理一个客户端。我曾经在生产环境见过有人直接拿这个上线——结果可想而知，第二个客户端一来就卡死了。

客户端实现

客户端更简单，三步走：

创建socket
连接服务器
收发数据

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

#define PORT 8888
#define BUFFER_SIZE 1024

int main() {
    int sock_fd;
    struct sockaddr_in server_addr;
    char buffer[BUFFER_SIZE];
    ssize_t n;

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

    // 2. 连接服务器
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);

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

    printf("已连接到服务器\n");

    // 3. 收发数据
    while (1) {
        printf("请输入消息: ");
        if (fgets(buffer, BUFFER_SIZE, stdin) == NULL) {
            break;
        }

        write(sock_fd, buffer, strlen(buffer));
        n = read(sock_fd, buffer, BUFFER_SIZE);
        if (n <= 0) {
            printf("服务器断开连接\n");
            break;
        }

        buffer[n] = '\0';
        printf("收到回射: %s", buffer);
    }

    close(sock_fd);
    return 0;
}

阻塞I/O的底层原理

你可能会问：为什么read()会阻塞？这得从操作系统层面讲起。

当进程调用read()时，系统会检查socket接收缓冲区。如果有数据，直接拷贝到用户空间。如果没有，进程就会被挂起，加入等待队列。直到数据到达，内核才会唤醒进程。

我画了一张图，帮你理解这个过程：

你看，整个过程就是：用户进程→内核→缓冲区→等待→数据到达→唤醒→拷贝数据。这就是阻塞I/O的完整链路。

阻塞I/O的优缺点

优点	缺点
编程模型简单，容易理解	一个线程只能处理一个连接
CPU利用率高（不忙等）	并发能力差
代码可读性强	不适合高并发场景
调试方便	线程/进程开销大

我的经验：如果你只是写个内部工具、测试程序，或者并发量不超过几十个，阻塞I/O完全够用。别一上来就整什么epoll、libevent，杀鸡焉用牛刀？

常见问题与避坑指南

我曾经踩过一个坑：客户端发送数据后，服务器端read()返回了0，但客户端明明还没关闭连接。后来发现是客户端发送了空数据——write()成功但长度为0。嗯，这里要注意：read()返回0只表示对端关闭了连接，不代表没数据。

还有一次，我在一个项目里发现服务器偶尔会漏掉客户端的最后一条消息。排查了半天，原来是客户端close()之后，服务器还没来得及read()，数据就丢了。解决方案是在客户端调用shutdown(SHUT_WR)而不是直接close()，这样服务器就能收到EOF信号，完整读取所有数据。

避坑指南：

永远检查read()和write()的返回值
不要假设一次read()就能读完所有数据
TCP是流协议，没有消息边界——你需要自己设计应用层协议
信号中断（EINTR）会导致系统调用提前返回，记得处理

总结

TCP回射服务器虽然简单，但它包含了网络编程的所有核心要素：socket创建、地址绑定、监听、接受连接、数据收发。阻塞I/O模型让你能清晰地看到每一步发生了什么。

我个人建议：把这个例子亲手敲一遍，跑起来，然后用strace跟踪一下系统调用。你会看到read()是如何阻塞的，数据是如何流动的。这种底层的感觉，看再多书都不如亲手做一次。

好了，今天就到这里。记住：基础不牢，地动山摇。把回射服务器吃透了，后面的多路复用、异步I/O才能学得扎实。

📚 课程目录

TCP回射服务器与客户端：理解阻塞I/O模型

什么是回射服务器？

阻塞I/O模型

服务器端实现

客户端实现

阻塞I/O的底层原理

阻塞I/O的优缺点

常见问题与避坑指南

总结