epoll的解释

 epoll是多路复用IO(I/O Multiplexing)中的一种方式,但是仅用于linux2.6以上内核,在开始讨论这个问题之前,先来解释一下为什么需要多路复用IO.

以一个生活中的例子来解释.

假设你在大学中读书,要等待一个朋友来访,而这个朋友只知道你在A号楼,但是不知道你具体住在哪里,于是你们约好了在A号楼门口见面.

如果你使用的阻塞IO模型来处理这个问题,那么你就只能一直守候在A号楼门口等待朋友的到来,在这段时间里你不能做别的事情,不难知道,这种方式的效率是低下的.

现在时代变化了,开始使用多路复用IO模型来处理这个问题.你告诉你的朋友来了A号楼找楼管大妈,让她告诉你该怎么走.这里的楼管大妈扮演的就是多路复用IO的角色.

进一步解释select和epoll模型的差异.

select版大妈做的是如下的事情:比如同学甲的朋友来了,select版大妈比较笨,她带着朋友挨个房间进行查询谁是同学甲,你等的朋友来了,于是在实际的代码中,select版大妈做的是以下的事情:

int  n  =  select( & readset,NULL,NULL, 100 );

for  ( int  i  =  0 ; n  >  0 ;  ++ i)
{
if  (FD_ISSET(fdarray[i],  & readset))
{
do_something(fdarray[i]);
--n;
}
}

epoll版大妈就比较先进了,她记下了同学甲的信息,比如说他的房间号,那么等同学甲的朋友到来时,只需要告诉该朋友同学甲在哪个房间即可,不用自己亲自带着人满大楼的找人了.于是epoll版大妈做的事情可以用如下的代码表示:

n = epoll_wait(epfd,events, 20 , 500 );

for (i = 0 ;i < n; ++ i)

在epoll中,关键的数据结构epoll_event定义如下:

typedef union epoll_data {
void  * ptr;
int  fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;

struct  epoll_event {
__uint32_t events; 
epoll_data_t data; 
};

可以看到,epoll_data是一个union结构体,它就是epoll版大妈用于保存同学信息的结构体,它可以保存很多类型的信息:fd,指针,等等.有了这个结构体,epoll大妈可以不用吹灰之力就可以定位到同学甲.

别小看了这些效率的提高,在一个大规模并发的服务器中,轮询IO是最耗时间的操作之一.再回到那个例子中,如果每到来一个朋友楼管大妈都要全楼的查询同学,那么处理的效率必然就低下了,过不久楼底就有不少的人了.

对比最早给出的阻塞IO的处理模型, 可以看到采用了多路复用IO之后, 程序可以自由的进行自己除了IO操作之外的工作, 只有到IO状态发生变化的时候由多路复用IO进行通知, 然后再采取相应的操作, 而不用一直阻塞等待IO状态发生变化了.

从上面的分析也可以看出,epoll比select的提高实际上是一个用空间换时间思想的具体应用.

 

 

 

 

 

 

其实，一切的解释都是多余的，按照我目前的了解，EPOLL模型似乎只有一种格式，所以大家只要参考我下面的代码，就能够对EPOLL有所了解了，代码的解释都已经在注释中：

while (TRUE)
{
int nfds = epoll_wait (m_epoll_fd, m_events, MAX_EVENTS, EPOLL_TIME_OUT);//等待EPOLL时间的发生，相当于监听，至于相关的端口，需要在初始化EPOLL的时候绑定。
if (nfds <= 0)
continue;
m_bOnTimeChecking = FALSE;
G_CurTime = time(NULL);
for (int i=0; i<nfds; i++)
{
try
{
if (m_events[i].data.fd == m_listen_http_fd)//如果新监测到一个HTTP用户连接到绑定的HTTP端口，建立新的连接。由于我们新采用了SOCKET连接，所以基本没用。
{
OnAcceptHttpEpoll ();
}
else if (m_events[i].data.fd == m_listen_sock_fd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
{
OnAcceptSockEpoll ();
}
else if (m_events[i].events & EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。
{
OnReadEpoll (i);
}

OnWriteEpoll (i);//查看当前的活动连接是否有需要写出的数据。
}
catch (int)
{
PRINTF ("CATCH捕获错误/n");
continue;
}
}
m_bOnTimeChecking = TRUE;
OnTimer ();//进行一些定时的操作，主要就是删除一些短线用户等。
}

　其实EPOLL的精华，按照我目前的理解，也就是上述的几段短短的代码，看来时代真的不同了，以前如何接受大量用户连接的问题，现在却被如此轻松的搞定，真是让人不得不感叹。

今天搞了一天的epoll，想做一个高并发的代理程序。刚开始真是郁闷,一直搞不通，网上也有几篇介绍epoll的文章。但都不深入，没有将一些注意的地方讲明。以至于走了很多弯路，现将自己的一些理解共享给大家,以少走弯路。

epoll用到的所有函数都是在头文件sys/epoll.h中声明，有什么地方不明白或函数忘记了可以去看一下。
epoll和select相比，最大不同在于:

1epoll返回时已经明确的知道哪个sokcet fd发生了事件，不用再一个个比对。这样就提高了效率。
2select的FD_SETSIZE是有限止的，而epoll是没有限止的只与系统资源有关。

1、epoll_create函数
函数声明：int epoll_create(int size)
该函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间，用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个epoll fd上能关注的最大socket fd数。随你定好了。只要你有空间。可参见上面与select之不同2.

22、epoll_ctl函数
函数声明：int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
该函数用于控制某个epoll文件描述符上的事件，可以注册事件，修改事件，删除事件。
参数：
epfd：由 epoll_create 生成的epoll专用的文件描述符；
op：要进行的操作例如注册事件，可能的取值EPOLL_CTL_ADD 注册、EPOLL_CTL_MOD 修 改、EPOLL_CTL_DEL 删除

fd：关联的文件描述符；
event：指向epoll_event的指针；
如果调用成功返回0,不成功返回-1

用到的数据结构
typedef union epoll_data {
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;

struct epoll_event {
__uint32_t events;
epoll_data_t data;
};


如：
struct epoll_event ev;
//设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
//设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);


常用的事件类型:
EPOLLIN ：表示对应的文件描述符可以读；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET：表示对应的文件描述符有事件发生；


3、epoll_wait函数
函数声明:int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout)
该函数用于轮询I/O事件的发生；
参数：
epfd:由epoll_create 生成的epoll专用的文件描述符；
epoll_event:用于回传代处理事件的数组；
maxevents:每次能处理的事件数；
timeout:等待I/O事件发生的超时值(单位我也不太清楚)；-1相当于阻塞，0相当于非阻塞。一般用-1即可
返回发生事件数。
 

[java]  view plain copy print ?

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <errno.h>
4. #include <string.h>
5. #include <sys/types.h>
6. #include <netinet/in.h>
7. #include <sys/socket.h>
8. #include <sys/wait.h>
9. #include <unistd.h>
10. #include <arpa/inet.h>
11. #include <openssl/ssl.h>
12. #include <openssl/err.h>
13. #include <fcntl.h>
14. #include <sys/epoll.h>
15. #include <sys/time.h>
16. #include <sys/resource.h>

[java]  view plain copy print ?

1. #define MAXBUF 1024
2. #define MAXEPOLLSIZE 10000

[java]  view plain copy print ?

1. int setnonblocking(int sockfd)
2. {
3. if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)
4. {
5. return -1;
6. }
7. return 0;
8. }

[java]  view plain copy print ?

1. int handle_message(int new_fd)
2. {
3. char buf[MAXBUF + 1];
4. int len;
5. bzero(buf, MAXBUF + 1);
6. len = recv(new_fd, buf, MAXBUF, 0);
7. if (len > 0)
8. {
9. printf
10. ("%d接收消息成功:'%s'，共%d个字节的数据/n",
11. new_fd, buf, len);
12. }
13. else
14. {
15. if (len < 0)
16. printf
17. ("消息接收失败！错误代码是%d，错误信息是'%s'/n",
18. errno, strerror(errno));
19. close(new_fd);
20. return -1;
21. }
22. return len;
23. }
24. int main(int argc, char **argv)
25. {
26. int listener, new_fd, kdpfd, nfds, n, ret, curfds;
27. socklen_t len;
28. struct sockaddr_in my_addr, their_addr;
29. unsigned int myport, lisnum;
30. struct epoll_event ev;
31. struct epoll_event events[MAXEPOLLSIZE];
32. struct rlimit rt;
33. myport = 5000;
34. lisnum = 2;
35. rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;
36. if (setrlimit(RLIMIT_NOFILE, &rt) == -1)
37. {
38. perror("setrlimit");
39. exit(1);
40. }
41. else
42. {
43. printf("设置系统资源参数成功！/n");
44. }

[java]  view plain copy print ?

1. if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1)
2. {
3. perror("socket");
4. exit(1);
5. }
6. else
7. {
8. printf("socket 创建成功！/n");
9. }
10. setnonblocking(listener);

[java]  view plain copy print ?

1. bzero(&my_addr, sizeof(my_addr));
2. my_addr.sin_family = PF_INET;
3. my_addr.sin_port = htons(myport);
4. my_addr.sin_addr.s_addr = INADDR_ANY;

[java]  view plain copy print ?

1. if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1)
2. {
3. perror("bind");
4. exit(1);
5. }
6. else
7. {
8. printf("IP 地址和端口绑定成功/n");
9. }
10. if (listen(listener, lisnum) == -1)
11. {
12. perror("listen");
13. exit(1);
14. }
15. else
16. {
17. printf("开启服务成功！/n");
18. }
19. kdpfd = epoll_create(MAXEPOLLSIZE);
20. len = sizeof(struct sockaddr_in);
21. ev.events = EPOLLIN | EPOLLET;
22. ev.data.fd = listener;
23. if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0)
24. {
25. fprintf(stderr, "epoll set insertion error: fd=%d/n", listener);
26. return -1;
27. }
28. else
29. {
30. printf("监听 socket 加入 epoll 成功！/n");
31. }
32. curfds = 1;
33. while (1)
34. {
35. nfds = epoll_wait(kdpfd, events, curfds, -1);
36. if (nfds == -1)
37. {
38. perror("epoll_wait");
39. break;
40. }
41. for (n = 0; n < nfds; ++n)
42. {
43. if (events[n].data.fd == listener)
44. {
45. new_fd = accept(listener, (struct sockaddr *) &their_addr,&len);
46. if (new_fd < 0)
47. {
48. perror("accept");
49. continue;
50. }
51. else
52. {
53. printf("有连接来自于： %d:%d，分配的 socket 为:%d/n",
54. inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);
55. }
56. setnonblocking(new_fd);
57. ev.events = EPOLLIN | EPOLLET;
58. ev.data.fd = new_fd;
59. if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0)
60. {
61. fprintf(stderr, "把 socket '%d' 加入 epoll 失败！%s/n",
62. new_fd, strerror(errno));
63. return -1;
64. }
65. curfds++;
66. }
67. else
68. {
69. ret = handle_message(events[n].data.fd);
70. if (ret < 1 && errno != 11)
71. {
72. epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,&ev);
73. curfds--;
74. }
75. }
76. }
77. }
78. close(listener);
79. return 0;
80. }

epoll_wait运行的原理是 等侍注册在epfd上的socket fd的事件的发生，如果发生则将发生的sokct fd和事件类型放入到events数组中。 并且将注册在epfd上的socket fd的事件类型给清空，所以如果下一个循环你还要关注这个socket fd的话，则需要用epoll_ctl(epfd,EPOLL_CTL_MOD,listenfd,&ev)来重新设置socket fd的事件类型。这时不用EPOLL_CTL_ADD,因为socket fd并未清空，只是事件类型清空。这一步非常重要。