I/O多路复用

为了高效地管理这些连接，IO多路复用（I/O Multiplexing）是一种非常重要的技术。本文将详细介绍IO多路复用的概念、常见实现方法以及其应用场景。

什么是IO多路复用？

IO多路复用是一种允许一个线程在单一的系统调用中同时监视多个文件描述符（文件、套接字等）的技术。当这些文件描述符中的任何一个就绪（例如可读或可写）时，系统调用会返回，就绪的文件描述符可以被处理。这样可以避免为每个文件描述符创建一个线程或进程，从而减少系统资源的消耗和上下文切换的开销。

常见的IO多路复用实现

1. select

select 是最早的IO多路复用机制，几乎在所有的类UNIX系统中都能找到。它通过一个文件描述符集合来管理监视的文件描述符。

#include <sys/select.h>

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

select的缺点包括：

• 每次调用都需要重新设置文件描述符集合，开销较大。
• 文件描述符数量有限（通常为1024）。

2. poll

poll 提供了类似于 select 的功能，但使用一个数组来管理文件描述符，并且没有数量限制。

#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

虽然poll解决了文件描述符数量限制的问题，但它仍然需要在每次调用时传递所有文件描述符，并且性能不如后续的epoll。

3. epoll

epoll 是Linux特有的IO多路复用机制，专为高效处理大量文件描述符而设计。epoll 使用一个文件描述符来表示事件集合，并通过系统调用操作这个集合。

#include <sys/epoll.h>

int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

epoll的优势在于：

• 不需要在每次调用时传递所有文件描述符，只需传递变化的部分。
• 支持边沿触发（edge-triggered）和水平触发（level-triggered）模式，提高了事件处理的灵活性和效率。

应用场景

IO多路复用广泛应用于高性能服务器和网络应用中，尤其适用于需要处理大量并发连接的场景，例如：

• Web服务器：同时处理大量客户端请求。
• 聊天服务器：同时处理大量用户的消息。
• 代理服务器：同时处理多个客户端和服务器之间的连接。

示例：使用epoll实现一个简单的回显服务器

下面是一个使用epoll实现的简单回显服务器的示例代码：

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

#define MAX_EVENTS 10 // 定义同时处理的最大事件数
#define PORT 8080 // 定义服务器监听的端口

// 设置套接字为非阻塞模式的函数
void setnonblocking(int sock) {
    int opts = fcntl(sock, F_GETFL); // 获取套接字的文件状态标志
    if (opts < 0) {
        perror("fcntl(F_GETFL)"); // 错误处理
        exit(EXIT_FAILURE);
    }
    opts = (opts | O_NONBLOCK); // 设置为非阻塞模式
    if (fcntl(sock, F_SETFL, opts) < 0) {
        perror("fcntl(F_SETFL)"); // 错误处理
        exit(EXIT_FAILURE);
    }
}

int main() {
    int listen_sock, conn_sock, nfds, epollfd;
    struct epoll_event ev, events[MAX_EVENTS]; // epoll_event结构体数组
    struct sockaddr_in addr;
    socklen_t addrlen;

    // 创建监听套接字
    listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_sock < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    setnonblocking(listen_sock); // 设置监听套接字为非阻塞模式

    // 设置地址结构
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = INADDR_ANY;

    // 绑定套接字到地址和端口
    if (bind(listen_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 开始监听
    if (listen(listen_sock, SOMAXCONN) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    // 创建epoll实例
    epollfd = epoll_create1(0);
    if (epollfd < 0) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }

    // 将监听套接字添加到epoll实例中
    ev.events = EPOLLIN; // 设置事件类型为输入事件
    ev.data.fd = listen_sock;
    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
        perror("epoll_ctl: listen_sock");
        exit(EXIT_FAILURE);
    }

    for (;;) {
        // 等待事件发生
        nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
        if (nfds == -1) {
            perror("epoll_wait");
            exit(EXIT_FAILURE);
        }

        // 处理所有就绪的文件描述符
        for (int n = 0; n < nfds; ++n) {
            if (events[n].data.fd == listen_sock) {
                // 处理新的连接
                conn_sock = accept(listen_sock, (struct sockaddr *)&addr, &addrlen);
                if (conn_sock == -1) {
                    perror("accept");
                    continue;
                }
                setnonblocking(conn_sock); // 设置新连接为非阻塞模式
                ev.events = EPOLLIN | EPOLLET; // 设置为输入事件和边沿触发
                ev.data.fd = conn_sock;
                if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) {
                    perror("epoll_ctl: conn_sock");
                    exit(EXIT_FAILURE);
                }
            } else {
                // 处理已有连接的数据
                char buffer[512];
                ssize_t count = read(events[n].data.fd, buffer, sizeof(buffer));
                if (count == -1) {
                    perror("read");
                    close(events[n].data.fd);
                } else if (count == 0) {
                    // 连接关闭
                    close(events[n].data.fd);
                } else {
                    // 回显数据
                    write(events[n].data.fd, buffer, count);
                }
            }
        }
    }

    close(listen_sock);
    return 0;
}