1. 概述

I/O 多路复用是现代高性能网络编程的核心技术，它允许单个线程同时监视多个文件描述符的状态变化，从而实现高效的并发处理。Linux 提供了多种 I/O 多路复用机制，每种都有其特点和适用场景。

本文将深入分析四种主要的 I/O 多路复用机制：select、poll、ppoll 和 epoll，并通过实际示例展示它们的使用方法和性能差异。

2. 四种机制对比分析

2.1 基本特性对比

特性	select	poll	ppoll	epoll
引入时间	早期Unix	SVR3 (1986)	Linux 2.6.16	Linux 2.5.44
文件描述符限制	FD_SETSIZE (通常1024)	无理论限制	无理论限制	无理论限制
数据结构	fd_set位图	pollfd数组	pollfd数组	epoll_event数组
文件描述符拷贝	每次调用都拷贝	每次调用都拷贝	每次调用都拷贝	注册一次，多次使用
事件复杂度	O(n)	O(n)	O(n)	O(1)
跨平台性	良好	良好	Linux特有	Linux特有
信号处理	基本支持	基本支持	增强支持	基本支持

2.2 详细特性分析

select

• 优点: 跨平台性最好，几乎所有Unix-like系统都支持
• 缺点: 文件描述符数量受限，每次调用都需要拷贝fd_set

poll

• 优点: 无文件描述符数量限制，API设计更清晰
• 缺点: 每次调用都需要遍历所有文件描述符

ppoll

• 优点: 提供了更好的信号处理机制，避免竞态条件
• 缺点: Linux特有，需要较新内核支持

epoll

• 优点: 性能最优，事件驱动，支持边缘触发和水平触发
• 缺点: Linux特有，学习成本较高

3. 实际示例代码

3.1 select 示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <string.h>

#define MAX_CLIENTS 1024
#define BUFFER_SIZE 1024

int main_select() {
    fd_set read_fds, master_fds;
    int max_fd = 0;
    int client_sockets[MAX_CLIENTS] = {0};
    char buffer[BUFFER_SIZE];
    
    printf("=== select 示例 ===\n");
    
    // 初始化文件描述符集合
    FD_ZERO(&master_fds);
    FD_SET(STDIN_FILENO, &master_fds);
    max_fd = STDIN_FILENO;
    
    while (1) {
        read_fds = master_fds;
        struct timeval timeout = {1, 0};  // 1秒超时
        
        int activity = select(max_fd + 1, &read_fds, NULL, NULL, &timeout);
        
        if (activity < 0) {
            if (errno == EINTR) continue;
            perror("select error");
            break;
        }
        
        if (activity == 0) {
            printf("select timeout\n");
            continue;
        }
        
        // 检查标准输入
        if (FD_ISSET(STDIN_FILENO, &read_fds)) {
            ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
            if (bytes_read > 0) {
                buffer[bytes_read] = '\0';
                printf("stdin: %s", buffer);
                
                if (strncmp(buffer, "quit", 4) == 0) {
                    break;
                }
            }
        }
    }
    
    return 0;
}

3.2 poll 示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <poll.h>
#include <errno.h>
#include <string.h>

#define MAX_FDS 10
#define TIMEOUT_MS 5000  // 5秒超时

int main_poll() {
    struct pollfd fds[MAX_FDS];
    int nfds = 1;
    char buffer[1024];
    
    printf("=== poll 示例 ===\n");
    
    // 初始化 pollfd 结构
    fds[0].fd = STDIN_FILENO;
    fds[0].events = POLLIN;
    fds[0].revents = 0;
    
    printf("监视标准输入，输入 'quit' 退出\n");
    
    while (1) {
        int ready = poll(fds, nfds, TIMEOUT_MS);
        
        if (ready == -1) {
            if (errno == EINTR) continue;
            perror("poll error");
            break;
        }
        
        if (ready == 0) {
            printf("poll timeout\n");
            continue;
        }
        
        // 处理就绪的文件描述符
        for (int i = 0; i < nfds; i++) {
            if (fds[i].revents & POLLIN) {
                if (fds[i].fd == STDIN_FILENO) {
                    ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
                    if (bytes_read > 0) {
                        buffer[bytes_read] = '\0';
                        printf("received: %s", buffer);
                        
                        if (strncmp(buffer, "quit", 4) == 0) {
                            return 0;
                        }
                    }
                }
            }
            
            if (fds[i].revents & (POLLERR | POLLHUP | POLLNVAL)) {
                printf("fd %d error\n", fds[i].fd);
                return 1;
            }
        }
    }
    
    return 0;
}

3.3 ppoll 示例

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <poll.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <string.h>

volatile sig_atomic_t signal_received = 0;

void signal_handler(int sig) {
    signal_received = sig;
    printf("\nSignal %d received\n", sig);
}

int main_ppoll() {
    struct pollfd fds[2];
    struct timespec timeout;
    sigset_t sigmask;
    char buffer[1024];
    
    printf("=== ppoll 示例 ===\n");
    
    // 设置信号处理
    struct sigaction sa;
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
    
    // 初始化 pollfd
    fds[0].fd = STDIN_FILENO;
    fds[0].events = POLLIN;
    fds[0].revents = 0;
    
    // 设置超时时间
    timeout.tv_sec = 3;
    timeout.tv_nsec = 0;
    
    // 设置信号屏蔽集
    sigemptyset(&sigmask);
    
    printf("Monitoring stdin with ppoll...\n");
    printf("Press Ctrl+C to send signal\n");
    printf("Type 'quit' to exit\n");
    
    while (!signal_received) {
        int ready = ppoll(fds, 1, &timeout, &sigmask);
        
        if (ready == -1) {
            if (errno == EINTR) {
                printf("ppoll interrupted by signal\n");
                if (signal_received) {
                    printf("Signal handling complete\n");
                }
                continue;
            } else {
                perror("ppoll error");
                break;
            }
        }
        
        if (ready == 0) {
            printf("ppoll timeout\n");
            continue;
        }
        
        if (fds[0].revents & POLLIN) {
            ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
            if (bytes_read > 0) {
                buffer[bytes_read] = '\0';
                printf("Input: %s", buffer);
                
                if (strncmp(buffer, "quit", 4) == 0) {
                    break;
                }
            }
        }
        
        fds[0].revents = 0;  // 重置事件
    }
    
    printf("Program exiting normally\n");
    return 0;
}

3.4 epoll 示例

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#define MAX_EVENTS 10
#define BUFFER_SIZE 1024

int make_socket_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        return -1;
    }
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main_epoll() {
    int epoll_fd;
    struct epoll_event ev, events[MAX_EVENTS];
    char buffer[BUFFER_SIZE];
    
    printf("=== epoll 示例 ===\n");
    
    // 创建 epoll 实例
    epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1");
        return 1;
    }
    
    // 设置标准输入为非阻塞
    if (make_socket_nonblocking(STDIN_FILENO) == -1) {
        perror("fcntl");
        close(epoll_fd);
        return 1;
    }
    
    // 添加标准输入到 epoll
    ev.events = EPOLLIN | EPOLLET;  // 边缘触发模式
    ev.data.fd = STDIN_FILENO;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) == -1) {
        perror("epoll_ctl: stdin");
        close(epoll_fd);
        return 1;
    }
    
    printf("epoll monitoring stdin (edge-triggered mode)\n");
    printf("Type 'quit' to exit\n");
    
    while (1) {
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, 3000);  // 3秒超时
        
        if (nfds == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait");
            break;
        }
        
        if (nfds == 0) {
            printf("epoll timeout\n");
            continue;
        }
        
        for (int n = 0; n < nfds; n++) {
            if (events[n].events & EPOLLIN) {
                if (events[n].data.fd == STDIN_FILENO) {
                    ssize_t bytes_read;
                    while ((bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer) - 1)) > 0) {
                        buffer[bytes_read] = '\0';
                        printf("epoll input: %s", buffer);
                        
                        if (strncmp(buffer, "quit", 4) == 0) {
                            close(epoll_fd);
                            return 0;
                        }
                    }
                    
                    if (bytes_read == -1) {
                        if (errno != EAGAIN && errno != EWOULDBLOCK) {
                            perror("read");
                        }
                    }
                }
            }
            
            if (events[n].events & (EPOLLERR | EPOLLHUP)) {
                printf("epoll error on fd %d\n", events[n].data.fd);
                close(epoll_fd);
                return 1;
            }
        }
    }
    
    close(epoll_fd);
    return 0;
}

4. 性能测试对比

4.1 基准测试代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <poll.h>
#include <sys/select.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <string.h>

#define TEST_ITERATIONS 10000
#define TEST_FDS 100

// 性能测试结构体
struct performance_test {
    const char *name;
    long long (*test_func)(int fd_count);
};

// select 性能测试
long long test_select_performance(int fd_count) {
    fd_set read_fds;
    struct timeval timeout = {0, 1000};  // 1ms 超时
    struct timeval start, end;
    
    gettimeofday(&start, NULL);
    
    for (int i = 0; i < TEST_ITERATIONS; i++) {
        FD_ZERO(&read_fds);
        FD_SET(STDIN_FILENO, &read_fds);
        
        select(STDIN_FILENO + 1, &read_fds, NULL, NULL, &timeout);
    }
    
    gettimeofday(&end, NULL);
    
    return (end.tv_sec - start.tv_sec) * 1000000LL + (end.tv_usec - start.tv_usec);
}

// poll 性能测试
long long test_poll_performance(int fd_count) {
    struct pollfd pfd;
    struct timeval start, end;
    
    pfd.fd = STDIN_FILENO;
    pfd.events = POLLIN;
    pfd.revents = 0;
    
    gettimeofday(&start, NULL);
    
    for (int i = 0; i < TEST_ITERATIONS; i++) {
        poll(&pfd, 1, 1);  // 1ms 超时
        pfd.revents = 0;
    }
    
    gettimeofday(&end, NULL);
    
    return (end.tv_sec - start.tv_sec) * 1000000LL + (end.tv_usec - start.tv_usec);
}

// 显示性能测试结果
void show_performance_results() {
    struct performance_test tests[] = {
        {"select", test_select_performance},
        {"poll", test_poll_performance},
        {NULL, NULL}
    };
    
    printf("=== 性能测试结果 (10000 次调用) ===\n");
    printf("%-10s %-15s %-15s\n", "机制", "耗时(微秒)", "平均耗时(纳秒)");
    printf("%-10s %-15s %-15s\n", "----", "----------", "--------------");
    
    for (int i = 0; tests[i].name; i++) {
        long long total_time = tests[i].test_func(TEST_FDS);
        double avg_time = (double)total_time * 1000.0 / TEST_ITERATIONS;
        
        printf("%-10s %-15lld %-15.2f\n", 
               tests[i].name, total_time, avg_time);
    }
    
    printf("\n性能特点:\n");
    printf("1. select: 有文件描述符数量限制，每次调用需要拷贝fd_set\n");
    printf("2. poll:   无文件描述符数量限制，但仍需遍历所有描述符\n");
    printf("3. epoll:  事件驱动，只处理活跃的描述符，性能最优\n");
    printf("4. ppoll:  提供更好的信号处理机制，避免竞态条件\n");
}

int main_performance_comparison() {
    printf("=== I/O 多路复用性能对比测试 ===\n\n");
    
    show_performance_results();
    
    printf("\n=== 实际应用建议 ===\n");
    printf("选择建议:\n");
    printf("1. 跨平台应用: 使用 select\n");
    printf("2. 中等并发(<1000): 使用 poll\n");
    printf("3. 高并发(>1000): 使用 epoll\n");
    printf("4. 需要信号处理: 使用 ppoll\n");
    printf("5. Linux 专用: 使用 epoll\n");
    
    return 0;
}

5. 实际应用场景分析

5.1 网络服务器场景

// 简单的 HTTP 服务器示例，展示不同机制的使用
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <poll.h>
#include <sys/epoll.h>

#define PORT 8080
#define MAX_CLIENTS 1000
#define BUFFER_SIZE 4096

// 创建监听套接字
int create_server_socket(int port) {
    int server_fd;
    struct sockaddr_in address;
    int opt = 1;
    
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        return -1;
    }
    
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
        perror("setsockopt");
        close(server_fd);
        return -1;
    }
    
    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");
        close(server_fd);
        return -1;
    }
    
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        close(server_fd);
        return -1;
    }
    
    return server_fd;
}

// 处理 HTTP 请求
void handle_http_request(int client_fd) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read = read(client_fd, buffer, sizeof(buffer) - 1);
    
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        
        // 简单的 HTTP 响应
        const char *response = 
            "HTTP/1.1 200 OK\r\n"
            "Content-Type: text/html\r\n"
            "Connection: close\r\n"
            "\r\n"
            "<html><body><h1>Hello from I/O Multiplexing Server!</h1></body></html>\r\n";
        
        write(client_fd, response, strlen(response));
    }
    
    close(client_fd);
}

// 使用 poll 的 HTTP 服务器
int http_server_poll(int port) {
    int server_fd, client_fd;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    struct pollfd *fds;
    int max_fds = MAX_CLIENTS + 1;
    int nfds = 1;
    
    printf("Starting HTTP server with poll on port %d\n", port);
    
    server_fd = create_server_socket(port);
    if (server_fd == -1) return -1;
    
    fds = calloc(max_fds, sizeof(struct pollfd));
    if (!fds) {
        perror("calloc");
        close(server_fd);
        return -1;
    }
    
    // 添加监听套接字
    fds[0].fd = server_fd;
    fds[0].events = POLLIN;
    fds[0].revents = 0;
    
    while (1) {
        int ready = poll(fds, nfds, 1000);  // 1秒超时
        
        if (ready == -1) {
            if (errno == EINTR) continue;
            perror("poll");
            break;
        }
        
        if (ready == 0) continue;  // 超时
        
        // 检查监听套接字
        if (fds[0].revents & POLLIN) {
            client_fd = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen);
            if (client_fd >= 0) {
                if (nfds < max_fds) {
                    fds[nfds].fd = client_fd;
                    fds[nfds].events = POLLIN;
                    fds[nfds].revents = 0;
                    nfds++;
                    printf("New connection from %s:%d\n", 
                           inet_ntoa(address.sin_addr), ntohs(address.sin_port));
                } else {
                    printf("Too many connections, rejecting\n");
                    close(client_fd);
                }
            }
        }
        
        // 检查客户端连接
        for (int i = 1; i < nfds; i++) {
            if (fds[i].revents & POLLIN) {
                handle_http_request(fds[i].fd);
                // 移除已处理的连接
                for (int j = i; j < nfds - 1; j++) {
                    fds[j] = fds[j + 1];
                }
                nfds--;
                i--;  // 重新检查当前位置
            }
        }
        
        // 重置 revents
        for (int i = 0; i < nfds; i++) {
            fds[i].revents = 0;
        }
    }
    
    free(fds);
    close(server_fd);
    return 0;
}

// 使用 epoll 的 HTTP 服务器
int http_server_epoll(int port) {
    int server_fd, client_fd, epoll_fd;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    struct epoll_event ev, events[MAX_CLIENTS];
    int nfds;
    
    printf("Starting HTTP server with epoll on port %d\n", port);
    
    server_fd = create_server_socket(port);
    if (server_fd == -1) return -1;
    
    epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1");
        close(server_fd);
        return -1;
    }
    
    // 添加监听套接字到 epoll
    ev.events = EPOLLIN;
    ev.data.fd = server_fd;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev) == -1) {
        perror("epoll_ctl: listen");
        close(server_fd);
        close(epoll_fd);
        return -1;
    }
    
    while (1) {
        nfds = epoll_wait(epoll_fd, events, MAX_CLIENTS, 1000);  // 1秒超时
        
        if (nfds == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait");
            break;
        }
        
        if (nfds == 0) continue;  // 超时
        
        for (int i = 0; i < nfds; i++) {
            if (events[i].data.fd == server_fd) {
                // 新连接
                client_fd = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen);
                if (client_fd >= 0) {
                    ev.events = EPOLLIN | EPOLLET;
                    ev.data.fd = client_fd;
                    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev) == -1) {
                        perror("epoll_ctl: client");
                        close(client_fd);
                    } else {
                        printf("New connection from %s:%d\n", 
                               inet_ntoa(address.sin_addr), ntohs(address.sin_port));
                    }
                }
            } else {
                // 客户端数据
                handle_http_request(events[i].data.fd);
                epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
            }
        }
    }
    
    close(epoll_fd);
    close(server_fd);
    return 0;
}

6. 最佳实践和使用建议

6.1 选择指南

// 根据应用场景选择合适的 I/O 多路复用机制

/*
选择决策树:

1. 是否需要跨平台支持?
   - 是 -> 选择 select
   - 否 -> 继续下一步

2. 操作系统是什么?
   - Windows -> 选择 select 或 IOCP
   - Linux -> 继续下一步

3. 并发连接数是多少?
   - < 100 -> select 或 poll 都可以
   - 100-1000 -> poll
   - > 1000 -> epoll

4. 是否需要特殊的信号处理?
   - 是 -> ppoll
   - 否 -> 继续下一步

5. 性能要求如何?
   - 高性能 -> epoll
   - 一般 -> poll
*/

// 配置结构体
struct io_multiplexing_config {
    enum {
        IO_SELECT,
        IO_POLL,
        IO_PPOLL,
        IO_EPOLL
    } method;
    
    int max_connections;
    int timeout_ms;
    int edge_triggered;  // 仅对 epoll 有效
    int signal_safe;    // 是否需要信号安全
};

// 根据配置推荐机制
const char* recommend_io_method(const struct io_multiplexing_config *config) {
    if (config->method != 0) {
        // 明确指定了方法
        switch (config->method) {
            case IO_SELECT: return "select";
            case IO_POLL: return "poll";
            case IO_PPOLL: return "ppoll";
            case IO_EPOLL: return "epoll";
        }
    }
    
    // 根据配置自动推荐
    if (config->signal_safe) {
        return "ppoll";
    }
    
    if (config->max_connections > 1000) {
        return "epoll";
    }
    
    if (config->max_connections > 100) {
        return "poll";
    }
    
    return "select";
}

// 显示推荐结果
void show_recommendation(const struct io_multiplexing_config *config) {
    printf("=== I/O 多路复用机制推荐 ===\n");
    printf("配置参数:\n");
    printf("  最大连接数: %d\n", config->max_connections);
    printf("  超时时间: %d ms\n", config->timeout_ms);
    printf("  边缘触发: %s\n", config->edge_triggered ? "是" : "否");
    printf("  信号安全: %s\n", config->signal_safe ? "是" : "否");
    printf("\n");
    printf("推荐机制: %s\n", recommend_io_method(config));
    printf("\n");
}

6.2 错误处理最佳实践

// 安全的 I/O 多路复用封装
typedef struct {
    int fd;
    void *data;
    int (*read_handler)(int fd, void *data);
    int (*write_handler)(int fd, void *data);
    int (*error_handler)(int fd, void *data);
} io_handler_t;

// 通用的错误处理函数
int handle_io_errors(int fd, int revents, const char *context) {
    if (revents & (POLLERR | POLLHUP | POLLNVAL)) {
        fprintf(stderr, "Error on fd %d in %s: ", fd, context);
        
        if (revents & POLLERR) {
            fprintf(stderr, "POLLERR ");
        }
        if (revents & POLLHUP) {
            fprintf(stderr, "POLLHUP ");
        }
        if (revents & POLLNVAL) {
            fprintf(stderr, "POLLNVAL ");
        }
        fprintf(stderr, "\n");
        
        return -1;
    }
    return 0;
}

// 安全的 poll 封装
int safe_poll(struct pollfd *fds, nfds_t nfds, int timeout_ms) {
    if (!fds || nfds == 0) {
        errno = EINVAL;
        return -1;
    }
    
    int result;
    do {
        result = poll(fds, nfds, timeout_ms);
    } while (result == -1 && errno == EINTR);
    
    return result;
}

// 安全的 ppoll 封装
int safe_ppoll(struct pollfd *fds, nfds_t nfds,
               const struct timespec *timeout_ts,
               const sigset_t *sigmask) {
    if (!fds || nfds == 0) {
        errno = EINVAL;
        return -1;
    }
    
    int result;
    do {
        result = ppoll(fds, nfds, timeout_ts, sigmask);
    } while (result == -1 && errno == EINTR);
    
    return result;
}

// 安全的 epoll 封装
int safe_epoll_wait(int epfd, struct epoll_event *events,
                    int maxevents, int timeout) {
    if (!events || maxevents <= 0) {
        errno = EINVAL;
        return -1;
    }
    
    int result;
    do {
        result = epoll_wait(epfd, events, maxevents, timeout);
    } while (result == -1 && errno == EINTR);
    
    return result;
}

7. 完整的综合示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <poll.h>
#include <sys/select.h>
#include <sys/epoll.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <string.h>

// 综合测试结构体
struct comprehensive_test {
    const char *name;
    void (*test_func)(void);
    int supported;
};

// 综合性能测试
void comprehensive_performance_test() {
    printf("=== 综合性能测试 ===\n");
    
    // 测试不同文件描述符数量下的性能
    int test_sizes[] = {10, 50, 100, 500, 1000};
    int num_tests = sizeof(test_sizes) / sizeof(test_sizes[0]);
    
    printf("%-10s %-10s %-15s %-15s %-15s\n", 
           "机制", "FD数量", "select(μs)", "poll(μs)", "epoll(μs)");
    printf("%-10s %-10s %-15s %-15s %-15s\n", 
           "----", "------", "----------", "---------", "----------");
    
    for (int i = 0; i < num_tests; i++) {
        int fd_count = test_sizes[i];
        // 这里简化处理，实际应该进行真实的时间测量
        printf("%-10s %-10d %-15d %-15d %-15d\n",
               "测试", fd_count,
               fd_count * 2,    // select 模拟时间
               fd_count * 1.5,  // poll 模拟时间
               fd_count * 0.5); // epoll 模拟时间
    }
}

// 实际使用场景演示
void practical_usage_scenarios() {
    printf("\n=== 实际使用场景 ===\n");
    
    printf("1. Web 服务器:\n");
    printf("   - 高并发: 推荐使用 epoll\n");
    printf("   - 中等并发: 可以使用 poll\n");
    printf("   - 简单场景: select 也足够\n");
    
    printf("\n2. 数据库连接池:\n");
    printf("   - 连接数较少: poll 或 select\n");
    printf("   - 连接数较多: epoll\n");
    printf("   - 需要信号处理: ppoll\n");
    
    printf("\n3. 实时通信应用:\n");
    printf("   - 聊天服务器: epoll (支持边缘触发)\n");
    printf("   - 游戏服务器: epoll (高性能)\n");
    printf("   - 需要精确信号处理: ppoll\n");
    
    printf("\n4. 系统监控工具:\n");
    printf("   - 文件监控: poll (简单可靠)\n");
    printf("   - 网络监控: epoll (高性能)\n");
    printf("   - 需要信号处理: ppoll\n");
}

// 移植性考虑
void portability_considerations() {
    printf("\n=== 移植性考虑 ===\n");
    
    printf("跨平台支持:\n");
    printf("1. select: 几乎所有 Unix-like 系统都支持\n");
    printf("2. poll: POSIX 标准，广泛支持\n");
    printf("3. ppoll: Linux 特有 (2.6.16+)\n");
    printf("4. epoll: Linux 特有 (2.5.44+)\n");
    
    printf("\n条件编译示例:\n");
    printf("#ifdef __linux__\n");
    printf("    // 使用 epoll\n");
    printf("#elif defined(__FreeBSD__) || defined(__APPLE__)\n");
    printf("    // 使用 kqueue\n");
    printf("#else\n");
    printf("    // 使用 poll 或 select\n");
    printf("#endif\n");
}

int main() {
    printf("=== Linux I/O 多路复用机制综合分析 ===\n\n");
    
    // 性能测试
    comprehensive_performance_test();
    
    // 实际使用场景
    practical_usage_scenarios();
    
    // 移植性考虑
    portability_considerations();
    
    printf("\n=== 总结 ===\n");
    printf("1. select: 简单可靠，跨平台性好，但有 FD 数量限制\n");
    printf("2. poll:   无 FD 限制，API 清晰，适合中等并发\n");
    printf("3. ppoll:  增强的信号处理，避免竞态条件，Linux 特有\n");
    printf("4. epoll:  性能最优，事件驱动，Linux 特有\n");
    printf("\n");
    printf("选择建议:\n");
    printf("- 新项目且只运行在 Linux: 首选 epoll\n");
    printf("- 需要跨平台支持: 使用 poll 或 select\n");
    printf("- 需要特殊信号处理: 考虑 ppoll\n");
    printf("- 简单应用场景: select 也足够\n");
    
    return 0;
}

8. 编译和运行说明

# 编译所有示例
gcc -o select_example example1.c
gcc -o poll_example example2.c
gcc -o ppoll_example example3.c -D_GNU_SOURCE
gcc -o epoll_example example4.c
gcc -o performance_test performance_test.c
gcc -o comprehensive_analysis comprehensive.c

# 运行示例
./select_example
./poll_example
./ppoll_example
./epoll_example
./performance_test
./comprehensive_analysis

# 测试不同场景
echo "Testing select with 100 FDs..."
./select_example 100

echo "Testing epoll with high concurrency..."
./epoll_example 1000

echo "Running comprehensive analysis..."
./comprehensive_analysis

9. 系统要求检查

# 检查内核版本
uname -r

# 检查 glibc 版本
ldd --version

# 检查 epoll 支持
grep -w epoll /usr/include/linux/eventpoll.h

# 检查 ppoll 支持
grep -w ppoll /usr/include/asm/unistd_64.h

# 查看系统调用限制
ulimit -n  # 文件描述符限制
cat /proc/sys/fs/file-max  # 系统最大文件描述符

10. 最佳实践总结

// 1. 错误处理模板
int robust_io_multiplexing() {
    struct pollfd *fds = NULL;
    int max_fds = 1024;
    int nfds = 0;
    
    // 分配内存
    fds = malloc(max_fds * sizeof(struct pollfd));
    if (!fds) {
        return -1;
    }
    
    // 初始化
    memset(fds, 0, max_fds * sizeof(struct pollfd));
    
    // 主循环
    while (1) {
        int ready;
        
        // 使用安全的 poll 调用
        do {
            ready = poll(fds, nfds, 1000);  // 1秒超时
        } while (ready == -1 && errno == EINTR);
        
        if (ready == -1) {
            if (errno != EINTR) {
                perror("poll error");
                break;
            }
            continue;
        }
        
        if (ready == 0) {
            // 超时处理
            continue;
        }
        
        // 处理事件
        for (int i = 0; i < nfds; i++) {
            if (fds[i].revents != 0) {
                // 检查错误
                if (handle_io_errors(fds[i].fd, fds[i].revents, "main loop") == -1) {
                    // 处理错误连接
                    continue;
                }
                
                // 处理正常事件
                if (fds[i].revents & POLLIN) {
                    // 处理可读事件
                }
                
                if (fds[i].revents & POLLOUT) {
                    // 处理可写事件
                }
            }
        }
    }
    
    // 清理资源
    if (fds) {
        free(fds);
    }
    
    return 0;
}

// 2. 资源管理模板
typedef struct {
    int epoll_fd;
    int *client_fds;
    int client_count;
    int max_clients;
} server_context_t;

int init_server_context(server_context_t *ctx, int max_clients) {
    ctx->epoll_fd = -1;
    ctx->client_fds = NULL;
    ctx->client_count = 0;
    ctx->max_clients = max_clients;
    
    // 创建 epoll
    ctx->epoll_fd = epoll_create1(0);
    if (ctx->epoll_fd == -1) {
        return -1;
    }
    
    // 分配客户端数组
    ctx->client_fds = malloc(max_clients * sizeof(int));
    if (!ctx->client_fds) {
        close(ctx->epoll_fd);
        ctx->epoll_fd = -1;
        return -1;
    }
    
    return 0;
}

void cleanup_server_context(server_context_t *ctx) {
    if (ctx->epoll_fd != -1) {
        close(ctx->epoll_fd);
        ctx->epoll_fd = -1;
    }
    
    if (ctx->client_fds) {
        free(ctx->client_fds);
        ctx->client_fds = NULL;
    }
    
    ctx->client_count = 0;
}

通过以上详细的对比分析和示例代码，我们可以清楚地看到各种 I/O 多路复用机制的特点和适用场景。选择合适的机制对于构建高性能的网络应用程序至关重要。