版权声明：本BLOG上原创文章未经本人许可，不得转载，否则属于侵权行为 https://blog.csdn.net/weixin_40204595/article/details/83213332
写在前面：本篇介绍epoll的ET和LT两种触发模式，和epoll反应堆，epoll反应堆是实现libevent原理的组成部分。可能代码部分也是会多一点。
Linux 网络编程 全解（一）--------网络基础协议
Linux 网络编程 全解（二）--------套接字socket
Linux 网络编程 全解（三）--------TCP三次握手、数据传输、四次挥手、滑动窗口
Linux 网络编程 全解（四）--------多进程并发服务器和多线程并发服务器
Linux 网络编程 全解（五）--------TCP状态切换
Linux 网络编程 全解（六）--------多路IO转接服务器
正文：
一、epoll的ET和LT触发模式
1、ET和LT简介
ET 模式即 Edge Triggered 工作模式，边沿触发，缓冲区剩余未读尽的数据不会导致epoll_wait返回，新的事件满足才会导致epoll_wait返回，边缘触发只有数据到来才触发，不管缓存区中是否还有数据。
LT 模式即 Level Triggered 工作模式，水平触发，默认，水平触发只要有数据都会触发，缓冲区剩余未读尽的数据会导致epoll_wait返回。默认情况下为LT触发模式。
2、代码实现，具体实验目的和实现方式都在代码注释中了，已经非常详细。
#include <stdio.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <string.h>
#define MAXLEN (10)
char w_buf[MAXLEN];
char r_buf[MAXLEN];
char ch = 'a';
/*pipe创建一个管道，fork创建子进程，子进程往管道中写数据，父进程从管道中读数据
*子进程每次发10个字节的数据，然后延时5s，父进程每次收5个字节的数据，
*当设置为ET模式时，因为边缘触发只有数据到来才触发，不管缓存区中是否还有数据，这样父进程每个
*5s内只会收到5个字节数据，当下个5s到来时，父进程才会收到上个5s子进程发的10个字节中的剩余5个字节数据。
*当设置为LT模式时，默认情况下就是这个模式，只要有数据都会触发，所以每次5s中都会将缓冲区中的数据
*读完，即都会将10个Bytes的数据读完。
*
*/
int main(void)
{
pid_t pid;
int pipefd[2] = {-1,-1};
int ret = -1;
ret = pipe(pipefd); //创建管道成功后，pipefd[0]为读端，pipefd[1]为管道的写入端
printf("pipefd[0] = %d, pipefd[1] = %d\n",pipefd[0],pipefd[1]);
if(ret < 0)
{
printf("pipe error\n");
return -1;
}
pid = fork();
if(0 == pid)//子进程
{
int i = 0;
close(pipefd[0]);
printf(" clid process\n");
while(1)
{
for(i = 0;i < MAXLEN/2;i ++)
{
w_buf[i] = ch;
}
w_buf[i-1] = '\n';
ch++;
for(;i < MAXLEN; i++)
{
w_buf[i] = ch;
}
w_buf[i-1] = '\n'; //即把w_buf构造成"aaaa\nbbbb\n"这种格式
ch ++;
//printf("before write buffer:%s\n",w_buf);
write(pipefd[1], w_buf, sizeof(w_buf));//即一次写10个Bytes
printf("write buffer:%s\n",w_buf);
sleep(5);
//printf("clid send buffer\n ");
}
close(pipefd[1]);
}else if(pid > 0)//父进程
{
sleep(1);
struct epoll_event lepevt; //listen epoll event
struct epoll_event ep_set[10];
int ep_nums = -1;
int i = 0;
close(pipefd[1]);
//创建一个监听树，监听树的最大节点设为50
int efd = epoll_create(10);
if(efd < 0)
{
printf("epoll_create error \n");
return -1;
}
lepevt.events = EPOLLIN | EPOLLET ;//ET模式，即边缘触发只有数据到来才触发，不管缓存区中是否还有数据
//lepevt.events = EPOLLIN; //LT模式，水平触发，默认就是LT模式，只要有数据都会触发
lepevt.data.fd = pipefd[0];
//将监听读事件添加到监听树上
epoll_ctl(efd, EPOLL_CTL_ADD, pipefd[0], &lepevt);
printf(" parents process\n");
while(1)
{
//阻塞监听事件
ep_nums = epoll_wait(efd, ep_set,10, -1);
printf("ep_nums = %d\n",ep_nums);
if(ep_nums > 0)
{
for(i = 0;i < ep_nums;i ++)
{
//如果监听到读端的数据
if(ep_set[0].data.fd == pipefd[0])
{
//每次读5个Bytes的数据
ret = read(pipefd[0], r_buf, MAXLEN/2);
//printf("ret = %d\n",ret);
if(ret > 0)
{
//write(STDOUT_FILENO,r_buf,ret);
printf("receive buffer: %s\n",r_buf);
memset(r_buf,0,sizeof(r_buf));
}
else
{
printf("read null\n");
}
break;
}
}
}
}
close(pipefd[0]);
close(efd);
}
return 0;
}
3、ET模式实验效果：从结果中可以看出，当配置为ET触发时，每次子进程写入管道时才会触发父进程中的epoll_wait返回。
LT实验效果：从现象可以看出，当配置成LT模式时，只要缓冲区中有数据，就会触发epoll_wait的返回，一直将缓冲区中的数据读完。
二、epoll反应堆
1、反应堆模型：epoll ET模式 + 非阻塞、忙轮询 + struct epoll_event中的data中的void *ptr
原来的流程：
epoll_create();//创建监听红黑树
epoll_ctl();//向书上添加监听fd
epoll_wait();//监听
有监听fd事件发送->返回监听满足数组，->判断返回数组元素->lfd满足accept-->cfd满足-->read（）读数据--->write给对 端回应。
epoll反应堆流程：
epoll_create();//创建监听红黑树
epoll_ctl();//向书上添加监听fd
epoll_wait();//监听
有监听fd事件发送->返回监听满足数组，->判断返回数组元素->lfd满足accept-->cfd满足-->read（）读数据-->cfd从监听 红黑树上摘下来--->event 中设置监听写事件 EPOLLOUT 和设置回调到 ptr中--->epoll_ctl() EPOLL_CTL_ADD重新放到监听红黑 树上监听写事件--->等待epoll_wait返回--->说明cfd可写--->write写到对端去--->再将cfd从监听红黑树上摘下--->修改成EPOLLIN---->epoll_ctl() EPOLL_CTL_ADD重新放到监听红黑树上监听读事件--->wpoll_wait监听。
2、这里可能说的不是很明白，直接上代码吧，代码中尽可能详细的做了注释
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <fcntl.h>
#define MAX_EVENTS (100) //最大的监听的个数
#define SER_PORT (6666)
typedef struct
{
int fd ;//文件描述符
int events;//事件
void *args;
void (*call_back)(int fd,int events,void *args);//事件回调函数，参数为上面三个
int status; //0:没有添加到监听树;1:已添加到监听树
char buff[1024]; //数据缓冲区
int len;//数据长度
long last_active;//上次的时间
}myevents_t;
myevents_t g_monitorEvs[MAX_EVENTS + 1];
int g_efd = -1;
int evtAdd(int efd,int events,myevents_t *p_evt);
int evtSet(myevents_t *p_evt,int fd, void (*call_back)(int fd,int events,void *args),void * arg);
int evtDel(int fd,myevents_t * p_evt);
void recvData(int fd,int events,void *args);
//发送给客户端数据
void sendData(int fd,int events,void *args)
{
int ret = -1;
myevents_t *p_evt = (myevents_t *)args;
printf("p_evt ->len = %d\n",p_evt ->len);
ret = send(fd, p_evt ->buff, p_evt ->len, 0);
if(ret > 0)
{
printf("server send to client :%s\n",p_evt ->buff);
//发送完数据之后，将fd从监听树中摘下，改为监听读事件,再放到监听树上去
evtDel(fd,p_evt);
evtSet(p_evt,fd, recvData,(void * )p_evt);
evtAdd(g_efd,EPOLLIN,p_evt);
}
else
{
close(fd);
evtDel(fd,p_evt);
}
}
//读取客户端发过来的数据的函数
void recvData(int fd,int events,void *args)
{
myevents_t *p_evt = (myevents_t *)args;
memset(p_evt ->buff,0,1024);
//读取客户端发过来的数据
p_evt ->len = recv(fd, p_evt ->buff, 1024, 0);
//将其从监听树中摘下
evtDel(fd,p_evt);
if(p_evt ->len > 0)
{
printf("client send buffer:%s\n",p_evt ->buff);
//再将此fd设置为监听写事件,再放到监听树上
evtSet(p_evt,fd, sendData,(void * )p_evt);
evtAdd(g_efd,EPOLLOUT,p_evt);
}
else
{
close(fd);
}
}
//server跟client连接函数
void acceptConnection(int fd,int events,void *args)
{
int cfd = -1;
struct sockaddr_in cli_ip;
socklen_t cli_ip_len = sizeof(cli_ip);
char cli_ip_addr[16] = {0};
int i = 0;
int flag = -1;
cfd = accept(fd, (struct sockaddr *)&cli_ip,&cli_ip_len);
if(cfd > 0)
{
memset(cli_ip_addr,0,16);
inet_ntop(AF_INET, &cli_ip.sin_addr.s_addr, cli_ip_addr, 16);
printf("client connected,client ip addr:%s\n",cli_ip_addr);
//查找没有加入到监听树中的数组节点
for(i = 0;i < MAX_EVENTS;i ++)
{
if(g_monitorEvs[i].status == 0)
break;
}
if(i >= MAX_EVENTS)
{
printf("%s:g_monitorEvs if full \n",__FUNCTION__);
return;
}
//将连接的cfd设置成非阻塞模式
flag = fcntl(cfd, F_GETFL);
flag |= O_NONBLOCK;
fcntl(cfd, F_SETFL, flag);
//找到合适的节点之后，将其添加到监听树中，并监听读事件
evtSet(&g_monitorEvs[i],cfd, recvData,(void *) &g_monitorEvs[i]);
evtAdd(g_efd,EPOLLIN,&g_monitorEvs[i]);
}
}
//初始化myevents_t 类型的一个变量
int evtSet(myevents_t *p_evt,int fd, void (*call_back)(int fd,int events,void *args),void * arg)
{
p_evt ->fd = fd;
p_evt ->events = 0;
p_evt ->args = arg;
p_evt ->call_back = call_back;
p_evt ->status = 0;
//memset(p_evt ->buff,0,1024);
//p_evt ->len = 0;
p_evt ->last_active = time(NULL);
return 0;
}
//将fd添加到监听树上，设置监听事件并设置相应的回调函数，和参数
int evtAdd(int efd,int events,myevents_t *p_evt)
{
struct epoll_event ep_evt;
int ret = -1;
int op;
memset(&ep_evt,0,sizeof(ep_evt));
ep_evt.events = events; //设置相应的监听事件
p_evt ->events = events;//监听数组中的元素也要设置
ep_evt.data.ptr = (void *)p_evt; //这里将myevents_t 类型的结构体给了ptr指针
//这里应该就是epoll反应堆的精髓了
if(1 == p_evt ->status)//监听树中已经有了这个fd
{
op = EPOLL_CTL_MOD; //EPOLL_CTL_MOD，linux中man手册的解释是Change the event event associated with the target file descrip‐
//tor fd,应该就是只更新这个fd对应的监听事件
}else//监听树中没有这个fd
{
op = EPOLL_CTL_ADD;
p_evt ->status = 1; //status 置1
}
ret = epoll_ctl(efd, op, p_evt ->fd, &ep_evt);
if(ret < 0)
{
printf("%s:epoll_ctl error\n",__FUNCTION__);
return -1;
}
return 0;
}
int evtDel(int fd,myevents_t* p_evt)
{
int op = EPOLL_CTL_DEL;
int ret = -1;
struct epoll_event ep_evt;
//如果fd没有添加到监听树上，就不用删除，直接返回
if(p_evt ->status == 0)
{
return 0;
}
//如果fd在监听树上
p_evt ->status = 0;
ep_evt.data.ptr = (void *)p_evt;
ret = epoll_ctl(g_efd,op,fd, &ep_evt);
if(ret < 0)
{
printf("%s:epoll_ctl error\n",__FUNCTION__);
return -1;
}
return 0;
}
//初始化监听lfd，并将lfd添加到监听树上去
int lfdInit(int efd,myevents_t * p_evt)
{
int lfd = -1;
struct sockaddr_in ser_ip;
//创建监听lfd
lfd = socket(AF_INET,SOCK_STREAM,0);
memset(&ser_ip,0,sizeof(struct sockaddr_in));
ser_ip.sin_family = AF_INET;
ser_ip.sin_port = htons(SER_PORT);
ser_ip.sin_addr.s_addr = htonl(INADDR_ANY);
bind(lfd, (const struct sockaddr*)&ser_ip,sizeof(ser_ip));
listen(lfd, 20);
//设置端口复用
int opt = 1;// 1:设置端口复用，0：设置端口不复用
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR,&opt, sizeof(opt));
//初始化g_monitorEvs[MAX_EVENTS],并设置回调
evtSet(p_evt,lfd, acceptConnection,(void *) p_evt);
//将lfd添加到监听树上，监听读事件
evtAdd(g_efd,EPOLLIN,p_evt);
}
int main(void)
{
int ret = -1;
int ep_wait_nums = -1;
int i = 0;
//创建监听树
g_efd = epoll_create(MAX_EVENTS);
if(g_efd < 0)
{
printf("epoll_create error\n");
}
//初始化监听lfd
//将g_monitorEvs[MAX_EVENTS]作为监听连接的数组节点
ret = lfdInit(g_efd,&g_monitorEvs[MAX_EVENTS]);
//定义这个结构体数组，用来接收epoll_wait传出的满足监听事件的fd结构体
struct epoll_event ep_evt[MAX_EVENTS];
myevents_t *p_evt;
while(1)
{
//调用eppoll_wait等待接入的客户端事件,再次声明,epoll_wait传出的是满足监听条件的那些fd的struct epoll_event
//类型
ep_wait_nums = epoll_wait(g_efd, ep_evt,MAX_EVENTS, -1);
if(ep_wait_nums > 0)
{
for(i = 0;i < ep_wait_nums;i ++)
{
//注意这里了，epoll反应堆精髓部分
//evtAdd()函数中，添加到监听树中监听事件的时候将myevents_t结构体类型给了ptr指针
//这里epoll_wait返回的时候，同样会返回对应fd的myevents_t类型的指针
p_evt = ( myevents_t *)ep_evt[i].data.ptr;
if(NULL != p_evt)
{
//如果监听的是读事件，并返回的是读事件
if((p_evt ->events & EPOLLIN)&&(ep_evt[i].events & EPOLLIN))
{
p_evt ->call_back(p_evt ->fd,ep_evt[i].events,p_evt ->args);
}
//如果监听的是写事件，并返回的是写事件
if((p_evt ->events & EPOLLOUT)&&(ep_evt[i].events & EPOLLOUT))
{
p_evt ->call_back(p_evt ->fd,ep_evt[i].events,p_evt ->args);
}
}
}
}
}
return 0;
}