Linux 核心 IO 模型深析：非阻塞 IO 与多路转接实现

如果不设置 fcntl()，我们看看是什么效果：recv 一直是阻塞的，读到数据才会有返回值。

重点：fcntl() 直接使用

非阻塞使用顺序：先查原状态，再添加非阻塞状态，再更新文件描述符属性。

为什么要 |=？因为会去除原来的文件属性，|= 为继续添加新属性。

// new_token 是操作的文件描述符
// 1: 查看当前状态
int fc = fcntl(new_token, F_GETFL);
if (fc == -1) {
    std::cout << "fcntl 获取标志失败" << std::endl;
}
// 2: 继续添加非阻塞 (关键)
fc |= O_NONBLOCK;
// 3: 写入新状态
if (fcntl(new_token, F_SETFL, fc) == -1) {
    perror("fcntl F_SETFL error");
    exit(0);
}

多路转接——select

**特点：**一次操控多个文件描述符，且支持读、写、监听状态。

函数接口介绍

原型：

#include <sys/select.h>
// 返回值：有事件的 fd 数量；失败返回 -1；超时返回 0
int select(int nfds, // 要监听的最大 fd + 1
           fd_set *readfds,   // 要监听'可读事件'的 fd 集合
           fd_set *writefds,  // 要监听'可写事件'的 fd 集合
           fd_set *exceptfds, // 要监听'异常事件'的 fd 集合
           struct timeval *timeout); // 等待超时时间

返回值：

• >0：返回的数字是'触发事件的 fd 总数'，需要用 FD_ISSET() 逐个查具体的文件描述符，例如：

// 监听 fd0（标准输入）和 fd5（客户端）
int ret = select(6, &read_fds, NULL, NULL, &tv);
if (ret > 0) {
    // 逐个检查哪个 fd 有事件
    if (FD_ISSET(0, &read_fds)) {
        /* 处理 fd0 */
    }
    if (FD_ISSET(5, &read_fds)) {
        /* 处理 fd5 */
    }
}

• =0：表明没有事件就绪。
• -1：表明调用错误，可通过 errno 分类调查具体的错误原因。

参数详解

1. 第一个参数

   • 理解：告诉它最大要查到哪个编号，比如 3,4,5,6，最大要查到 6，即 nfds = 6+1。
   • 填写：最大文件描述符 +1。

2. 第二个参数（输入输出型）

   • 理解：告诉它要帮你管理哪些文件描述符的读状态，如果列表中的文件读状态就绪了，就告诉我。
   • 填写：需要一个 fd_set 类型的变量，比如 fd_set set;。

3. 第三个参数（输入输出型）

   • 理解：告诉它要帮你管理哪些文件描述符的写状态，如果列表中的文件写状态就绪了，就告诉我。
   • 填写：和（第二个参数）一样的变量类型。

4. 第四个参数（输入输出型）

   • 理解：告诉它要帮你管理哪些文件描述符的监听状态，如果列表中的文件有情况，就告诉我。
   • 填写：和（第二个参数）一样的变量类型。

5. 第五个参数（输入输出型）

   • 理解：设置等待方式，比如每隔 5 秒检测一次，每隔 1 秒检测一次。（每次需要重复设置）。
   • 填写：需要 struct timeval 类型的结构体变量，例如：

struct timeval {
    long tv_sec;   // 秒
    long tv_usec;  // 微秒（1 秒=1000000 微秒）
};

• timeout = NULL：一直等，直到有 fd 有事件（死等，类似阻塞模式）。
• timeout = {0, 0}：不等待，直接返回当前有事件的 fd（非阻塞模式）。
• timeout = {5, 0}：最多等 5 秒，没事件就返回 0。

select 使用说明

（1）等待时间注意

select() 的第三个参数表示最多等待多长时间，因此：一但有客户端连接，就会直接跳过等待。

如果没有客户端连接，每次调用 select() 需要重新设置时间，因为该参数是输入输出特点。

（2）输入输出参数

准确来说除了第一个参数，其它都是输入输出参数，即每次调用需要重新设置。

多路转接使用教程

基本结构

既然 select() 属于输入输出结构的，所以需要在循环里面去重新设置。

它可以代替 accept() 去处理等的时间，当有新链接到来再交给 accept() 处理。

_V.Socket(); // 绑定
_V.Bind();   // 发起连接
_V.Listen(); // 创建套接字
int socket = _V.Fd();
for (;;) {
    fd_set set;
    // 清空
    FD_ZERO(&set);
    // 添加文件描述符
    FD_SET(socket, &set);
    // 设置时间
    struct timeval tim = {2, 0};
    int sel = select(socket + 1, &set, nullptr, nullptr, &tim);
    // 判断事件
    switch (sel) {
        case 0: {
            std::cout << "没有客户端访问我...." << std::endl;
            break;
        }
        case -1: {
            std::cout << "select 调用失败" << std::endl;
            break;
        }
        default: {
            // 处理新链接
            Handle(set);
        }
    }
}

判断 listen 套接字

此时说明有新链接到来，先判断是不是那个 listen 套接字，再执行 accept() 处理新链接请求：

void Handle(fd_set set) {
    // 如果该 listen 监听的套接字准备就绪了
    if (_arry[i] == _V.Fd() && FD_ISSET(_V.Fd(), &set)) {
        // 可以直接 accept 不会阻塞
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        socklen_t sz = sizeof(addr);
        int new_token = accept(_V.Fd(), (sockaddr*)&addr, &sz);
    }
}

但是 accept() 之后就说明有数据了吗？我们还需要添加到 set 里面让 select() 管理，但出现一个问题：如果现在添加，那么下次调用 select() 会被重置，所以我们需要辅助数组！数组的大小我们设置为 fd_set 的大小：这里需要讲解一下 fd_set 的大小：所以需要 *8。

select() 的读写监听是操作的位图，例如 0000 0000 监控 1 号——>0000 0001

再监控 2 号——>0000 0021

那么执行步骤：将 accept() 返回的加入辅助数组下标为 -1 的位置。

// 找到添加的位置
int j = 1;
for (j; j < max_num_arry; j++) {
    if (_arry[j] != -1) continue;
    else break;
}
// 如果数组满了
if (j == max_num_arry) {
    std::cout << "满了，执行错误" << std::endl;
    close(new_token);
} else {
    // 添加到数组
    std::cout << "成功添加到数组" << std::endl;
    _arry[j] = new_token;
}

判断读端

此时如果不是 listen 套接字，那么就只能是读端了。

else if (FD_ISSET(_arry[i], &set)) // 就绪了才能读取
{
    std::cout << "recv" << std::endl;
    sleep(1);
    char buffer[1024] = {0};
    ssize_t d = recv(_arry[i], buffer, sizeof(buffer) - 1, 0);
    if (d > 0) {
        buffer[d] = 0;
        std::cout << "客户端发送了数据 : ";
        std::cout << buffer << std::endl;
    } else if (d == 0) {
        // 对方断开了连接
        close(_arry[i]);
        _arry[i] = -1; // 关闭当前的文件描述符，并且从数组中删掉
    } else {
        // 读取错误
        close(_arry[i]);
        _arry[i] = -1;
    }
}

重新写入 set

select 的第一个参数需要保证是最大的，所以需要在辅助数组找最大值。 再把辅助数组中不是 -1 的重新添加到 fd_set 对应变量中。

完整代码

数组说明：

// 定义辅助数组
int _arry[max_num_arry] = {-1}; // (max_num_arry==sizeof(fd_set)*8)

如果 set 里面有准备好的文件描述符：

void Handle(fd_set set) {
    // 此时我们只关注了读，如果不是 listen 套接字说明是读端就绪了
    for (int i = 0; i < max_num_arry; i++) {
        if (_arry[i] == -1) continue;
        std::cout << "i==" << i << " " << "_arry[i]==" << _arry[i] << std::endl;
        // 如果是 listen 套接字，说明需要将 accept 返回的文件描述符再次添加到读端
        if (_arry[i] == _V.Fd() && FD_ISSET(_V.Fd(), &set)) {
            // 可以直接 accept 不会阻塞
            struct sockaddr_in addr;
            memset(&addr, 0, sizeof(addr));
            socklen_t sz = sizeof(addr);
            int new_token = accept(_V.Fd(), (sockaddr *)&addr, &sz);
            // 找到添加的位置
            int j = 1;
            for (j; j < max_num_arry; j++) {
                if (_arry[j] != -1) continue;
                else break;
            }
            // 如果数组满了
            if (j == max_num_arry) {
                std::cout << "满了，执行错误" << std::endl;
                close(new_token);
            } else {
                // 添加到数组
                std::cout << "成功添加到数组" << std::endl;
                _arry[j] = new_token;
            }
        } else if (FD_ISSET(_arry[i], &set)) // 就绪了才能读取
        {
            std::cout << "recv" << std::endl;
            sleep(1);
            char buffer[1024] = {0};
            ssize_t d = recv(_arry[i], buffer, sizeof(buffer) - 1, 0);
            if (d > 0) {
                buffer[d] = 0;
                std::cout << "客户端发送了数据 : ";
                std::cout << buffer << std::endl;
            } else if (d == 0) {
                // 对方断开了连接
                close(_arry[i]);
                _arry[i] = -1; // 关闭当前的文件描述符，并且从数组中删掉
            } else {
                // 读取错误
                close(_arry[i]);
                _arry[i] = -1;
            }
        }
    }
}

监听指定的文件描述符：

void Deal() {
    std::fill(_arry, _arry + max_num_arry, -1);
    // 创建套接字
    int socket = _V.Fd();
    _arry[0] = socket;
    // 借助辅助数组重新设置
    int max = _arry[0];
    for (;;) {
        fd_set set;
        // 清空
        FD_ZERO(&set);
        // 设置时间
        struct timeval tim = {2, 0};
        for (int i = 0; i < max_num_arry; i++) {
            std::cout << _arry[i] << " ";
            if (_arry[i] == -1) continue;
            // 说明存在文件描述
            // 添加到 set 里面
            FD_SET(_arry[i], &set);
            // 如果出现比 max 更大的文件描述符
            if (_arry[i] > max) max = _arry[i];
        }
        std::cout << std::endl;
        int sel = select(max + 1, &set, nullptr, nullptr, &tim);
        // 判断事件
        switch (sel) {
            case 0: {
                std::cout << "没有客户端访问我...." << std::endl;
                continue;
            }
            case -1: {
                std::cout << "select 调用失败" << std::endl;
                perror("failed to select call back");
                break;
            }
            default: {
                // 处理新链接
                Handle(set);
            }
        }
    }
}

整体思路讲解

首先由于 select 每次调用都会对描述符集全部清零，所以我们需要准备一个辅助数组：

那么对 select 描述符集的管理就变成了对辅助数组的增删管理！

如果 select 中有描述符就绪了，那么需要对就绪中的文件描述符进行判断：

1. 如果就绪中的是 listen 套接字的，说明需要将 accept 返回的文件描述符重新添加到数组。
2. 如果只有读端，那么剩余就绪中的是读端描述符了，代表有数据读取。

注意：此时需要遍历辅助数组进行判断，因为数组中的描述符集就代表 select 中就绪的。

总结

非阻塞 IO 通过 fcntl 设置标志位，避免了进程在等待 IO 时的挂起，适合少量连接的高频轮询场景。而多路转接 IO 利用 select 机制，允许单个线程同时监控多个文件描述符的状态，显著减少了上下文切换和线程开销，适用于中等规模的高并发服务。开发者应根据具体业务场景的连接数量和 IO 密集程度选择合适的模型。