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] 
  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] 
  1. #define MAXBUF 1024
  2. #define MAXEPOLLSIZE 10000
[java] 
  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] 
  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] 
  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] 
  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] 
  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并未清空,只是事件类型清空。这一步非常重要。