1. epoll的ET模式与LT模式

epoll对文件描述符有两种操作模式：

LT（level trigger水平模式）
ET（edge trigger边缘模式）

简单来讲，LT是epoll的默认操作模式，当epoll_wait函数检测到有事件发生并将通知应用程序，而应用程序不一定必须立即进行处理，这样epoll_wait函数再次检测到此事件的时候还会通知应用程序，直到事件被处理。

而ET模式，只要epoll_wait函数检测到事件发生，通知应用程序立即进行处理，后续的epoll_wait函数将不再检测此事件。因此ET模式在很大程度上降低了同一个事件被epoll触发的次数，因此效率比LT模式高

通俗的说调用epoll_wait函数就像上学时组长催你交作业，在LT模式下，你的小组长见你一次就会催你交一次作业。而ET模式下，你的组长只通知你交一次作业，之后都不会再通知你交作业。

客户端向服务器端发送数据，服务器把数据显示出来，一次读十个字节

#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <pthread.h>
#include <string.h>
#include <iostream>
using namespace std;
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10
#define SERV_PORT 6666

//将文件设置为非阻塞
int setnonblocking(int fd){
    
    
    int old_option = fcntl(fd,F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd,F_SETFL,new_option);
    return old_option;
}

//将文件描述符fd上的EPOLLIN注册到epollfd指示的epoll内核事件表中，参数enable_et指定是否对fd启用ET模式
void addfd(int epolled,int fd,bool enable_et){
    
    
    epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = fd;
    if(enable_et){
    
    
        event.events |= EPOLLET;
    }
    epoll_ctl(epolled,EPOLL_CTL_ADD,fd,&event);
    setnonblocking(fd);
}

//LT模式的工作流程
void lt(epoll_event* events,int number,int epollfd,int listenfd){
    
    
    char buf[BUFFER_SIZE];
    for(int i = 0;i < number;i++){
    
    
        int sockfd = events[i].data.fd;
        if(sockfd == listenfd){
    
    //连接客户端
            struct sockaddr_in client_address;
            socklen_t client_address_len = sizeof(client_address);
            int connfd = accept(listenfd,(struct sockaddr*)&client_address,&client_address_len);
            addfd(epollfd,connfd,false);//对connfd禁用ET模式
        }else if(events[i].events & EPOLLIN){
    
    
            //只要sockfd读缓存中还有未读出的数据，这段代码就被触发
            cout << " event trigger once " << endl;
            memset(buf,'\0',BUFFER_SIZE);
            int ret = recv(sockfd,buf,BUFFER_SIZE-1,0);
            if(ret <= 0){
    
    
                close(sockfd);
                continue;
            }
            cout << " get " << ret << " bytes of content: " << buf << endl;
        }else{
    
    
            cout << "something else happend "  << endl;
        }
    }
}

void et(epoll_event* events,int number,int epollfd,int listenfd){
    
    
    for(int i = 0;i < number;i++){
    
    
        int sockfd = events[i].data.fd;
        if(sockfd == listenfd){
    
    
            struct sockaddr_in client_address;
            socklen_t client_address_len = sizeof(client_address);
            int connfd = accept(listenfd,(struct sockaddr*)&client_address,&client_address_len);
            addfd(epollfd,connfd,true);//开启ET模式
        }else if(events[i].events & EPOLLIN){
    
    
            //这段代码不会被重复触发，所以循环读取数据，确保把sockfd读缓存中的数据全部读出
            cout << "event trigger once" << endl;
            while(1){
    
    
                memset(buf,'\0',BUFFER_SIZE);
                int ret = recv(sockfd,buf,BUFFER_SIZE-1,0);
                if(ret < 0){
    
    
                    //对于非阻塞IO，下面的条件成立表示数据已经全部读取完毕，此后epoll就能再次触发sockfd上的EPOLLIN事件，以驱动下次读操作
                    if((errno == EAGAIN) || (errno == EWOULDBLOCK)){
    
    
                        cout << "read later" << endl;
                        break;
                    }
                    close(sockfd);
                    break;
                }else if(ret == 0){
    
    
                    close(sockfd);
                }else{
    
    
                    cout << " get " << ret << " bytes of content: " << buf << endl;
                }
            }
        }else{
    
    
            cout << "something else happend!" << endl;
        }
    }
}

int main(){
    
    
    struct sockaddr_in address;
    bzero(&address,sizeof(address));
    address.sin_family = AF_INET;
    address.sin_port = htons(SERV_PORT);
    address.sin_addr.s_addr = htonl(INADDR_ANY);

    int listenfd = socket(PF_INET,SOCK_STREAM,0);
    assert(listenfd >= 0);

    int reuse = 1;//本地地址复用
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse));

    int ret = bind(listenfd,(struct sockaddr*)&address,sizeof(address));
    assert(ret != -1);

    ret = listen(listenfd,5);
    assert(ret != -1);

    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);

    addfd(epollfd,listenfd,true);

    while(1){
    
    
        int ret = epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-1);
        if(ret < 0 ){
    
    
            perror("epoll_wait error");
            exit(1);
        }
        cout << "启用LT模式："
        lt(events,ret,epollfd,listenfd);//LT模式
        
	    //cout << "启用LT模式：" << endl;
		//et(events,ret,epollfd,listenfd);//ET模式
    }
    return 0;
}

ET模式

客户端
服务器端

LT模式

客户端
服务器端

2. poll和epoll在索引文描述符上的区别

poll
poll和select一样都采用轮询方式，即每次调用都要扫描整个注册文件描述符集合，并将其中就绪的文件描述符返回给用户程序，因此它们检测就绪事件的时间复杂度为O(n)

int ret = poll(fds,MAX_EVENTS_NUMBER,-1);
//poll必须遍历所有已经注册的文件描述符，并找到其中的就绪者
for(int i = 0; i < MAX_EVENTS_NUMBER;i++){
    
    //判断第i个文件描述符是否就绪
	if(fds[i].revents & POLLIN){
    
    
		int sockfd = fds[i].fd;
		//处理sockfd
	}
}

epoll
epoll_wait函数如果检查到事件，就将所有就绪的事件从内核事件表中复制到它的第二个参数events指向的数组中。这个数组只用于输出epoll_wait检测到的就绪事件。
采用回调的方式，内核检测到就绪事件的文件描述符时，将出发回调函数，回调函数就将该文件描述符上对应的事件插入内核就绪队列，内核最后在合适的时机将就绪事件队列中的内容拷贝到用户空间。时间复杂度为O(1)。

int ret = epoll_wait(epollfd,events,MAX_EVENTS_NUMBER,-1);
//采用回调方式
//仅遍历就绪的ret个文件描述符
for(int i = 0;i < ret i++){
    
    
	int sockfd = events[i].data.fd;
	//sockfd肯定是就绪的，可以直接处理
}

epoll的ET模式与LT模式

epoll的ET模式与LT模式

1. epoll的ET模式与LT模式

2. poll和epoll在索引文描述符上的区别

おすすめ