程序员经验分享-hwhale

处理大并发之四 libevent demo详细分析（对比epoll）

2023-11-15

处理大并发之四 libevent demo详细分析（对比epoll）

libevent默认情况下是单线程，每个线程有且仅有一个event_base，对应一个struct event_base结构体，以及赋予其上的事件管理器，用来安排托管给它的一系列的事件。

当有一个事件发生的时候，event_base会在合适的时间去调用绑定在这个事件上的函数，直到这个函数执行完成，然后在返回安排其他事件。需要注意的是：合适的时间并不是立即。

例如：

  1. struct event_base *base;  
  2. base = event_base_new();//初始化libevent  

event_base_new对比epoll，可以理解为epoll里的epoll_create。

event_base内部有一个循环，循环阻塞在epoll调用上，当有一个事件发生的时候，才会去处理这个事件。其中，这个事件是被绑定在event_base上面的，每一个事件就会对应一个struct event，可以是监听的fd。 

其中struct event 使用event_new 来创建和绑定，使用event_add来启用，例如：

  1. struct event *listener_event;  
  2. listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);  

参数说明：

base：event_base类型，event_base_new的返回值

listener：监听的fd，listen的fd

EV_READ|EV_PERSIST：事件的类型及属性

do_accept：绑定的回调函数

(void*)base：给回调函数的参数

event_add(listener_event, NULL);

对比epoll：

event_new相当于epoll中的epoll_wait，其中的epoll里的while循环，在libevent里使用event_base_dispatch。

event_add相当于epoll中的epoll_ctl，参数是EPOLL_CTL_ADD，添加事件。

注：libevent支持的事件及属性包括(使用bitfield实现，所以要用 | 来让它们合体)
EV_TIMEOUT: 超时
EV_READ: 只要网络缓冲中还有数据，回调函数就会被触发
EV_WRITE: 只要塞给网络缓冲的数据被写完，回调函数就会被触发
EV_SIGNAL: POSIX信号量
EV_PERSIST: 不指定这个属性的话，回调函数被触发后事件会被删除
EV_ET: Edge-Trigger边缘触发，相当于EPOLL的ET模式

事件创建添加之后，就可以处理发生的事件了，相当于epoll里的epoll_wait,在libevent里使用event_base_dispatch启动event_base循环，直到不再有需要关注的事件。

有了上面的分析，结合之前做的epoll服务端程序，对于一个服务器程序，流程基本是这样的：

1. 创建socket，bind，listen，设置为非阻塞模式

2. 创建一个event_base，即

  1. struct event_base *  event_base_new(void)  

3. 创建一个event，将该socket托管给event_base，指定要监听的事件类型，并绑定上相应的回调函数(及需要给它的参数)。即

  1. struct event *  event_new(struct event_base *base, evutil_socket_t fd, short events, void (*cb)(evutil_socket_t, short, void *), void *arg)  

4. 启用该事件，即

  1. int  event_add(struct event *ev, const struct timeval *tv)  

5.  进入事件循环，即

  1. int  event_base_dispatch(struct event_base *event_base)  

 

有了这些知识储备，来看下官网上的demo，网址：http://www.wangafu.net/~nickm/libevent-book/01_intro.html，这里引用的例子是Example: A low-level ROT13 server with Libevent

首先来翻译下例子上面的一段话：

对于select函数来说，不同的操作系统有不同的代替函数，它包括：poll,epoll,kqueue,evport和/dev/poll。这些函数的性能都比select要好，其中epoll在IO中添加，删除，通知socket准备好方面性能复杂度为O(1)。

不幸的是，没有一个有效的接口是一个普遍存在的标准，linux下有epoll，BSDS有kqueue，Solaris 有evport和/dev/poll，等等。没有任何一个操作系统有它们中所有的，所以如果你想做一个轻便的高性能的异步应用程序，你就需要把这些接口抽象的封装起来，并且无论哪一个系统使用它都是最高效的。

这对于你来说就是最低级的libevent API，它提供了统一的接口取代了select，当它在计算机上运行的时候，使用了最有效的版本。

这里是ROT13服务器的另外一个版本，这次，他使用了libevent代替了select。这意味着我们不再使用fd_sets，取而代之的使用event_base添加和删除事件，它可能在select，poll，epoll，kqueue等中执行。

代码分析：

这是一个服务端的程序，可以处理客户端大并发的连接，当收到客户端的连接后，将收到的数据做了一个变换，如果是 ’a’-‘m’之间的字符，将其增加13，如果是 ’n’-‘z’之间的字符，将其减少13，其他字符不变，然后将转换后的数据发送给客户端。

例如：客户端发送：Client 0 send  Message!

服务端会回复：Pyvrag 0 fraq  Zrffntr!

在这个代码中没有使用bufferevent这个强大的东西，在一个结构体中自己管理了一个缓冲区。结构体为：

  1. struct fd_state {  
  2.     char buffer[MAX_LINE];//缓冲区的大小  
  3.     size_t buffer_used;//接收到已经使用的buffer大小，每次将接收到的数据字节数相加，当发送的字节数累计相加和buffer_used都相等时候，将它们都置为1  
  4.   
  5.     size_t n_written;//发送的累加字节数  
  6.     size_t write_upto;//相当于一个临时变量，当遇到换行符的时，将其收到的字节数（换行符除外）赋给该值，当检测到写事件的时候，用已经发送的字节数和该数值做比较，若收到的字节总数小于该值，则发送数据，等于该值，将结构体中3个字节数统计变量都置为1，为什么会置为1呢，因为有一个换行符吧。  
  7.   
  8.     struct event *read_event;  
  9.     struct event *write_event;  
  10. };  

代码中自己管理了一个缓冲区，用于存放接收到的数据，发送的数据将其转换后也放入该缓冲区中，代码晦涩难懂，我也是经过打日志分析后，才明白点，这个缓冲区自己还得控制好。但是libevent 2已经提供了一个神器bufferevent，我们在使用的过程中最好不要自己管理这个缓冲区，之所以分析这个代码，是为了熟悉libevent 做服务端程序的流程及原理。

下面是代码，加有部分注释和日志：

代码：lowlevel_libevent_server.c 

  1. //说明，为了使我们的代码兼容win32网络API，我们使用evutil_socket_t代替int，使用evutil_make_socket_nonblocking代替fcntl  
  2.   
  3. /* For sockaddr_in */  
  4. #include <netinet/in.h>  
  5. /* For socket functions */  
  6. #include <sys/socket.h>  
  7. /* For fcntl */  
  8. #include <fcntl.h>  
  9.   
  10. #include <event2/event.h>  
  11.   
  12. #include <assert.h>  
  13. #include <unistd.h>  
  14. #include <string.h>  
  15. #include <stdlib.h>  
  16. #include <stdio.h>  
  17. #include <errno.h>  
  18.   
  19. #define MAX_LINE 80  
  20.   
  21. void do_read(evutil_socket_t fd, short events, void *arg);  
  22. void do_write(evutil_socket_t fd, short events, void *arg);  
  23.   
  24. char rot13_char(char c)  
  25. {  
  26.     /* We don't want to use isalpha here; setting the locale would change 
  27.      * which characters are considered alphabetical. */  
  28.     if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))  
  29.         return c + 13;  
  30.     else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))  
  31.         return c - 13;  
  32.     else  
  33.         return c;  
  34. }  
  35.   
  36. struct fd_state {  
  37.     char buffer[MAX_LINE];  
  38.     size_t buffer_used;  
  39.   
  40.     size_t n_written;  
  41.     size_t write_upto;  
  42.   
  43.     struct event *read_event;  
  44.     struct event *write_event;  
  45. };  
  46.   
  47. struct fd_state * alloc_fd_state(struct event_base *base, evutil_socket_t fd)  
  48. {  
  49.     struct fd_state *state = malloc(sizeof(struct fd_state));  
  50.     if (!state)  
  51.         return NULL;  
  52.   
  53.     state->read_event = event_new(base, fd, EV_READ|EV_PERSIST, do_read, state);  
  54.     if (!state->read_event)  
  55.     {  
  56.         free(state);  
  57.         return NULL;  
  58.     }  
  59.   
  60.     state->write_event = event_new(base, fd, EV_WRITE|EV_PERSIST, do_write, state);  
  61.     if (!state->write_event)  
  62.     {  
  63.         event_free(state->read_event);  
  64.         free(state);  
  65.         return NULL;  
  66.     }  
  67.   
  68.     state->buffer_used = state->n_written = state->write_upto = 0;  
  69.   
  70.     assert(state->write_event);  
  71.     return state;  
  72. }  
  73.   
  74. void free_fd_state(struct fd_state *state)  
  75. {  
  76.     event_free(state->read_event);  
  77.     event_free(state->write_event);  
  78.     free(state);  
  79. }  
  80.   
  81. void do_read(evutil_socket_t fd, short events, void *arg)  
  82. {  
  83.     struct fd_state *state = arg;  
  84.     char buf[20];  
  85.     int i;  
  86.     ssize_t result;  
  87.     printf("\ncome in do_read: fd: %d, state->buffer_used: %d, sizeof(state->buffer): %d\n", fd, state->buffer_used, size  
  88. of(state->buffer));  
  89.     while (1)  
  90.     {  
  91.         assert(state->write_event);  
  92.         result = recv(fd, buf, sizeof(buf), 0);  
  93.         if (result <= 0)  
  94.             break;  
  95.         printf("recv once, fd: %d, recv size: %d, recv buff: %s\n", fd, result, buf);  
  96.   
  97.         for (i=0; i < result; ++i)  
  98.         {  
  99.             if (state->buffer_used < sizeof(state->buffer))//如果读事件的缓冲区还未满，将收到的数据做转换  
  100.                 state->buffer[state->buffer_used++] = rot13_char(buf[i]);  
  101. //              state->buffer[state->buffer_used++] = buf[i];//接收什么发送什么，不经过转换，测试用  
  102.             if (buf[i] == '\n') //如果遇到换行，添加写事件，并设置写事件的大小  
  103.             {  
  104.                 assert(state->write_event);  
  105.                 event_add(state->write_event, NULL);  
  106.                 state->write_upto = state->buffer_used;  
  107.                 printf("遇到换行符，state->write_upto: %d, state->buffer_used: %d\n",state->write_upto, state->buffer_use  
  108. d);  
  109.             }  
  110.         }  
  111.         printf("recv once, state->buffer_used: %d\n", state->buffer_used);  
  112. }  
  113.   
  114.     //判断最后一次接收的字节数  
  115.     if (result == 0)  
  116.     {  
  117.         free_fd_state(state);  
  118.     }  
  119.     else if (result < 0)  
  120.     {  
  121.         if (errno == EAGAIN) // XXXX use evutil macro  
  122.             return;  
  123.         perror("recv");  
  124.         free_fd_state(state);  
  125.     }  
  126. }  
  127.   
  128. void do_write(evutil_socket_t fd, short events, void *arg)  
  129. {  
  130.     struct fd_state *state = arg;  
  131.   
  132.     printf("\ncome in do_write, fd: %d, state->n_written: %d, state->write_upto: %d\n",fd, state->n_written, state->write  
  133. _upto);  
  134.     while (state->n_written < state->write_upto)  
  135.     {  
  136.         ssize_t result = send(fd, state->buffer + state->n_written, state->write_upto - state->n_written, 0);  
  137.         if (result < 0) {  
  138.             if (errno == EAGAIN) // XXX use evutil macro  
  139.                 return;  
  140.             free_fd_state(state);  
  141.             return;  
  142.         }  
  143.         assert(result != 0);  
  144.   
  145.         state->n_written += result;  
  146.         printf("send fd: %d, send size: %d, state->n_written: %d\n", fd, result, state->n_written);  
  147.     }  
  148.   
  149.     if (state->n_written == state->buffer_used)  
  150.     {  
  151.         printf("state->n_written == state->buffer_used: %d\n", state->n_written);  
  152.         state->n_written = state->write_upto = state->buffer_used = 1;  
  153.         printf("state->n_written = state->write_upto = state->buffer_used = 1\n");  
  154.     }  
  155.   
  156.     event_del(state->write_event);  
  157. }  
  158.   
  159. void do_accept(evutil_socket_t listener, short event, void *arg)  
  160. {  
  161.     struct event_base *base = arg;  
  162.     struct sockaddr_storage ss;  
  163.     socklen_t slen = sizeof(ss);  
  164.     int fd = accept(listener, (struct sockaddr*)&ss, &slen);  
  165.     if (fd < 0)  
  166.     { // XXXX eagain??  
  167.         perror("accept");  
  168.     }  
  169.     else if (fd > FD_SETSIZE)  
  170.     {  
  171.         close(fd); // XXX replace all closes with EVUTIL_CLOSESOCKET */  
  172.     }  
  173.     else  
  174.     {  
  175.         struct fd_state *state;  
  176.         evutil_make_socket_nonblocking(fd);  
  177.         state = alloc_fd_state(base, fd);  
  178.         assert(state); /*XXX err*/  
  179.         assert(state->write_event);  
  180.         event_add(state->read_event, NULL);  
  181.     }  
  182. }  
  183.   
  184. void run(void)  
  185. {  
  186.     evutil_socket_t listener;  
  187.     struct sockaddr_in sin;  
  188.     struct event_base *base;  
  189.     struct event *listener_event;  
  190.   
  191.     base = event_base_new();//初始化libevent  
  192.     if (!base)  
  193.         return; /*XXXerr*/  
  194.   
  195.     sin.sin_family = AF_INET;  
  196.     sin.sin_addr.s_addr = 0;//本机  
  197.     sin.sin_port = htons(8000);  
  198.   
  199.     listener = socket(AF_INET, SOCK_STREAM, 0);  
  200.     evutil_make_socket_nonblocking(listener);  
  201.   
  202. #ifndef WIN32  
  203.     {  
  204.         int one = 1;  
  205.         setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));  
  206.     }  
  207. #endif  
  208.   
  209.     if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0)  
  210.     {  
  211.         perror("bind");  
  212.         return;  
  213. 　　}  
  214. 　　  
  215. 　　  
  216. 　　    if (listen(listener, 16)<0)  
  217. 　　    {  
  218. 　　        perror("listen");  
  219. 　　        return;  
  220. 　　    }  
  221. 　　  
  222. 　　    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);  
  223. 　　    /*XXX check it */  
  224. 　　    event_add(listener_event, NULL);  
  225. 　　  
  226. 　　    event_base_dispatch(base);  
  227. 　　}  
  228. 　　  
  229. 　　int main(int c, char **v)  
  230. 　　{  
  231. 　　//    setvbuf(stdout, NULL, _IONBF, 0);  
  232. 　　  
  233. 　　    run();  
  234. 　　    return 0;  
  235. 　　}  

编译：gcc -I/usr/include -o test lowlevel_libevent_server.c -L/usr/local/lib -levent

运行结果：



FROM:  http://blog.csdn.net/feitianxuxue/article/details/9372535


本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

网络libevent

处理大并发之四 libevent demo详细分析（对比epoll） 的相关文章

随机推荐

  • OGRE动画

    动画是由若干静态画面 快速交替显示而成 因人的眼睛会产生视角暂留 对上一个画面的感知还末消失 下一张画面又出现 就会有动的感觉 计算机图形学中的动画也同样遵循着这一本质的原理 只不过不同于传统动画的手绘和拍摄 Ogre图形引擎可以通过自动或

  • java实现----阶乘相加1的阶乘+2的阶乘加3的阶乘......

    计算1 2 3 见下列代码 import java util Scanner 导包 public class 阶乘 public static void main String args Scanner sc new Scanner Sys

  • Xss练习(level11/12/13/16/17/18)

    本文为学习笔记 仅限学习交流 不得利用 从事危害国家或人民安全 荣誉和利益等活动 level11 查看源代码 尝试 利用BP抓包 改包 构造语句 注意闭合 level12 尝试BP抓包 改包 type test nclick alert 1

  • vue中style设置scoped后部分样式不生效

    因为用了elementUI的组件库 一个页面用到了el dialog 需要改一下样式 但

  • UDP用户数据报协议分析

    简介 UDP User Datagram Protocol 即用户数据报协议 在网络中它与TCP协议一样用于处理数据包 是一种无连接的协议 在OSI模型中 在第四层 传输层 处于IP协议的上一层 UDP用来支持那些需要在计算机之间传输数据的

  • vue通过uniapp打包运行页面空白(Failed to load resource)

    vue调试时候 真机打开url和mac电脑打开都正常 然后npm run build 在移植到uniapp项目里打包apk ipa传到手机运行页面空白 打开safari浏览器 查看ipa文件包的页面 发现报了Failed to load r

  • 【重磅整理】180篇NIPS-2020顶会《强化学习领域》Accept论文大全

    深度强化学习实验室 作者 DeepRL Lab AMiner cn 联合发布 来源 https neurips cc Conferences 2020 编辑 DeepRL 图片来自新智元 NeurIPS终于放榜 提交数再次创新高 与去年相比

  • Linux-C基础之输入输出函数

    一 输出 一 数据输出 C语言无I O语句 I O操作由函数实现 include

  • 搭建个人的第一个服务器以及域名申请和绑定--阿里云服务器

    在大学阶段 购买并搭建了自己的第一个服务器 心情激动无比 写下本片博文记录购买并搭建服务器的全过程 方便自己以后在服务器方面进行更加深入的学习 阿里云和腾讯的服务器都有学生价 价格都是一折左右 真心实惠 本人因为学习的Java 所以偏向于阿

  • 12.荔枝派 zero(全志V3S)-使用新版本的buildroot

    上面是我的微信和QQ群 欢迎新朋友的加入 1 下载新版buildroot 我下载了19年2月份发布的buildroot 2 文件系统配置 make menuconfig 设置target option 设置编译链 其中Toolchain p

  • nginx实现动静分离

    nginx实现动静分离 1 什么是动静分离 2 nginx反向代理与负载均衡 3 nginx实现负载均衡 4 nginx实现动静分离 1 什么是动静分离 动静分离主要是通过nginx PHP FPM来实现 其中nginx处理图片 html等

  • 89C51七段数码管显示“12345678”

    1 延时模块 void Delay ms unsigned int xms 11 0592MHz延时模块 unsigned char i j while xms nop i 2 j 199 do while j while i 2 显示模块

  • linux + gitee配置教程

    用gitee管理小红迟早50迈的项目 上手教程 1 git安装 sudo apt get update sudo apt get install git 检查一下git版本 看看是否安装成功 git version 2 git配置 下面两行

  • 该用什么软件分割音频？这些软件可以帮助你分割音频

    大家都知道想要制作一个好的视频是需要进行后期各种剪辑的 不仅视频需要后期剪辑 其实音频也是需要剪辑的 比如合并音频 裁剪音频片段 调整音频的速度 分割音频等等 那么这个时候挑选一款合适的音频剪辑软件就很重要了 今天我整理了一些简单好用的音频

  • Strapi之Entity Service API

    Query Engine API 和 Entity Service API 都是 Strapi 平台提供的 API 但是它们的功能和用途有所不同 Entity Service API 主要用于管理实体对象的创建 读取 更新和删除操作 它是对

  • Vue.js学习记录-4-Vue基础：条件渲染 +列表渲染

    4 条件渲染 根据条件进行元素展示 v if v if v else if 2 1 0新增 v else三大指令必须紧贴使用 否则指令将不被识别 指令举例 div This is A div div This is B div div Th

  • P1218 [USACO1.5]特殊的质数肋骨 Superprime Rib【普及】

    USACO1 5 特殊的质数肋骨 Superprime Rib 题目描述 农民约翰的母牛总是产生最好的肋骨 你能通过农民约翰和美国农业部标记在每根肋骨上的数字认出它们 农民约翰确定他卖给买方的是真正的质数肋骨 是因为从右边开始切下肋骨 每次

  • sklearn机器学习：高斯朴素贝叶斯GaussianNB

    认识高斯朴素贝叶斯 class sklearn naive bayes GaussianNB priors None var smoothing 1e 09 如果Xi是连续值 通常Xi的先验概率为高斯分布 也就是正态分布 即在样本类别Ck中

  • 让生活充满快乐

    文章目录 一 效果图以及素材 二 制作步骤 一 效果图以及素材 效果图 素材 二 制作步骤 打开素材 拷贝一份 找到滤镜 camera Raw滤镜 拷贝一份 ctrl t 自由变换 逆时间90度 确定 不透明度调50方便查看效果 多边形工具

  • 处理大并发之四 libevent demo详细分析（对比epoll）

    处理大并发之四 libevent demo详细分析 对比epoll libevent默认情况下是单线程 每个线程有且仅有一个event base 对应一个struct event base结构体 以及赋予其上的事件管理器 用来安排托管给它的

热门标签