Linux C语言 53-IO复用之epoll

Linux C语言 53-IO复用之epoll

本节关键字：Linux、C语言、IO复用、epoll
相关C库函数：epoll_create、epoll_ctl、epoll_wait、read、write

epoll理解

epoll支持水平触发和边缘触发，最大特点在于边缘触发，只告诉哪些fd刚刚变为就绪态，并且只通知一次。还有一特点是，epoll使用“事件”的就绪通知方式，通过epoll_ctl注册fd，一量该fd就绪，内核就会采用类似callback的回调机制来激活该fd，epoll_wait便可以收到通知。

epoll的优点：

（1）没有最大并发连接的限制。

（2）效率提升，只有活跃可用的FD才会调用callback函数。

（3）内存拷贝，利用mmap()文件映射内存加速与内核空间的消息传递。

epoll相关接口

#include 

typedef union epoll_data {
    void *ptr;
    int fd;        // 一般用fd
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

struct epoll_event {
    uint32_t event;    // Epoll events
    epoll_data_t data; // User data variable
};

int epool_create(int size);
/**
@brief 创建一个新的epoll实例，在内核中创建了一个数据
@param size  目前没有意义，必须是大于0的正整数
@return 成功返回大于0的文件描述符；失败返回-1，并设置错误码errno

错误码errno类型：
	EINVAL 参数size不是正数
	EINVAL (epoll_create1()) 参数flags指定的值无效
	EMFILE 遇到了/proc/sys/fs/epoll/max_user_instances对每个用户的epoll实例数量的限制。请参阅epoll（7）了解更多详细信息。
	ENFILE 已达到打开文件总数的系统限制。
	ENOMEM 内存不足，无法创建内核对象。
*/

int epoll_ctrl(int epfd, int op, int fd, struct epoll_event *event);
/**
@brief 对Epoll实例进行管理：添加文件描述符信息、删除信息、修改信息。将需要检测的文件描述符添加到内核的红黑树中
@param epfd  epoll实例对应的文件描述符
@param op  要进行什么操作 
	EPOLL_CTL_ADD 添加
	EPOLL_CTL_MOD 修改
	EPOLL_CTL_DEL 删除
@param fd  要检测的文件描述符
@param event  检测文件描述符什么事情
	EPOLL_IN   关联的文件描述符可用于读操作read()
	EPOLL_OUT  关联的文件描述符可用于写操作write()
	EPOLLRDHUP 流套接字对等关闭连接，或关闭写入连接的一半。（当使用边缘触发监控时，此标志对于编写检测对等关闭的简单代码特别有用。）
	EPOLLPRI   有紧急数据可读read()
	EPOLLERR   关联的文件描述符出现错误。epoll_wait()将始终等待此事件；没有必要在events中设置它。
	EPOLLHUP   关联的文件描述符发生挂断。epoll_wait()将始终等待此事件；没有必要在events中设置它。
	EPOLLET    设置关联文件描述符的“边缘触发”行为。epoll的默认行为为“级别触发”。有关边缘和级别触发的事件分发架构的更多详细信息，请参阅epoll（7）。
	EPOLLONESHOT （自Linux 2.6.2起）设置关联文件描述符的一次性行为。这意味着在使用epoll_wait()拉出事件后，相关的文件描述符在内部被禁用，并且epoll接口不会报告其他事件。用户必须使用EPOLL_CTL_MOD调用epoll_ctl()，才能使用新的事件掩码重新武装文件描述符。
@return 成功返回0；失败返回-1，并设置错误码errno

错误码errno类型：
	EBADF  epfd或fd不是有效的文件描述符。
	EEXIST op是EPOLL_CTL_ADD，并且提供的文件描述符fd已经向该EPOLL实例注册。
	EINVAL epfd不是epoll文件描述符，或者fd与epfd相同，或者此接口不支持请求的操作op。
	ENOENT op是EPOLL_CTL_MOD或EPOLL_CTL _DEL，并且fd未在此EPOLL实例上注册。
	ENOMEM 内存不足，无法处理请求的操作控制操作。
	EPERM  The target file fd does not support epoll.
*/

int epoll_wait(int epfd, struct epoll_event *events, int maxevent, int timeout);
/**
@brief epoll实例检测
@param epfd  epoll实例对应的文件描述符
@param events  传出参数，保存了发送了变化的文件描述符的信息
@param maxevent  第二个参数结构体数组的大小
@param timeout  阻塞时间，0不阻塞 -1阻塞，直到检测到fd数据发生变化 >0阻塞的时长（毫秒）
@return 成功后，epoll_wait()返回为请求的I/O准备好的文件描述符数，如果在请求的超时毫秒内没有文件描述符准备好，则返回零。当发生错误时，epoll_wait()返回-1，并适当设置errno。

错误码errno类型：
	EBADF  epfd不是有效的文件描述符。
	EFAULT events指向的内存区域无法使用写入权限访问。
	EINTR  在任何请求的events发生或timeout()到期之前，调用被信号处理程序中断；参见signal（7）。
	EINVAL epfd不是epoll文件描述符，或者maxevents小于或等于零。
*/

epoll例程

// 服务端
#include 
#include 
#include 
#include 
#include 
#include 

int main()
{
    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    asddr.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);
    
    // 传出参数，这个大小可以随便指定
    strucr epoll_event epevs[1024];
    
    while (1) {
        int ret = epoll_wait(epfd, epevs, 1024, -1);
        if (ret == -1) {
            perror("epoll_wait");
            eixt(-1);        
        }
        printf("ret = %d\n", ret); // 打印发生数据变化的文件描述符的个数
        
        for (int i=0; i<ret; i++) {
            int currfd = epevs[i].data.fd;
            if (currfd == lfd) {
                // 监听的文件描述符有数据达到，有客户端连接
                struct sockaddr_in cliaddr;
                int len = sizeof(cliaddr);
                int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);
                
                // 将客户端的文件描述符添加到epoll实例进行检测
                epev.events = EPOLLIN;
                // 如果同时有读事件，也有写事件 epev.events = EPOLLIN | EPOLLOUT
                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) {
                    peintf("client close...\n");
                    // 从内核epoll实例的红黑树中移除
                    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模式（水平触发）

假设委托内核检测读事件 -> 检测fd的读缓冲区，读缓冲区有数据 -> epoll检测到了会给用户通知：

a.用户不读数据，数据一直在缓冲区，epoll会一直通知；

b.用户只读了一部分数据，epoll会通知；

c.缓冲区的数据读完了，不通知；

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

LT模式例程

// 服务端
#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
   // 创建socket
   int lfd = socket(PF_INET, SOCK_STREAM, 0);
   struct sockaddr_in saddr;
   asddr.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);
   
   // 传出参数，这个大小可以随便指定
   strucr epoll_event epevs[1024];
   
   while (1) {
       int ret = epoll_wait(epfd, epevs, 1024, -1);
       if (ret == -1) {
           perror("epoll_wait");
           eixt(-1);        
       }
       printf("ret = %d\n", ret); // 打印发生数据变化的文件描述符的个数
       
       for (int i=0; i<ret; i++) {
           int currfd = epevs[i].data.fd;
           if (currfd == lfd) {
               // 监听的文件描述符有数据达到，有客户端连接
               struct sockaddr_in cliaddr;
               int len = sizeof(cliaddr);
               int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);
               
               // 将客户端的文件描述符添加到epoll实例进行检测
               epev.events = EPOLLIN;
               // 如果同时有读事件，也有写事件 epev.events = EPOLLIN | EPOLLOUT
               epev.data.fd = cfd;
               epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);                                                                                        
           } else {
               // 这个是针对既要检测读事件，也要检测写事件，需要将写事件过滤掉
               if (epevs[i].events & EPOLLOUT) {
                   continue;                                    
               }
               // 有数据到达，需要通信，一次只读5个字节，这样epoll会持续通知
               char buf[5] = {0};
               int len = read(curfd, buf, sizeof(buf));
               if (len == -1) {
                   perror("read");
                   exit(-1);          
               } else if (len == 0) {
                   peintf("client close...\n");
                   // 从内核epoll实例的红黑树中移除
                   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;
}

// 客户端
#include 
#include 
#include 
#include 
#include 
int main()
{
   int fd = socket(PF_INET, SOCK_STREAM, 0);
   if (fd == -1) {
       perror("socket");
       exit(-1);    
   }
   
   struct sockaddr_in seraddr;
   inet_pton(AF_INET, "127.0.0.1", &seraddr.sin_addr.s_addr);
   seraddr.sin_family = AF_INET;
   seraddr.sin_port = htons(9999);
   
   int ret = connect(fd, (struct sockaddr *)&seraddr, sizeof(seraddr));
   if (ret == -1) {
       perror("connect");
       return -1;    
   }
   
   int num = 0;
   while (1) {
       char senfbuf[1024] = {0};
       fgets(sendbuf, sizeof(sendbuf), stdin);
       write(fd, sendbuf, strlen(sendbuf) + 1);
       int len = read(fd, sendbuf, sizeof(sendbuf));
       if (len == -1) {
           perror("read");
           return -1;        
       } else if (len > 0) {
           printf("read buf = %s\n", sendbuf);       
       } else {
           printf("服务器断开连接\n");
           break;        
       }
   }
   close(fd);
   return 0;
}

epoll工作模式-ET模式（边沿触发）

假设委托内核检测读事件 -》 检测fd的读缓冲区，读缓冲区有数据 -》 epoll检测到了会通知用户（epoll只会通知一次）

a.用户不读数据，数据一直在缓冲区，epoll下次检测的时候就不通知了

b.用户只读一部分数据，epoll不通知

c.缓冲区的数据读完了，不通知

ET（edge - triggered）是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll高速用户，然后它会假设你直到文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了，但是请注意，如果一直不对这个fd做IO操作（从而导致它再次变成未就绪），内核就不会发送更多的通知（only once）。

ET模式再很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高，epoll工作再ET模式的时候，必须使用非阻塞套接字，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死、（防止一个文件描述复读阻塞在那里，其它文件描述符的事件不执行，因此需要设置ET模式-非阻塞套接字）。
内核检测到文件描述符中有数据，只会通知一次，数据没读完不会再通知（水平模式会继续通知）；

只有将这次数据读完了，后面文件描述符中有新数据时，ET模式下，才会继续通知；所以我们要在内核通知的这一次中，将数据全部读出来。

ET模式例程

#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
   // 创建socket
   int lfd = socket(PF_INET, SOCK_STREAM, 0);
   struct sockaddr_in saddr;
   asddr.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);
   
   // 传出参数，这个大小可以随便指定
   strucr epoll_event epevs[1024];
   
   while (1) {
       int ret = epoll_wait(epfd, epevs, 1024, -1);
       if (ret == -1) {
           perror("epoll_wait");
           eixt(-1);        
       }
       printf("ret = %d\n", ret); // 打印发生数据变化的文件描述符的个数
       
       for (int i=0; i<ret; i++) {
           int currfd = epevs[i].data.fd;
           if (currfd == lfd) {
               // 监听的文件描述符有数据达到，有客户端连接
               struct sockaddr_in cliaddr;
               int len = sizeof(cliaddr);
               int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);
               
               // 设置连接的文件描述符-cfd属性为非阻塞
               int flag = fcntl(cfd, F_GETFL);
               flag |= O_NONBLOCK;
               cntl(cfd, F_SRTFL, flag);
               
               // 将客户端的文件描述符添加到epoll实例进行检测
               epev.events = EPOLLIN | EPOLLET; // 设置边沿触发
               // 如果同时有读事件，也有写事件 epev.events = EPOLLIN | EPOLLOUT
               epev.data.fd = cfd;
               epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);                                                                                        
           } else {
               // 这个是针对既要检测读事件，也要检测写事件，需要将写事件过滤掉
               if (epevs[i].events & EPOLLOUT) {
                   continue;                                    
               }
               
               // 有数据到达，需要通信
               char buf[5] = {0};
               int len = 0;
               while ((len = read(curfd, buf, sizeof(buf))) > 0) {
                   write(STDOUT_FILENO, buf, len);
                   write(curfd, buf, len);               
               }
               if (len == 0) {
                   printf("client closed\n");                
               } else if (len == -1) {
                   if (errno == EAGAIN) { // 数据完毕会返回EAGAIN信号
                       printf("data over\n");                    
                   } else {
                       perror("read");
                       exit(-1);                    
                   }
               }
           }
       }
   }
   close(lfd);
   close(epfd);
   return 0;
}

注意：
len == -1的情况下可能会出现一种错误：
EINTR：如果read函数在阻塞时，被一个信号中断了，回来之后就不会阻塞了，回来之后就会报错EINTR
EAGAIN：在read函数的返回值为-1的情况下，如果socket为非阻塞，缓冲区没有数据了，可能会出这种错，
就是数据已经读完了，还通过非阻塞的方式进行读，需要进行判断处理下（只会在非阻塞的情况下产生）。