Linux C语言 53-IO复用之epoll

2024-01-09 20:34:16

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 <sys/epoll.h>

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 <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;
    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 <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;
   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 <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
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 <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;
   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为非阻塞,缓冲区没有数据了,可能会出这种错,
就是数据已经读完了,还通过非阻塞的方式进行读,需要进行判断处理下(只会在非阻塞的情况下产生)。

文章来源:https://blog.csdn.net/qq_45157350/article/details/135455307
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。