• 【Linux】网络IO(select、poll、epoll)

    目录

    1. 五种IO模型

    1.1. 阻塞IO

    1.2. 非阻塞IO

    1.3. 信号驱动IO

    1.4. IO多路复用(转接)

    1.5. 异步IO

    1.6. 小结

    1.7. fcntl

    2.select

    2.1. 什么是select

    2.1. select函数

    2.2. 实现单进程版select

    2.3. select的优缺点

    2.4. socket就绪条件

    3.poll

    3.1. poll函数

    3.2. poll的使用

    3.3. poll的优缺点

    4.epoll

    4.1. epoll相关系统调用

    4.2. epoll的使用

    4.3. epoll原理

    4.4. epoll的优点

    4.5. epoll的工作模式

    4.5.1. LT模式(水平触发Level Triggered )

    4.5.2. ET模式(边缘触发Edge Triggered)

    4.6. 实现ET模式下的epoll服务器

    1. 五种IO模型

    1.1. 阻塞IO

    阻塞IO: 在内核将数据准备好之前, 系统调用会一直等待. 所有的套接字, 默认都是阻塞方式。

    1.2. 非阻塞IO

    非阻塞IO: 如果内核还未将数据准备好, 系统调用仍然会直接返回, 并且返回EWOULDBLOCK错误码.

    非阻塞IO往往需要程序员循环的方式反复尝试读写文件描述符, 这个过程称为轮询. 这对CPU来说是较大的浪费, 一般只有特定场景下才使用.

    1.3. 信号驱动IO

    信号驱动IO: 内核将数据准备好的时候, 使用SIGIO信号通知应用程序进行IO操作。

    1.4. IO多路复用(转接)

    IO多路转接: 虽然从流程图上看起来和阻塞IO类似. 实际上最核心在于IO多路转接能够同时等待多个文件描述符的就绪状态.

    1.5. 异步IO

    异步IO: 由内核在数据拷贝完成时, 通知应用程序(而信号驱动是告诉应用程序何时可以开始拷贝数据).

    1.6. 小结

    任何IO过程中, 都包含两个步骤. 第一是等待, 第二是拷贝. 而且在实际的应用场景中, 等待消耗的时间往往都远远高于拷贝的时间. 让IO更高效, 最核心的办法就是让等待的时间尽量少.

    前四种IO都属于同步io，同步io与异步io的区别在于：同步io在等待和拷贝的两个过程中应用进程至少做了一步，而异步io都由OS完成。

    阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态：

    • 阻塞调用是指调用结果返回之前，当前线程会被挂起. 调用线程只有在得到结果之后才会返回。

    • 非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。

    1.7. fcntl

    非阻塞io的概念我们，都知道，那么该如何实现呢？

    使用系统调用函数 fcntl：

    1. #include 
    2. #include c
    3. int fcntl(int fd, int cmd, ... /* arg */ );
    4.  
    5. // fcntl的五种功能
    6. //复制一个现有的描述符（cmd=F_DUPFD） .
    7. //获得/设置文件描述符标记(cmd=F_GETFD或F_SETFD).
    8. //获得/设置文件状态标记(cmd=F_GETFL或F_SETFL)，可以将一个文件描述符设置为非阻塞。
    9. //获得/设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).
    10. //获得/设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW).

    这里我们使用fcntl将stdin设置为非阻塞

    使用F_GETFL将当前的文件描述符的属性取出来(这是一个位图).

    然后再使用F_SETFL将文件描述符设置回去. 设置回去的同时, 加上一个O_NONBLOCK参数.

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. void SetNoBlock(int fd)
    8. {
    9.     int fl = fcntl(fd, F_GETFL); // 获取fd属性
    10.     if (fl < 0)
    11.     {
    12.         perror("fcntl");
    13.         return;
    14.     }
    15.     fcntl(fd, F_SETFL, fl | O_NONBLOCK); // 设置fd为非阻塞
    16. }
    17. int main()
    18. {
    19.     SetNoBlock(0);
    20.     while (1)
    21.     {
    22.         char buf[1024] = {0};
    23.         ssize_t s = read(0, buf, sizeof(buf) - 1);
    24.         if (s < 0)
    25.         {
    26.             if(errno== EAGAIN|| errno == EWOULDBLOCK)
    27.             {
    28.               printf("数据未准备好！\n");
    29.               printf("read error  errno: %d\n" ,errno);
    30.               sleep(1);
    31.               continue;
    32.             }
    33.         }
    34.         else
    35.         {
    36.             buf[s] = 0;
    37.             write(1, buf, strlen(buf));
    38.             printf("read success,  s: %d\n", s);
    39.         }
    40.     }
    41.     return 0;
    42. }

    测试结果：

    在非阻塞的情况下，读取数据，如果数据没有就绪，系统是以出错的形式返回的(不是错误)，会将errno设置为11，表示try agin

    2.select

    2.1. 什么是select

    系统提供select函数来实现多路复用输入/输出模型.

    • select系统调用是用来让我们的程序监视多个文件描述符的状态变化的;

    • 程序会停在select这里等待，直到被监视的文件描述符有一个或多个发生了状态改变

    select定位：只负责等待，得到fd就绪，就通知上层进行读取或写入，没有读取或写入的功能。

    read、write、recv、send本身也有等待功能，但只能等待一个fd；但select可以同时等待多个fd。

    2.1. select函数

    1. #include 
    2. int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
    3.  
    4. // nfds: select等待的fd中最大的fd+1 (nfs = maxfd+1)
    5. // fd_set: 位图结构，每个比特位表示一个fd(输入时：用户告诉内核自己关心的fd；输出时：内核告诉用户，哪些fd上的事件已经就绪)
    6. // readfds：读事件fd(用户层：用户告知内核需要等待的读事件fd，内核层：告诉用户哪些fd的读事件已经就绪)(输入输出型参数)(下2个同理)
    7. // writefds：写事件fd
    8. // exceptfds：异常事件fd
    9. // struct timeval：该结构体中包含秒和毫秒两个成员
    10. // timeout：设置一个deadline，在deadline之内如果事件不就绪，就不返回；在deadline之外，立即返回
    11. // timeout: NULL，阻塞等待； {0,0}，非阻塞；{5,0}，5s超时
    12. // 返回值：大于0，表示有几个fd就绪；等于0，表示超时；小于0，表示出错

    readfds、writefds、exceptfds三个参数虽然是位图结构，但是使用时不能自己使用位操作，只能使用OS提供的接口：

    1. void FD_CLR(int fd, fd_set *set);
    2. int  FD_ISSET(int fd, fd_set *set); // 判断fd是否就绪
    3. void FD_SET(int fd, fd_set *set); // 将fd设置进位图
    4. void FD_ZERO(fd_set *set); // 将位图清0

    select执行过程：

    1. 执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000

    2. 若fd＝ 5,执行FD_SET(fd,&set);后set变为0010,0000(第5位置为1)

    3. 若再加入fd＝ 2， fd=1,则set变为0010,0110 (用户告诉内核)

    4. 执行select(6,&set,0,0,0)阻塞等待

    5. 若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0110 (内核告诉用户)

    注意：没有事件发生的fd=5被清空

    2.2. 实现单进程版select

    话不多说，细节都在代码中：

    1. #include
    2. #include
    3. #include"sock.hpp" // 封装的套接字接口
    4.  
    5. #define NUM (sizeof(fd_set)*8)
    6.  
    7. int fd_array[NUM]; // 内容>=0,合法；如果是-1，表示该位置没有fd
    8.  
    9. // ./select_server 8080
    10.  
    11. static void Usage(string proc)
    12. {
    13.     cout<<"Usage: "<"port"<
    14. }
    15.  
    16. int main(int argc, char* argv[])
    17. {
    18.     if(argc!=2)
    19.     {
    20.         Usage(argv[0]);
    21.         exit(1);
    22.     }
    23.    
    24.     uint16_t port = (uint16_t)atoi(argv[1]);
    25.     int listen_sock = Sock::Socket();
    26.     Sock::Bind(listen_sock, port);
    27.     Sock::Listen(listen_sock);
    28.  
    29.     for (int i = 0; i < NUM; ++i)
    30.     {
    31.         fd_array[i] = -1;
    32.     }
    33.  
    34.         // 这里不能立即accept，其本质是通过listen_sock获取新连接，前提是listen_sock上面有新连接，
    35.         // 但是accept不知道是否有新连接，所以会阻塞等待
    36.         // 在多路转接视角，连接到来时对于listen_sock来说，就是读事件就绪！
    37.         // 对于所有服务器，最开始的时候，只有listen_sock
    38.  
    39.         fd_set rfds;
    40.     fd_array[0] = listen_sock;
    41.     while (true)
    42.     {
    43.  
    44.         FD_ZERO(&rfds);
    45.         int max_fd = fd_array[0];
    46.         for (int i = 1; i < NUM; i++)
    47.         {
    48.             if(fd_array[i] == -1)
    49.                 continue;
    50.             // 合法fd
    51.             FD_SET(fd_array[i], &rfds); // 将所有要关心的事件的fd，添加到rfds中
    52.             if(max_fd < fd_array[i])
    53.             {
    54.                 max_fd = fd_array[i]; // 更新最大fd
    55.             }
    56.         }
    57.  
    58.         FD_SET(listen_sock, &rfds);
    59.         struct timeval timeout = {5, 0};
    60.         int n = select(max_fd + 1, &rfds, nullptr, nullptr, nullptr);
    61.  
    62.         switch (n)
    63.         {
    64.             case -1:
    65.                 cerr << "select error" << endl;
    66.                 break;
    67.             case 0:
    68.                 cout << "select timeout" << endl;
    69.                 break;
    70.             default:
    71.                 cout << "有fd对应的事件就绪了！" << endl;
    72.                 // 判断是那个fd就绪了
    73.                 for (int i = 0; i < NUM; ++i)
    74.                 {
    75.                     if(fd_array[i] == -1)
    76.                     continue;
    77.                     //下面的fd都是合法的，但不一定是就绪的
    78.                     if(FD_ISSET(fd_array[i], &rfds))
    79.                     {
    80.                         cout << "sock: " << fd_array[i] << " 有读事件可以读取了！" << endl;
    81.                         // 一定是读事件就绪了，该fd在fd_array[i]中
    82.                         // read、recv时，一定不会被阻塞
    83.                         if(fd_array[i] == listen_sock)// 判断是否是listen套接字就绪
    84.                         {
    85.                             cout << "listen_sock: " << listen_sock << " 有链接事件到来！" << endl;
    86.                             // accept
    87.                             int sock = Sock::Accept(listen_sock);
    88.                             if(sock >= 0)
    89.                             {
    90.                                 cout << "sock: " << sock << " 获取新连接成功！" << endl;
    91.                                 //获取成功
    92.                                 // 不能立即读取连接，连接到来不意味着数据到来，需要交给select去等待
    93.                                 // 无法直接将fd设置进select，但好在有fd_array
    94.                                 int pos = 1;
    95.                                 for (; pos < NUM; ++pos)
    96.                                 {
    97.                                     if(fd_array[pos] == -1)
    98.                                         break;
    99.                                 }
    100.                                 // 1.找到了一个位置没有被使用
    101.                                 // 2.所有位置都被占用
    102.                                 if(pos < NUM)
    103.                                 {
    104.                                     cout << "新连接：" << sock << " 已经被添加到了数组[" << pos << "]的位置！" << endl;
    105.                                     fd_array[pos] = sock;
    106.                                 }
    107.                                 else
    108.                                 {
    109.                                     // 服务器已经满载，无法处理新的请求
    110.                                     close(sock);
    111.                                 }
    112.                             }
    113.                         }
    114.                         else //普通套接字就绪 
    115.                         {
    116.                             cout << "sock: " << fd_array[i] << "上面有普通读取" << endl;
    117.                             // 本次读取一定会读完吗？会产生数据包粘包问题吗？
    118.                             // 现在不解决这个问题
    119.                             char recv_buffer[1024] = {0};
    120.                             ssize_t s = recv(fd_array[i], recv_buffer, sizeof(recv_buffer)-1, 0);
    121.                             if(s > 0)
    122.                             {
    123.                                 recv_buffer[s] = 0;
    124.                                 cout << "client[" << fd_array[i] << "]# " << recv_buffer << endl;
    125.                             }
    126.                             else if(s == 0)
    127.                             {
    128.                                 cout << "sock: " << fd_array[i] << "关闭， client quit..." << endl;
    129.                                 // 对端关闭了连接
    130.                                 close(fd_array[i]);
    131.                                 cout << "fd_array中" << i << "位置去掉了sock：" << fd_array[i] << endl;
    132.                                 fd_array[i] = -1;
    133.                                 
    134.                             }
    135.                             else
    136.                             {
    137.                                 // 读取失败
    138.                                 close(fd_array[i]);
    139.                                 cout << "fd_array中" << i << "位置去掉了sock：" << fd_array[i] << endl;
    140.                                 fd_array[i] = -1;
    141.                                 cerr << "recv error" << endl;
    142.                             }
    143.                         }
    144.                     }
    145.                 }
    146.                     break;
    147.         }
    148.     }
    149.  
    150.     return 0;
    151. }

    2.3. select的优缺点

    优点：

    可以一次等待多个fd，使等待时间重叠，提高IO效率

    缺点：

    1. 每次调用select, 都需要手动设置fd集合，需要遍历检测, 从接口使用角度来说也非常不便。

    2. fd_set能够让select同时完成检测的fd是有上限的。

    3. select底层(OS)需要遍历检测哪些fd的事件已经就绪，消耗较大。

    4. select可能会较为高频率的进行用户到内核，内核到用户的拷贝问题。(设置位图)

    2.4. socket就绪条件

    读就绪 ：

    • socket内核中, 接收缓冲区中的字节数, 大于等于低水位标记SO_RCVLOWAT. 此时可以无阻塞的读该文件描述符, 并且返回值大于0;

    • socket TCP通信中, 对端关闭连接, 此时对该socket读, 则返回0;

    • 监听的socket上有新的连接请求;

    • socket上有未处理的错误;

    写就绪 ：

    • socket内核中, 发送缓冲区中的可用字节数(发送缓冲区的空闲位置大小), 大于等于低水位标记SO_SNDLOWAT, 此时可以无阻塞的写, 并且返回值大于0;

    • socket的写操作被关闭(close或者shutdown). 对一个写操作被关闭的socket进行写操作, 会触发SIGPIPE信号;

    • socket使用非阻塞connect连接成功或失败之后;

    • socket上有未读取的错误;

    异常就绪 ：

    • socket上收到带外数据. 关于带外数据, 和TCP紧急模式相关

    3.poll

    poll同select类似，也是一种多路转接的方案，只负责等待文件描述符，poll是select的优化。

    3.1. poll函数

    1. #include 
    2. int poll(struct pollfd *fds, nfds_t nfds, int timeout);
    3. //fds：是一个poll函数监听的polled结构体数组. 每一个元素中, 包含了三部分内容: 文件描述符, 监听的事件集合, 返回的事件集合.
    4. //nfds：表示fds数组的长度.
    5. //timeout: 与select一样表示poll函数的超时时间(0表示非阻塞，-1表示阻塞), 单位是毫秒(ms)
    6.  
    7. // pollfd结构
    8. struct pollfd {
    9. int fd; 		/* 文件描述符 */
    10. short events; 	/* 请求事件(需要关心哪些事件) */
    11. short revents; 	/* 返回事件(哪些事件已经就绪) */
    12. };

    events和revents的取值: 系统宏定义了事件，通过按位或可添加事件

    3.2. poll的使用

    使用poll来监控标准输入：

    1. #include
    2. #include
    3. #include
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8.     struct pollfd rfds;
    9.     rfds.fd = 0;
    10.     rfds.events = POLLIN;
    11.     rfds.revents = 0;
    12.  
    13.     while(true)
    14.     {
    15.         int n = poll(&rfds, 1, 1000);
    16.         switch(n)
    17.         {
    18.             case 0:
    19.                 cout << "time out ...." << endl;
    20.                 break;
    21.             case -1:
    22.                 cerr << "poll error..." << endl;
    23.                 break;
    24.             default:
    25.                 if(rfds.revents & POLLIN)
    26.                 {
    27.                     cout << rfds.fd << ": 读事件已经就绪" << endl;
    28.                     char buffer[128];
    29.                     ssize_t s = read(0, buffer, sizeof(buffer));
    30.                     if(s>0)
    31.                     {
    32.                         buffer[s] = 0;
    33.                         cout << buffer << endl;
    34.                     }
    35.                     else
    36.                     {
    37.                         cout << "read error..." << endl;
    38.                     }
    39.                     
    40.                 }
    41.                 break;
    42.         }
    43.     }
    44.     return 0;
    45. }

    tcp部分的代码，将select数组与接口简单的改了以后也可以正常使用，因为篇幅问题，这里就不贴代码了。

    poll的就绪条件同select一样。

    3.3. poll的优缺点

    优点：

    • poll不要求开发者计算最大文件描述符加一的大小。

    • poll在应付大数目的文件描述符的时候速度更快，相比于select。

    • poll没有最大连接数的限制，原因是它是基于链表来存储的。

    • poll调用函数时，只需要对参数进行一次设置就好了。(不会覆盖用户传的fd)

    缺点：

    • 和select函数一样， poll返回后，需要轮询pollfd来获取就绪的描述符.

    • 每次调用poll都需要把大量的pollfd结构从用户态拷贝到内核中.

    • 同时连接的大量客户端在一时刻可能只有很少的处于就绪状态, 因此随着监视的描述符数量的增长, 其效率也会线性下降.

    4.epoll

    epoll是为了处理大批量句柄而做了改进的poll，它几乎具备了select和poll的所有优点，被公认为Linux2.6下性能最好的多路转接方案。

    4.1. epoll相关系统调用

    epoll_create: 创建一个epoll的句柄（fd）

    1. #include 
    2. int epoll_create(int size);
    3. // 自从linux2.6.8之后， size参数被忽略了(但是必须大于0)
    4. // 使用完毕后，需要调用close()关闭

    epoll_ctl：将用户关心的fd对应的事件告诉内核

    1. #include 
    2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    3. // epfd: epoll_create创建的fd
    4. // op: 新增或删除或修改fd对应的事件(EPOLL_CTL_ADD ：注册新的fd到epfd中；
    5. //                                EPOLL_CTL_MOD ：修改已经注册的fd的监听事件；
    6. //                                EPOLL_CTL_DEL ：从epfd中删除一个fd；)
    7. // fd: 用户关心的fd
    8. // struct epoll_event:
    9. struct epoll_envent{
    10.     uint32_t envents; // 用户关心的fd上的事件
    11.     epoll_data_t data; // 由于该结构只返回了就绪的事件，但不知道是哪个fd上就绪的事件
    12. }                      // 所以该联合体是用来描述该sh

    events可以是以下几个宏的集合：

    • EPOLLIN : 表示对应的文件描述符可以读 (包括对端SOCKET正常关闭);

    • EPOLLOUT : 表示对应的文件描述符可以写;

    • EPOLLPRI : 表示对应的文件描述符有紧急的数据可读 (这里应该表示有带外数据到来);

    • EPOLLERR : 表示对应的文件描述符发生错误;

    • EPOLLHUP : 表示对应的文件描述符被挂断;

    • EPOLLET : 将EPOLL设为边缘触发(Edge Triggered)模式, 这是相对于水平触发(Level Triggered)来说的.

    • EPOLLONESHOT：只监听一次事件, 当监听完这次事件之后, 如果还需要继续监听这个socket的话, 需要再次把这个socket加入到EPOLL队列里 。

    epoll_wait：内核告诉用户哪些fd的对应事件已经就绪

    1. #include 
    2. int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
    3. // epfd: epoll_create创建的fd
    4. // envents: 输出型参数，把发生的事件赋值到events数组中
    5. // maxenvents: 告之内核这个events数组有多大，这个 maxevents的值不能大于创建epoll_create()时的size
    6. // timeout: 超时时间(单位毫秒；0为非阻塞；-1为阻塞)
    7. // 返回值: 如果函数调用成功，返回对应I/O上已准备好的文件描述符数目，如返回0表示已超时, 返回小于0表示函数失败

    4.2. epoll的使用

    epoll使用三板斧：

    1. 调用epoll_create创建一个epoll句柄;

    2. 调用epoll_ctl, 将要监控的文件描述符进行注册;

    3. 调用epoll_wait, 等待文件描述符就绪;

    代码：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include"sock.hpp"
    6. using namespace std;
    7.  
    8. #define NUM 64
    9. #define SIZE 128
    10.  
    11. static void Usage(string proc)
    12. {
    13.     cerr << "Usage: " << proc << " port" << endl;
    14. }
    15.  
    16. int main(int argc, char*argv[])
    17. {
    18.     if(argc != 2)
    19.     {
    20.         Usage(argv[0]);
    21.         exit(1);
    22.     }
    23.  
    24.     // 1.建立tcp监听socket
    25.     uint16_t port = atoi(argv[1]);
    26.     int listen_sock = Sock::Socket();
    27.     Sock::Bind(listen_sock, port);
    28.     Sock::Listen(listen_sock);
    29.  
    30.     // 2.建立epoll模型,获得epfd
    31.     int epfd = epoll_create(SIZE);
    32.  
    33.     // 3.添加listen_sock和所关心的事件添加到内核
    34.     struct epoll_event ev;
    35.     ev.events = EPOLLIN;
    36.     ev.data.fd = listen_sock;
    37.     epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &ev);
    38.  
    39.     // 4.事件循环
    40.     volatile bool quit = false;
    41.     struct epoll_event revs[NUM]; //该数组仅仅是尝试从内核中拿到已经就绪的事件
    42.     while (!quit)
    43.     {
    44.         int timeout = 1000;
    45.         int n = epoll_wait(epfd, revs, NUM, -1);
    46.         switch(n)
    47.         {
    48.             case 0:
    49.                 cout << "timeout!" << endl;
    50.                 break;
    51.             case -1:
    52.                 cerr << "epoll error!" << endl;
    53.                 break;
    54.             default:
    55.                 cout << "有事件已经就绪！" << endl;
    56.                 
    57.                 // 5. 处理就绪事件
    58.                 for (int i = 0; i < n; ++i)
    59.                 {
    60.                     int sock = revs[i].data.fd; //暂时方案
    61.                     cout << "fd: " << sock << "事件已经就绪..." << endl;
    62.                     if (revs[i].events & EPOLLIN)
    63.                     {
    64.                         // 处理读事件
    65.                         cout << "fd: " << sock << " 读事件就绪..." << endl;
    66.                         if (sock == listen_sock)
    67.                         {
    68.                             // 5.1.处理连接事件
    69.                             int fd = Sock::Accept(listen_sock);
    70.                             cout << "fd: " << sock << " 连接事件就绪..." << endl;
    71.                             if(fd >= 0)
    72.                             {
    73.                                 cout << "获取连接成功..." << endl;
    74.                                 // 不能立即读取，不能确定该fd上的事件是否就绪
    75.                                 struct epoll_event _ev;
    76.                                 _ev.events = EPOLLIN;
    77.                                 _ev.data.fd = fd;
    78.                                 epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &_ev); // 将新的fd托管给epoll
    79.                                 cout << "已经将fd: " << fd << " 托管给epoll" << endl;
    80.                             }
    81.                             else
    82.                             {
    83.                                 cout << "连接获取失败..." << endl;
    84.                             }
    85.                         }
    86.                         else
    87.                         {
    88.                             // 处理正常读取
    89.                             cout << "fd: " << sock << " 正常读取事件就绪..." << endl;
    90.                             char buffer[1024];
    91.                             ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
    92.                             if(s > 0)
    93.                             {
    94.                                 buffer[s] = 0;
    95.                                 cout << "client [" << sock << "] #" << buffer << endl;
    96.                                 //将关心的事件改成写事件EPOOLOUT
    97.                                 // struct epoll_event _ev;
    98.                                 // _ev.events = EPOLLOUT;
    99.                                 // _ev.data.fd = sock;
    100.                                 // epoll_ctl(epfd, EPOLL_CTL_MOD, sock, &_ev);
    101.                             }
    102.                             else if(s == 0)
    103.                             {
    104.                                 // 对端关闭连接
    105.                                 cout << "client quit " << sock << endl;
    106.                                 close(sock); // 关闭连接
    107.                                 epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr); // 删除epoll中的fd
    108.                                 cout << "sock: " << sock << "delete from success!" << endl;
    109.                             }
    110.                             else
    111.                             {
    112.                                 //读取失败
    113.                                 cout << "recv error" << endl;
    114.                                 close(sock); // 关闭连接
    115.                                 epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr); // 删除epoll中的fd
    116.                                 cout << "sock: " << sock << "delete from success!" << endl;
    117.                             }
    118.                         }
    119.                     }
    120.                     else
    121.                     {
    122.                         // 处理写事件
    123.                     }
    124.                 }
    125.                 break;
    126.         }
    127.     }
    128.  
    129.     close(epfd);
    130.     close(listen_sock);
    131.     return 0;
    132. }

    4.3. epoll原理

    • 当某一进程调用epoll_create方法时， Linux内核会创建一个eventpoll结构体，这个结构体中有两个成员与epoll的使用方式密切相关。

    • 每一个epoll对象都有一个独立的eventpoll结构体，用于存放通过epoll_ctl方法向epoll对象中添加进来的事件。

    • 这些事件都会挂载在红黑树中，如此，重复添加的事件就可以通过红黑树而高效的识别出来(红黑树的插入时间效率是lgn，其中n为树的高度)。

    • 而所有添加到epoll中的事件都会与设备(网卡)驱动程序建立回调关系，也就是说，当响应的事件发生时会调用这个回调方法.这个回调方法在内核中叫ep_poll_callback,它会将发生的事件添加到rdlist双链表(即就绪队列)中。

    • 在epoll中，对于每一个事件，都会建立一个epitem结构体(即图中的rb_node)。

    • 当调用epoll_wait检查是否有事件发生时，只需要检查eventpoll对象中的rdlist双链表中是否有epitem元素即可。

    • 如果rdlist不为空，则把发生的事件复制到用户态，同时将事件数量返回给用户. 这个操作的时间复杂度是O(1)

    4.4. epoll的优点

    • 接口使用方便: 虽然拆分成了三个函数, 但是反而使用起来更方便高效. 不需要每次循环都设置关注的文件描述符, 也做到了输入输出参数分离开。

    • 数据拷贝轻量: 只在合适的时候调用 EPOLL_CTL_ADD 将文件描述符结构拷贝到内核中, 这个操作并不频繁(而select/poll都是每次循环都要进行拷贝)。

    • 事件回调机制: 避免使用遍历, 而是使用回调函数的方式, 将就绪的文件描述符结构加入到就绪队列中,epoll_wait 返回直接访问就绪队列就知道哪些文件描述符就绪. 这个操作时间复杂度O(1). 即使文件描述符数目很多, 效率也不会受到影响。

    • 没有数量限制: 文件描述符数目无上限。

    4.5. epoll的工作模式

    4.5.1. LT模式(水平触发Level Triggered )

    epoll默认状态下就是LT工作模式.

    • 当epoll检测到socket上事件就绪的时候, 可以不立刻进行处理. 或者只处理一部分。

    • 如果只处理了部分数据, 缓冲区中还剩数据, 在第二次调用epoll_wait 时,epoll_wait仍然会立刻返回并通知socket读事件就绪。

    • 直到缓冲区上所有的数据都被处理完, epoll_wait 才不会立刻返回。

    • 支持阻塞读写和非阻塞读写。

    4.5.2. ET模式(边缘触发Edge Triggered)

    如果在listen_sock添加到epoll描述符的时候使用了EPOLLET标志, epoll进入ET工作模式。

    • 当epoll检测到socket上事件就绪时, 必须立刻处理。

    • 如果只处理了部分数据, 缓冲区中还剩数据, 在第二次调用 epoll_wait 的时候,epoll_wait 不会再返回了。

    • 也就是说, ET模式下, 文件描述符上的事件就绪后, 只有一次处理机会。

    • ET的性能比LT性能更高( epoll_wait 返回的次数少了很多). Nginx默认采用ET模式使用epoll。

    • 只支持非阻塞的读写。

    简单来说一个fd如果被设置为了ET模式，不管这个fd上面的事件发生了多少次，epoll都只会通知你一次。

    ET模式的通知策略其实是倒逼程序猿一旦开始读取数据时，就必须要一直读完，否则可能会导致数据丢失。

    select、poll采用的都是LT模式，epoll默认是LT模式，也可以设置为ET模式。

    4.6. 实现ET模式下的epoll服务器

    前面我们已经了解了什么是ET模式，但是现在有一个问题，当我们使用ET模式时，由于底层只会通知一次，如果缓冲区中数据的大小超过了一次读取的大小，那么怎么才能将缓冲区中的数据读取完呢？

    循环读取！但是recv、accept、read等接口在没有读取到数据时会阻塞，在循环读取的情况下可能最后一次读取肯定是没有读取到数据的(例如一次读取100个字节，而缓冲区中有200个字节的数据，当读了两次之后不能确定缓冲区中是否还有数据，所以还会再读一次)，所以服务器会一直阻塞住，所以在ET模式下，所有的fd必须要设置为非阻塞！

    该epoll服务器提供计算服务，目前只实现了加法功能。

    epoll_server.cc:

    1. #include"Reactor.hpp"
    2. #include"sock.hpp"
    3. #include"Accepter.hpp"
    4. #include"Util.hpp"
    5.  
    6. static void Usage(string proc)
    7. {
    8.     cout << "Usage: " << proc << " port" << endl;
    9. }
    10.  
    11. int main(int argc, char* argv[])
    12. {
    13.     if(argc != 2)
    14.     {
    15.         Usage(argv[0]);
    16.         exit(1);
    17.     }
    18.  
    19.     // 1. 创建socket监听
    20.     uint16_t port = (uint16_t)atoi(argv[1]);
    21.     int listen_sock = Sock::Socket();
    22.     SetNonBlock(listen_sock); //套接字设为非阻塞
    23.     Sock::Bind(listen_sock, port);
    24.     Sock::Listen(listen_sock);
    25.  
    26.     // 2.创建Reactor对象
    27.     Reactor *R = new Reactor();
    28.     R->InitReactor();
    29.  
    30.     // 3. 给Reactor中反应堆中添加套接字
    31.     Event* evp = new Event();
    32.     evp->sock = listen_sock;
    33.     evp->R = R;
    34.  
    35.     //Accepter：连接管理器
    36.     evp->RegisterCallback(Accepter, nullptr, nullptr);
    37.     R->InsertEvent(evp, EPOLLIN | EPOLLET); // 设置为ET模式
    38.  
    39.     // 4. 开始事件派发
    40.     int timeout = 1000;
    41.     while (true)
    42.     {
    43.         R->Dispatcher(timeout);
    44.     }
    45.     return 0;
    46. }

    Reactor.hpp: 反应堆模式，通过多路转接方案，被动采用事件派发方式，去反向的调用对应的回调函数。

    检测事件：epoll

    派发事件：Dispatcher

    连接事件：accepter

    IO事件：recver、sender

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. using namespace std;
    10.  
    11. class Event;
    12. class Reactor;
    13.  
    14. typedef int (*callback_t)(Event *ev); // 函数指针类型
    15. #define SIZE 128
    16. #define NUM 64
    17.  
    18. class Event
    19. {
    20. public:
    21.     // 对应的文件描述符
    22.     int sock; 
    23.     // 对应的sock的输入缓冲区
    24.     string inbuffer;
    25.     // 对应sock的输出缓冲区 
    26.     string outbuffer; 
    27.  
    28.     //给sock设置回调
    29.     callback_t recver;
    30.     callback_t sender;
    31.     callback_t errorer;
    32.  
    33.     // 设置Event回指Reactor的指针
    34.     Reactor *R;
    35.  
    36. public:
    37.     Event()
    38.     {
    39.         sock = -1;
    40.         recver = nullptr;
    41.         sender = nullptr;
    42.         errorer = nullptr;
    43.         R = nullptr;
    44.     }
    45.  
    46.     void RegisterCallback(callback_t _recver, callback_t _sender, callback_t _errorer)
    47.     {
    48.         recver = _recver;
    49.         sender = _sender;
    50.         errorer = _errorer;
    51.     }
    52.  
    53.     ~Event(){}
    54. };
    55.  
    56. // 不需要关心任何sock的类型
    57. // 只关心如何使用该类，对Event管理
    58. class Reactor
    59. {
    60. private:
    61.     int epfd;
    62.     unordered_map<int, Event *> events; // Epoll类管理的所有Event的集合
    63. public:
    64.     Reactor():epfd(-1){}
    65.     void InitReactor()
    66.     {
    67.         epfd = epoll_create(SIZE);
    68.         if(epfd < 0)
    69.         {
    70.             cerr << "epoll_create error! " << endl;
    71.             exit(2);
    72.         }
    73.  
    74.         cout << "InitReactor success! " << endl;
    75.     }
    76.     bool InsertEvent(Event *evp, uint32_t evs)
    77.     {
    78.         // 1. 将sock插入到epoll中
    79.         struct epoll_event ev;
    80.         ev.events = evs;
    81.         ev.data.fd = evp->sock;
    82.         if(epoll_ctl(epfd, EPOLL_CTL_ADD, evp->sock, &ev) < 0)
    83.         {
    84.             cerr << "epoll_ctr add event failed!" << endl;
    85.             return false;
    86.         }
    87.         // 2. 将ev本身插入到unordered_map中
    88.         events.insert({evp->sock, evp});
    89.         cout << "insert listen_sock success!" << endl;
    90.     }
    91.     void DeleteEvent(Event *evp)
    92.     {
    93.        
    94.         int sock = evp->sock;
    95.         
    96.         auto iter = events.find(sock);
    97.         if(iter != events.end())
    98.         {
    99.             // 1. 将sock从epoll中删除
    100.             epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr);
    101.         
    102.             // 2. 将sock对应的ev从map中删除
    103.             events.erase(iter);
    104.  
    105.             close(sock);
    106.  
    107.             delete evp;
    108.         }
    109.         
    110.     }
    111.  
    112.     // 修改，使该sock能读写
    113.     bool EnableReadWrite(int sock, bool enable_read, bool enable_write)
    114.     {
    115.         struct epoll_event ev;
    116.         ev.events = EPOLLET | (enable_read ? EPOLLIN : 0) | (enable_write ? EPOLLOUT : 0);
    117.         ev.data.fd = sock;
    118.         if(epoll_ctl(epfd, EPOLL_CTL_MOD, sock, &ev)< 0)
    119.         {
    120.             cerr << "epoll_ctr mod event failed!" << endl;
    121.             return false;
    122.         }
    123.         return true;
    124.     }
    125.  
    126.     bool IsSockOk(int sock)
    127.     {
    128.         auto iter = events.find(sock);
    129.         return iter != events.end();
    130.     }
    131.  
    132.     // 就绪事件的派发器
    133.     void Dispatcher(int timeout)
    134.     {
    135.  
    136.         struct epoll_event revs[NUM];
    137.         int n = epoll_wait(epfd, revs, NUM, timeout);
    138.  
    139.         for (int i = 0; i < n; ++i)
    140.         {
    141.             int sock = revs[i].data.fd;
    142.  
    143.             uint32_t revents = revs[i].events;
    144.             // 差错处理，将所有的错误问题全部转化为让IO函数处理
    145.             if(revents & EPOLLERR)
    146.                 revents |= (EPOLLIN | EPOLLOUT);
    147.             if(revents & EPOLLHUP)
    148.                 revents |= (EPOLLIN | EPOLLOUT);
    149.             
    150.             // 读数据就绪
    151.             if(revents & EPOLLIN)
    152.             {
    153.  
    154.                 if (IsSockOk(sock) && events[sock]->recver) //如果该回调函数被设置
    155.                     events[sock]->recver(events[sock]); // 直接调用回调方法，执行对应的读取
    156.  
    157.             }
    158.             if(revents & EPOLLOUT)
    159.             {
    160.                 if(IsSockOk(sock) && events[sock]->sender)
    161.                     events[sock]->sender(events[sock]);
    162.             }
    163.         }
    164.     }
    165.  
    166.     ~Reactor(){}
    167. };

    Accepter.hpp: 获取连接

    1. #pragma once
    2. #include"Reactor.hpp"
    3. #include"sock.hpp"
    4. #include"Service.hpp"
    5. #include"Util.hpp"
    6. int Accepter (Event *evp)
    7. {
    8.     cout << "有新的连接到来，sock：" << evp->sock << endl;
    9.     while(true)
    10.     {
    11.         int sock = Sock::Accept(evp->sock);
    12.         if(sock < 0)
    13.         {
    14.             cout << "Accept Done! " << endl;
    15.             break;
    16.         }
    17.  
    18.         cout << "Accept success, sock: " << sock << endl;
    19.         //获取连接成功
    20.         SetNonBlock(sock);
    21.         Event *other_evp = new Event();
    22.         other_evp->sock = sock;
    23.         other_evp->R = evp->R; 
    24.         // recver,sender,errorer 只负责读写
    25.         other_evp->RegisterCallback(Recver, Sender, Errorer);
    26.         evp->R->InsertEvent(other_evp, EPOLLIN | EPOLLET);
    27.     }
    28. }

    Service.hpp: 提供读、写服务

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include"Reactor.hpp"
    6. #include"Util.hpp"
    7. #define ONCE_SIZE 128
    8.  
    9.  
    10. // 返回值
    11. // 1：本轮读取完成
    12. // 0: 对端关闭连接
    13. // -1: 读取出错
    14.  
    15.  
    16. static int RecverCore(int sock, string & inbuffer)
    17. {
    18.     while(true)
    19.     {
    20.         char buffer[ONCE_SIZE];
    21.         ssize_t s = recv(sock, buffer, ONCE_SIZE -1, 0);
    22.         if(s > 0)
    23.         {
    24.             buffer[s] = 0;
    25.             // 读取成功
    26.             inbuffer += buffer;
    27.         }
    28.         else if(s ==0) //对端关闭连接
    29.         {
    30.             return 0;
    31.         }
    32.         else
    33.         {
    34.             // s<0；
    35.             // 1.读完，底层没数据了；
    36.             if(errno == EINTR)
    37.             {
    38.                 // IO被信号中断
    39.                 continue;
    40.             }
    41.             if(errno == EAGAIN||errno ==EWOULDBLOCK)
    42.             {
    43.                 return 1;
    44.             }
    45.             // 2.出错了
    46.             return -1;
    47.         }
    48.     }
    49. }
    50.  
    51. int Recver(Event *evp)
    52. {
    53.     cout << "Recver been called!" << endl;
    54.     // 1.读取数据
    55.     int result = RecverCore(evp->sock, evp->inbuffer);
    56.     if(result <= 0)
    57.     {
    58.         // 差错处理
    59.         if(evp->errorer)
    60.         {
    61.             evp->errorer(evp);
    62.         }
    63.         return -1;
    64.     }
    65.     
    66.     // 2.分包(解决粘包问题)
    67.     vector tokens;
    68.     string sep = "X";
    69.     SplitSegment(evp->inbuffer, &tokens, sep);
    70.     
    71.  
    72.     // 3.反序列化，针对一个报文，提取有效参与计算或者存储的信息
    73.     for(auto seg:tokens)
    74.     {
    75.         string data1, data2;
    76.         if(Deserialize(seg, &data1, &data2))// 反序列化
    77.         {
    78.             // 4.业务逻辑，得到结果
    79.             int x = atoi(data1.c_str());
    80.             int y = atoi(data2.c_str());
    81.             int z = x + y;
    82.  
    83.             // 5.构建响应, 再添加到evp->outbuffer
    84.             string res = data1;
    85.             res += "+";
    86.             res += data2;
    87.             res += "=";
    88.             res = to_string(z);
    89.             res += sep;
    90.  
    91.             evp->outbuffer += res; //发送数据
    92.         } 
    93.     }
    94.  
    95.     // 6.尝试直接/间接进行发送
    96.     // 写事件一般都是就绪的，但用户不一定就绪
    97.     // 对于写事件，通常是按需设置
    98.     if(!evp->outbuffer.empty())
    99.     {
    100.         // 写事件打开的时候，默认就是就绪的，即便是发送缓冲区满了
    101.         // epoll只要用户重新设置了out事件，EPOLLOUT至少会触发一次
    102.         evp->R->EnableReadWrite(evp->sock, true, true);
    103.     }
    104. }
    105.  
    106.  
    107. // 返回值
    108. // 1: 数据全部发送完成
    109. // 0: 数据没发完，不能再发
    110. // -1: 发送出错
    111. int SenderCore(int sock, string &outbuffer)
    112. {
    113.     
    114.     while(true)
    115.     { 
    116.         int total = 0; // 本轮累计发送的数据量
    117.         const char *start = outbuffer.c_str();
    118.         int size = outbuffer.size(); // 缓冲区数据总大小
    119.         ssize_t curr = send(sock, start + total, size - total, 0);
    120.         if(curr > 0)
    121.         {
    122.             total += curr;
    123.             if(total == size)
    124.             {
    125.                 // 将数据全部发送完成
    126.                 outbuffer.clear();
    127.                 return 1;
    128.             }
    129.         }
    130.         else
    131.         {
    132.             // 数据没发完，但是不能再发了
    133.             if(errno == EINTR) continue;
    134.             if(errno == EAGAIN || errno == EWOULDBLOCK)
    135.             {
    136.                 outbuffer.erase(0, total);
    137.                 return 0;
    138.             }
    139.             return -1;
    140.         }
    141.     }
    142. }
    143. int Sender(Event *evp)
    144. {
    145.     cout << "Sender been called!" << endl;
    146.    int res = SenderCore(evp->sock, evp->outbuffer);
    147.     if(res == 1)
    148.     {
    149.         evp->R->EnableReadWrite(evp->sock, true, false);
    150.     }
    151.     else if(res == 0)
    152.     {
    153.         evp->R->EnableReadWrite(evp->sock, true, true);
    154.     }
    155.     else
    156.     {
    157.         if(evp->errorer)
    158.             evp->errorer(evp);
    159.     }
    160. }
    161.  
    162. int Errorer(Event *evp)
    163. {
    164.     cout << "errorer been called!" << endl;
    165.     evp->R->DeleteEvent(evp);
    166. }

    Sock.hpp: TCP相关接口的实现

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. using namespace std;
    12. class Sock
    13. {
    14. public:
    15.     static int Socket()
    16.     {
    17.         int sock = socket(AF_INET, SOCK_STREAM, 0);
    18.         if(sock < 0)
    19.         {
    20.             cerr << "socket error" << endl;
    21.             exit(2);
    22.         }
    23.         return sock;
    24.     }
    25.     static void Bind(int sock, uint16_t port)
    26.     {
    27.         struct sockaddr_in local;
    28.         memset(&local, 0, sizeof(local));
    29.         local.sin_family = AF_INET;
    30.         local.sin_port = htons(port);
    31.         local.sin_addr.s_addr = INADDR_ANY;
    32.         if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    33.         {
    34.             cerr << "bind error" << endl;
    35.             exit(3);
    36.         }
    37.     }
    38.     static void Listen(int sock)
    39.     {
    40.         if(listen(sock, 5) < 0)
    41.         {
    42.             cerr << "listen error" << endl;
    43.             exit(4);
    44.         }
    45.     }
    46.     static int Accept(int sock)
    47.     {
    48.         struct sockaddr_in peer;
    49.         socklen_t len = sizeof(peer);
    50.         int fd = accept(sock, (struct sockaddr *)&peer, &len);
    51.         if(fd >= 0)
    52.         {
    53.             return fd;
    54.         }
    55.         return -1;
    56.     }
    57.     static void Connect(int sock, string ip , uint16_t port)
    58.     {
    59.         struct sockaddr_in server;
    60.         memset(&server, 0, sizeof(server));
    61.         server.sin_family = AF_INET;
    62.         server.sin_port = htons(port);
    63.         server.sin_addr.s_addr = inet_addr(ip.c_str());
    64.         if(connect(sock, (struct sockaddr*)&server, sizeof(server)==0))
    65.         {
    66.             cout << "connect success!" << endl;
    67.         }
    68.         else
    69.         {
    70.             cout << "connect failed" << endl;
    71.             exit(5);
    72.         }
    73.     }
    74. };

    Util.hpp: 工具文件，设置文件描述符为非阻塞、分包、反序列化

    1. #pragma once
    2.  
    3.  
    4.  
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include"Service.hpp"
    11. using namespace std;
    12.  
    13. // 工具类
    14. //设置文件描述符为非阻塞
    15. void SetNonBlock(int sock)
    16. {
    17.     int fl = fcntl(sock, F_GETFL);
    18.     if(fl < 0)
    19.     {
    20.        std::cerr << "fcntl failed!" << std::endl;
    21.        return;
    22.     }
    23.     fcntl(sock, F_SETFL, fl | O_NONBLOCK);
    24. }
    25.  
    26.  
    27. void SplitSegment(string& inbuffer, vector*tokens, string sep)
    28. {
    29.     while(true)
    30.     {
    31.         cout << "inbuffer: " << inbuffer << endl;
    32.         auto pos = inbuffer.find(sep);
    33.         if(pos == string::npos)
    34.         {
    35.             break;
    36.         }
    37.         string sub = inbuffer.substr(0, pos);
    38.         tokens->push_back(sub);
    39.         inbuffer.erase(0, pos + sep.size());
    40.     }
    41. }
    42.  
    43. bool Deserialize(const string& seg, string *out1, string *out2)
    44. {
    45.     string op = "+";
    46.     auto pos = seg.find(op);
    47.     if(pos == std::string::npos)
    48.     {
    49.         return false;
    50.     }
    51.  
    52.     *out1 = seg.substr(0, pos);
    53.     *out2 = seg.substr(pos + op.size());
    54.     cout << *out2 << endl;
    55.     return true;
    56. }
  • 相关阅读:
    回环设备（/dev/loop*）与losetup命令
    云原生 | Docker - [Dockerfile]
    java面向对象02——常见的设计模式
    c++异常处理-在构造函数中
    GIS小技术分享（一）：python中json数据转geojson或者shp
    因mapjoin加载内存溢出而导致return code 3
    【平衡二叉搜索树】细撕AVL树的插入操作
    想进大厂的朋友请注意！Java多线程面试题来袭，跳槽涨薪必备法器
    OpenCV（十五）：拷贝图像
    没有公网IP，怎样实现私有化部署？
  • 原文地址：https://blog.csdn.net/Edward_Asia/article/details/127865661