【webserver 前置知识 03】Linux网络编程入门其二，I/O多路复用

I/O多路复用

I/O多路复用使得程序能够同时监听多个文件描述符

LInux下实现I/O多路复用的系统调用主要由select、poll以及epoll（常问，要会自己写出来）

例子

阻塞等待

阻塞等待可以一定程度上提高程序运行的效率

优点是：不占用cpu的时间片；

缺点是：同一时刻只能处理一个操作，效率较低；

使用多线程/多进程解决上述问题

但是仍然有缺点：不论是线程还是进程都会消耗资源，且两者的调度也会消耗cpu资源

BIO模型

简单来说就是每个线程/进程对应一个client

缺点：还是会消耗cpu资源，根本原因是blocking导致的

非阻塞忙轮询

例如accept和read

如果没有accept或者read到预期的连接/数据，就会继续往下执行

如果需要不断查询，就要设置循环来增加阻塞

优点：提高程序执行效率

缺点：占用更多的CPU和系统资源

解决上述问题的办法是使用IO多路复用技术select/poll/epoll（epoll与前两者原理不同且效率更高）

select

主旨思想：

1、首先构建一个关于文件描述符的列表，把待监听的文件描述符添加到该列表中

2、调用一个系统函数，监听列表中的文件描述符，直到这些描述符中的一个或多个进行I/O操作时，该函数才返回

​ a.该系统函数是阻塞

​ b.函数对文件描述符的检测操作时由内核完成的

3、在返回时，它会高速进程有哪些描述符要进行I/O操作

API

// sizeof(fd_set) = 128     1024
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);
    - 参数：
            - nfds : 委托内核检测的最大文件描述符的值 + 1
            - 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);

代码实现

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

int main() {

    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));

    // 监听
    listen(lfd, 8);

    // 创建一个fd_set的集合，存放的是需要检测的文件描述符
    fd_set rdset, tmp;//监听文件描述符,内核修改tmp,外部检测用rdset
    FD_ZERO(&rdset);//清空rdset
    FD_SET(lfd, &rdset);
    int maxfd = lfd;

    while(1) {

        tmp = rdset;

        // 调用select系统函数，让内核帮检测哪些文件描述符有数据
        int 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);

                // 将新的文件描述符加入到集合中
                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};
                    int len = read(i, buf, sizeof(buf));
                    if(len == -1) {
                        perror("read");
                        exit(-1);
                    } else if(len == 0) {
                        printf("client closed...\n");
                        close(i);
                        FD_CLR(i, &rdset);//清空当前断开连接的描述符
                    } else if(len > 0) {//读到数据，打印出来
                        printf("read buf = %s\n", buf);
                        write(i, buf, strlen(buf) + 1);
                    }
                }
            }

        }

    }
    close(lfd);
    return 0;
}

八股

select会经历 两次遍历+两次拷贝 ，把已连接的socket放在一个文件描述符集合，调用 select 函数将文件描述符集合拷贝到内核里，让内核来检查是否有网络事件产生；

通过遍历，有事件产生就把此socket标记为 可读/可写 ，然后再整个拷贝回用户态。用户态还需要遍历找到刚刚标记socket。

poll

API

#include <poll.h>
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 : 阻塞时长
            0 : 不阻塞
            -1 : 阻塞，当检测到需要检测的文件描述符有变化，解除阻塞
            >0 : 阻塞的时长
    - 返回值：
         -1 : 失败
         >0（n） : 成功,n表示检测到集合中有n个文件描述符发生变化

代码实现

#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>

int main() {

    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));

    // 监听
    listen(lfd, 8);

    // 初始化检测的文件描述符数组
    struct pollfd fds[1024];
    for(int i = 0; i < 1024; 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("poll");
            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);
                // 将新的文件描述符加入到集合中
                for(int i = 1; i < 1024; i++) {
                    if(fds[i].fd == -1) {
                        fds[i].fd = cfd;
                        fds[i].events = POLLIN;
                        break;
                    }
                }

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

八股

poll是以链表形式来组织的动态数组，相较于select，poll没有限制文件描述符个数（由系统限制）

epoll

API

#include <sys/epoll.h>
// 创建一个新的epoll实例。在内核中创建了一个数据，这个数据中有两个比较重要的数据，一个是需要检
测的文件描述符的信息（红黑树），还有一个是就绪列表，存放检测到数据发送改变的文件描述符信息（双向
链表）。
int epoll_create(int size);
    - 参数：
        size : 目前没有意义了。随便写一个数，必须大于0
    - 返回值：
        -1 : 失败
        > 0 : 文件描述符，操作epoll实例的

typedef union epoll_data {
    void        *ptr;
    int          fd;
    uint32_t     u32;
    uint64_t     u64;
} epoll_data_t;
struct epoll_event {
    uint32_t     events;      /* Epoll events */
    epoll_data_t data;        /* User data variable */
};
常见的Epoll检测事件：
    - EPOLLIN
    - EPOLLOUT
    - EPOLLERR
// 对epoll实例进行管理：添加文件描述符信息，删除信息，修改信息
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    - 参数：
            - epfd : epoll实例对应的文件描述符
            - op : 要进行什么操作
                EPOLL_CTL_ADD:  添加
                EPOLL_CTL_MOD:  修改
                EPOLL_CTL_DEL:  删除
            - fd : 要检测的文件描述符
            - event : 检测文件描述符什么事情
// 检测函数
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int
timeout);
    - 参数：
        - epfd : epoll实例对应的文件描述符
        - events : 传出参数，保存了发送了变化的文件描述符的信息
        - maxevents : 第二个参数结构体数组的大小
        - timeout : 阻塞时间
            - 0 : 不阻塞
            - -1 : 阻塞，直到检测到fd数据发生变化，解除阻塞
            - > 0 : 阻塞的时长（毫秒）

    - 返回值：
         - 成功，返回发送变化的文件描述符的个数 > 0
         - 失败 -1

代码实现

#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>

int main() {
    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));

    // 监听
    listen(lfd, 8);

    // 调用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) {
        int ret = epoll_wait(epfd, epevs, 1024, -1);
        if(ret == -1) {
            perror("epoll_wait");
            exit(-1);
        }

        printf("ret = %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;
                epev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
            } else {
                if(epevs[i].events & EPOLLOUT) {
                    continue;
                }
                // 有数据到达，需要通信
                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简介

1、epoll(event poll)在内核中使用红黑树来跟踪所有待检测的文件描述符

2、调用 epoll ctl() 函数，把需要监控的 socket 加入内核中的红黑树里：(红黑树的增删查时间复杂度是O(logn)，不需要每次操作都传入整个集合，只需要传入一个待检测的socket，减少了内核和用户空间的大量数据拷贝和内存分配)

3、epoll 使用事件驱动的机制，内核里维护了一个链表来记录就绪事件 (当某个 socket 有事件发生时，通过回调函数，内核会将其加入到这个就绪事件列表中)

4、当用户调用 epoll_wait() 函数时，只会返回有事件发生的文件描述符的个数，不需要像 select/poll 那样轮询扫描整个 socket 集合，大大提高了检测的效率。

epoll触发模式

epoll支持两种事件触发模式：ET边缘触发、LT水平触发（默认）

边缘触发ET

工作模式：

1、ET（edge - triggered）是高速工作方式，只支持 no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。

2、当被监控的 Socket 描述符上有可读事件发生时，服务器只会从 epoll wait中苏醒一次，即使进程没有调用 read 函数从内核读取数据，也依然只苏醒一次，因此我们程序要保证一次性将内核缓冲区的数据读取完，只有第一次满足条件的时候才触发，之后就不会再传递同样的事件。

3、ET 模式在很大程度上减少了epoll 事件被重复触发的次数，因此效率要比 LT 模式高。epoll工作在 ET 模式的时候，必须使用非阻塞套接口，以避免由于一个文件柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

水平触发LT

工作模式：

1、LT (level- triggered) 是缺省的工作方式，并且同时支持 block和 no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的 fd 进行 IO 操作。如果你不作任何操作，内核还是会继续通知你的。

2、当被监控的 Socket 上有可读事件发生时，服务器不断地从 epoll_wait中苏醒，直到内核缓冲区数据被 read 函数读完才结束，目的是告诉我们有数据，只要满足事件的条件，比如内核中有数据需要读，就一直不断地把这个事件传递给用户

select和epoll的区别

1、select 和 poll 采用轮询的方式检查就绪事件，每次都要扫描整个文件描述符，复杂度O(N)；

2、epoll 采用回调方式检查就绪事件，只会返回有事件发生的文件描述符的个数，复杂度0(1)；

3、select 只工作在低效的LT模式，epoll 可以在 ET 高效模式工作;

4、epoll 是 Linux 所特有，而 select 则应该是 POSIX 所规定，一般操作系统均有实现；

5、select 单个进程可监视的fd数量有限，即能监听端口的大小有限，64位是2048；epoll 没有最大并发连接的限制，能打开的 fd 的上限远大于2048 (1G的内存上能监听约10万个端口)；

6、select中，内核需要将消息传递到用户空间，都需要内核拷贝动作；而epoll通过内核和用户空间共享一块内存来实现的。

知识补充

这部分会扩充一些在项目中使用到的，之前又介绍过的知识点

阻塞/非阻塞 同步/异步（在网络IO中）

先说IO，IO主要指两类东西：

• 网络IO：通过网络进行数据的拉取和输出
• 磁盘IO：主要是对磁盘进行读写工作

典型的一次网络IO的两个阶段是什么？---> 数据就绪 和 数据读写

数据就绪：一种由系统IO操作决定的就绪状态

• 阻塞（不满足条件就一直等下去，满足条件再进行下一步操作）
• 非阻塞（应用进程与内核的交互，条件不满足直接返回，通过轮询方式查询）

数据读写：一种应用程序与内核的交互方式

• 同步（导致请求进程阻塞，直到IO操作完成）
• 异步（不阻塞进程）

阻塞和非阻塞属于异步IO吗？---> 阻塞和非阻塞都是同步IO，只有使用了特殊的API才是异步IO。

一个典型的网络IO接口调用，分为两个阶段，即 “数据就绪” 和 “数据读写” ，数据就绪阶段分为阻塞和非阻塞，表现得结果就是，阻塞当前线程或是直接返回。

同步表示A向B请求调用一个网络IO接口时 (或者调用某个业务逻辑API接口时)，数据的读写都是由请求方A自己来完成的(不管是阻塞还是非阻塞)；

异步表示A向B请求调用一个网络IO接口时(或者调用某个业务逻辑API接口时)，向B传入请求的事件以及事件发生时通知的方式，A就可以处理其它逻辑了，当B监听到事件处理完成后，会用事先约定好的通知方式，通知A处理结果；

Unix/Linux上的五种IO模型

1、阻塞blocking

调用者调用了某个函数，等待这个函数返回，期间什么也不做，不停的去检查这个函数有没有返回，必

须等这个函数返回才能进行下一步动作。

2、非阻塞non-blocking(NIO)

非阻塞等待，即每隔一段时间就去检测IO事件是否就绪，没就绪就可以干别的事情

非阻塞I/O执行系统调用总是立即返回

不管事件是否已经发生，若事件没有发生，则返回-1，此时可以根据 errno 区分这两种情况，对于accept，recv 和 send，事件未发生时，errno 通常被设置成EAGAIN。

3、IO复用（IO multiplexing）

Linux用select/poll/epoll函数实现IO复用模型，这些函数也会使进程阻塞，但与阻塞IO所不同的是，这些函数可以同时阻塞多个IO操作。

并且，这些函数还可以同时对多个读写IO函数进行检测，直到有数据可以进行读写是，才会真正调用IO函数

4、信号驱动（signal-driven）

Linux 用套接口进行信号驱动 IO，定义一个信号处理函数，进程继续运行并不阻塞，当IO事件就绪，进

程收到 SIGIO 信号，然后处理 IO 事件。

此时，内核在第一个阶段（等待数据）是异步的，数据报准备好之后内核会为该进程产生一个SIGIO信号并发送给进程。

在第二个阶段是同步的，因为将数据从内核空间读取至用户空间是由请求信号的进程来完成的。

相比于非阻塞IO，信号驱动的方式引入了消息通知机制，避免了用户进程不断轮询检查数据，从而减少了系统API的调用次数，提高了效率

5、异步

异步基本上都是要靠调用系统提供的接口才能实现

Linux中，实现异步可以调用aio_read函数，告诉内核描述符缓冲区指针、缓冲区大小以及文件偏移和通知方式，然后就立刻返回

当内核完成处理（把数据拷贝到缓冲区）后，再通过约定好的通知方式通知应用程序