【Linux系统编程】I/O多路复用

I/O多路复用（I/O多路转接）

(传统IO：Input: 从文件读入内存中 output: 从内存写入到文件中)

I/O 多路复用使得程序能同时监听多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用的系统调用主要有 select、poll 和 epoll。

阻塞等待(Bloking IO, BIO)

使用read()、accept()等阻塞函数时。会触发阻塞等待：

• 好处：不占用CPU宝贵的时间片

• 缺点：同一时刻只能处理一个操作,效率低

  • 解决办法：多线程或者多进程解决

    • 优点：支持并发

    • 缺点：

      1. 线程或者进程会消耗资源

      2. 线程或进程调度消耗CPU资源

BIO模型

非阻塞，忙轮询(Nonblocking IO, NIO)

将read() 、accept()设置为非阻塞，但是需要轮询，需要对每个通信询问是否有数据到达

• 优点：提高了程序的执行效率
• 缺点：需要占用更多的CPU和系统资源
• 解决办法：使用IO多路转接技术select/poll/epoll

设置socket为非阻塞non-blocking

使用socket()创建的socket(file descriptor)，默认是阻塞的(blocking)；使用函数fcntl()(file control)可设置创建的socket为非阻塞的non-blocking。

#include 
#include 

sock = socket(PF_INET, SOCK_STREAM, 0);
int flags = fcntl(sock, F_GETFL, 0);
fcntl(sock, F_SETFL, flags | O_NONBLOCK); 

这样使用原本blocking的各种函数，可以立即获得返回结果。通过判断返回的errno了解状态：

• accept()：在non-blocking模式下，如果返回值为-1，且errno == EAGAIN或errno == EWOULDBLOCK表示no connections没有新连接请求；

• recv()/recvfrom()：在non-blocking模式下，如果返回值为-1，且errno == EAGAIN表示没有可接受的数据或正在接受尚未完成；

• send()/sendto()：在non-blocking模式下，如果返回值为-1，且errno == EAGAIN或errno == EWOULDBLOCK表示没有可发送数据或数据发送正在进行没有完成。

• read/write：在non-blocking模式下，如果返回-1，且errno == EAGAIN 表示没有可读写数据或可读写正在进行尚未完成。

• connect()：在non-bloking模式下，如果返回-1，且errno = EINPROGRESS表示正在连接。

参考：https://blog.csdn.net/qq_17308321/article/details/73188035

IO多路转接技术

第一种：select/poll

select

主旨思想：

1. 首先要构造一个关于文件描述符的列表，将要监听的文件描述符添加到该列表中。
2. 调用一个系统函数select()，监听该列表中的文件描述符，直到这些描述符中的一个或者多个进行I/O
   操作时，该函数才返回。
   a. 这个函数是阻塞函数
   b. 函数对文件描述符的检测的操作是由内核完成的
3. 在返回时，它会告诉进程有多少（哪些）描述符要进行I/O操作。

select()工作过程分析

缺点：

// sizeof(fd_set) = 128(Bytes) -> 1024(Bit) 每一位对应一个文件描述符
#include 
#include 
#include 
#include 
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
    - 参数：
        - nfds : 委托内核检测的 最大文件描述符 的值 + 1  
            eg. 最大文件描述符 = 101   在内核中遍历 [0,102) 中需要检测的文件描述符属性是否发生改变
        - readfds : 要检测的文件描述符的 读的集合，委托内核检测那些文件描述符的读的属性
                    - 一般检测读操作
                    - 对应的是对方发送过来的数据，因为读是被动的接收数据，检测的就是读缓冲区
                    - 是一个传入传出参数
        - writefds : 要检测的文件描述符的 写的集合，委托内核检测哪些文件描述符的写的属性
        			- 委托内核检测写缓冲区是不是还可以写数据（缓冲区不满就可以写）
        - exceptfds : 检测发生异常的文件描述符的集合
        - timeout : 设置的超时时间
            struct timeval {
            long tv_sec; 	/* seconds */ 
            long tv_usec; 	/* microseconds */
            };
                - NULL : 永久阻塞，直到检测到了文件描述符有变化
                - tv_sec = 0 tv_usec = 0， 不阻塞
                - tv_sec > 0 tv_usec > 0， 阻塞对应的时间
    - 返回值 :
        - -1 : 失败
        - >0(n) : 检测的集合中有n个文件描述符发生了变化
// 将参数文件描述符fd对应的标志位设置为0
void FD_CLR(int fd, fd_set *set);
// 判断fd对应的标志位是0还是1， 返回值 ： fd对应的标志位的值，0，返回0， 1，返回1
int FD_ISSET(int fd, fd_set *set);
// 将参数文件描述符fd 对应的标志位，设置为1
void FD_SET(int fd, fd_set *set);
// fd_set一共有1024 bit, 全部初始化为0
void FD_ZERO(fd_set *set);

示例：基于select实现IO多路复用，使服务器同时支持多个客户端进行接入

#include 
#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
    // 创建socket
    int lfd = socket(AF_INET,SOCK_STREAM, 0);
    if(lfd == -1)
    {
        perror("socket");
        exit(-1);
    }
    struct sockaddr_in saddr;
    saddr.sin_addr.s_addr = INADDR_ANY;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    // 绑定
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if(ret == -1) {
        perror("bind");
        return -1;
    }
    // 监听
    listen(lfd, 128);
    // 创建一个fd_set集合，存放的是需要检测的文件描述符
    fd_set rdset, tmp;
    FD_ZERO(&rdset);
    FD_SET(lfd, &rdset);
    int maxfd = lfd;
    while(1)
    {
        tmp = rdset;
        // 调用select系统调用，让内核帮忙检测哪些文件描述符有数据
        ret = select(maxfd + 1, &tmp, NULL, NULL, NULL);
        if(ret == -1)
        {
            perror("select");
            exit(-1);
        }
        else if(ret == 0) continue;
        else if(ret > 0)
        {
            // 说明检测到了有文件描述符对应的读缓冲区的数据发生了改变
            if(FD_ISSET(lfd, &tmp))
            {
                // 有新的客户端连接进来
                struct sockaddr_in cliaddr;
                int len = sizeof(cliaddr);
                int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
                
                char cliIP[16];
                inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, cliIP, sizeof(cliIP));
                int port = ntohs(cliaddr.sin_port);
                // 输出客户端的信息
                printf("client's ip is %s, and port is %d\n", cliIP, port);

                // 将新的文件描述符加入到集合中
                FD_SET(cfd, &rdset);
                maxfd = maxfd > cfd ? maxfd: cfd;
            }
            for(int i = lfd + 1; i <= maxfd; ++i)
            {
                if(FD_ISSET(i, &tmp))
                {
                    // 说明这个文件描述符对应的客户端发来了数据
                    char buf[1024] = {0};
                    ret = read(i, buf, sizeof(buf));
                    if(ret == -1)
                    {
                        perror("read");
                        exit(-1);
                    }
                    else if(ret == 0)
                    {
                        printf("client closed...\n");
                        close(i);
                        FD_CLR(i, &rdset);
                    }
                    else if(ret > 0)
                    {
                        printf("read buf = %s\n", buf);
                        write(i, buf, strlen(buf) + 1);
                    }
                }
            }
        }
    }
    close(lfd);
    return 0; 
}

poll

#include 
struct pollfd {
    int fd; 		/* 委托内核检测的文件描述符 */
    short events; 	/* 委托内核检测文件描述符的什么事件 */
    short revents; 	/* 文件描述符实际发生的事件 */
};
struct pollfd myfd;
myfd.fd = 5;
myfd.events = POLLIN | POLLOUT;

int poll(struct pollfd *fds, nfds_t nfds, int timeout);
    - 参数：
        - fds : 是一个struct pollfd 结构体数组，这是一个需要检测的文件描述符的集合
        - nfds : 这个是第一个参数数组中最后一个有效元素的下标 + 1
        - timeout : 阻塞时长(单位：ms)
            0  : 不阻塞
            -1 : 阻塞，当检测到需要检测的文件描述符有变化，解除阻塞
            >0 : 阻塞的时长
    - 返回值：
        -1 : 失败
        >0(n) : 成功,n表示检测到集合中有n个文件描述符发生变化

示例：基于poll实现IO多路复用，使服务器同时支持多个客户端进行接入

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define LINKMAXCOUNTS 1024

int main()
{
    // 创建socket
    int lfd = socket(AF_INET,SOCK_STREAM, 0);
    if(lfd == -1)
    {
        perror("socket");
        exit(-1);
    }
    struct sockaddr_in saddr;
    saddr.sin_addr.s_addr = INADDR_ANY;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;

    // 绑定
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if(ret == -1) {
        perror("bind");
        return -1;
    }

    // 监听
    listen(lfd, 128);

    // 初始化检测的文件描述符数组
    struct pollfd fds[LINKMAXCOUNTS];
    for(int i = 0; i < LINKMAXCOUNTS; i++)
    {
        fds[i].fd = -1;
        fds[i].events = POLLIN;
    }
    fds[0].fd = lfd;
    int nfds = 0;

    while(1)
    {
        // 调用poll系统调用，让内核帮忙检测哪些文件描述符有数据
        int ret = poll(fds, nfds + 1, -1);
        if(ret == -1)
        {
            perror("select");
            exit(-1);
        }
        else if(ret == 0) continue;
        else if(ret > 0)
        {
            // 说明检测到了有文件描述符对应的读缓冲区的数据发生了改变
            if(fds[0].revents & POLLIN)
            {
                // 有新的客户端连接进来
                struct sockaddr_in cliaddr;
                int len = sizeof(cliaddr);
                int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
                
                char cliIP[16];
                inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, cliIP, sizeof(cliIP));
                int port = ntohs(cliaddr.sin_port);
                // 输出客户端的信息
                printf("client's ip is %s, and port is %d\n", cliIP, port);

                // 将新的文件描述符加入到集合中
                for(int i = 1; i < LINKMAXCOUNTS; ++i)
                {
                    if(fds[i].fd == -1)
                    {
                        fds[i].fd = cfd;
                        fds[i].events = POLLIN;
                        // 更新最大的文件描述符的索引
                        nfds = nfds > i ? nfds: i;
                        break;
                    }
                }
            }
            for(int i = 1; i <= nfds; ++i)
            {
                if(fds[i].revents & POLLIN)
                {
                    // 说明这个文件描述符对应的客户端发来了数据
                    char buf[1024] = {0};
                    ret = read(fds[i].fd, buf, sizeof(buf));
                    if(ret == -1)
                    {
                        perror("read");
                        exit(-1);
                    }
                    else if(ret == 0)
                    {
                        printf("client closed...\n");
                        close(fds[i].fd);
                        fds[i].fd = -1;
                    }
                    else if(ret > 0)
                    {
                        printf("read buf = %s\n", buf);
                        write(fds[i].fd, buf, strlen(buf) + 1);
                    }
                }
            }
        }
    }
    close(lfd);
    return 0; 
}

第二种：epoll

克服select的缺点：

poll：

1. 不再限制文件描述符数量，表示为一个数组格式。
2. fds集合可以重用，不再需要重置。

epoll：（在poll基础上）

1. 存储位置不同：直接在内核空间中建立了一个结构体eventpoll，将对应要检测的文件描述符都保存在其中，省去了将数据从用户空间拷贝到内核空间，再拷贝回去的开销，直接对内核空间的数据进行操作。
2. 数据结构不同：之前文件描述符存放在线性数组结构中，现在存放在红黑树rbr的结构中，遍历效率非常快。
3. 检测之后直接返回数据发生改变的文件描述符集合，不需要在用户空间重复遍历检测。

rbr：存放要求检测的文件描述符，rbr是红黑树结构的根节点。

rdlist：就绪链表，在要求检测的文件描述符中哪些已经检测出数据发生改变的。

#include 
/* 
    创建一个新的epoll实例。在内核中创建了一个数据，这个数据中有两个比较重要的数据，一个是需要检
    测的文件描述符的信息（红黑树），还有一个是就绪列表，存放检测到数据发送改变的文件描述符信息（双向
    链表）。
*/
int epoll_create(int size);
    - 参数：
        size : 目前没有意义了。随便写一个数，必须大于0
    - 返回值：
        -1 : 失败
        >0 : 文件描述符，操作epoll实例的
                
// 对epoll实例进行管理：添加文件描述符信息，删除信息，修改信息
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    - 参数：
        - epfd : epoll实例对应的文件描述符
        - op : 要进行什么操作
            EPOLL_CTL_ADD: 注册目标fd到epfd中, 同时关联event到fd上
            EPOLL_CTL_MOD: 修改已经注册到fd的监听事件
            EPOLL_CTL_DEL: 从epfd中删除/移除已注册的fd, event可以被忽略, 也可以为NULL
        - fd : 要检测的文件描述符
        - event : 检测文件描述符什么事情(读/写)
            
        struct epoll_event {
            uint32_t events; 	/* Epoll events */
            epoll_data_t data; 	/* User data variable */
        };
        常见的Epoll检测事件events：
        - EPOLLIN：表示关联的fd可以进行读操作了
        - EPOLLOUT：表示关联的fd可以进行写操作了。
        - EPOLLERR：表示关联的fd发生了错误, epoll_wait会一直等待这个事件, 一般没必要设置这个属性。
        - EPOLLET： 设置边沿触发
        - EPOLLRDHUP: 表示套接字关闭了连接, 或者关闭了正写一半的连接。
        - EPOLLHUP
        - EPOLLONESHOT:  操作系统最多触发其上注册的一个可读、可写或者异常事件，且只触发一次
// cited from: https://blog.csdn.net/weixin_33277243/article/details/116609618
            
// 联合体(union)在C语言中是一个特殊的数据类型，能够存储不同类型的数据在同一个内存位置。可以定义一个联合体使用许多成员，但只有一个部件可以包含在任何时候给定的值。
// union所占用的内存将大到足以容纳联合体的最大成员
// ps.由于联合体的成员使用同一块儿地址，因此我们可以通过联合体来巧妙的判断当前机器的存储方式是大端字节序还是小端字节序 
// cited from: https://blog.csdn.net/weixin_56505730/article/details/124505214
        typedef union epoll_data {
            void *ptr;
            int fd;
            uint32_t u32;
            uint64_t u64;
        } epoll_data_t;
                
// 检测函数
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int
timeout);
    - 参数：
        - epfd : epoll实例对应的文件描述符
        - events : 传出参数，保存了发生变化的文件描述符的信息
        - maxevents : 第二个参数结构体数组的大小
        - timeout : 阻塞时间
            - 0 : 不阻塞
            - -1 : 阻塞，直到检测到fd数据发生变化，解除阻塞
            - > 0 : 阻塞的时长（毫秒）
    - 返回值：
        - 成功，返回发送变化的文件描述符的个数 > 0
        - 失败 -1

epoll的各个事件触发条件测试:

• listen fd，有新连接请求，触发EPOLLIN。
• 对端发送普通数据，触发EPOLLIN。
• 带外数据，只触发EPOLLPRI。
• 对端正常关闭（程序里close()，shell下kill或ctr+c），触发EPOLLIN和EPOLLRDHUP，但是不触发EPOLLERR和EPOLLHUP。
• 对端异常断开连接（只测了拔网线），没触发任何事件。

示例：基于epoll实现IO多路复用，使服务器同时支持多个客户端进行接入

#include 
#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
    // 创建socket
    int lfd = socket(AF_INET,SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_addr.s_addr = INADDR_ANY;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    // 绑定
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    // 监听
    listen(lfd, 128);
    // 调用epoll_create()创建一个epoll示例
    int epfd = epoll_create(100);
    // 将监听的文件描述符相关的监测信息添加到epoll实例中
    struct epoll_event epev;
    epev.events = EPOLLIN;
    epev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);
    struct epoll_event epevs[1024];
    while(1)
    {
        ret = epoll_wait(epfd, epevs, sizeof(epevs) / sizeof(struct epoll_event), -1);
        if(ret == -1)
        {
            perror("epoll_wait");
            exit(-1);
        }
        printf("已经检测到变化的文件描述符数量 = %d\n", ret);
        for(int i = 0; i < ret; ++i)
        {
            int curfd = epevs[i].data.fd;
            if(curfd == lfd)
            {
                // 监听的文件描述符有数据到达(有客户端连接)
                struct sockaddr_in cliaddr;
                int len = sizeof(cliaddr);
                int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
                // epev.events = EPOLLIN | EPOLLOUT;
                epev.events = EPOLLIN;
                epev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
            }
            else{
                // 判断不同事件 并进行对应处理
                if(epevs[i].events & EPOLLIN)
                {
                    // 有数据到达，需要通信
                    char buf[1024] = {0};
                    int len = read(curfd, buf, sizeof(buf));
                    if(len == -1)
                    {
                        perror("read");
                        exit(-1);
                    }
                    else if(len == 0)
                    {
                        printf("client closed...\n");
                        epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
                        close(curfd);
                    }
                    else if(len > 0)
                    {
                        printf("read buf = %s\n", buf);
                        write(curfd, buf, strlen(buf) + 1);
                    }
                }
            }
        }
    }
    close(lfd);
    close(epfd);
    return 0;
}

Epoll 的工作模式

• LT 模式 （水平触发）

  LT（level - triggered）是缺省的工作方式，并且同时支持 block 和 no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的 fd 进行 IO 操作。如果你不作任何操作（没有读数据或者读数据还剩余一部分），内核还是会继续通知你的。

  eg. 假设委托内核检测读事件 -> 检测fd的读缓冲区

  • 读缓冲区有数据 - > epoll检测到了会给用户通知
    • a.用户不读数据，数据一直在缓冲区，epoll 会一直通知
    • b.用户只读了一部分数据，epoll会通知
    • c.缓冲区的数据读完了，不通知

• ET 模式（边沿触发）

  ET（edge - triggered）是高速工作方式，只支持 no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了。

  请注意：如果一直不对这个 fd 作 IO 操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once）。

  • ET 模式在很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。

  • epoll工作在 ET 模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

  eg. 假设委托内核检测读事件 -> 检测fd的读缓冲区

  • 读缓冲区有数据 - > epoll检测到了会给用户通知
    • a.用户不读数据，数据一致在缓冲区中，epoll下次检测的时候就不通知了
    • b.用户只读了一部分数据，epoll不通知 （但是客户端再发送信息到读缓冲区就又会通知，即使原先读缓冲区依旧有数据）
    • c.缓冲区的数据读完了，不通知

示例：设置epoll为ET模式，即边沿触发。同时设置文件描述符属性为O_NONBLOCK，即非阻塞。在一次读取少量数据情况下循环读取出所有数据。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
    // 创建socket
    int lfd = socket(AF_INET,SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_addr.s_addr = INADDR_ANY;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    // 绑定
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    // 监听
    listen(lfd, 128);
    // 调用epoll_create()创建一个epoll示例
    int epfd = epoll_create(100);
    // 将监听的文件描述符相关的监测信息添加到epoll实例中
    struct epoll_event epev;
    epev.events = EPOLLIN;
    epev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);
    struct epoll_event epevs[1024];
    while(1)
    {
        ret = epoll_wait(epfd, epevs, sizeof(epevs) / sizeof(struct epoll_event), -1);
        if(ret == -1)
        {
            perror("epoll_wait");
            exit(-1);
        }
        printf("已经检测到变化的文件描述符数量 = %d\n", ret);
        for(int i = 0; i < ret; ++i)
        {
            int curfd = epevs[i].data.fd;
            if(curfd == lfd)
            {
                // 监听的文件描述符有数据到达(有客户端连接)
                struct sockaddr_in cliaddr;
                int len = sizeof(cliaddr);
                int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
                // 设置文件描述符cfd属性为非阻塞
                int flag = fcntl(cfd, F_GETFL);
                fcntl(cfd, F_SETFL, flag | O_NONBLOCK);

                epev.events = EPOLLIN | EPOLLET; // 设置边沿触发
                epev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
            }
            else{
                // 判断不同事件 并进行对应处理
                if(epevs[i].events & EPOLLIN)
                {
                    // 循环读取出所有数据
                    char buf[5];
                    int len = 0;
                    while((len = read(curfd, buf,sizeof(buf))) > 0)
                    {
                        // 打印数据
                        write(STDOUT_FILENO, buf, len);
                        // printf("recv data: %s\n", buf);
                        write(curfd, buf, len);
                    }
                    if(len == 0)
                    {
                        printf("client closed...\n");
                    }
                    else if(len == -1)
                    {
                        // 如果errno = EAGAIN 表示没有可读写数据或可读写正在进行尚未完成
                        if(errno == EAGAIN) 
                        {
                            char * cur = "data over...\n";
                            write(STDOUT_FILENO, cur, strlen(cur));
                        }
                        else{
                            perror("read");
                            exit(-1);
                        }
                    }
                }
            }
        }
    }
    close(lfd);
    close(epfd);
    return 0;
}