linux 网络编程【五】 非阻塞通信epoll

其他 2018-10-31 14:22:41 阅读次数: 0

Epoll引入

Epoll在linux 2.6内核中引入，替代了以前的select/poll模型，能够充分支持linux下的大规模并发网络程序。

Epoll和其他linux下并发网络程序对比

PPC

典型的Apache模型，Process Per Connection，为每一个新的连接创建一个进程进行相关的处理。

TPC

Thread Per Connection，为每一个新的连接创建一个线程进行相关的处理。显然PPC和TPC的开销是较大的，尤其是在大量连接的情况下。

select

1. 最大并发数限制，因为一个进程所打开的 FD （文件描述符）是有限制的，由 FD_SETSIZE 设置，默认值是 1024/2048 ，因此 Select 模型的最大并发数就被相应限制了。自己改改这个 FD_SETSIZE ？想法虽好，可是先看看下面吧 …


2. 效率问题， select 每次调用都会线性扫描全部的 FD 集合，这样效率就会呈现线性下降，把 FD_SETSIZE 改大的后果就是，大家都慢慢来，什么？都超时了？？！！


3. 内核 / 用户空间 内存拷贝问题，如何让内核把 FD 消息通知给用户空间呢？在这个问题上 select 采取了内存拷贝方法。

poll

基本上效率和 select <1> 支持一个进程打开大数目的socket描述符(FD)

epoll

1. select 最不能忍受的是一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是2048。对于那些需要支持上万连接数目的IM服务器来说显然太少了。这时候你一是可以选择修改这个宏然后重新编译内核，不过资料也同时指出这样会带来网络效率的下降；二是可以选择多进程的解决方案(传统的Apache方案)，不过虽然linux上面创建进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步高效，所以这也不是一种完美的方案。不过epoll 没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于select 所支持的2048。举个例子，在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看，一般来说这个数目和系统内存关系很大。

2. IO效率不随FD数目增加而线性下降

    传统select/poll的另一个致命弱点就是当你拥有一个很大的socket集合，由于网络得延时，使得任一时间只有部分的socket是"活跃"的，而select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。于是，只有"活跃"的socket才会主动去调用callback函数，其他idle状态的socket则不会，在这点上，epoll实现了一个"伪"AIO，因为这时候推动力在os内核。在一些 benchmark中，如果所有的socket基本上都是活跃的---比如一个高速LAN环境，epoll也不比select/poll低多少效率，但若过多使用的调用epoll_ctl，效率稍微有些下降。然而一旦使用idle connections模拟WAN环境，那么epoll的效率就远在select/poll之上了。

3.使用mmap加速内核与用户空间的消息传递
    这点实际上涉及到epoll的具体实现。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就显得很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。而如果你像我一样从2.5内核就开始关注epoll的话，一定不会忘记手工mmap这一步的。

4. 内核微调
    这一点其实不算epoll的优点，而是整个linux平台的优点。也许你可以怀疑linux平台，但是你无法回避linux平台赋予你微调内核的能力。比如，内核TCP/IP协议栈使用内存池管理sk_buff结构，可以在运行期间动态地调整这个内存pool(skb_head_pool)的大小---通过echo XXXX>/proc/sys/net/core/hot_list_length来完成。再比如listen函数的第2个参数(TCP完成3次握手的数据包队列长度)，也可以根据你平台内存大小来动态调整。甚至可以在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的NAPI网卡驱动架构。是相同的， select 缺点的 2 和 3 它都没有改掉。

Epoll详细介绍

数据结构

epoll用到的所有函数都是在头文件sys/epoll.h中声明的，下面简要说明所用到的数据结构和函数：
所用到的数据结构：
typedef union epoll_data {
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;
struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
结构体epoll_event 被用于注册所感兴趣的事件和回传所发生待处理的事件，而epoll_data 联合体用来保存触发事件的某个文件描述符相关的数据。例如一个client连接到服务器，服务器通过调用accept函数可以得到于这个client对应的socket文件描述符，可以把这文件描述符赋给epoll_data的fd字段，以便后面的读写操作在这个文件描述符上进行。epoll_event 结构体的events字段是表示感兴趣的事件和被触发的事件，可能的取值为：
EPOLLIN：表示对应的文件描述符可以读；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET：表示对应的文件描述符有事件发生；

函数

1.epoll_create函数
函数声明：int epoll_create(int size)
该函数生成一个epoll专用的文件描述符，其中的参数是指定生成描述符的最大范围。


2.epoll_ctl函数
函数声明：int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
该函数用于控制某个文件描述符上的事件，可以注册事件，修改事件，删除事件。
参数：
epfd：由 epoll_create 生成的epoll专用的文件描述符；
op：要进行的操作，可能的取值EPOLL_CTL_ADD 注册、EPOLL_CTL_MOD 修改、EPOLL_CTL_DEL 删除；
fd：关联的文件描述符；
event：指向epoll_event的指针；
如果调用成功则返回0，不成功则返回-1。

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.使用epoll_create()函数创建文件描述，设定可管理的最大socket描述符数目。


2. 创建与epoll关联的接收线程，应用程序可以创建多个接收线程来处理epoll上的读通知事件，线程的数量依赖于程序的具体需要。


3.创建一个侦听socket的描述符ListenSock，并将该描述符设定为非阻塞模式，调用Listen()函数在该套接字上侦听有无新的连接请求，在epoll_event结构中设置要处理的事件类型EPOLLIN，同时使用epoll_ctl()来注册事件，最后启动网络监视线程。


4. 网络监视线程启动循环，epoll_wait()等待epoll事件发生。


5. 如果epoll事件表明有新的连接请求，则调用accept()函数，将用户socket描述符添加到epoll_data联合体，同时设定该描述符为非阻塞，并在epoll_event结构中设置要处理的事件类型为读和写。


6. 如果epoll事件表明socket描述符上有数据可读，则将该socket描述符加入可读队列，通知接收线程读入数据，并将接收到的数据放入到接收数据的链表中，经逻辑处理后，将反馈的数据包放入到发送数据链表中，等待由发送线程发送。

使用例子（转载）

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

猜你喜欢

转载自blog.csdn.net/hualicuan/article/details/39495771
今日推荐
基于大语言模型的开源知识库问答系统 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