epoll非阻塞的I/O反应堆
目录
- 前言
- 一、基于epoll非阻塞的I/O反应堆源码
- 二、个人理解与注释
-
- 1.基于epoll非阻塞的I/O反应堆的逻辑思路
- 2.头文件、宏及结构体
- 3.主函数
- 4.主函数中initlistensocket阶段
- 5.主函数中initlistensocket之后的阶段
- 6.读函数，写函数
- 总结
前言
本文章为黑马程序员Linux网络编程中的epoll反应堆的具体实现的个人理解与注释。
对于黑马程序员中epoll反应堆这章个人觉得因为首先代码量相对epoll的LT模式的简单实现激增，并且对于ET模式下还增加了回调函数，参与了void * ptr的回调函数，难度也是激增。等于是按照C++的多态来写C的多态。对于不同的传入的文件描述符采用不同的回调函数实现多态。并且采用超时来踢掉不活跃的客户端。
首先附上源码
一、基于epoll非阻塞的I/O反应堆源码
#include 看的人想崩溃。
二、个人理解与注释
1.基于epoll非阻塞的I/O反应堆的逻辑思路
简单来说就是 epoll的ET模式+非阻塞轮询+多态下针对不同的文件描述符的回调函数
反应堆不仅要监听读事件，也要监听写事件。
简要逻辑流程如下：（服务器端）
1.lfd=socket()创建lfd套接字—>bind()绑定地址—>listen()设置监听上限—>epoll_create()创建监听红黑树()—>epoll_ctl()把lfd加入红黑树—>while(1) 服务器端上线等待连接。
2.epoll_wait()服务器监听—>有事件发生—>epoll_wait()返回监听满足数组—>一旦有事件发生则lfd一定在满足数组中，lfd进行accept()—>用lfd进行accept()返回的连接套接字cfd放到红黑树中—>执行读操作—>进行大小写转换操作—>把cfd节点的属性从EPOLLIN变为EPOLLOUT—>再把cfd重新挂上红黑树去监听写事件—>等待epoll_wait()返回—>有返回说明能写—>执行写操作—>把cfd从红黑树中拿下来—>再把cfd节点的属性从EPOLLIN变为EPOLLOUT—>再把cfd重新挂上红黑树去监听读事件—>epoll_wait()服务器监听。从而形成一个完美的闭环。
再在其中加上超时验证，main函数的主要流程就是这样。接下来进行每一步按照自己的逻辑进行注释。
2.头文件、宏及结构体
#include 3.主函数
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));//__fun__为系统宏定义
initlistensocket(g_efd, port); //初始化监听socket
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) //不在红黑树 g_efd 上
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);
//lfd EPOLLIN
}
if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) { //写就绪事件
ev->call_back(ev->fd, events[i].events, ev->arg);
}
}
}
/* 退出前释放所有资源 */
return 0;
}
4.主函数中initlistensocket阶段
initlistensocket(g_efd, port);
initlistensocket(g_efd,port)对于红黑树的根节点进行初始化，并且完成一系列的入socket、bind、listen等操作，重要的是
eventset(&g_events[MAX_EVENTS], lfd, acceptconn, &g_events[MAX_EVENTS]);我们在创立之处就建立了myevent_s类型的数组g_events，用于保存对于不同文件描述符的不同的事件匹配。这里是将lfd放在数组的最后一个位置，eventset()就是为lfd的文件描述符绑定acceptconn的回调函数。然后再通过eventadd()将红黑树根节点g_efd挂上红黑树并设置属性为EPOLLIN，！！！epoll一定是先挂红黑树的根节点，只有满足通信响应条件，才会将别的文件描述符，如lfd、cfd设置属性后再挂上红黑树！！！
acceptconn就是利用lfd已经满足响应的情况下进行accept()，创造出通信套接字cfd，并且在g_events中找个空位将其放下，因为我们采用的是epoll的ET的非阻塞模式，所以再将创造出的cfd的套接字按照linux源码样式设置为非阻塞模式fcntl(cfd, F_SETFL, O_NONBLOCK);，这里采用flag就是对其进行状态返回。！！！只有在lfd满足响应的情况下才会通过epoll_wait传出的满足监听条件的fd的结构体中调用acceptconn的回调函数。eventset只是将lfd与acceptconn进行绑定。
同样，对于通过accept()新创建的文件描述符cfd，我们也要用eventset()对其进行事件匹配，不过lfd只会绑定acceptconn事件，而cfd在读阶段绑定recvdata事件，在写阶段绑定senddata事件。acceptconn中这里cfd刚创立，自然绑定读事件recvdata，然后再用eventadd挂上红黑树，并设置其属性为EPOLLIN。
这里只重点说了对于回调函数的绑定，如status（是否在树上）、last_active（加入红黑树的事件）、events（对于监听的事件）等待这些比较简单，就不展开注释了。不过last_active在之后对于文件描述符超时验证有很大帮助。
void initlistensocket(int efd, short port)
{
struct sockaddr_in sin;
int lfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(lfd, F_SETFL, O_NONBLOCK); //将socket设为非阻塞
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 ;
}
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->events = 0;
ev->arg = arg;
ev->status = 0;
memset(ev->buf, 0, sizeof(ev->buf));
ev->len = 0;
ev->last_active = time(NULL); //调用eventset函数的时间
return;
}
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 */
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 ;
}
//eventadd(efd, EPOLLIN, &g_events[MAX_EVENTS]);
void eventadd(int efd, int events, struct myevent_s *ev)
{
struct epoll_event epv = {0, {0}};
int op;
epv.data.ptr = ev;
epv.events = ev->events = events; //EPOLLIN 或 EPOLLOUT
if (ev->status == 0) { //已经在红黑树 g_efd 里
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 ;
}
5.主函数中initlistensocket之后的阶段
struct epoll_event events[MAX_EVENTS+1];
创建用于epoll_wait()中作为传出参数满足通信响应条件的文件描述符的数组。
int checkpos = 0, i;
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) //不在红黑树 g_efd 上
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移除
}
}
超时验证-----单位是秒
如果持续时间超过一分钟，就主动关闭改文件描述符，并且将该文件秒师傅通过eventdel()摘除
void eventdel(int efd, struct myevent_s *ev)
{
struct epoll_event epv = {0, {0}};
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 ;
}
但是超时验证对于“迎宾”文件描述符lfd是不进行超时检测的，因为lfd是要对于每个客户端的连接创建的cfd都要有lfd的参与。因为我们初始化的时候将lfd放在了最后一个位置，checkpos == MAX_EVENTS自然避开了对于lfd的检测。
正儿八经的epoll_wait()阶段
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);
//lfd EPOLLIN
}
if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) { //写就绪事件
ev->call_back(ev->fd, events[i].events, ev->arg);
}
}
g_events数组是作为全局数组，存放所有的已知的文件描述符，而events数组是epoll_wait()中作为传出参数满足通信响应条件的文件描述符的数组。nfd表示满足监听的总个数，可以作为循环遍历events数组的上限值。如果该响应文件描述符满足读事件，则调用读回调函数，如果满足写事件则调用写回调函数。
如果例如一个myevent_s类型的指针ev满足读事件，对应g_events中的状态应该为：
ev->fd=cfd;
ev->call_back=recvdata;
ev->events=EPOLLIN;
ev->arg=&g_events[index]; //index为cfd所在g_events中的位置
ev->status=1; //既然响应了则必然在红黑树挂着
len... //长度、时间等等。。
last_active...
则 ev->call_back(ev->fd, events[i].events, ev->arg);相当于void recvdata(int fd, int events, void *arg);写事件同理。
这样终于把主函数讲清楚了
6.读函数，写函数
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, 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); //直接将数据 回写给客户端。未作处理
eventdel(g_efd, ev); //从红黑树g_efd中移除
if (len > 0) {
printf("send[fd=%d], [%d]%s\n", fd, len, ev->buf);
eventset(ev, fd, recvdata, ev); //将该fd的 回调函数改为 recvdata
eventadd(g_efd, EPOLLIN, ev); //从新添加到红黑树上， 设为监听读事件
} else {
close(ev->fd); //关闭链接
printf("send[fd=%d] error %s\n", fd, strerror(errno));
}
return ;
}
读函数和写函数都是简单的I/O流程函数。
但是在读函数将数据读入成员ev的buf中后，要将该文件描述符从红黑树中摘除，读到数据后将该文件描述符的回调函数从recvdata改为senddata，并且将该文件描述符再加入红黑树中，从读监听转为写监听，等待客户端允许写的状态返回再进行写。
写函数同理，是将写监听转为读监听，从而形成2.1中逻辑思路所说的大闭环。
总结
全文手打真的好累=^=
看到这里是不是觉得豁然开朗了呢？我写完这些注释我倒是豁然开朗了=V=
是不是觉得epoll很简单呢？还有线程池没有加进去呢hhh！
希望这边博客对于你的epoll有理解上的帮助！