Linux下的I/O复用与epoll详解

粪逗er

已于 2022-10-28 16:20:36 修改

阅读量900

点赞数 3

分类专栏： Unix内核编程相关文章标签： linux 运维服务器

于 2018-10-29 15:16:55 首次发布

JaweG

本文链接：https://blog.csdn.net/weixin_36750623/article/details/83506220

版权

Unix内核编程相关专栏收录该内容

68 篇文章 9 订阅

订阅专栏

一.为什么引出epoll？

1.select的缺点

1.select所用到的FD_SET是有限的

/linux/posix_types.h:
#define __FD_SETSIZE         1024

3.select/poll都要进行不断的将fd集合在内核空间和用户空间的来回拷贝
2.内核中实现 select是用轮询方法，即每次检测都会遍历所有FD_SET中的句柄，显然，select函数执行时间与FD_SET中的句柄个数有一个比例关系，即 select要检测的句柄数越多就会越费时

2.epoll高效的奥秘（实现原理）

三大关键因素：mmap/红黑树/链表
(1) epoll_create：epoll是通过内核与用户空间mmap同一块内存映射区实现的。mmap将用户空间的一块地址和内核空间的一块地址映射到物理内存地址，使得这块物理内存对内核和用户均可见，减少用户态和内核态之间的数据交换。
(2) epoll_ctl：红黑树将存储epoll所监听的套接字，当epoll_ctl添加/删除一个套接字时，实际上是在红黑树上进行节点的插入/删除。
注意：当使用epoll_ctl函数将事件添加到红黑树上后，会完成更为关键的异步（那就是该事件都会与相应的设备驱动程序建立回调关系）
(3) epoll_wait：一旦有事件发生，就会调用注册的回调函数ep_poll_callback，该回调函数的作用是这个事件添加到就绪双向链表rdlist中。调用epoll_wait时，epoll_wait只需要检查双向链表rdlist中是否有存在注册的事件
epoll_wait的工作流程：
1.epoll_wait调用ep_poll，当rdlist为空（无就绪fd）时挂起当前进程，直到rdlist不空时进程才被唤醒
2.当有就绪fd发生时，将调用ep_poll_callback，它将相应fd对应epitem加入rdlist，导致rdlist不为空，进程被唤醒，epoll_wait将返回
3.ep_events_transfer函数将双向链表rdlist中的epitem拷贝到txlist中，并将双向链表rdlist清空
4.ep_send_event函数（很关键），它扫描txlist中的每个epitem，调用其关联fd对应的poll方法。此时对poll的调用仅仅是取得fd上较新的events（防止之前events被更新），之后将取得的events和相应的fd发送到用户空间（封装在struct epoll_event，从epoll_wait返回）。==之后如果这个epitem对应的fd是LT模式监听且取得的events是用户所关心的，则将其重新加入回rdlist（图中蓝线），否则（ET模式）不在加入rdlist。

常用的事件类型:
EPOLLIN ：表示对应的文件描述符可以读；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET：表示对应的文件描述符有事件发生；

二.epoll函数API

int epoll_create(int size); //哈希表
int epoll_create1(int flags); //红黑树

int epoll_ctl ( int epfd, int op, int fd, struct epoll_event *event );
参数
epfd：epoll_create的返回值
fd：要操作的文件描述符
op：操作类型 EPOLL_CTL_ADD/EPOLL_CTL_MOD/EPOLL_CTL_DEL
event：指定事件，它是epoll_event结构指针类型

其中，epoll_event—>每一个文件描述符都有一个对应的epoll_event结构，该结构为：

struct epoll_event{
     __unit32_t events;    // epoll事件类型：EPOLLET / EPOLLONESHOT
     epoll_data_t data;    // 存储用户数据
};
其中，epoll_data_t定义：
	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 );

返回值：成功时返回就绪的文件描述符的个数，失败时返回-1并设置errno
参数
timeout：指定epoll的超时时间，单位是毫秒。
maxevents：指定最多监听多少个事件
events：传出参数，是一个数组，epoll_wait函数返回后，所有就绪的事件

三.使用epoll接口的一般操作流程为：

（1）使用epoll_create()创建一个epoll对象，该对象与epfd关联，后续操作使用epfd来使用这个epoll对象，这个epoll对象才是红黑树，epfd作为描述符只是能关联而已。
（2）调用epoll_ctl()向epoll对象中进行增加、删除等操作。
（3）调用epoll_wait()可以阻塞(或非阻塞或定时) 返回待处理的事件集合。
（3）处理事件。

/*
 *  -[  一般epoll接口使用描述01  ]-
 */
int main(void)
{
 /* 
  *   此处省略网络编程常用初始化方式（从申请到最后listen）
  *   并且部分的错误处理省略，我会在后面放上所有的源码，这里只放重要步骤
  *   部分初始化也没写
  */ 
  // [1] 创建一个epoll对象
  ep_fd = epoll_create(OPEN_MAX);       /* 创建epoll模型,ep_fd指向红黑树根节点 */
  listen_ep_event.events  = EPOLLIN;    /* 指定监听读事件 注意:默认为水平触发LT */
  listen_ep_event.data.fd = listen_fd;  /* 注意:一般的epoll在这里放fd */ 
  // [2] 将listen_fd和对应的结构体设置到树上
  epoll_ctl(ep_fd, EPOLL_CTL_ADD, listen_fd, &listen_ep_event);

  while(1) { 
      // [3] 为server阻塞(默认)监听事件,ep_event是数组,装满足条件后的所有事件结构体
      n_ready = epoll_wait(ep_fd, ep_event, OPEN_MAX, -1); 
      for(i=0; i<n_ready; i++) {
         temp_fd = ep_event[i].data.fd;

         if(ep_event[i].events & EPOLLIN){
            if(temp_fd == listen_fd) {  //说明有新连接到来
               connect_fd = accept(listen_fd, (struct sockaddr *)&client_socket_addr, &client_socket_len);
               // 给即将上树的结构体初始化
               temp_ep_event.events  = EPOLLIN;
               temp_ep_event.data.fd = connect_fd;
               // 上树
               epoll_ctl(ep_fd, EPOLL_CTL_ADD, connect_fd, &temp_ep_event);
             }
             else {                      //cfd有数据到来
               n_data = read(temp_fd , buf, sizeof(buf));
               if(n_data == 0)  {        //客户端关闭
                   epoll_ctl(ep_fd, EPOLL_CTL_DEL, temp_fd, NULL) //下树
                   close(temp_fd);
                }
                else if(n_data < 0) {}

                do {
                   //处理数据
                 }while( (n_data = read(temp_fd , buf, sizeof(buf))) >0 ) ;
             }
          }
         else if(ep_event[i].events & EPOLLOUT){
                //处理写事件
         }
         else if(ep_event[i].events & EPOLLERR) {
                //处理异常事件
         }
      }      
   }
  close(listen_fd);
  close(ep_fd);
}

四. 水平触发LT / 边缘触发ET

evt.events = EPOLLIN | EPOLLET; /*边沿触发 */
evt.events = EPOLLIN | EPOLLIN; /*水平触发 */

1.ET和LT在本质上的区别

https://www.jianshu.com/p/f58fbe351935

epoll 监控的 fd 产生事件，fd 从红黑树移到就绪列表
epoll_wait 遍历就绪列表，处理fd的读写事件
检查事件模式是 LT 还是 ET，如果是 LT，重新将 fd 信息添加回就绪列表，下次重新触发

[1] 水平触发LT

在这里插入图片描述
从图中可以看到：只要有数据，LT方式epoll_wait就会返回
1.如果用户在监听epoll事件，当内核有事件的时候，会拷贝给用户态事件，但是如果用户只处理了一次，那么剩下没有处理的会在下一次epoll_wait再次返回该事件。
2.这样如果用户永远不处理这个事件，就导致每次都会有该事件从内核到用户的拷贝，耗费性能，但是水平触发相对安全，最起码事件不会丢掉，除非用户处理完毕。

[2] 边缘触发ET

在这里插入图片描述
从图中可以看到：尽管还有数据未被处理，但是ET方式epoll_wait也不会返回
1.边缘触发，相对跟水平触发相反，当内核有事件到达，只会通知用户一次，至于用户处理还是不处理，以后将不会再通知。
2.这样减少了拷贝过程，增加了性能，但是相对来说，如果用户马虎忘记处理，将会产生事件丢的情况。

2.ET和LT的区别

if ET：当且仅当有新到来的数据，epoll_wait才返回
if LT：只要有数据，epoll_wait就返回
在这里插入图片描述
废话不多说，直接看代码

示例代码
代码解读：使用ET方式，用epoll监控标准输入STDIN_FILENO
代码执行结果如图示：
在这里插入图片描述
代码运行分析：
每次输入新的字符串(相当于新的数据到来)，epoll_wait都会返回
若不输入字符串时，程序阻塞在epoll_wait代码位置

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

int main(void)
{
  char buf[1024];
  int epfd,nfds;
  struct epoll_event ev,events[5]; //ev用于注册事件，数组用于返回要处理的事件
  epfd = epoll_create(1); //只需要监听一个描述符——标准输入
  ev.data.fd = STDIN_FILENO;
  ev.events = EPOLLIN|EPOLLET; //监听读状态同时设置ET模式
  epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev); //注册epoll事件
  
  while(1)
  {
    nfds = epoll_wait(epfd, events, 5, -1);
    
    printf("epoll_wait ...    ");

    for(int i = 0; i < nfds; i++)
    {
      if(events[i].data.fd==STDIN_FILENO)
        printf("hello world\n");
    }
  }
}

代码修改1：将ev.events = EPOLLIN|EPOLLET;改成ev.events = EPOLLIN|EPOLLIN; //默认使用LT模式
编译并运行，随便输入字符后，执行结果如下：屏幕不断的打印epoll_wait … hello world! 这是为什么呢？
在这里插入图片描述
因为在标准输入中输入字符串后，因为没有调用read函数将输入的字符串读走，所有在标准输入中一直会存在数据。又因为水平触发LT不会将数据移走，故epoll_wait认为buffer可读返回读就绪
代码修改2：如果在if(events[i].data.fd==STDIN_FILENO)判断中，将标准输入的数据通过read函数读走，程序执行结果将和ET模式结果一样。（因为read都走了数据，导致epoll_wait不能返回）

2.那么，为什么说边沿触发(ET) 的效率更高呢？*

(1) 边沿触发只在数据到来的一刻才触发，很多时候服务器在接受大量数据时会先接受数据头部(水平触发在此触发第一次，边沿触发第一次)。
(2) 接着服务器通过解析头部决定要不要接这个数据。此时，如果不接受数据，水平触发需要手动清除，而边沿触发可以将清除工作交给一个定时的清除程序去做，自己立刻返回。
(3) 如果接受，两种方式都可以用while接收完整数据。

3.边缘触发ET的使用技巧:epoll + 非阻塞fd+ET

举例说明：Client向Server一次性发送10个字节的数据；服务器一次接受5个字节的数据，下面Server使用两种方式去读取数据：

① 阻塞+LT触发模式

代码分析：读取10字节的数据：(1)先执行step1的epoll_wait，再执行step2的read读取5个字节；(2)再执行step1的epoll_wait，再执行step2的read读取5个字节
结论：读取10个字节，需要调用2次epoll_wait

while (1){
	epoll_wait(epfd, resevent, maxi+1, -1);   //step1
	if (resevent[0].data.fd == connfd){
		len = read(connfd, buf, 5);       //step2
		write(STDOUT_FILEND, buf, len);
	}
}

② 非阻塞+ET触发模式+while(read)

代码分析：(1)先执行step1的epoll_wait，再执行step2的read2读取5个字节(2)继续调用step2的read读取5个字节
结论：读取10个字节，只需要调用1次epoll_wait

先用fcntl将连接的套接字connfd设置为非阻塞O_NOBLOCK
while (1){
	epoll_wait(epfd, resevent, maxi+1, -1); 
	if (resevent[0].data.fd == connfd){
		while ((len = read(connfd, buf, 5))){//非阻塞读,有数据就轮询读,直到读完缓冲区中所有的数据
			write(STDOUT_FILEND, buf, len);
		}
	}
}

总结：采用[非阻塞fd+边缘触发ET+while循环读]的方式，比采用[阻塞fd+水平触发LT]的方式调用epoll_wait的次数大大减少！效率更高

五.EPOLLONESHOT事件

引出背景：在并发程序中，经常出现一个问题。比如一个线程在读取完某个socket上的数据后开始处理这些数据，但是在数据处理过程中该socket又有新数据可读，此时另外一个线程被唤醒来读取这些新的数据 ==> 于是出现了两个线程同时操作一个socket的局面，这当然不是我们期望的。
解决方案：注册EPOLLONESHOT事件的文件描述符，最多触发注册的一个可读、可写、异常事件，且只触发一次。这样，当一个线程处理某个socket时，其他线程是不可能有机会操作该socket的。但反过来思考，注册了EPOLLONESHOT事件的socket一旦被某个线程处理完毕，就应该立即重置这个EPOLLONESHOT事件，以确保这个socket下一次可读时能被触发，进而让其他工作线程有机会继续处理这个socket。
使用方案：P158~P61

六.epoll实现`服务器`

/**
 *    使用epoll实现的服务器：回射服务器
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <string.h>
#include <poll.h>
#include <sys/epoll.h>
#include <limits.h>
#include <errno.h>

#define MAXLINE 1024
#define OPEN_MAX 128
#define INFTIM -1

#define PORT 66666

char buf[MAXLINE];

int main(int argc, char **argv)
{
    int i, listenfd, connfd, sockfd, epollfd, nfds;
    int nready;
    ssize_t n;

    socklen_t clilen;
    struct pollfd client[OPEN_MAX];
    struct sockaddr_in cliaddr, serveraddr;
    struct epoll_event ev, events[20];

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    bzero(&serveraddr, sizeof(serveraddr));

    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(PORT);

    epollfd = epoll_create1(0);

    // 监听套接字
    ev.data.fd = listenfd;
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &ev);

    bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    listen(listenfd, 100);

    printf("ready for event loop\n");
    for (;;) {
        nfds = epoll_wait(epollfd, events, 20, -1);
        for (i = 0; i < nfds; ++i) 
        {
            if (events[i].data.fd == listenfd)   // 监听套接字
            {
                clilen = sizeof(cliaddr);
                // 接收新的client连接：connfd
                connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);  
                if (connfd < 0) {
                    perror("accept error");
                    continue;
                }

                printf("connection from %s, port is %d\n", inet_ntop(AF_INET, &cliaddr.sin_addr, buf, sizeof(buf)), ntohs(cliaddr.sin_port));

                // 将connfd添加到epoll中，关心读时间EPOLLIN
                ev.events = EPOLLIN | EPOLLET;
                ev.data.fd = connfd;
                if (epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &ev) < 0) {
                    fprintf(stderr, "epoll set insertion error: fd = %d\n", connfd);
                    return -1;
                }
            } 
            else  // 是客户端套接字
            { 
                int n;
                int sockfd = events[i].data.fd;

                // 发生读事件
                if (events[i].events & EPOLLIN) 
                { 
                    bzero(buf, MAXLINE);
                  
                    if (sockfd < 0)
                        continue;
                    
                    // 读取数据
                    if ((n = read(sockfd, buf, MAXLINE)) < 0) {  // 发生错误
                        close(sockfd);
                        sockfd = -1;
                        perror("read error");
                        return -1;
                    } 
                    else if (n == 0) {  // 对方关闭
                        epoll_ctl(epollfd, EPOLL_CTL_DEL, sockfd, &ev);
                        printf("terminated from port %d\n", ntohs(cliaddr.sin_port));
                        close(sockfd);
                        sockfd = -1;
                    } 
                    else {  // 读取数据正确
                        printf("read %d characters\n", n - 1);
                        ev.data.fd = sockfd;
                        ev.events = EPOLLOUT | EPOLLET;

                        // 修改关心的事件为可写：EPOLLOUT
                        epoll_ctl(epollfd, EPOLL_CTL_MOD, sockfd, &ev);
                    }
                }
                if (events[i].events & EPOLLOUT) { 
                    if (sockfd < 0)
                        continue;

                    if ((n = write(sockfd, buf, strlen(buf))) < 0) {
                        perror("write error");
                        return -1;
                    } 
                    else {
                        printf("write %d characters\n", (n - 1) > 0 ? (n - 1) : 0);
                        ev.data.fd = sockfd;
                        ev.events = EPOLLIN | EPOLLET;
                        bzero(buf, n);
                        // 修改关心的事件为可读：EPOLLIN
                        epoll_ctl(epollfd, EPOLL_CTL_MOD, sockfd, &ev);
                    }
                }
            }
        }
    }

    return 0;
}

测试：

# telnet 0.0.0.0 6610
Trying 0.0.0.0...
Connected to 0.0.0.0.
Escape character is '^]'.
hello
hello
world
world