1 epoll反应堆过程
这里简单说明一下，我们只需要清楚，当cfd读事件满足，然后read，接着下树。改成监听写事件，再上树，当cfd的写事件满足，然后write，接着下树改会监听读事件，一直循环即可。下面的图就是这个思想。
2 epoll反应堆案例
2.1 案例前了解
在将案例前，我们首先明确我们想要操作的数据结构。由于epoll操作的都是树节点，节点类型为struct epoll_event，所以我们操作epoll_event，因其成员有data，所以我们操作data(events是事件所以不需要操作)，data是一个共用体，更深一层就是使用ptr(当我们使用ptr时，fd就不会使用到)，然后当我们使用ptr指向自定义对象时，由于自定义对象封装了回调函数，这样当事件满足就能执行到我们对应的回调。
所以归根结底我们就是维护ptr的指向和自定义结构体的成员。
操作struct epoll_event节点的函数为epoll_ctl，我们注意参2和参4即可，参2代表何种操作，参4为epoll_event节点。
2.2 案例
/*
*epoll基于非阻塞I/O事件驱动
*/
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#define MAX_EVENTS 1024 //监听上限数
#define BUFLEN 4096
#define SERV_PORT 8080
void recvdata(int fd, int events, void *arg);
void senddata(int fd, int events, void *arg);
/* 描述就绪文件描述符相关信息 */
struct myevent_s {
int fd; //要监听的文件描述符
int events; //描述符对应的监听事件，和节点的监听事件对应
void *arg; //泛型参数，这里指向结构体本身
void (*call_back)(int fd, int events, void *arg); //回调函数
int status; //是否在红黑树上监听:1->在红黑树上(监听), 0->不在(不监听)
char buf[BUFLEN]; //读或写数据的缓存
int len;
long last_active; //记录每次加入红黑树 g_efd 的时间值，用于踢掉长时间连接却不发消息的用户
};
int g_efd; //全局变量, 保存epoll_create返回的文件描述符
struct myevent_s g_events[MAX_EVENTS + 1]; //自定义结构体类型数组. +1是为了在数组下标为1024存放lfd，0-1023就可以存放cfd，这才是真正的监听上限
/* 当有文件描述符就绪, epoll返回, 调用该函数 与客户端建立链接 */
void acceptconn(int lfd, int events, void *arg){
struct myevent_s *mev = (struct myevent_s*)arg;
struct sockaddr_in cin;
socklen_t len = sizeof(cin);
int cfd, i;
if ((cfd = accept(mev->fd, (struct sockaddr *)&cin, &len)) == -1) {
if (errno != EAGAIN && errno != EINTR) {
/* 暂时不做出错处理 */
}
printf("%s: accept, %s\n", __func__, strerror(errno));
return ;
}
do{
for(i = 0; i < MAX_EVENTS; i++){
if(g_events[i].status == 0){/* 从自定义结构体数组获取未连接元素 */
break;
}
}
if(MAX_EVENTS == i){ /* 超过连接 */
printf("超过1024个客户端，程序退出.\n");
//exit(0);
break;
}
int flag = 0;
if ((flag = fcntl(cfd, F_SETFL, O_NONBLOCK)) < 0) {//将每个连接的cfd设置为非阻塞
printf("%s: fcntl nonblocking failed, %s\n", __func__, strerror(errno));
break;
}
/* 将节点挂上树 */
struct epoll_event epv = {0, {0}};
epv.events = EPOLLIN | EPOLLET; /* 这个是节点的监听事件，下面是自定义结构体的监听事件 */
g_events[i].fd = cfd;
g_events[i].events = EPOLLIN | EPOLLET;
g_events[i].call_back = recvdata; /* cfd的读事件回调 */
g_events[i].arg = &g_events[i]; /* arg指向本结构体 */
g_events[i].last_active = time(NULL); /* 记录该客户端的连接时间 */
epv.data.ptr = (void*)&g_events[i]; /* 指向自定义结构体 */
epoll_ctl(g_efd, EPOLL_CTL_ADD, cfd, &epv);
g_events[i].status = 1; /* 记得每次epoll_ctl上下树完重置status */
}while(0);
}
/* 读事件回调函数 */
void recvdata(int fd, int events, void *arg)
{
struct myevent_s *mev = (struct myevent_s*)arg;
if(mev->status == 0){
return;
}
/* 1 读数据*/
int len = recv(fd, mev->buf, sizeof(mev->buf), 0);
/* 2 读完数据下树 */
struct epoll_event epv = {0, {0}};
epv.data.ptr = NULL;
epoll_ctl(g_efd, EPOLL_CTL_DEL, fd, &epv);
/* 3 修改监听事件 */
mev->events = EPOLLOUT | EPOLLET;
mev->call_back = senddata; /* 设置写事件回调函数 */
mev->last_active = time(NULL);
mev->status = 0;
mev->len = len;
if(len > 0){
/* 4 重新上树 */
mev->buf[len] = '\0'; //手动添加字符串结束标记
printf("recvdata[fd=%d]:%s\n", fd, mev->buf);
epv.events = EPOLLOUT | EPOLLET;
epv.data.ptr = mev;
epoll_ctl(g_efd, EPOLL_CTL_ADD, fd, &epv);
mev->status = 1;
}else if(len == 0){
close(mev->fd);
mev->call_back = NULL;
mev->arg = NULL;
/* ev-g_events 地址相减得到偏移元素位置 */
printf("[fd=%d] pos[%ld], closed\n", fd, (long)(mev - g_events));
}else {
close(mev->fd);
mev->call_back = NULL;
mev->arg = NULL;
printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
}
return;
}
/* 写事件回调函数 */
void senddata(int fd, int events, void *arg)
{
struct myevent_s *mev = (struct myevent_s*)arg;/* 临时指针 */
if(mev->status == 0){/* 写需要判断0的状态，读不需要，因为满足读是有epoll_wait返回的说明必定在树上，而写的时候有可能客户端已经关闭连接 */
return;
}
/* 1 写数据 */
int len = send(fd, mev->buf, mev->len, 0);
/* 2 下树 */
struct epoll_event epv = {0, {0}};
epv.data.ptr = NULL;
epoll_ctl(g_efd, EPOLL_CTL_DEL, fd, &epv);
/* 3 修改监听事件 */
mev->events = EPOLLIN | EPOLLET;
mev->call_back = recvdata;
mev->last_active = time(NULL);
mev->status = 0;
mev->len = len;
if(len > 0){
/* 4 重新上树 */
mev->buf[len] = '\0'; //手动添加字符串结束标记
printf("senddata[fd=%d]:%s\n", fd, mev->buf);
epv.events = EPOLLIN | EPOLLET;
epv.data.ptr = mev;
epoll_ctl(g_efd, EPOLL_CTL_ADD, fd, &epv);
mev->status = 1;
}else if(len == 0){
close(mev->fd);
mev->call_back = NULL;
mev->arg = NULL;
/* ev-g_events 地址相减得到偏移元素位置 */
printf("[fd=%d] pos[%ld], closed\n", fd, (long)(mev - g_events));
}else {
close(mev->fd);
mev->call_back = NULL;
mev->arg = NULL;
printf("send[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
}
return;
}
/*创建 socket, 初始化lfd */
void initlistensocket(int efd, short port)
{
//下面为了方便而没做出错处理
int lfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(lfd, F_SETFL, O_NONBLOCK); //将lfd设为非阻塞，也可使用位图实现
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(port);
bind(lfd, (struct sockaddr *)&sin, sizeof(sin));
listen(lfd, 20);
struct epoll_event epv = {0, {0}};
//epv.events = EPOLLIN | EPOLLET;//lfd只需监听读事件即可
epv.events = EPOLLIN; /* 这个是节点的监听事件，下面是自定义结构体的监听事件，自定义结构体的监听事件是用于区分自定义数组g_events内的元素在监听什么事件 */
g_events[MAX_EVENTS].fd = lfd;
g_events[MAX_EVENTS].events = EPOLLIN;
g_events[MAX_EVENTS].call_back = acceptconn; /* lfd回调函数 */
g_events[MAX_EVENTS].arg = &g_events[MAX_EVENTS]; /* arg指向本结构体 */
epv.data.ptr = (void*)&g_events[MAX_EVENTS]; /* 指向自定义结构体 */
epoll_ctl(efd, EPOLL_CTL_ADD, lfd, &epv);
g_events[MAX_EVENTS].status = 1; /* 记得每次epoll_ctl上下树完重置status */
return ;
}
int main(int argc, char *argv[])
{
unsigned short port = SERV_PORT;
if (argc == 2)
port = atoi(argv[1]); //使用用户指定端口.如未指定,用默认端口
g_efd = epoll_create(MAX_EVENTS+1); //创建红黑树,返回给全局 g_efd
if (g_efd <= 0)
printf("create efd in %s err %s\n", __func__, strerror(errno));
initlistensocket(g_efd, port); //初始化监听lfd和设置lfd的回调处理
struct epoll_event events[MAX_EVENTS+1]; //保存已经满足就绪事件的文件描述符数组
printf("server running:port[%d]\n", port);
int checkpos = 0, i;
while (1) {
/* 超时验证，每次测试100个链接，不测试listenfd 当客户端60秒内没有和服务器通信，则关闭此客户端链接 */
long now = time(NULL); //当前时间
for (i = 0; i < 100; i++, checkpos++) { //一次循环检测100个。 使用checkpos控制检测对象
if (checkpos == MAX_EVENTS)
checkpos = 0;
if (g_events[checkpos].status != 1) //不在红黑树的数组节点无需处理
continue;
long duration = now - g_events[checkpos].last_active; //客户端不活跃的时间
if (duration >= 60) {
close(g_events[checkpos].fd); //关闭与该客户端链接
printf("[fd=%d] timeout\n", g_events[checkpos].fd);
struct epoll_event epv = {0, {0}}; //将该客户端 从红黑树 g_efd移除
g_events[checkpos].arg = NULL;
g_events[checkpos].status = 0;
epv.data.ptr = NULL;
epoll_ctl(g_efd, EPOLL_CTL_DEL, g_events[checkpos].fd, &epv);
}
}
/*监听红黑树g_efd, 将满足的事件的文件描述符加至events数组中, 1秒没有事件满足, 返回 0*/
int nfd = epoll_wait(g_efd, events, MAX_EVENTS+1, 1000);
if (nfd < 0) {
printf("epoll_wait error, exit\n");
break;
}
for (i = 0; i < nfd; i++) {
/*使用自定义结构体myevent_s类型指针, 接收 联合体data的void *ptr成员*/
struct myevent_s *mev = (struct myevent_s *)events[i].data.ptr;
if ((events[i].events & EPOLLIN) && (mev->events & EPOLLIN)) { //读就绪事件
mev->call_back(mev->fd, events[i].events, mev->arg);
}
if ((events[i].events & EPOLLOUT) && (mev->events & EPOLLOUT)) { //写就绪事件
mev->call_back(mev->fd, events[i].events, mev->arg);
}
}
}
/* 退出前释放所有资源 */
return 0;
}
服务器结果，超时会自动关闭连接。
2.3 非阻塞+LT模型
上面的代码更加直观，是我完全手写的非阻塞+ET模型。而下面是非阻塞+LT模型的代码封装。
再次注意：下面的封装代码并非是EPOLLET边沿触发事件模型，我下面代码我是拷贝的，若大家想要非阻塞加边沿，将上面的代码封装即可。
/*
*epoll基于非阻塞I/O事件驱动
*/
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#define MAX_EVENTS 1024 //监听上限数
#define BUFLEN 4096
#define SERV_PORT 8080
void recvdata(int fd, int events, void *arg);
void senddata(int fd, int events, void *arg);
/* 描述就绪文件描述符相关信息 */
struct myevent_s {
int fd; //要监听的文件描述符
int events; //描述符对应的监听事件
void *arg; //泛型参数
void (*call_back)(int fd, int events, void *arg); //回调函数
int status; //是否在红黑树上监听:1->在红黑树上(监听), 0->不在(不监听)
char buf[BUFLEN];
int len;
long last_active; //记录每次加入红黑树 g_efd 的时间值，用于踢掉长时间连接却不发消息的用户
};
int g_efd; //全局变量, 保存epoll_create返回的文件描述符
struct myevent_s g_events[MAX_EVENTS+1]; //自定义结构体类型数组. +1是为了在数组下标为1024存放lfd，0-1023就可以存放cfd，这才是真正的监听上限
/*
* 将结构体 myevent_s 成员变量 初始化，参2，3，4均是为了参1的赋值。
* 即初始化自定义结构体myevent_s。
*/
void eventset(struct myevent_s *ev, int fd, void (*call_back)(int, int, void *), void *arg)
{
ev->fd = fd;
ev->call_back = call_back;
ev->arg = arg;
ev->events = 0;
ev->status = 0;
//memset(ev->buf, 0, sizeof(ev->buf));
//ev->len = 0;
ev->last_active = time(NULL); //记住本次连接的开始时间
return;
}
/* 将epoll_event类型的树节点添加到红黑树或者修改该节点属性 */
void eventadd(int efd, int events, struct myevent_s *ev)
{
struct epoll_event epv = {0, {0}}; //epv实际是临时操作ev的临时变量
int op;
epv.data.ptr = ev; //使ptr指向自定义的结构体
epv.events = ev->events = events; //EPOLLIN 或 EPOLLOUT
if (ev->status == 1) { //已经在红黑树 g_efd 里
op = EPOLL_CTL_MOD; //修改其属性
} else { //不在红黑树里
op = EPOLL_CTL_ADD; //将其加入红黑树 g_efd, 并将status置1
ev->status = 1;
}
if (epoll_ctl(efd, op, ev->fd, &epv) < 0) //实际添加/修改
printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
else
printf("event add OK [fd=%d], op=%d, events[%0X]\n", ev->fd, op, events);
return ;
}
/* 从epoll 监听的 红黑树中删除一个 文件描述符*/
void eventdel(int efd, struct myevent_s *ev)
{
struct epoll_event epv = {0, {0}}; //epv实际是临时操作ev的临时变量
if (ev->status != 1) //不在红黑树上
return ;
//epv.data.ptr = ev;
epv.data.ptr = NULL;
ev->status = 0; //修改状态
epoll_ctl(efd, EPOLL_CTL_DEL, ev->fd, &epv); //从红黑树 efd 上将 ev->fd 摘除
return ;
}
/* 当有文件描述符就绪, epoll返回, 调用该函数 与客户端建立链接 */
void acceptconn(int lfd, int events, void *arg)
{
struct sockaddr_in cin;
socklen_t len = sizeof(cin);
int cfd, i;
if ((cfd = accept(lfd, (struct sockaddr *)&cin, &len)) == -1) {
if (errno != EAGAIN && errno != EINTR) {
/* 暂时不做出错处理 */
}
printf("%s: accept, %s\n", __func__, strerror(errno));
return ;
}
do {
for (i = 0; i < MAX_EVENTS; i++) //从全局数组g_events中找一个空闲元素
if (g_events[i].status == 0) //类似于select中找值为-1的元素
break; //跳出 for
if (i == MAX_EVENTS) {
printf("%s: max connect limit[%d]\n", __func__, MAX_EVENTS);
break; //跳出do while(0) 不执行后续代码
}
int flag = 0;
if ((flag = fcntl(cfd, F_SETFL, O_NONBLOCK)) < 0) { //将cfd也设置为非阻塞
printf("%s: fcntl nonblocking failed, %s\n", __func__, strerror(errno));
break;
}
/* 给cfd设置一个 myevent_s 结构体, 回调函数设置为 recvdata，注意lfd的回调为acceptconn */
eventset(&g_events[i], cfd, recvdata, &g_events[i]);
eventadd(g_efd, EPOLLIN, &g_events[i]); //将cfd添加到红黑树g_efd中,监听读事件
} while(0);
printf("new connect [%s:%d][time:%ld], pos[%d]\n",
inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), g_events[i].last_active, i);
return ;
}
void recvdata(int fd, int events, void *arg)
{
struct myevent_s *ev = (struct myevent_s *)arg;
int len;
len = recv(fd, ev->buf, sizeof(ev->buf), 0); //读文件描述符, 数据存入myevent_s成员buf中
eventdel(g_efd, ev); //将该节点从红黑树上摘除
if (len > 0) {
ev->len = len;
ev->buf[len] = '\0'; //手动添加字符串结束标记
printf("C[%d]:%s\n", fd, ev->buf);
eventset(ev, fd, senddata, ev); //设置该 fd 对应的回调函数为 senddata
eventadd(g_efd, EPOLLOUT, ev); //将fd加入红黑树g_efd中,监听其写事件
} else if (len == 0) {
close(ev->fd);
/* ev-g_events 地址相减得到偏移元素位置 */
printf("[fd=%d] pos[%ld], closed\n", fd, (long)(ev - g_events));
} else {
close(ev->fd);
printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
}
return;
}
void senddata(int fd, int events, void *arg)
{
struct myevent_s *ev = (struct myevent_s *)arg;
int len;
len = send(fd, ev->buf, ev->len, 0); //直接将数据 回写给客户端。未作处理
/*
printf("fd=%d\tev->buf=%s\ttev->len=%d\n", fd, ev->buf, ev->len);
printf("send len = %d\n", len);
*/
if (len > 0) {
printf("send[fd=%d], [%d]%s\n", fd, len, ev->buf);
eventdel(g_efd, ev); //从红黑树g_efd中移除
eventset(ev, fd, recvdata, ev); //将该fd的 回调函数改为 recvdata
eventadd(g_efd, EPOLLIN, ev); //从新添加到红黑树上， 设为监听读事件
} else {
close(ev->fd); //关闭链接
eventdel(g_efd, ev); //从红黑树g_efd中移除
printf("send[fd=%d] error %s\n", fd, strerror(errno));
}
return ;
}
/*创建 socket, 初始化lfd */
void initlistensocket(int efd, short port)
{
int lfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(lfd, F_SETFL, O_NONBLOCK); //将socket设为非阻塞，也可使用位图实现
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin)); //bzero(&sin, sizeof(sin))
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(port);
bind(lfd, (struct sockaddr *)&sin, sizeof(sin));
listen(lfd, 20);
/* void eventset(struct myevent_s *ev, int fd, void (*call_back)(int, int, void *), void *arg); */
eventset(&g_events[MAX_EVENTS], lfd, acceptconn, &g_events[MAX_EVENTS]);
/* void eventadd(int efd, int events, struct myevent_s *ev) */
eventadd(efd, EPOLLIN, &g_events[MAX_EVENTS]);
return ;
}
int main(int argc, char *argv[])
{
unsigned short port = SERV_PORT;
if (argc == 2)
port = atoi(argv[1]); //使用用户指定端口.如未指定,用默认端口
g_efd = epoll_create(MAX_EVENTS+1); //创建红黑树,返回给全局 g_efd
if (g_efd <= 0)
printf("create efd in %s err %s\n", __func__, strerror(errno));
initlistensocket(g_efd, port); //初始化监听lfd和设置lfd的回调处理
struct epoll_event events[MAX_EVENTS+1]; //保存已经满足就绪事件的文件描述符数组
printf("server running:port[%d]\n", port);
int checkpos = 0, i;
while (1) {
/* 超时验证，每次测试100个链接，不测试listenfd 当客户端60秒内没有和服务器通信，则关闭此客户端链接 */
long now = time(NULL); //当前时间
for (i = 0; i < 100; i++, checkpos++) { //一次循环检测100个。 使用checkpos控制检测对象
if (checkpos == MAX_EVENTS)
checkpos = 0;
if (g_events[checkpos].status != 1) //不在红黑树的数组节点无需处理
continue;
long duration = now - g_events[checkpos].last_active; //客户端不活跃的时间
if (duration >= 60) {
close(g_events[checkpos].fd); //关闭与该客户端链接
printf("[fd=%d] timeout\n", g_events[checkpos].fd);
eventdel(g_efd, &g_events[checkpos]); //将该客户端 从红黑树 g_efd移除
}
}
/*监听红黑树g_efd, 将满足的事件的文件描述符加至events数组中, 1秒没有事件满足, 返回 0*/
int nfd = epoll_wait(g_efd, events, MAX_EVENTS+1, 1000);
if (nfd < 0) {
printf("epoll_wait error, exit\n");
break;
}
for (i = 0; i < nfd; i++) {
/*使用自定义结构体myevent_s类型指针, 接收 联合体data的void *ptr成员*/
struct myevent_s *ev = (struct myevent_s *)events[i].data.ptr;
if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) { //读就绪事件
ev->call_back(ev->fd, events[i].events, ev->arg);
}
if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) { //写就绪事件
ev->call_back(ev->fd, events[i].events, ev->arg);
}
}
}
/* 退出前释放所有资源 */
return 0;
}
优化后的服务器打印结果。
3 一道腾讯后台开发的面试题
问题：使用Linux epoll模型，水平触发模式；当socket可写时，会不停的触发socket可写的事件，如何处理？
这就是上面我给出2.3的非阻塞+LT模型封装代码的原因。
答案：
-
1）第一种最普遍的方式：
需要在可读事件后，将socket改成可写事件后加入epoll【红黑树】，等待可写事件。接受到可写事件后，调用write或者send发送数据，当所有数据都写完后，把socket移出epoll，然后换成监听可读。实际上这就是我们上面2.3的例子做法。
这种方式的缺点是，即使发送很少的数据，也要把socket加入epoll，写完后在移出epoll，有一定操作代价。 -
2）一种改进的方式：
开始不把socket加入epoll，需要向socket写数据的时候，直接调用write或者send发送数据。如果返回EAGAIN，把socket加入epoll，在epoll的驱动下写数据，全部数据发送完毕后，再移出epoll。这种方式的优点是：数据不多的时候可以避免epoll的事件处理，提高效率。(这种方法我也不是很理解)
上面问题的测试，即若我们是非阻塞加LT事件模型，那么fd可写时，我将2.3可写事件转成可读事件的代码注释掉，这样就会造成该可写事件回调函数一直被触发而不断发送数据。可以看到，服务器一直回发wqda给客户端。
然而我们同样将上面手写的非阻塞加ET事件模型中的可写事件转成可读事件的代码注释掉，它的结果只会触发一次可写回调函数。并且可以看到，由于我们只是监听了只写，当客户端再发送数据过来epoll是无法监听的，所以读事件回调是无法被触发的。
5043
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
