Socket编程之epoll的学习笔记

清疚 2022-03-16 10:00 369阅读 0赞

1.内核事件表  
epoll是Linux特有的I/O复用函数,首先，epoll使用一组函数来完成任务，而不是单个函数.其次,epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中，epoll需要使用一个额外的文件描述符，来唯一标识内核的这个事件表.

#include<sys/epoll.h>
    int epoll_create(int size)

size只是告诉内核，事件表需要多大.该函数返回的文件描述符将用作其他所有的epoll系统调用的第一个函数,指定要返回的文件描述符

#include <sys/epoll.h>
    int epoll_ctl(int epfd,int op, int fd, struct epoll_event * event)

fd参数是要操作的文件描述符，op参数是指定操作类型,操作类型有下面几种:  
EPOLL\_CTL\_ADD,往事件表中注册fd上的事件  
EPOLL\_CTL\_MOD，修改fd上的注册事件  
EPOLL\_CTL\_DEL，删除fd上的注册事件  
event参数指定事件，它是epoll\_event结构指针类型,epoll\_event的定义如下

struct epoll_event
    {
    	_unit32_t events;//epoll事件
    	epoll_data_t data;//用户数据
    }

其中events成员描述事件类型.epoll支持的事件类型和poll基本相同.表示epoll事件类型的宏在poll对应的宏前加"E"  
, data成员用于存储用户数据，epoll\_data\_t的定义如下：

typedef union epoll_data
    {
    	void * ptr;
    	int fd;
    	uint32_tu32;
    	uint64_t u64;
    }

epoll\_data是一个联合体,其中4个成员中使用最多的fd,它指定事件所属的目标文件描述符，ptr成员可用来指定与fd相关的用户数据,epoll\_data\_t是一个联合题，不能同时使用ptr和fd成员,将文件描述符和用户数据关联起来，以实现快速的数据访问

2.epoll\_wait函数

epoll系列系统调用的主要接口是epoll\_wait函数，它在一端超时时间里等待一组文件描述符上的事情

#include<sys/epoll.h>
    int epoll_wait(int epfd,struct epoll_event* events,int maxevents,int timeout)

该函数成功返回就绪的文件描述符的各数  
timeout参数的含义与poll接口的timeout参数相同.maxevents参数指定最多监听多少个时间，它必须大于0。  
epoll\_wait函数如果检测到时间，就将所有就绪的事件从内核事件表中复制到它的第二个参数events指向的数组中.  
这个数组值用于输出epoll\_wait检测到的就绪事件,而不是像select和poll的数组参数用于传入用户注册的事件，用于输出内核检测的就绪事件，极大的提高了应用程序索引就绪文件描述符的效率

poll和epoll在使用的差别
    int ret = poll(fd,MAX_EVENT_NUMBER,-1);
    //必须遍历完所有已经注册文件描述符并找到其中的就绪这
    for(int i=0;i<MAX_EVENT_NUMBER,++i)
    {
    	if(fds[i].revents.&POLLIN)
    	{
    	int sockfd = fds[i].fd;
    	//处理sockfd
    	}
        }
        如何索引epoll返回就绪的文件描述符
    int ret = epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-1);
    
    for(int i = 0; i <ret; i++)
    {
    	int sockfd = events[i].data.fd;
    }

LT和ET模式

epoll对于文件描述符的操作有两种模式,LT模式和ET模式

*  LT是默认的工作模式，相当于一个效率较高的poll,epoll\_wait检测到其上有事件发生并将事件通知应用程序后，应用程序可以不立即处理该事件，当应用程序再一次调用epoll\_wait时，epoll\_wait会再次向应用程序通告此事的，直到事件被处理
 *  ET是高效工作模式，注册了一个文件描述符上的EPOLLET事件，以ET模式来进行操作,epoll\_wait检测上的事件发生并且将事件通知给应用程序之后，应用程序必须立即处理该事件。因为后续的epoll\_wait调用将不再向应用程序通知这一事件
 *  ET在很大程序上降低了一个epoll被多次触发的次数，效率比较高.

//LT和ET模式  
\#include <sys/types.h>  
\#include <sys/socket.h>  
\#include <netinet/in.h>  
\#include <arpa/inet.h>  
\#include <assert.h>  
\#include <stdio.h>  
\#include <unistd.h>  
\#include <errno.h>  
\#include <string.h>  
\#include <fcntl.h>  
\#include <stdlib.h>  
\#include <sys/epoll.h>  
\#include <pthread.h>  
\#define MAX\_EVENT\_NUMBER 1024  
\#define BUFFER\_SIZE 10  
/*将文件描述符设置为非阻塞的*/  
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 表示是不是要开启et模式  
//et模式即epoll的高效的模式，表示epoll只给应用程序触发一次  
void addfd(int epollfd , int fd, bool enable\_et)  
\{  
epoll\_event event;  
event.data.fd = fd;  
event.events = EPOLLIN;//可读事件  
//如果是et的话enable\_et为1  
if( enable\_et )  
\{  
event.events |= EPOLLET;//开启et模式  
//event.events |= EPOLLONESHOT;  
\}  
epoll\_ctl(epollfd,EPOLL\_CTL\_ADD,fd,&event);//操作epoll内核表事件  
setnonblocking(fd);//非阻塞  
\}  
//重置fd上的事件,这样的操作之后,fd中的epoll的EPOLLONESHOT事件虽然已经被注册了，但是依旧会触发fd中的EPOLLIN事件，且只能触发一次  
void reset\_oneshot(int epollfd,int fd)  
\{  
epoll\_event event;  
event.data.fd = fd;  
event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;  
epoll\_ctl(epollfd,EPOLL\_CTL\_MOD,fd,&event);//修改内核注册表事件  
\}  
//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\_addrlength = sizeof(client\_address);  
int connfd = accept(listenfd,(struct sockaddr \*)&client\_address,&client\_addrlength);  
addfd(epollfd,connfd,false);//对于connfd不使用et模式  
\}  
else if(events\[i\].events & EPOLLIN)//如果有读事件的话  
\{  
//只要socket的读缓存区中还有没有读取出来的数据,代码将会被触发  
printf(“event trigger once\\n”);  
memset(buf,’\\0’,BUFFER\_SIZE);  
int ret = recv(sockfd,buf,BUFFER\_SIZE - 1, 0);  
if(ret <= 0)  
\{  
//reset\_oneshot(epollfd,sockfd);  
close(fd);  
continue;  
\}  
printf(“get %d btys of content : %s\\n”,ret,buf);  
\}  
else  
\{  
printf(“something else happened \\n”);  
\}  
\}  
\}  
//ET模式的工作流程  
void et(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\_addrlength = sizeof(client\_address);  
int connfd = accept(listenfd, (struct sockaddr \*)&client\_address, &client\_addrlength);  
addfd(epollfd, connfd, true); //对于connfd使用et模式  
\}  
else if(events\[i\].events & EPOLLIN)  
\{  
//只有触发一次et的工作模式  
printf(“event trigger once\\n”);  
//不断的重复接收socket套接字的内容  
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))  
\{  
printf(“read later\\n”);  
break;  
\}  
close(sockfd);  
break;  
\}  
else if(ret == 0)  
\{  
close(sockfd);  
\}  
else  
\{  
printf(“get %d bytes of content : %s\\n”,ret,buf);  
\}  
\}  
\}  
else  
\{  
printf(“something else happened\\n”);  
\}  
\}  
\}  
int main(int argc,char \*\* argv)  
\{  
epoll\_event event \[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 )  
\{  
printf(“epoll failed \\n”);  
break;  
\}  
lt(events,ret,epollfd,listenfd);//使用LT模式  
\}  
close(listenfd);  
return 0;  
\}

*  每个使用ET模式的文件描述符都应该是非阻塞的，如果文件描述符是阻塞的，那么读或者写操作都应该会是堵塞的.

4.EPOLLONESHOT事件

*  纵使我们使用ET模式，一个socket上的事件可能会被触发多次。会造成线程竞争的问题，这显然不是我们所期望的，我们期望的是一个socket在任意是和都只被一个线程处理，这一点可以使用epoll中的EPOLLONESHOT事件来实现  
    \-对于注册EPOLLONESHOT事件的文件描述符，操作系统最多触发其上注册的一个可读，可写或者异常的事件，且只触发以次，除非我们使用epoll\_ctl重置注册的EPOLLONESHOT事件，以确保这个socket下次可读，让其他的工作进程也可以处理这个socket