[IO复用]EPOLL 如何实现ET(边缘触发)

已于 2023-12-17 11:45:13 修改
阅读量240 收藏 2
点赞数
分类专栏： # IO复用 文章标签： linux ubuntu 服务器 网络
于 2023-11-13 12:32:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zlllc/article/details/134329000
版权

LT和ET的

我们在做epoll网络编程的时候，可以选择LT(水平触发)或者ET(边缘触发)。
epoll默认就是水平触发，水平触发也不需要什么特别的设置。所以这里主要研究一下边缘触发怎么弄。

边缘触发(edge-triggered)

什么是边缘触发

关于定义的解释，网上有很多。
我的理解就是，有事件的时候，比如可读了，epoll_wait会触发一次，即使读了一次以后，缓冲区中还有数据，也不会再次触发。

问题：

  1. 如何实现边缘触发
  2. 边缘触发如何使用recv & send

如何实现边缘触发

初始化函数，和LT模式没有区别。

//Description:    Ubuntu 16.04.6 LTS
//Release:        16.04
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <netinet/in.h>
#include <errno.h>
#include <arpa/inet.h>
#include <string.h>
#include <fcntl.h> //fctnl()
#define BUFFER_LENGTH 128
#define ARRAY_LENGTH 1024
typedef struct connections
{
    int     fd;    
    char    rbuffer[BUFFER_LENGTH];
    int     rbuff_index;
    //char wbuffer[128];
} connections_t;

int InitServer(int* listenfd, int* epfd)
{
    *listenfd = socket(AF_INET,SOCK_STREAM,0);
    if (-1 == *listenfd) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in svraddr;
    svraddr.sin_family = AF_INET;
    svraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    svraddr.sin_port = htons(2048);
    socklen_t len = sizeof(svraddr);
    if(-1 == bind(*listenfd,(struct sockaddr*)&svraddr,len)) {
        perror("bind");
        return -1;
    }
    if(-1 == listen(*listenfd,10)) {
        perror("listen");
        return -1;
    }
    *epfd = epoll_create(1);
    if(-1 == *epfd) {
        perror("epoll_create");
        return -1;
    }
    return 0;
}
int InitConnListItem(int fd, connections_t *connlist)
{
    if(fd < ARRAY_LENGTH) {
        connlist[fd].fd = fd;
        connlist[fd].rbuff_index = 0;
        memset(connlist[fd].rbuffer, 0x00 ,ARRAY_LENGTH);
    } else {
        printf("error:fd out of range.");
        return -1;
    }
    return 0;
}

使用fcntl把fd设置为非阻塞的函数

int SetNonBlockFD(int fd) 
{
    int oldflag = fcntl(fd,F_GETFL);
    int newflag = fcntl(fd,F_SETFL, oldflag | O_NONBLOCK);
    if(newflag == -1)
        return -1;
    return oldflag;
}

main函数
这里只写了个recv。利用recv的调用次数来看是否实现了ET。

int main()
{
    int listenfd, epfd;
    if(InitServer(&listenfd, &epfd) < 0)
        return -1;

    connections_t connlist[ARRAY_LENGTH] = { 0x00 };
    struct epoll_event events[ARRAY_LENGTH] = { 0x00 };

    struct epoll_event ev;
    ev.data.fd = listenfd;
    ev.events = EPOLLIN;
    ev.events |= EPOLLET;  
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    int oldflag = SetNonBlockFD(listenfd);
    if(oldflag < 0)
        return -1;

    if(InitConnListItem(listenfd,connlist) < 0) 
        return -1;
    
    while(1) {
       int nready = epoll_wait(epfd,events,ARRAY_LENGTH,-1);
       if(nready > 0)
       {
        int i = 0;
         for(i = 0; i < nready; i++) {
            int eventfd = events[i].data.fd;
            if(events[i].events & EPOLLIN) {
                if(eventfd == listenfd) {
                    struct sockaddr acceptaddr;
                    socklen_t len = sizeof(acceptaddr);
                    int acceptfd = accept(listenfd,&acceptaddr,&len);
                    if(accept < 0) {
                        perror("accept.");
                        continue;
                    }
                    printf("accept fd:%d\n",acceptfd);
                    int oldflag = SetNonBlockFD(acceptfd);
                    if (oldflag < 0)
                        return -1;

                    InitConnListItem(acceptfd,connlist);
                    
                     ev.data.fd = acceptfd;
                     ev.events = EPOLLIN;
                     ev.events |= EPOLLET;
                     epoll_ctl(epfd, EPOLL_CTL_ADD, acceptfd, &ev);
                }   
                else {
                    #define READ_LENGTH 1
                    int count = recv(eventfd, connlist[eventfd].rbuffer, READ_LENGTH, 0);
                    printf("recv, fd:%d,count:%d,msg:%s\n",eventfd, count, connlist[eventfd].rbuffer);
                }
            }
            if(events[i].events & EPOLLOUT) {
                printf("EPOLLOUT\n");
            }
         }
       }
    }

    return 0;    
}

测试：
使用net assistant来模拟客户端，向server发送一个长36Byte的字符串。
根据mainloop中recv处的限定，recv一次只会读1个字节。
如果实现了ET，recv在一定时间内只会调用一次，读一个字节。
如果实现的还是LT，recv会连续调用36次，直到把缓冲区读完。
在这里插入图片描述
可以看到，只recv了一次，读了一个"0"，所以实现了ET。

总结&注意

实现ET的代码时的总结：

  1. 把listenfd的 ev.events |= EPOLLET; 和 int oldflag = SetNonBlockFD(listenfd);注释掉，
    还是可以实现recv的边缘触发，所以listenfd的设置，对于acceptfd的边缘触发不是必要条件。
  2. 在mainloop中新增以下代码：
			for(i = 0; i < nready; i++) {
            int eventfd = events[i].data.fd;
            if(events[i].events & EPOLLET) 				//新增
                printf("fd:%d is EPOLLET\n",eventfd); 	//新增
            else 										//新增
                printf("fd:%d is LT\n",eventfd); 		//新增

虽然把listenfd和acceptfd的ev.events 都设置为了|=EPOLLET，但是以上新增的代码，输出一直都是“is LT”，
所以没法用 if(events[i].events & EPOLLET) 这样的方式判断fd是否是ET。
在这里插入图片描述
↑此时已经执行了步骤1，fd 3 (listenfd) 是LT可以理解，fd 5(acceptfd)还是 LT就无法理解了。
这个原因我没搜到。在这里先记录一下，看后续有没有机会调查。
3. if(events[i].events & EPOLLIN) { }的部分，InitConnListItem(acceptfd, connlist);， epoll_ctl(epfd, EPOLL_CTL_ADD, acceptfd, &ev);， int oldflag = SetNonBlockFD(acceptfd);的执行顺序对ET的实现没有影响。之前我在一份LT代码的基础上改ET，一直不成功，我以为是这三个函数的顺序问题。重写代码后，成功实现ET，调换了这三个的顺序，发现对ET没有影响。
4. 把acceptld的 ev.events |= EPOLLET;注释掉，recv会恢复成水平触发（此时仍是非阻塞的）。

边缘触发如何使用recv & send

recv

使用边缘触发的时候，伴随的是fd的非阻塞。需要一次性读完所有缓冲区内的数据。
需要在一个非阻塞的recv循环中读完：

						while (1)
                        {
                            int count = recv(eventfd, connlist[eventfd].rbuffer, READ_LENGTH, 0);
                            if (count <= 0)
                            {
                                if(count  == 0) {
                                    perror("et recv return 0:");
                                    epoll_ctl(epfd,EPOLL_CTL_DEL,eventfd,NULL);
                                    close(eventfd);
                                    break;
                                }
                                if(count == -1) {
                                    perror("et recv return -1:");
                                    if(errno == EAGAIN) {
                                        printf("errno is EAGAIN,read end.\n");
                                    }
                                    else if(errno == EINTR) {
                                        printf("errno is EINTR,read end.\n");
                                    }
                                    else {
                                        printf("errno is not EAGAIN,read error.\n");
                                        epoll_ctl(epfd,EPOLL_CTL_DEL,eventfd,NULL);
                                        close(eventfd);
                                    }
                                    break;
                                }
                            }
                            printf("recv, fd:%d,count:%d,msg:%s,time:%s\n", eventfd, count, connlist[eventfd].rbuffer, __TIME__);
                        }
recv的返回值
  • 非阻塞情况下：
    recv return -1 且 errno == EINTR || EAGAIN (EWOULDBLOCK)：读完成。（perror：Resource temporarily unavailable）
    recv return -1 且 errno != EINTR || EAGAIN (EWOULDBLOCK)：出现错误。
    recv return 0 ：客户端已断开连接。
  • 阻塞情况下：
    除了EAGAIN这个errno，别的相同。
    返回值参考的文章:linux socket编程中的recv和send的返回值介绍及其含义。
send

在上面的代码中，留了一个EPOLLOUT的响应代码：

 if(events[i].events & EPOLLOUT) {
                printf("EPOLLOUT\n");
            }

根据recv的经验，如果是LT模式，当可写时，就会一直触发EPOLLOUT ，当ET时，就只会触发一次EPOLLOUT。
把accepted的events设置为EPOLLOUT：

ev.data.fd = acceptfd;
events = EPOLLOUT;

测试一下LT模式下的EPOLLOUT执行情况：
不停地触发EPOLLOUT。
在这里插入图片描述
测试一下ET模式下的EPOLLOUT执行情况：
只触发一次EPOLLOUT。
在这里插入图片描述

水平触发(level-trggered)

epoll默认就是是LT的。
当触发条件满足时，会一直触发。
比如读缓冲区中有数据，recv一次没有读完，那缓冲区中还剩余数据，就会再次触发EPOLLIN，可以继续recv。

写一段代码测试一下，代码在 [水平触发完整代码]，这里只说一下结果。
用net assistant作为客户端，客户端向服务器发送一条长度为26个字符的消息。
“0123456789abcdefghijklmnopqrstuvwxyz”
每次epoll_wait()前会打印“epoll_wait”。
每次recv后，会打印收到的长度，和完整的fd rbuffer的长度。限定每次最多读10个字符。recv后会把epoll_event改写成EPOLLOUT。
每次send后，会打印send的长度。send完成后会把epoll_event改写成EPOLLIN。
结果如下：
在这里插入图片描述
实际上我只在net assistant进行了一次消息发送。
可以看到自动触发了4次recv()，读完了所有发过去的字符。
而且在recv中，我插入了EPOLLOUT事件，在recv和send来回切换时，还是可以正确读到度缓冲区中的字符的。

LT必须经过wpoll_wati才能再次触发recv。

水平触发代码

这里错误处理弄的不好，后面需要专门总结一下返回值的处理。
这段代码不看也罢。

//Description:    Ubuntu 16.04.6 LTS
//Release:        16.04
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <netinet/in.h>
#include <errno.h>
#include <arpa/inet.h>
#include <string.h>

#define BUFFER_LENGTH 128
typedef struct connections
{
    int     fd;    
    char    rbuffer[BUFFER_LENGTH];
    int     rbuff_index;
    //char wbuffer[128];
} connections_t;

int main()
{
    printf("epoll_event size=%ld\n",sizeof(struct epoll_event));
    int listenfd = socket(AF_INET,SOCK_STREAM,0);
    if (-1 == listenfd) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in svraddr;
    svraddr.sin_family = AF_INET;
    svraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    svraddr.sin_port = htons(2048);
    socklen_t len = sizeof(svraddr);
    if(-1 == bind(listenfd,(struct sockaddr*)&svraddr,len)) {
        perror("bind");
        return -1;
    }
    if(-1 == listen(listenfd,10)) {
        perror("listen");
        return -1;
    }
    int epfd = epoll_create(1);
    if(-1 == epfd) {
        perror("epoll_create");
        return -1;
    }
    connections_t connlist[1024] = { 0x00 };

    struct epoll_event events[1024] = { 0x00 };
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = listenfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
    connlist[listenfd].fd = listenfd;
    short iserror = 0;
    while(1) {
        printf("epoll_wait\n");
        int nready = epoll_wait(epfd, events, 1024, -1);       
        for(int i = 0; i < nready; ++i) {
            int eventfd = events[i].data.fd;
            if (events[i].events & EPOLLIN)
            {
                
                if (eventfd == listenfd) {
                    struct sockaddr cliaddr;
                    socklen_t len = sizeof(cliaddr);
                    int acceptfd = accept(eventfd,(struct sockaddr*)&cliaddr,&len);
                    printf("accept,fd:%d\n",acceptfd);
                    
                    ev.events = EPOLLIN;
                    ev.data.fd = acceptfd;
                    epoll_ctl(epfd,EPOLL_CTL_ADD,acceptfd,&ev);

                    connlist[acceptfd].fd = acceptfd;
                    connlist[acceptfd].rbuff_index = 0;
                    memset(connlist[acceptfd].rbuffer,0x00,BUFFER_LENGTH);
                   
                }
                else {
                    char *buff = connlist[eventfd].rbuffer;
                    int *index = &connlist[eventfd].rbuff_index;
                    int recv_length = 10;
                    int msg_count = recv(eventfd, buff + (*index), recv_length, 0);
                    if(msg_count == 0) {
                        perror("recv");
                        printf("disconnect %d\n",eventfd);
                        epoll_ctl(epfd, EPOLL_CTL_DEL, eventfd, NULL);
                        close(eventfd);
                        continue;
                    }
                    if(msg_count == -1) {
                        perror("recv");
                         printf("recv error fd:%d\n",eventfd);
                        iserror = 1;
                        break;
                    }
                    (*index) += msg_count;
                    printf("recv,count:%d,rbuffer:%s\n", msg_count, buff);

                    ev.events = EPOLLOUT;
                    ev.data.fd = eventfd;
                    epoll_ctl(epfd,EPOLL_CTL_MOD,eventfd,&ev);
                }
            }
            if(events[i].events & EPOLLOUT) {
                char *send_msg = connlist[eventfd].rbuffer ;
                int send_msg_length = connlist[eventfd].rbuff_index;
                usleep(100000);
                int msg_count = send(eventfd,send_msg, send_msg_length, 0);
                printf("send,count:%d,msg=%s\n", msg_count, send_msg);

                ev.events = EPOLLIN;
                ev.data.fd = eventfd;            
                epoll_ctl(epfd, EPOLL_CTL_MOD, eventfd, &ev);
            }            
        }
        if(iserror == 1)
             break;
    }
    close(epfd);
    close(listenfd);
    return 0;    
}
zlllc
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java epoll et lt_epoll的ET和LT模式详解
weixin_42470969的博客
02-26 255
从man手册中，得到ET和LT的具体描述如下EPOLL事件有两种模型：Edge Triggered (ET)Level Triggered (LT)假如有这样一个例子：1. 我们已经把一个用来从管道中读取数据的文件句柄(RFD)添加到epoll描述符2. 这个时候从管道的另一端被写入了2KB的数据3. 调用epoll_wait(2)，并且它会返回RFD，说明它已经准备好读取操作4. 然后我们读取了...
epoll边缘触发_echo-epoll/epoll边缘触发与水平触发.md at master · superLish/echo-epoll · GitHub...
weixin_31921223的博客
01-17 145
在网络编程中，会涉及到水平触发与边缘触发的概念，工程中以边缘触发较为常见，本文讲述了边缘触发与水平触发的概念，并给出代码示例，通过代码可以很清楚的看到它们之间的区别。水平触发与边缘触发水平触发(level-trggered)只要文件描述符关联的读内核缓冲区非空，有数据可以读取，就一直发出可读信号进行通知，当文件描述符关联的内核写缓冲区不满，有空间可以写入，就一直发出可写信号进行通知边缘触发(edg...
epoll的两种工作模式
nyist327的专栏
10-01 2302
epoll有两种模式,Edge Triggered(简称ET) 和 Level Triggered(简称LT).在采用这两种模式时要注意的是,如果采用ET模式,那么仅当状态发生变化时才会通知,而采用LT模式类似于原来的select/poll操作,只要还有没有处理的事件就会一直通知.
epoll的LT和ET模式介绍
最新发布
m0_62689947的博客
05-04 401
epoll的ET模式如何设置，ET模式和LT模式的区别
epoll的边缘触发与水平触发
weixin_30502157的博客
05-26 103
epoll的边缘触发与水平触发 　　Tcp连接是双向的，内核为每个socket维护两个缓冲区，读缓冲区与写缓冲区，内核会一个关注这两个缓冲区，当采用水平触发时，对于写缓冲区而言，如果有多余空间可写，对于读缓冲区而言，如果有数据可读，内核就会通知epoll，使得wait函数返回，进而通过IO线程对这两个事件进行处理，如果一次没有处理好，eg：没有读全或者写全，下次epoll时，内核还会继续提醒上次...
使用select实现I/O复用
明月漫千山
01-12 324
实验条件：在使用一个服务器，多个客户端的情况下，实现回声效果，即客户端传什么内容给服务器，服务器将该内容返回。 具体实现：每个客户端将自己的进程号传到服务器端，服务器端将该内容传给客户端。 运行方法： server.cpp #include <stdio.h> #include <stdlib.h> #include <sys/socket.h> #include <unistd.h> #include <arpa/inet.h> #
IO多路复用之epoll全面总结(必看篇)
09-15
此外，`event`结构体还可以设置`EPOLLONESHOT`（一次性监听）和`EPOLLET`（边缘触发）标志。 - **epoll_wait()**: 此函数阻塞直到有事件发生，或达到指定的`timeout`超时。`events`参数用于从内核接收发生的事件，...
基于io复用的服务器开发例子
11-28
结合Epoll的边缘触发（EPOLLET）或水平触发（EPOLLONESHOT）模式，可以进一步优化性能。边缘触发意味着只有在事件发生后且未被处理时才会再次通知，而水平触发则会在事件发生后每次调用`epoll_wait`时都返回。 对于...
多路IO复用-epoll，通过epoll实现事件通知，实现了水平（阻塞），边缘（非阻塞）触发
04-04
`epoll`有两种主要的事件触发模式：水平触发（Level Triggered，LT）和边缘触发（Edge Triggered，ET）。水平触发模式下，当文件描述符上有可读写事件发生时，`epoll_wait`会一直返回该事件，直到I/O操作完成。而...
IO多路复用之epoll实例
04-23
- **EPOLLET**：边缘触发（Edge Triggered）模式，当文件描述符状态从非就绪变为就绪时，epoll_wait()才会返回。相比默认的水平触发（Level Triggered），边缘触发可以减少不必要的唤醒，提高效率。 - **EPOLLERR**...
Linux IO多路复用之epoll网络编程
09-15
`EPOLLET`标志设置为边缘触发模式，这样只有当事件真正发生时，`epoll_wait()`才会返回。 总结一下，`epoll`在网络编程中扮演着至关重要的角色，它允许高效地处理大量并发连接。通过使用`epoll_ctl()`来管理文件...
epoll边缘触发和水平触发
lzg_zone的博客
04-15 374
Level_triggered(水平触发)：当被监控的文件描述符上有可读写事件发生时，epoll_wait()会通知处理程序去读写。如果这次没有把数据一次性全部读写完(如读写缓冲区太小)，那么下次调用 epoll_wait()时，它还会通知你在上没读写完的文件描述符上继续读写，当然如果你一直不去读写，它会一直通知你！！！如果系统中有大量你不需要读写的就绪文件描述符，而它们每次都会返回，这样会大大降...
网络编程：事件模型关于epoll 边缘触发与水平触发的理解
玖玖玖
10-20 805
那么在第5步调用epoll_wait之后将有可能会挂起，因为剩余的数据还存在于文件的输入缓冲区内，而且数据发出端还在等待一个针对已经发出数据的反馈信息。分析：边缘触发，第一次只输出aaaa\n,等到下一次epoll记录到读事件的时候才会发送下一条数据bbbb\n,并且此时缓冲区中会有cccc\ndddd\n数据，时间一长会造成缓冲区数据过多。（2）非阻塞方式：假如需要读的数据读不够n个字节，server会阻塞，epoll不能继续执行，则会产生死锁。(两种触发模式，减少epoll_wait()调用的次数)
EPOLL边缘触发和水平触发的区别
jollyjumper的专栏
02-18 5472
原文:http://blog.csdn.net/wei801004/article/details/4246635 LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一
epoll边缘触发_epoll 水平触发与边缘触发
weixin_29151301的博客
01-17 221
epoll也是实现I/O多路复用的一种方法，为了深入了解epoll的原理，我们先来看下epoll水平触发(level trigger，LT，LT为epoll的默认工作模式)与边缘触发(edge trigger，ET)两种工作模式。使用脉冲信号来解释LT和ET可能更加贴切。Level是指信号只需要处于水平，就一直会触发；而edge则是指信号为上升沿或者下降沿时触发。说得还有点玄乎，我们以生活中的一个...
C语言 epoll 工作模式之et 边缘触发 edge trigger
ma_de_hao_mei_le的博客
04-10 2486
友链 // epoll的工作模式 // lt level trigger 水平触发模式 // et edge trigger 边缘触发 // lt模式是默认的 // et是高速工作方式 // 前者会一直通知，后者只会通知一次，如果你缓冲区里面的数据没读完，也不会再通知了 // 后者比较高效，但是需要解决read阻塞的问题 运行效果： 小米游戏本：everything搜索 root@DESKTOP-OKFA7PP_ _home_x 2022-04-10 18-11-02.mp4 再不解封流量都没了 g
epoll机制TCP服务器和ET(edge-trigger) 边缘触发
weixin_41873545的博客
09-18 346
当客户端给tcp服务器发送一个数据时,这个client_socket将会是可读的,调用epoll_wait函数将会返回该client_socket,如果服务器不做处理,这个client_socket将会是一直可读的,下次调用epoll_wait函数将会继续返回client_socket。epoll_create() 创建epoll监听socket。在实现epoll机制前,我们得先了解下ET/LT模式。epoll_ctl()注册,删除,修改监听。epoll_wait() 等待事件触发函数。
【I/O多路复用】epoll系统调用的ET(Edge Trigger)模式
Lebron
07-20 1551
文章目录什么是LT和ET模式 什么是LT和ET模式 epoll对文件描述符的操作有两种模式 LT(LevelTigger)电平触发模式和ET (EdgeTrigger, 边沿触发)模式。 LT模式是默认的工作模式，这种模式下cpoll相当于一 个效率较高的poll.当往epoll内核事件表中注册一个文件描述符上的EPOLET事件时，epoll将以ET模式来操作该文件描述符。ET模式是epoll的高...
epoll之水平触发和边缘触发
qq_40276626的博客
09-09 8210
epoll中有两种触发模式，分别为 1、水平触发 水平触发为Level Triggered，简称LT。 水平触发关心的是缓冲区的状态，当缓冲区可读的时候，就会发出通知，也就是当缓冲区中只要有数据就会发出通知。 2、边缘触发 边缘触发为Edge Triggered，简称ET。 边缘触发关心的是缓冲区状态的变化，当缓冲区状态发生变化的时候才会发出通知，比如缓冲区中来了新的数据。 从上述表述可能不太看得出他们之间的区别，我们设想这样一个场景，当一次read()读取没有读取完缓冲区中的数据时，LT和ET的区别： 1
epoll水平和边缘触发
08-31
epoll是Linux系统下的一种高效的I/O事件通知机制，它可以用于处理大量的并发连接。epoll提供了两种工作模式：水平触发（LT）和边缘触发（ET）。 水平触发模式（LT）是epoll的默认工作模式。在水平触发模式下，当一个文件描述符上有事件到达时，epoll_wait()会立即返回该事件，并且如果该事件没有被处理，下次调用epoll_wait()时会再次返回该事件。也就是说，在水平触发模式下，如果一个事件没有被完全处理，那么每次调用epoll_wait()都会返回该事件。 边缘触发模式（ET）是一种更高效的工作模式。在边缘触发模式下，当一个文件描述符上有事件到达时，epoll_wait()只会通知一次，即使该事件没有被完全处理。如果没有处理完整个事件，下次调用epoll_wait()时不会再次返回该事件。边缘触发模式要求应用程序在收到通知后尽可能地处理完整个事件，并且要确保及时读取或写入所有的数据。 总的来说，水平触发模式适用于需要反复处理的事件，而边缘触发模式适用于需要高效处理的事件。在实际应用中，根据具体需求选择适合的工作模式可以提高程序的性能和效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值