Linux中的多路复用技术---epoll的详解

其他 2018-07-16 23:47:40 阅读次数: 0

在linux 没有实现epoll事件驱动机制之前，我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。在大数据、高并发、集群等一些名词唱得火热之年代，select和poll的用武之地越来越有限，风头已经被epoll占尽。

本文便来介绍epoll的实现机制，并附带讲解一下select和poll。通过对比其不同的实现机制，真正理解为何epoll能实现高并发。

select()和poll() IO多路复用模型

select的缺点：

  1. 单个进程能够监视的文件描述符的数量存在最大限制，通常是1024，当然可以更改数量，但由于select采用轮询的方式扫描文件描述符，文件描述符数量越多，性能越差；(在linux内核头文件中，有这样的定义：#define __FD_SETSIZE    1024)
  2. 内核 / 用户空间内存拷贝问题，select需要复制大量的句柄数据结构，产生巨大的开销；
  3. select返回的是含有整个句柄的数组，应用程序需要遍历整个数组才能发现哪些句柄发生了事件；
  4. select的触发方式是水平触发，应用程序如果没有完成对一个已经就绪的文件描述符进行IO操作，那么之后每次select调用还是会将这些文件描述符通知进程。

相比select模型，poll使用链表保存文件描述符，因此没有了监视文件数量的限制，但其他三个缺点依然存在。

拿select模型为例，假设我们的服务器需要支持100万的并发连接，则在__FD_SETSIZE 为1024的情况下，则我们至少需要开辟1k个进程才能实现100万的并发连接。除了进程间上下文切换的时间消耗外，从内核/用户空间大量的无脑内存拷贝、数组轮询等，是系统难以承受的。因此，基于select模型的服务器程序，要达到10万级别的并发访问，是一个很难完成的任务。

因此，该epoll上场了。

epoll IO多路复用模型实现机制

由于epoll的实现机制与select/poll机制完全不同，上面所说的 select的缺点在epoll上不复存在。

设想一下如下场景：有100万个客户端同时与一个服务器进程保持着TCP连接。而每一时刻，通常只有几百上千个TCP连接是活跃的(事实上大部分场景都是这种情况)。如何实现这样的高并发？

在select/poll时代，服务器进程每次都把这100万个连接告诉操作系统(从用户态复制句柄数据结构到内核态)，让操作系统内核去查询这些套接字上是否有事件发生，轮询完后，再将句柄数据复制到用户态，让服务器应用程序轮询处理已发生的网络事件，这一过程资源消耗较大，因此，select/poll一般只能处理几千的并发连接。

epoll的设计和实现与select完全不同。epoll通过在Linux内核中申请一个简易的文件系统(文件系统一般用什么数据结构实现？B+树)。把原先的select/poll调用分成了3个部分：

1）调用epoll_create()建立一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)

扫描二维码关注公众号，回复： 2191120 查看本文章

2）调用epoll_ctl向epoll对象中添加这100万个连接的套接字

3）调用epoll_wait收集发生的事件的连接

如此一来，要实现上面说是的场景，只需要在进程启动时建立一个epoll对象，然后在需要的时候向这个epoll对象中添加或者删除连接。同时，epoll_wait的效率也非常高，因为调用epoll_wait时，并没有一股脑的向操作系统复制这100万个连接的句柄数据，内核也不需要去遍历全部的连接。

下面来看看Linux内核具体的epoll机制实现思路。

当某一进程调用epoll_create方法时，Linux内核会创建一个eventpoll结构体，这个结构体中有两个成员与epoll的使用方式密切相关。eventpoll结构体如下所示：

  1. struct eventpoll{
  2. ....
  3. /*红黑树的根节点，这颗树中存储着所有添加到epoll中的需要监控的事件*/
  4. struct rb_root rbr;
  5. /*双链表中则存放着将要通过epoll_wait返回给用户的满足条件的事件*/
  6. struct list_head rdlist;
  7. ....
  8. };

每一个epoll对象都有一个独立的eventpoll结构体，用于存放通过epoll_ctl方法向epoll对象中添加进来的事件。这些事件都会挂载在红黑树中，如此，重复添加的事件就可以通过红黑树而高效的识别出来(红黑树的插入时间效率是lgn，其中n为树的高度)。

而所有添加到epoll中的事件都会与设备(网卡)驱动程序建立回调关系，也就是说，当相应的事件发生时会调用这个回调方法。这个回调方法在内核中叫ep_poll_callback,它会将发生的事件添加到rdlist双链表中。

在epoll中，对于每一个事件，都会建立一个epitem结构体，如下所示：

  1. struct epitem{
  2. struct rb_node rbn; //红黑树节点
  3. struct list_head rdllink; //双向链表节点
  4. struct epoll_filefd ffd; //事件句柄信息
  5. struct eventpoll *ep; //指向其所属的eventpoll对象
  6. struct epoll_event event; //期待发生的事件类型
  7. }

当调用epoll_wait检查是否有事件发生时，只需要检查eventpoll对象中的rdlist双链表中是否有epitem元素即可。如果rdlist不为空，则把发生的事件复制到用户态，同时将事件数量返回给用户。

epoll.jpg

epoll数据结构示意图

从上面的讲解可知：通过红黑树和双链表数据结构，并结合回调机制，造就了epoll的高效。

OK，讲解完了Epoll的机理，我们便能很容易掌握epoll的用法了。一句话描述就是：三步曲。

第一步：epoll_create()系统调用。此调用返回一个句柄，之后所有的使用都依靠这个句柄来标识。

第二步：epoll_ctl()系统调用。通过此调用向epoll对象中添加、删除、修改感兴趣的事件，返回0标识成功，返回-1表示失败。

第三部：epoll_wait()系统调用。通过此调用收集收集在epoll监控中已经发生的事件。

最后，附上一个epoll编程实例。(作者为sparkliang)

  1. //
  2. // a simple echo server using epoll in linux
  3. //
  4. // 2009-11-05
  5. // 2013-03-22:修改了几个问题，1是/n格式问题，2是去掉了原代码不小心加上的ET模式;
  6. // 本来只是简单的示意程序，决定还是加上 recv/send时的buffer偏移
  7. // by sparkling
  8. //
  9. #include <sys/socket.h>
  10. #include <sys/epoll.h>
  11. #include <netinet/in.h>
  12. #include <arpa/inet.h>
  13. #include <fcntl.h>
  14. #include <unistd.h>
  15. #include <stdio.h>
  16. #include <errno.h>
  17. #include <iostream>
  18. using namespace std;
  19. #define MAX_EVENTS 500
  20. struct myevent_s
  21. {
  22. int fd;
  23. void (*call_back)( int fd, int events, void *arg);
  24. int events;
  25. void *arg;
  26. int status; // 1: in epoll wait list, 0 not in
  27. char buff[ 128]; // recv data buffer
  28. int len, s_offset;
  29. long last_active; // last active time
  30. };
  31. // set event
  32. void EventSet(myevent_s *ev, int fd, void (*call_back)(int, int, void*), void *arg)
  33. {
  34. ev->fd = fd;
  35. ev->call_back = call_back;
  36. ev->events = 0;
  37. ev->arg = arg;
  38. ev->status = 0;
  39. bzero(ev->buff, sizeof(ev->buff));
  40. ev->s_offset = 0;
  41. ev->len = 0;
  42. ev->last_active = time( NULL);
  43. }
  44. // add/mod an event to epoll
  45. void EventAdd(int epollFd, int events, myevent_s *ev)
  46. {
  47. struct epoll_event epv = { 0, { 0}};
  48. int op;
  49. epv.data.ptr = ev;
  50. epv.events = ev->events = events;
  51. if(ev->status == 1){
  52. op = EPOLL_CTL_MOD;
  53. }
  54. else{
  55. op = EPOLL_CTL_ADD;
  56. ev->status = 1;
  57. }
  58. if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0)
  59. printf( "Event Add failed[fd=%d], evnets[%d]\n", ev->fd, events);
  60. else
  61. printf( "Event Add OK[fd=%d], op=%d, evnets[%0X]\n", ev->fd, op, events);
  62. }
  63. // delete an event from epoll
  64. void EventDel(int epollFd, myevent_s *ev)
  65. {
  66. struct epoll_event epv = { 0, { 0}};
  67. if(ev->status != 1) return;
  68. epv.data.ptr = ev;
  69. ev->status = 0;
  70. epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);
  71. }
  72. int g_epollFd;
  73. myevent_s g_Events[MAX_EVENTS+ 1]; // g_Events[MAX_EVENTS] is used by listen fd
  74. void RecvData(int fd, int events, void *arg);
  75. void SendData(int fd, int events, void *arg);
  76. // accept new connections from clients
  77. void AcceptConn(int fd, int events, void *arg)
  78. {
  79. struct sockaddr_in sin;
  80. socklen_t len = sizeof(struct sockaddr_in);
  81. int nfd, i;
  82. // accept
  83. if((nfd = accept(fd, (struct sockaddr*)& sin, &len)) == -1)
  84. {
  85. if(errno != EAGAIN && errno != EINTR)
  86. {
  87. }
  88. printf( "%s: accept, %d", __func__, errno);
  89. return;
  90. }
  91. do
  92. {
  93. for(i = 0; i < MAX_EVENTS; i++)
  94. {
  95. if(g_Events[i].status == 0)
  96. {
  97. break;
  98. }
  99. }
  100. if(i == MAX_EVENTS)
  101. {
  102. printf( "%s:max connection limit[%d].", __func__, MAX_EVENTS);
  103. break;
  104. }
  105. // set nonblocking
  106. int iret = 0;
  107. if((iret = fcntl(nfd, F_SETFL, O_NONBLOCK)) < 0)
  108. {
  109. printf( "%s: fcntl nonblocking failed:%d", __func__, iret);
  110. break;
  111. }
  112. // add a read event for receive data
  113. EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);
  114. EventAdd(g_epollFd, EPOLLIN, &g_Events[i]);
  115. } while( 0);
  116. printf( "new conn[%s:%d][time:%d], pos[%d]\n", inet_ntoa( sin.sin_addr),
  117. ntohs( sin.sin_port), g_Events[i].last_active, i);
  118. }
  119. // receive data
  120. void RecvData(int fd, int events, void *arg)
  121. {
  122. struct myevent_s *ev = (struct myevent_s*)arg;
  123. int len;
  124. // receive data
  125. len = recv(fd, ev->buff+ev->len, sizeof(ev->buff) -1-ev->len, 0);
  126. EventDel(g_epollFd, ev);
  127. if(len > 0)
  128. {
  129. ev->len += len;
  130. ev->buff[len] = '\0';
  131. printf( "C[%d]:%s\n", fd, ev->buff);
  132. // change to send event
  133. EventSet(ev, fd, SendData, ev);
  134. EventAdd(g_epollFd, EPOLLOUT, ev);
  135. }
  136. else if(len == 0)
  137. {
  138. close(ev->fd);
  139. printf( "[fd=%d] pos[%d], closed gracefully.\n", fd, ev-g_Events);
  140. }
  141. else
  142. {
  143. close(ev->fd);
  144. printf( "recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
  145. }
  146. }
  147. // send data
  148. void SendData(int fd, int events, void *arg)
  149. {
  150. struct myevent_s *ev = (struct myevent_s*)arg;
  151. int len;
  152. // send data
  153. len = send(fd, ev->buff + ev->s_offset, ev->len - ev->s_offset, 0);
  154. if(len > 0)
  155. {
  156. printf( "send[fd=%d], [%d<->%d]%s\n", fd, len, ev->len, ev->buff);
  157. ev->s_offset += len;
  158. if(ev->s_offset == ev->len)
  159. {
  160. // change to receive event
  161. EventDel(g_epollFd, ev);
  162. EventSet(ev, fd, RecvData, ev);
  163. EventAdd(g_epollFd, EPOLLIN, ev);
  164. }
  165. }
  166. else
  167. {
  168. close(ev->fd);
  169. EventDel(g_epollFd, ev);
  170. printf( "send[fd=%d] error[%d]\n", fd, errno);
  171. }
  172. }
  173. void InitListenSocket(int epollFd, short port)
  174. {
  175. int listenFd = socket(AF_INET, SOCK_STREAM, 0);
  176. fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking
  177. printf( "server listen fd=%d\n", listenFd);
  178. EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVENTS]);
  179. // add listen socket
  180. EventAdd(epollFd, EPOLLIN, &g_Events[MAX_EVENTS]);
  181. // bind & listen
  182. sockaddr_in sin;
  183. bzero(& sin, sizeof( sin));
  184. sin.sin_family = AF_INET;
  185. sin.sin_addr.s_addr = INADDR_ANY;
  186. sin.sin_port = htons(port);
  187. bind(listenFd, ( const sockaddr*)& sin, sizeof( sin));
  188. listen(listenFd, 5);
  189. }
  190. int main(int argc, char **argv)
  191. {
  192. unsigned short port = 12345; // default port
  193. if(argc == 2){
  194. port = atoi(argv[ 1]);
  195. }
  196. // create epoll
  197. g_epollFd = epoll_create(MAX_EVENTS);
  198. if(g_epollFd <= 0) printf( "create epoll failed.%d\n", g_epollFd);
  199. // create & bind listen socket, and add to epoll, set non-blocking
  200. InitListenSocket(g_epollFd, port);
  201. // event loop
  202. struct epoll_event events[MAX_EVENTS];
  203. printf( "server running:port[%d]\n", port);
  204. int checkPos = 0;
  205. while( 1){
  206. // a simple timeout check here, every time 100, better to use a mini-heap, and add timer event
  207. long now = time( NULL);
  208. for( int i = 0; i < 100; i++, checkPos++) // doesn't check listen fd
  209. {
  210. if(checkPos == MAX_EVENTS) checkPos = 0; // recycle
  211. if(g_Events[checkPos].status != 1) continue;
  212. long duration = now - g_Events[checkPos].last_active;
  213. if(duration >= 60) // 60s timeout
  214. {
  215. close(g_Events[checkPos].fd);
  216. printf( "[fd=%d] timeout[%d--%d].\n", g_Events[checkPos].fd, g_Events[checkPos].last_active, now);
  217. EventDel(g_epollFd, &g_Events[checkPos]);
  218. }
  219. }
  220. // wait for events to happen
  221. int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000);
  222. if(fds < 0){
  223. printf( "epoll_wait error, exit\n");
  224. break;
  225. }
  226. for( int i = 0; i < fds; i++){
  227. myevent_s *ev = (struct myevent_s*)events[i].data.ptr;
  228. if((events[i].events&EPOLLIN)&&(ev->events&EPOLLIN)) // read event
  229. {
  230. ev->call_back(ev->fd, events[i].events, ev->arg);
  231. }
  232. if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event
  233. {
  234. ev->call_back(ev->fd, events[i].events, ev->arg);
  235. }
  236. }
  237. }
  238. // free resource
  239. return 0;

猜你喜欢

转载自blog.csdn.net/wyz0516071128/article/details/81058898
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022