UNIX下C语言编程与实践41-UNIX 单线程 I/O 超时处理：终端方式、信号跳转方式与多路复用方式

从终端专属到通用兼容，掌握单线程环境下 I/O 超时控制的核心方案

一、核心认知：为什么需要 I/O 超时处理？

在 UNIX 单线程程序中，I/O 操作（如 read、write、accept）默认是"阻塞式"的------若 I/O 无数据（如键盘未输入、网络无响应），进程会一直阻塞在 I/O 调用处，无法执行其他逻辑。这种特性在实际场景中存在严重问题：

• 终端输入超时：用户长时间未操作键盘，程序一直等待，影响用户体验；
• 网络 I/O 超时：客户端断开连接后，服务器仍阻塞在 read 调用，浪费系统资源；
• 设备 I/O 超时：外部设备（如打印机）故障，程序阻塞在 write 调用，导致整体流程卡死。

因此，I/O 超时处理成为单线程程序的核心需求------通过特定机制，让 I/O 操作在指定时间内无响应时自动返回，避免进程永久阻塞。UNIX 系统提供三种经典的单线程 I/O 超时方案，分别适用于不同场景，需根据 I/O 类型（终端、网络、设备）和功能需求选择。

二、方式一：终端方式------ioctl 配置终端超时（仅适用于终端设备）

终端设备（如键盘、串口）在 UNIX 中被视为特殊文件，可通过 ioctl 函数修改其属性（如输入超时、最小输入字符数）。这种方式仅针对终端 I/O，通过设置 VMIN（最小输入字符数）和 VTIME（超时时间），实现终端输入的超时控制。

1. 核心原理与参数

终端的输入模式由 struct termios 结构体控制，其中与超时相关的关键字段是 c_cc[VMIN] 和 c_cc[VTIME]，需通过 ioctl 或 tcsetattr 函数配置：

参数	含义	取值与效果
c_cc[VMIN]	最小输入字符数：read 函数返回前需读取的最小字符数	- VMIN = 0：read 不等待字符，有数据则返回，无数据则立即返回 0（结合 VTIME 实现超时）； - VMIN > 0：read 至少读取 VMIN 个字符才返回，或等待 VTIME 超时后返回已读取字符。
c_cc[VTIME]	超时时间（单位：1/10 秒，即 100 毫秒）：从调用 read 开始计时，超时后 read 强制返回	- VTIME = 0：无超时，read 一直阻塞直到读取 VMIN 个字符； - VTIME > 0：超时时间为 VTIME * 100ms（如 VTIME=30 表示 3 秒超时）。

核心逻辑 ：通过 ioctl 将终端设置为"非规范模式"（禁用行缓冲），再配置 VMIN 和 VTIME，使 read 函数在超时时间内无足够输入时自动返回，实现终端 I/O 超时。

2. 实战：用 ioctl 实现终端输入 3 秒超时

需求

从标准输入（键盘）读取用户输入，设置 3 秒超时------3 秒内无输入或输入不足，则 read 返回，提示超时；若有输入，则打印输入内容。

#include <stdio.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <stdlib.h>

// 配置终端超时：返回原终端属性，便于后续恢复
struct termios set_terminal_timeout(int fd, int vmin, int vtime) {
    struct termios old_attr, new_attr;

    // 1. 获取当前终端属性
    if (tcgetattr(fd, &old_attr) == -1) {
        perror("tcgetattr 获取终端属性失败");
        exit(EXIT_FAILURE);
    }
    new_attr = old_attr;

    // 2. 设置为非规范模式（禁用行缓冲，不等待回车）
    new_attr.c_lflag &= ~(ICANON | ECHO);  // ICANON：禁用规范模式；ECHO：禁用输入回显
    new_attr.c_cc[VMIN] = vmin;            // 最小输入字符数：0（不等待字符）
    new_attr.c_cc[VTIME] = vtime;          // 超时时间：30 → 30*100ms=3秒

    // 3. 应用新终端属性
    if (tcsetattr(fd, TCSANOW, &new_attr) == -1) {
        perror("tcsetattr 设置终端属性失败");
        exit(EXIT_FAILURE);
    }
    return old_attr;  // 返回原属性，用于恢复
}

int main() {
    char buf[128] = {0};
    int fd = STDIN_FILENO;  // 标准输入（键盘）文件描述符

    // 1. 配置终端：3秒超时（VTIME=30），不等待最小字符（VMIN=0）
    struct termios old_attr = set_terminal_timeout(fd, 0, 30);
    printf("请在 3 秒内输入内容（无需按回车）：\n");

    // 2. 读取终端输入（超时 3 秒）
    ssize_t n = read(fd, buf, sizeof(buf)-1);
    if (n == -1) {
        perror("read 失败");
        tcsetattr(fd, TCSANOW, &old_attr);  // 恢复终端属性
        return 1;
    } else if (n == 0) {  // 超时：无输入数据
        printf("\n3 秒超时，未收到任何输入\n");
    } else {  // 成功读取输入
        buf[n] = '\0';  // 添加字符串结束符
        printf("\n成功读取 %zd 个字符，内容：%s\n", n, buf);
    }

    // 3. 恢复终端原属性（避免影响后续终端使用）
    if (tcsetattr(fd, TCSANOW, &old_attr) == -1) {
        perror("tcsetattr 恢复终端属性失败");
        return 1;
    }
    return 0;
}

编译与运行说明

# 1. 编译程序
gcc ioctl_terminal_timeout.c -o ioctl_terminal_timeout

# 2. 运行程序（两种测试场景）
# 场景 1：3 秒内不输入
./ioctl_terminal_timeout

# 场景 2：3 秒内输入 "hello"
./ioctl_terminal_timeout

测试场景输出

# 场景 1：超时输出
请在 3 秒内输入内容（无需按回车）：
3 秒超时，未收到任何输入

# 场景 2：成功输入输出
请在 3 秒内输入内容（无需按回车）：
hello
成功读取 5 个字符，内容：hello

关键注意：

• 必须恢复终端原属性：终端属性修改后会影响后续终端操作（如禁用回车后无法正常输入），需在程序结束前通过 tcsetattr 恢复；
• 仅适用于终端设备：该方式依赖终端特有的 struct termios 属性，无法用于网络套接字（如 socket）、普通文件等非终端 I/O；
• 非规范模式：禁用 ICANON 后，终端输入无需按回车，read 会立即读取字符，符合实时输入场景需求。

二、方式二：信号跳转方式------setjmp/longjmp + alarm（通用但有风险）

信号跳转方式是一种通用的 I/O 超时方案，适用于所有类型的 I/O（终端、网络、设备）。其核心逻辑是：通过 alarm 函数设置超时定时器，超时后触发 SIGALRM 信号；在信号处理函数中调用 longjmp 跳转，中断阻塞的 I/O 调用，实现超时退出。

1. 核心原理与流程

信号跳转超时的完整流程：

1. 保存上下文 ：调用 setjmp 保存当前执行上下文到 jmp_buf 结构体，为后续跳转做准备；
2. 设置定时器 ：调用 alarm(seconds) 设置超时时间（如 3 秒），超时后内核发送 SIGALRM 信号；
3. 执行 I/O 操作 ：调用 read、write 等 I/O 函数，若 I/O 阻塞超过超时时间，SIGALRM 信号触发；
4. 信号跳转 ：SIGALRM 信号处理函数中调用 longjmp，恢复 setjmp 保存的上下文，程序跳回 setjmp 处，I/O 调用被中断；
5. 清理资源 ：跳转后取消 alarm 定时器，处理超时逻辑（如提示超时、重试 I/O）。

关键特性：

• 通用性：不依赖 I/O 类型，可用于终端、网络套接字、设备文件等所有 I/O 场景；
• 异步性：通过信号中断 I/O 阻塞，无需修改 I/O 本身的属性；
• 风险点 ：信号可能中断不可重入函数（如 malloc），导致数据错乱；且 alarm 与 ITIMER_REAL 定时器冲突，需避免同时使用。

2. 实战：用信号跳转实现 read 函数 3 秒超时

需求

从标准输入读取数据，设置 3 秒超时------3 秒内无数据则触发 SIGALRM 信号，通过 longjmp 跳转中断 read，提示超时；若读取成功，则打印数据。

代码实现

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <setjmp.h>
#include <stdlib.h>

// 全局变量：保存跳转上下文和超时标记（volatile 避免编译器优化）
jmp_buf g_jmp_env;
volatile int g_timeout_flag = 0;

// SIGALRM 信号处理函数：触发跳转
void sigalrm_handler(int sig) {
    g_timeout_flag = 1;
    longjmp(g_jmp_env, 1); // 跳转回 setjmp 处，setjmp 返回 1
}

// 带超时的 read 函数：timeout_sec 为超时秒数
ssize_t read_with_timeout(int fd, void *buf, size_t count, int timeout_sec) {
    // 1. 注册 SIGALRM 信号处理函数
    struct sigaction sa;
    sa.sa_handler = sigalrm_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    if (sigaction(SIGALRM, &sa, NULL) == -1) {
        perror("sigaction 注册 SIGALRM 失败");
        return -1;
    }

    // 2. 保存跳转上下文
    int ret = setjmp(g_jmp_env);
    if (ret == 0) {
        // 首次执行：设置定时器并执行 read
        alarm(timeout_sec); // 设置超时定时器
        ssize_t n = read(fd, buf, count); // 阻塞 I/O 操作
        alarm(0); // 读取成功，取消定时器
        return n;
    } else {
        // 跳转后执行：超时
        alarm(0); // 取消定时器
        errno = ETIMEDOUT; // 设置错误码为"超时"
        return -1;
    }
}

int main() {
    char buf[128] = {0};
    int fd = STDIN_FILENO;

    printf("请在 3 秒内输入内容（需按回车）：\n");

    // 调用带超时的 read 函数
    ssize_t n = read_with_timeout(fd, buf, sizeof(buf)-1, 3);
    if (n == -1) {
        if (errno == ETIMEDOUT) {
            printf("\n3 秒超时，未读取到数据\n");
        } else {
            perror("read_with_timeout 失败");
            return 1;
        }
    } else if (n == 0) {
        printf("\n读取到 EOF（输入被关闭）\n");
    } else {
        // 去除换行符（因输入需按回车，buf 末尾会有 '\n'）
        buf[strcspn(buf, "\n")] = '\0';
        printf("\n成功读取 %zd 个字符，内容：%s\n", n, buf);
    }

    return 0;
}

编译与运行

# 1. 编译程序
gcc signal_jump_timeout.c -o signal_jump_timeout

# 2. 运行程序（两种测试场景）
# 场景 1：3 秒内不输入
./signal_jump_timeout

# 场景 2：3 秒内输入 "unix" 并按回车
./signal_jump_timeout

测试场景输出

# 场景 1：超时输出
请在 3 秒内输入内容（需按回车）：
3 秒超时，未读取到数据

# 场景 2：成功输入输出
请在 3 秒内输入内容（需按回车）：
unix
成功读取 5 个字符，内容：unix

关键注意：

• 设置错误码：超时后手动将 errno 设为 ETIMEDOUT，便于调用者区分"超时错误"和其他错误（如 EINTR）；
• 取消定时器：I/O 成功读取后必须调用 alarm(0) 取消定时器，避免后续触发 SIGALRM 信号；
• 信号安全：信号处理函数中仅调用 longjmp 和简单赋值，避免使用不可重入函数（如 printf），防止数据错乱。

三、方式三：多路复用方式------select 监控 I/O 超时（最通用）

多路复用方式是 UNIX 单线程 I/O 超时的"通用解决方案"，通过 select 函数监控文件描述符的 I/O 就绪状态，并设置超时时间------超时前若 I/O 就绪，则执行 read/write；超时后 select 返回，避免 I/O 阻塞。该方式适用于所有类型的 I/O（终端、网络、设备），且支持同时监控多个文件描述符。

1. 核心原理与 select 函数

#include <sys/select.h>

// 功能：监控多个文件描述符的 I/O 就绪状态，支持超时设置
// 参数：
// nfds：需监控的最大文件描述符 + 1；
// readfds：需监控"读就绪"的文件描述符集合（如 read 前检查是否有数据）；
// writefds：需监控"写就绪"的文件描述符集合（如 write 前检查是否可写）；
// exceptfds：需监控"异常事件"的文件描述符集合（通常设为 NULL）；
// timeout：超时时间结构体，NULL 表示无超时（一直阻塞）；
// 返回值：
// - 成功：就绪的文件描述符数量；
// - 0：超时，无文件描述符就绪；
// - -1：失败，设置 errno（如 EINTR 被信号中断）。
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

// 辅助宏：操作文件描述符集合
void FD_ZERO(fd_set *set);      // 清空集合
void FD_SET(int fd, fd_set *set);  // 将 fd 加入集合
void FD_CLR(int fd, fd_set *set);  // 将 fd 从集合中移除
int FD_ISSET(int fd, fd_set *set); // 检查 fd 是否在集合中（就绪）

// 超时时间结构体
struct timeval {
    long tv_sec;  // 秒数
    long tv_usec; // 微秒数（0 ~ 999999）
};

核心逻辑：

1. 初始化文件描述符集合：将需监控的 I/O 文件描述符（如 stdin）加入 readfds；
2. 设置超时时间：通过 struct timeval 配置超时（如 3 秒）；
3. 调用 select 监控：若超时前 I/O 就绪（如键盘有输入），select 返回就绪数量，调用 read 读取数据；
4. 处理超时：若 select 返回 0，表示超时，执行超时逻辑。

2. 实战：用 select 实现标准输入 3 秒超时

需求

用 select 监控标准输入，设置 3 秒超时------3 秒内有输入则读取并打印，超时则提示超时。

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

// 用 select 实现 I/O 超时读取
ssize_t select_read_timeout(int fd, void *buf, size_t count, int timeout_sec) {
    fd_set readfds;
    struct timeval tv;

    // 初始化文件描述符集合
    FD_ZERO(&readfds);  // 清空集合
    FD_SET(fd, &readfds);  // 将 fd 加入读集合
    int nfds = fd + 1;  // 最大 fd + 1

    // 设置超时时间（timeout_sec 秒）
    tv.tv_sec = timeout_sec;
    tv.tv_usec = 0;  // 微秒数为 0

    // 调用 select 监控读就绪
    int ret = select(nfds, &readfds, NULL, NULL, &tv);
    if (ret == -1) {
        perror("select 失败");
        return -1;
    } else if (ret == 0) {  // 超时：无文件描述符就绪
        errno = ETIMEDOUT;
        return -1;
    }

    // 检查 fd 是否就绪，读取数据
    if (FD_ISSET(fd, &readfds)) {
        return read(fd, buf, count);
    }
    return 0;  // 理论上不会执行
}

int main() {
    char buf[128] = {0};
    int fd = STDIN_FILENO;
    printf("请在 3 秒内输入内容（需按回车）：\n");

    ssize_t n = select_read_timeout(fd, buf, sizeof(buf)-1, 3);
    if (n == -1) {
        if (errno == ETIMEDOUT) {
            printf("\n3 秒超时，未读取到数据\n");
        } else {
            perror("select_read_timeout 失败");
            return 1;
        }
    } else if (n == 0) {
        printf("\n读取到 EOF\n");
    } else {
        buf[strcspn(buf, "\n")] = '\0';
        printf("\n成功读取 %zd 个字符，内容：%s\n", n, buf);
    }
    return 0;
}

# 编译程序
gcc select_timeout.c -o select_timeout

# 运行程序
./select_timeout

# 超时场景
请在 3 秒内输入内容（需按回车）：
3 秒超时，未读取到数据

# 成功输入场景
请在 3 秒内输入内容（需按回车）：unix io
成功读取 7 个字符，内容：unix io

扩展能力：select 支持同时监控多个文件描述符，例如同时监控标准输入和网络套接字，示例：

// 同时监控 stdin（fd=0）和 socket（fd=3）
FD_ZERO(&readfds);
FD_SET(0, &readfds);
FD_SET(3, &readfds);
int nfds = 3 + 1; // 最大 fd 为 3
int ret = select(nfds, &readfds, NULL, NULL, &tv);
if (FD_ISSET(0, &readfds)) {
    /* 读取 stdin */
}
if (FD_ISSET(3, &readfds)) {
    /* 读取 socket */
}

四、三种 I/O 超时方式的对比与场景选择

三种 I/O 超时方式在通用性、复杂度、风险上存在显著差异，需根据 I/O 类型、功能需求和系统环境选择。以下是详细对比与选择指南：

1. 核心差异对比

对比维度	终端方式（ioctl）	信号跳转方式（setjmp/longjmp + alarm）	多路复用方式（select）
适用 I/O 类型	仅终端设备（如 stdin、串口）	所有类型（终端、网络、设备、普通文件）	所有类型（终端、网络、设备；普通文件始终就绪）
超时精度	100 毫秒（VTIME 单位为 1/10 秒）	秒级（alarm 精度为秒）	微秒级（struct timeval 支持微秒）
多 I/O 监控	不支持，仅能监控单个终端 fd	不支持，一次仅能监控一个 I/O	支持，可同时监控多个 fd（读/写/异常）
代码复杂度	中（需处理终端属性保存与恢复）	中（需处理信号、跳转上下文）	低（仅需操作 fd 集合和 select 调用）
风险与限制	仅终端可用；修改终端属性可能影响后续操作	信号可能中断不可重入函数；与 alarm/ITIMER_REAL 冲突	fd 数量限制（默认 1024）；超时时间结构体可能被修改
优点	终端场景下高效；不依赖信号，无中断风险	通用性强；无需修改 I/O 属性，仅中断阻塞	通用性最强；支持多 fd 监控；精度高；无信号风险
缺点	适用范围极窄；非终端 I/O 无法使用	信号安全风险；精度低；不支持多 fd	fd 数量有限制；超时时间需每次重新初始化

2. 场景选择指南

• 优先选择 select 方式的场景
  • 需要监控多个文件描述符（如同时处理键盘输入和网络数据）；
  • 对超时精度要求较高（如毫秒级超时）；
  • I/O 类型不确定（可能是终端、网络或设备）；
  • 避免信号中断风险（如程序中使用不可重入函数）。
• 选择信号跳转方式的场景
  • 单 I/O 场景，且对精度要求不高（秒级）；
  • 无法使用 select（如嵌入式系统不支持 select）；
  • 需最小化代码对 I/O 操作的修改（仅通过信号中断，不改变 I/O 本身）。
• 选择终端方式的场景
  • 仅需处理终端 I/O（如串口通信、键盘输入）；
  • 需禁用终端行缓冲（如实时读取键盘按键，无需按回车）；
  • 避免信号和 select 的额外开销（终端场景下更轻量）。

五、常见错误与解决方法

在使用三种 I/O 超时方式时，易因参数配置、资源清理或 API 特性误解导致错误。以下是高频错误及解决方法：

常见错误	问题现象	原因分析	解决方法
终端方式：未恢复终端属性	程序运行后，终端输入异常（如无回显、无需按回车），影响后续终端使用	修改终端属性（如禁用 ICANON、ECHO）后，未调用 tcsetattr 恢复原属性，导致终端保持非规范模式	1. 程序启动时通过 tcgetattr 保存原属性； 2. 程序结束前（包括异常退出）必须调用 tcsetattr 恢复； 3. 示例： struct termios old; tcgetattr(fd, &old); /* 业务逻辑 */ tcsetattr(fd, TCSANOW, &old);
信号跳转方式：信号中断不可重入函数	程序随机崩溃、内存泄漏或数据错乱（如 malloc 分配失败、链表结构损坏）	SIGALRM 信号中断了不可重入函数（如 malloc、printf、fopen）的执行，导致其全局数据结构损坏	1. 信号处理函数中仅调用 longjmp 和简单赋值，避免不可重入函数； 2. 关键逻辑（如 malloc）执行前，通过 sigprocmask 阻塞 SIGALRM 信号； 3. 示例： sigset_t mask; sigaddset(&mask, SIGALRM); sigprocmask(SIG_BLOCK, &mask, NULL); /* 不可重入函数调用 */ sigprocmask(SIG_UNBLOCK, &mask, NULL);
select 方式：fd 数量超过限制	select 调用失败，errno 为 EBADF 或 EINVAL，无法监控所有 fd	select 支持的最大 fd 数量默认为 1024（由 FD_SETSIZE 定义），超过该数量会导致调用失败	1. 增大 FD_SETSIZE：编译时添加 -D FD_SETSIZE=4096； 2. 改用 poll 或 epoll（Linux 特有），无 fd 数量限制； 3. 优化 fd 管理：关闭无用 fd，避免 fd 数量膨胀
select 方式：超时时间结构体被修改	首次 select 超时正常，后续调用超时时间异常（如立即返回或超时时间变长）	select 会修改 timeout 结构体的内容（将剩余时间写入），若未重新初始化，后续调用会使用剩余时间，导致超时异常	1. 每次调用 select 前，重新初始化 timeout 结构体； 2. 示例： while (1) { struct timeval tv = {3, 0}; select(..., &tv); /* 重新赋值 tv */ }
信号跳转方式：alarm 与 ITIMER_REAL 冲突	定时器超时时间与预期不符，或信号处理逻辑错乱	alarm 与 setitimer(ITIMER_REAL) 共享 SIGALRM 信号和内核定时器，同时使用会相互覆盖	1. 同一程序中禁止同时使用 alarm 和 ITIMER_REAL； 2. 若需高精度定时，改用 setitimer(ITIMER_VIRT) 或 ITIMER_PROF，避免与 alarm 冲突； 3. 示例： // 用 ITIMER_VIRT 替代 alarm，触发 SIGVTALRM 信号 setitimer(ITIMER_VIRT, &timer, NULL);

六、拓展：poll 与 epoll 函数（select 的替代方案）

select 函数存在"fd 数量限制""每次调用需重新初始化 fd 集合"等缺陷，UNIX 系统提供 poll 和 epoll（Linux 特有）作为替代方案，在多 fd 场景下更高效。

1. poll 函数：无 fd 数量限制的 select 替代

#include <poll.h>

// 功能：监控多个文件描述符的 I/O 就绪状态，无 fd 数量限制
// 参数：
//   fds：struct pollfd 数组，每个元素对应一个监控的 fd；
//   nfds：fds 数组的长度；
//   timeout：超时时间（单位：毫秒），-1 表示无超时，0 表示立即返回；
// 返回值：
//   - 成功：就绪的 fd 数量；
//   - 0：超时；
//   - -1：失败。
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

// 监控的 fd 结构体
struct pollfd {
    int fd;       // 待监控的文件描述符
    short events; // 关注的事件（如 POLLIN 表示读就绪）
    short revents;// 实际发生的事件（由 poll 填充）
};

// 常用事件标志
#define POLLIN  0x001 // 读就绪（有数据可读）
#define POLLOUT 0x004 // 写就绪（可写入数据）
#define POLLERR 0x008 // 错误事件
#define POLLHUP 0x010 // 挂起事件（如连接关闭）

与 select 的核心差异：

• 无 fd 数量限制：poll 通过数组长度 nfds 控制监控数量，理论上仅受内存限制；
• 事件分离：events 表示"关注的事件"，revents 表示"实际发生的事件"，无需每次重新初始化 fd 集合；
• 超时单位：poll 超时单位为毫秒，比 select 的微秒更直观，且无需处理 struct timeval 的修改问题。

超时处理示例：用 poll 实现标准输入 3 秒超时：

struct pollfd fds = {STDIN_FILENO, POLLIN, 0};  // 监控 stdin 读就绪
int ret = poll(&fds, 1, 3000);                 // 3000 毫秒 = 3 秒超时

if (ret == 0) {
    printf("超时\n");
} else if (ret > 0 && (fds.revents & POLLIN)) {
    read(STDIN_FILENO, buf, sizeof(buf));      // 读数据
}

2. epoll 函数（Linux 特有）：高效的多 fd 监控

epoll 是 Linux 内核为高并发场景设计的多路复用接口，采用"事件驱动"模型，仅在 fd 就绪时才通知进程，避免 select/poll 的"轮询所有 fd"开销，在万级以上 fd 场景下性能远超 select/poll。

#include <sys/epoll.h>

// 1. 创建 epoll 实例
int epoll_create(int size);
// size 为历史参数，现已忽略，传 1 即可

// 2. 向 epoll 实例添加/修改/删除 fd 监控
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
// op：EPOLL_CTL_ADD（添加）、EPOLL_CTL_MOD（修改）、EPOLL_CTL_DEL（删除）

// 3. 等待 fd 就绪，支持超时
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
// timeout：毫秒，-1 无超时，0 立即返回

// epoll 事件结构体
struct epoll_event {
    uint32_t events;  // 关注的事件（如 EPOLLIN）
    epoll_data_t data; // 关联数据（如 fd）
};

typedef union epoll_data {
    void *ptr;
    int fd;  // 常用：关联的文件描述符
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

核心优势：

• 高效事件通知：采用"回调"机制，fd 就绪时主动通知，无需轮询；
• 无 fd 数量限制：仅受系统内存和内核参数限制（如 /proc/sys/fs/epoll/max_user_watches）；
• 内存高效：fd 信息仅需注册一次，无需每次传递 fd 集合。

超时处理示例：用 epoll 实现标准输入 3 秒超时：

// 1. 创建 epoll 实例
int epfd = epoll_create(1);
struct epoll_event ev, events[1];
ev.events = EPOLLIN;  // 关注读就绪
ev.data.fd = STDIN_FILENO;

// 2. 添加 stdin 到 epoll 监控
epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev);

// 3. 等待就绪（3 秒超时）
int ret = epoll_wait(epfd, events, 1, 3000);
if (ret == 0) {
    printf("3 秒超时\n");
} else if (ret > 0 && (events[0].events & EPOLLIN)) {
    read(STDIN_FILENO, buf, sizeof(buf));
}

// 4. 清理
close(epfd);

本文详细讲解了 UNIX 单线程环境下三种 I/O 超时处理方式（终端方式、信号跳转方式、多路复用方式）的原理、实战应用、对比与常见错误，同时拓展了 poll 和 epoll 函数的使用。三种方式各有适用场景：终端方式适合终端专属 I/O，信号跳转方式适合简单单 I/O 场景，多路复用方式（select/poll/epoll）是通用且推荐的方案。

在实际开发中，需根据 I/O 类型、精度需求和并发量选择：

• 终端 I/O 且需实时按键读取 → 选择 ioctl 方式；
• 单 I/O 且无信号风险 → 选择信号跳转方式；
• 多 I/O 监控、高精度超时或通用场景 → 选择 select/poll/epoll 方式；
• Linux 高并发场景（万级 fd） → 选择 epoll 方式。

掌握 I/O 超时处理，是编写健壮 UNIX 单线程程序的关键，尤其在网络编程、终端交互和设备控制中，能有效避免进程永久阻塞，提升程序的稳定性和用户体验。