Linux 核心 IO 模型深析：CMake 构建与 Poll 多路转接实现

【二】poll 接口介绍

（1）函数原型

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

（2）参数说明

（1）第一个参数

参数描述：指向结构体 pollfd 类型的指针（管理多个文件描述符可以是 struct pollfd 类型的数组）。

struct pollfd {
    int fd;             // 要监听的文件描述符（-1 表示忽略此结构体）
    short events;       // 要监听的事件（输入参数，由程序设置）
    short revents;      // 实际发生的事件（输出参数，由内核填充）
};

监听事件选项：即 events 由你设置选项，revents 由 poll 调用之后由操作系统给你填写。

（2）第二个参数

参数描述：数组中有效结构体的数量（必须大于 0），可理解为监听的文件描述符个数。

（3）第三个参数

参数描述：超时时间（单位：毫秒）。>0 最大返回时间；=0 非阻塞立刻返回；=-1 阻塞使用。

（3）返回值

• 成功：返回就绪的文件描述符总数（可能为 0，即超时）
• 失败：返回 -1，且设置 errno（如 EINTR 表示被信号中断，可重试）

（4）特点

（1）只要有事件就绪就会一直通知你，这和 select 通知特点一样

（2）监听个数由用户决定，受限于系统资源，而 select 受限于自身数组

（3）输入和输出分离，而 select 输入输出是合并的

（4）每次调用不需要重新设置监听集合

（5）函数使用

（1）建立关心数组

#define max_num_size 10
struct pollfd fds[max_num_size];

（2）初始化关心数组

void Initialize_struct() {
    for(int i=0; i<max_num_size; i++) {
        fds[i].fd = -1;
    }
}

（3）设置 poll

先将 listen 套接字添加到关心数组，再根据 poll 的返回值判断是否需要处理新链接。

void Deal() {
    // 初始化结构体
    Initialize_struct();
    // 将 listen 套接字添加到关心结构体
    fds[0].fd = _V.Fd();
    fds[0].events = POLLIN;
    
    for(;;) {
        // 计算关心的个数
        int nods = 0;
        for(nods=0; nods<max_num_size; nods++) {
            if(fds[nods].fd == -1) continue;
            else nods++;
        }
        
        // 调用 poll
        int po = poll(fds, nods, 1000);
        
        // 判断事件
        switch (po) {
            case 0: {
                std::cout << "等待超时" << std::endl;
                break;
            }
            case -1: {
                // log_message(LOG_LEVEL_ERROR,__FILE__,__LINE__,"错误码：%d,错误信息：%s",errno,strerror(errno));
                break;
            }
            default: {
                // 处理新链接
                Handle();
                break;
            }
        }
    }
}

（4）任务处理

遍历关心数组： 如果是 listen 套接字 并且 该套接字准备就绪，就将 accept 返回的文件描述符重新添加到关心数组。 如果不是 listen 套接字 并且 该套接字又准备就绪，说明是读端（只关心了读），可以直接 recv。

void Handle() {
    for(int i=0; i<max_num_size; i++) {
        // 如果是 listen 套接字且 listen 套接字准备就绪
        if(fds[i].fd == _V.Fd() && fds[i].revents & POLLIN) {
            Accept();
        } else if(fds[i].revents & POLLIN) { // 需要判断该文件描述符的读端是否就绪
            Recv(i);
        }
    }
}

（5）添加新链接

找到下标为 -1 的空余结构体位置，将 accept 返回的进行添加。

void Accept() {
    // 获取 accept 文件描述符
    int fd = _V.Accept();
    // 添加到关心结构体
    int i;
    for(i=0; i<max_num_size; i++) {
        if(fds[i].fd == -1) break;
    }
    if(i == max_num_size) {
        std::cout << "连接数已满" << std::endl;
        close(fd);
    }
    // 添加
    fds[i].fd = fd;
    fds[i].events = POLLIN;
}

（6）读取数据

读取对应文件描述符即可。

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

（7）效果演示

首先我们创建 Cmake 文件：

避免垃圾信息干扰当前目录，我们新建一个目录，执行 cmake .. 指令，再执行 make，运行程序。

运行效果：

（8）完整代码

注意：以下类中，Accept() 为服务器 accept 函数。

// 辅助数组大小
#define max_num_size 10

class Media {
public:
    void Install() {
        _V.Socket();     // 绑定
        _V.Bind();       // 发起连接
        _V.Listen();
    }

    void Initialize_struct() {
        for(int i=0; i<max_num_size; i++) {
            fds[i].fd = -1;
        }
    }

    void Accept() {
        // 获取 accept 文件描述符
        int fd = _V.Accept();
        // 添加到关心结构体
        int i;
        for(i=0; i<max_num_size; i++) {
            if(fds[i].fd == -1) break;
        }
        if(i == max_num_size) {
            std::cout << "连接数已满" << std::endl;
            close(fd);
        }
        // 添加
        fds[i].fd = fd;
        fds[i].events = POLLIN;
    }

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

    void Handle() {
        for(int i=0; i<max_num_size; i++) {
            // 如果是 listen 套接字且 listen 套接字准备就绪
            if(fds[i].fd == _V.Fd() && fds[i].revents & POLLIN) {
                Accept();
            } else if(fds[i].revents & POLLIN) { // 需要判断该文件描述符的读端是否就绪
                Recv(i);
            }
        }
    }

    void Deal() {
        // 初始化结构体
        Initialize_struct();
        // 将 listen 套接字添加到关心结构体
        fds[0].fd = _V.Fd();
        fds[0].events = POLLIN;
        
        for(;;) {
            // 计算关心的个数
            int nods = 0;
            for(nods=0; nods<max_num_size; nods++) {
                if(fds[nods].fd == -1) continue;
                else nods++;
            }
            
            // 调用 poll
            int po = poll(fds, nods, 1000);
            
            // 判断事件
            switch (po) {
                case 0: {
                    std::cout << "等待超时" << std::endl;
                    break;
                }
                case -1: {
                    // log_message(LOG_LEVEL_ERROR,__FILE__,__LINE__,"错误码：%d,错误信息：%s",errno,strerror(errno));
                    break;
                }
                default: {
                    // 处理新链接
                    Handle();
                    break;
                }
            }
        }
    }

private:
    Server _V;
    struct pollfd fds[max_num_size];
};