C++ 网络编程深度实战：IO 多路复用 select/poll/epoll 对比、TCP 粘包处理与异步 IO

一、引言

在计算机网络编程的世界里，C++ 一直是性能卓越的代表。今天咱们就深入探讨一下 C++ 网络编程中的几个关键技术：IO 多路复用的 select、poll、epoll 对比，TCP 粘包处理以及异步 IO。这些技术在构建高性能网络应用时至关重要，下面咱们就一个一个来详细了解。

二、IO 多路复用之 select

2.1 原理

select 是最早出现的 IO 多路复用技术。它的基本原理是，程序通过将需要监听的文件描述符集合（包括读、写、异常等）传递给 select 函数，然后 select 函数会阻塞，直到有文件描述符就绪（有数据可读、可写或者出现异常），或者超时。之后程序通过遍历文件描述符集合来判断哪些文件描述符就绪。

2.2 示例代码

#include <iostream>
#include <sys/select.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    // 创建一个文件描述符集合
    fd_set readfds;
    FD_ZERO(&readfds);  // 清空集合

    // 添加标准输入到集合中
    FD_SET(STDIN_FILENO, &readfds);

    // 等待文件描述符就绪
    struct timeval timeout;
    timeout.tv_sec = 5;  // 超时时间为 5 秒
    timeout.tv_usec = 0;

    int activity = select(STDIN_FILENO + 1, &readfds, NULL, NULL, &timeout);
    if (activity == -1) {
        std::cerr << "select error" << std::endl;
    } else if (activity == 0) {
        std::cout << "Timeout occurred!" << std::endl;
    } else {
        if (FD_ISSET(STDIN_FILENO, &readfds)) {
            char buffer[1024];
            ssize_t bytes = read(STDIN_FILENO, buffer, sizeof(buffer));
            if (bytes > 0) {
                buffer[bytes] = '\0';
                std::cout << "Read: " << buffer << std::endl;
            }
        }
    }

    return 0;
}

2.3 应用场景

select 适用于连接数较少且不是特别高并发的场景，比如一些小型的局域网服务。

2.4 优缺点

优点：跨平台性好，几乎所有的操作系统都支持。缺点：文件描述符数量有限制（一般为 1024），每次调用 select 都需要将文件描述符集合从用户空间复制到内核空间，效率较低。

2.5 注意事项

要注意文件描述符的数量限制，如果需要处理大量连接，select 可能不是一个好的选择。同时，每次调用 select 后都需要重新设置文件描述符集合。

三、IO 多路复用之 poll

3.1 原理

poll 和 select 类似，也是一种 IO 多路复用技术。它通过一个 pollfd 结构体数组来管理文件描述符，每个 pollfd 结构体包含一个文件描述符、需要监听的事件和实际发生的事件。poll 函数会阻塞，直到有文件描述符就绪或者超时，之后程序可以直接通过 pollfd 结构体中的实际发生事件字段来判断哪些文件描述符就绪。

3.2 示例代码

#include <iostream>
#include <poll.h>
#include <unistd.h>

int main() {
    // 创建一个 pollfd 结构体数组
    struct pollfd fds[1];
    fds[0].fd = STDIN_FILENO;  // 监听标准输入
    fds[0].events = POLLIN;    // 监听读事件

    // 等待文件描述符就绪
    int activity = poll(fds, 1, 5000);  // 超时时间为 5 秒
    if (activity == -1) {
        std::cerr << "poll error" << std::endl;
    } else if (activity == 0) {
        std::cout << "Timeout occurred!" << std::endl;
    } else {
        if (fds[0].revents & POLLIN) {
            char buffer[1024];
            ssize_t bytes = read(STDIN_FILENO, buffer, sizeof(buffer));
            if (bytes > 0) {
                buffer[bytes] = '\0';
                std::cout << "Read: " << buffer << std::endl;
            }
        }
    }

    return 0;
}

3.3 应用场景

poll 适用于连接数较多，但不是特别高并发的场景，它比 select 更灵活一些，因为没有文件描述符数量的严格限制。

3.4 优缺点

优点：没有文件描述符数量的严格限制，比 select 更灵活。缺点：和 select 一样，每次调用 poll 都需要将 pollfd 结构体数组从用户空间复制到内核空间，效率仍然不高。

3.5 注意事项

虽然 poll 没有文件描述符数量的严格限制，但随着文件描述符数量的增加，性能也会逐渐下降。

四、IO 多路复用之 epoll

4.1 原理

epoll 是 Linux 特有的 IO 多路复用技术，它通过事件驱动的方式来管理文件描述符。epoll 有三个主要的函数：epoll_create 用于创建一个 epoll 实例，epoll_ctl 用于向 epoll 实例中添加、修改或删除文件描述符，epoll_wait 用于等待文件描述符就绪。epoll 使用红黑树来管理文件描述符，使用链表来管理就绪的文件描述符，因此在处理大量连接时性能非常高。

4.2 示例代码

#include <iostream>
#include <sys/epoll.h>
#include <unistd.h>

#define MAX_EVENTS 10

int main() {
    // 创建 epoll 实例
    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        std::cerr << "epoll_create1 error" << std::endl;
        return 1;
    }

    // 创建一个 epoll_event 结构体
    struct epoll_event ev, events[MAX_EVENTS];
    ev.events = EPOLLIN;
    ev.data.fd = STDIN_FILENO;

    // 将标准输入添加到 epoll 实例中
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) == -1) {
        std::cerr << "epoll_ctl error" << std::endl;
        close(epoll_fd);
        return 1;
    }

    // 等待文件描述符就绪
    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, 5000);  // 超时时间为 5 秒
    if (nfds == -1) {
        std::cerr << "epoll_wait error" << std::endl;
    } else if (nfds == 0) {
        std::cout << "Timeout occurred!" << std::endl;
    } else {
        for (int i = 0; i < nfds; ++i) {
            if (events[i].data.fd == STDIN_FILENO) {
                char buffer[1024];
                ssize_t bytes = read(STDIN_FILENO, buffer, sizeof(buffer));
                if (bytes > 0) {
                    buffer[bytes] = '\0';
                    std::cout << "Read: " << buffer << std::endl;
                }
            }
        }
    }

    // 关闭 epoll 实例
    close(epoll_fd);

    return 0;
}

3.3 应用场景

epoll 适用于高并发场景，比如大型的网络服务器，能够高效地处理大量的连接。

3.4 优缺点

优点：性能高，处理大量连接时效率远高于 select 和 poll，因为它只需要将文件描述符的变化通知给用户空间，而不需要每次都复制整个文件描述符集合。缺点：只支持 Linux 系统，不具备跨平台性。

3.5 注意事项

在使用 epoll 时，要注意合理设置 epoll_ctl 的操作，避免频繁地添加、修改或删除文件描述符，因为这些操作会影响性能。

五、TCP 粘包处理

5.1 问题描述

TCP 是面向流的协议，在数据传输过程中会出现粘包问题，即发送方发送的多个数据包在接收方可能会被合并成一个数据包，或者一个数据包被拆分成多个部分。

5.2 解决方案

5.2.1 定长协议

发送方和接收方约定好每个数据包的长度，接收方按照固定长度来接收数据。

5.2.2 分隔符协议

在每个数据包的末尾添加一个特殊的分隔符，接收方根据分隔符来分割数据包。

5.2.3 长度前缀协议

在每个数据包的前面添加一个长度字段，用来表示数据包的长度，接收方先读取长度字段，然后根据长度字段来接收完整的数据包。

5.3 示例代码（长度前缀协议）

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define BUFFER_SIZE 1024

// 发送带长度前缀的数据包
void send_packet(int sockfd, const char* data) {
    int length = strlen(data);
    // 先发送长度
    send(sockfd, &length, sizeof(length), 0);
    // 再发送数据
    send(sockfd, data, length, 0);
}

// 接收带长度前缀的数据包
void receive_packet(int sockfd) {
    int length;
    // 先接收长度
    recv(sockfd, &length, sizeof(length), 0);
    char buffer[BUFFER_SIZE];
    // 再接收数据
    recv(sockfd, buffer, length, 0);
    buffer[length] = '\0';
    std::cout << "Received: " << buffer << std::endl;
}

int main() {
    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        std::cerr << "socket error" << std::endl;
        return 1;
    }

    // 绑定地址
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(8888);
    if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        std::cerr << "bind error" << std::endl;
        close(sockfd);
        return 1;
    }

    // 监听
    if (listen(sockfd, 5) == -1) {
        std::cerr << "listen error" << std::endl;
        close(sockfd);
        return 1;
    }

    // 接受连接
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    int client_sockfd = accept(sockfd, (struct sockaddr*)&client_addr, &client_addr_len);
    if (client_sockfd == -1) {
        std::cerr << "accept error" << std::endl;
        close(sockfd);
        return 1;
    }

    // 发送和接收数据包
    send_packet(client_sockfd, "Hello, World!");
    receive_packet(client_sockfd);

    // 关闭套接字
    close(client_sockfd);
    close(sockfd);

    return 0;
}

六、异步 IO

6.1 原理

异步 IO 是指程序在发起 IO 操作后，不需要等待 IO 操作完成，可以继续执行其他任务，当 IO 操作完成后，系统会通过回调函数或者事件通知程序。

6.2 示例代码（使用 Linux 的 aio 库）

#include <iostream>
#include <aio.h>
#include <fcntl.h>
#include <unistd.h>

#define BUFFER_SIZE 1024

// 异步 IO 完成回调函数
void aio_completion_handler(sigval_t sigval) {
    struct aiocb* aiocbp = (struct aiocb*)sigval.sival_ptr;
    if (aio_error(aiocbp) == 0) {
        ssize_t bytes = aio_return(aiocbp);
        if (bytes > 0) {
            char* buffer = (char*)aiocbp->aio_buf;
            buffer[bytes] = '\0';
            std::cout << "Read: " << buffer << std::endl;
        }
    }
}

int main() {
    // 打开文件
    int fd = open("test.txt", O_RDONLY);
    if (fd == -1) {
        std::cerr << "open error" << std::endl;
        return 1;
    }

    // 创建 aiocb 结构体
    struct aiocb aiocb;
    memset(&aiocb, 0, sizeof(aiocb));
    aiocb.aio_fildes = fd;
    aiocb.aio_buf = new char[BUFFER_SIZE];
    aiocb.aio_nbytes = BUFFER_SIZE;
    aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;
    aiocb.aio_sigevent.sigev_notify_function = aio_completion_handler;
    aiocb.aio_sigevent.sigev_notify_attributes = NULL;
    aiocb.aio_sigevent.sigev_value.sival_ptr = &aiocb;

    // 发起异步读操作
    if (aio_read(&aiocb) == -1) {
        std::cerr << "aio_read error" << std::endl;
        close(fd);
        delete[] (char*)aiocb.aio_buf;
        return 1;
    }

    // 继续执行其他任务
    std::cout << "Doing other tasks..." << std::endl;

    // 等待异步 IO 完成
    while (aio_error(&aiocb) == EINPROGRESS) {
        // 可以在这里执行其他任务
    }

    // 关闭文件
    close(fd);
    delete[] (char*)aiocb.aio_buf;

    return 0;
}

6.3 应用场景

异步 IO 适用于对响应时间要求较高的场景，比如实时数据处理、高并发的网络服务器等。

6.4 优缺点

优点：可以提高程序的并发性能，减少程序的等待时间。缺点：实现复杂度较高，需要处理回调函数和事件通知等问题。

6.5 注意事项

在使用异步 IO 时，要注意内存管理，避免出现内存泄漏。同时，要合理处理回调函数和事件通知，避免出现死锁等问题。

七、文章总结

通过对 IO 多路复用的 select、poll、epoll 对比，TCP 粘包处理以及异步 IO 的学习，我们可以看到不同技术在不同场景下的应用。select 跨平台性好，但性能有限；poll 比 select 更灵活，但在高并发场景下性能也不理想；epoll 是 Linux 下处理高并发的利器，性能卓越。TCP 粘包问题需要根据具体情况选择合适的解决方案，长度前缀协议是一种比较常用的方法。异步 IO 可以提高程序的并发性能，但实现复杂度较高。在实际开发中，我们要根据具体的需求和场景选择合适的技术，以达到最佳的性能和稳定性。

敲码拾光专注于编程技术，涵盖编程语言、代码实战案例、软件开发技巧、IT前沿技术、编程开发工具，是您提升技术能力的优质网络平台。

C++ 网络编程深度实战：IO 多路复用 select/poll/epoll 对比、TCP 粘包处理与异步 IO

一、引言

二、IO 多路复用之 select

2.1 原理

2.2 示例代码

2.3 应用场景

2.4 优缺点

2.5 注意事项

三、IO 多路复用之 poll

3.1 原理

3.2 示例代码

3.3 应用场景

3.4 优缺点

3.5 注意事项

四、IO 多路复用之 epoll

4.1 原理

4.2 示例代码

3.3 应用场景

3.4 优缺点

3.5 注意事项

五、TCP 粘包处理

5.1 问题描述

5.2 解决方案

5.2.1 定长协议

5.2.2 分隔符协议

5.2.3 长度前缀协议

5.3 示例代码（长度前缀协议）

六、异步 IO

6.1 原理

6.2 示例代码（使用 Linux 的 aio 库）

6.3 应用场景

6.4 优缺点

6.5 注意事项

七、文章总结

评论

关联文章