注册 登录
> 各行各业

Libevent（2）— event、event_base

系统 2080 0

转自：http://name5566.com/4198.html

 

参考文献列表：
http://www.wangafu.net/~nickm/libevent-book/

此文编写的时候，使用到的 Libevent 为 2.0.21。本文略过了关于 event 优先权和超时相关的讨论。

创建和销毁 event_base

event_base 是首先需要被创建出来的对象。event_base 结构持有了一个 event 集合。如果 event_base 被设置了使用锁，那么它在多个线程中可以安全的访问。但是对 event_base 的循环（下面会马上解释什么是“对 event_base 的循环”）只能在某个线程中执行。如果你希望多个线程进行循环，那么应该做的就是为每一个线程创建一个 event_base。

event_base 存在多个后端可以选择（我们也把 event_base 后端叫做 event_base 的方法）：

  1. select
  2. poll
  3. epoll
  4. kqueue
  5. devpoll
  6. evport
  7. win32

在我们创建 event_base 的时候，Libevent 会为我们选择最快的后端。创建 event_base 通过函数 event_base_new() 来完成：

  1. // 创建成功返回一个拥有默认设置的 event base
  2. // 创建失败返回 NULL
  3. struct event_base * event_base_new ( void );
  4.  
  5. // 查看 event_base 实际上使用到的后端
  6. const char * event_base_get_method ( const struct event_base * base );

对于大多数程序来说，默认设置已经够用了。

event_base 的释放使用函数：

  1. void event_base_free ( struct event_base * base );

事件循环（event loop）

event_base 会持有一组 event（这是我们前面说到的），换而言之就是说，我们可以向 event_base 中注册 event（具体如何注册本文先不谈）。如果我们向 event_base 中注册了一些 event，那么就可以让 Libevent 开始事件循环了：

  1. // 指定一个 event_base 并开始事件循环
  2. // 此函数内部被实现为一个不断进行的循环
  3. // 此函数返回 0 表示成功退出
  4. // 此函数返回 -1 表示存在未处理的错误
  5. int event_base_dispatch ( struct event_base * base );

默认的事件循环会在以下的情况停止（也就是 event_base_dispatch 会返回）：

  1. 如果 base 中没有 event，那么事件循环将停止
  2. 调用 event_base_loopbreak()，那么事件循环将停止
  3. 调用 event_base_loopexit()，那么事件循环将停止
  4. 如果出现错误，那么事件循环将停止

事件循环会检测是否存在活跃事件（之前已经介绍过活跃事件这一术语： http://name5566.com/4190.html ），若存在活跃事件，那么调用事件对应的回调函数。

停止事件循环的可以通过移除 event_base 中的 event 来实现。如果你希望在 event_base 中存在 event 的情况下停止事件循环，可以通过以下函数完成：

  1. // 这两个函数成功返回 0 失败返回 -1
  2. // 指定在 tv 时间后停止事件循环
  3. // 如果 tv == NULL 那么将无延时的停止事件循环
  4. int event_base_loopexit ( struct event_base * base ,
  5. const struct timeval * tv );
  6. // 立即停止事件循环（而不是无延时的停止）
  7. int event_base_loopbreak ( struct event_base * base );

这里需要区别一下 event_base_loopexit(base, NULL) 和 event_base_loopbreak(base)：

  1. event_base_loopexit(base, NULL) 如果当前正在为多个活跃事件调用回调函数，那么不会立即退出，而是等到所有的活跃事件的回调函数都执行完成后才退出事件循环
  2. event_base_loopbreak(base) 如果当前正在为多个活跃事件调用回调函数，那么当前正在调用的回调函数会被执行，然后马上退出事件循环，而并不处理其他的活跃事件了

有时候，我们需要在事件的回调函数中获取当前的时间，这时候你不需要调用 gettimeofday() 而是使用 event_base_gettimeofday_cached()（你的系统可能实现 gettimeofday() 为一个系统调用，你可以避免系统调用的开销）：

  1. // 获取到的时间为开始执行此轮事件回调函数的时间
  2. // 成功返回 0 失败返回负数
  3. int event_base_gettimeofday_cached ( struct event_base * base ,
  4. struct timeval * tv_out );

如果我们需要（为了调试）获取被注册到 event_base 的所有的 event 和它们的状态，调用 event_base_dump_events() 函数：

  1. // f 表示输出内容的目标文件
  2. void event_base_dump_events ( struct event_base * base , FILE * f );

event

现在开始详细的讨论一下 event。在 Libevent 中 event 表示了一组条件，例如：

  1. 一个文件描述符可读或者可写
  2. 超时
  3. 出现一个信号
  4. 用户触发了一个事件

event 的相关术语：

  1. 一个 event 通过 event_new() 创建出来，那么它是已初始化的，另外 event_assign() 也被用来初始化 event（但是有它特定的用法）
  2. 一个 event 被注册到（通过 add 函数添加到）一个 event_base 中，其为 pending 状态
  3. 如果 pending event 表示的条件被触发了，那么此 event 会变为活跃的，其为 active 状态，则 event 相关的回调函数被调用
  4. event 可以是 persistent（持久的）也可以是非 persistent 的。event 相关的回调函数被调用之后，只有 persistent event 会继续转为 pending 状态。对于非 persistent 的 event 你可以在 event 相关的事件回调函数中调用 event_add() 使得此 event 转为 pending 状态

event 常用 API：

  1. // 定义了各种条件
  2. // 超时
  3. #define EV_TIMEOUT 0x01
  4. // event 相关的文件描述符可以读了
  5. #define EV_READ 0x02
  6. // event 相关的文件描述符可以写了
  7. #define EV_WRITE 0x04
  8. // 被用于信号检测（详见下文）
  9. #define EV_SIGNAL 0x08
  10. // 用于指定 event 为 persistent
  11. #define EV_PERSIST 0x10
  12. // 用于指定 event 会被边缘触发（Edge-triggered 可参考 http://name5566.com/3818.html ）
  13. #define EV_ET 0x20
  14.  
  15. // event 的回调函数
  16. // 参数 evutil_socket_t --- event 关联的文件描述符
  17. // 参数 short --- 当前发生的条件（也就是上面定义的条件）
  18. // 参数 void* --- 其为 event_new 函数中的 arg 参数
  19. typedef void (* event_callback_fn )( evutil_socket_t , short , void *);
  20.  
  21. // 创建 event
  22. // base --- 使用此 event 的 event_base
  23. // what --- 指定 event 关心的各种条件（也就是上面定义的条件）
  24. // fd --- 文件描述符
  25. // cb --- event 相关的回调函数
  26. // arg --- 用户自定义数据
  27. // 函数执行失败返回 NULL
  28. struct event * event_new ( struct event_base * base , evutil_socket_t fd ,
  29. short what , event_callback_fn cb ,
  30. void * arg );
  31.  
  32. // 释放 event（真正释放内存，对应 event_new 使用）
  33. // 可以用来释放由 event_new 分配的 event
  34. // 若 event 处于 pending 或者 active 状态释放也不会存在问题
  35. void event_free ( struct event * event );
  36.  
  37. // 清理 event（并不是真正释放内存）
  38. // 可用于已经初始化的、pending、active 的 event
  39. // 此函数会将 event 转换为非 pending、非 active 状态的
  40. // 函数返回 0 表示成功 -1 表示失败
  41. int event_del ( struct event * event );
  42.  
  43. // 用于向 event_base 中注册 event
  44. // tv 用于指定超时时间，为 NULL 表示无超时时间
  45. // 函数返回 0 表示成功 -1 表示失败
  46. int event_add ( struct event * ev , const struct timeval * tv );

一个范例：

  1. #include <event2/event.h>
  2.  
  3. // event 的回调函数
  4. void cb_func ( evutil_socket_t fd , short what , void * arg )
  5. {
  6. const char * data = arg ;
  7. printf ( "Got an event on socket %d:%s%s%s%s [%s]" ,
  8. ( int ) fd ,
  9. ( what & EV_TIMEOUT ) ? " timeout" : "" ,
  10. ( what & EV_READ ) ? " read" : "" ,
  11. ( what & EV_WRITE ) ? " write" : "" ,
  12. ( what & EV_SIGNAL ) ? " signal" : "" ,
  13. data );
  14. }
  15.  
  16. void main_loop ( evutil_socket_t fd1 , evutil_socket_t fd2 )
  17. {
  18. struct event * ev1 , * ev2 ;
  19. struct timeval five_seconds = { 5 , 0 };
  20. // 创建 event_base
  21. struct event_base * base = event_base_new ();
  22.  
  23. // 这里假定 fd1、fd2 已经被设置好了（它们都被设置为非阻塞的）
  24.  
  25. // 创建 event
  26. ev1 = event_new ( base , fd1 , EV_TIMEOUT | EV_READ | EV_PERSIST , cb_func ,
  27. ( char *) "Reading event" );
  28. ev2 = event_new ( base , fd2 , EV_WRITE | EV_PERSIST , cb_func ,
  29. ( char *) "Writing event" );
  30.  
  31. // 注册 event 到 event_base
  32. event_add ( ev1 , & five_seconds );
  33. event_add ( ev2 , NULL );
  35. // 开始事件循环
  36. event_base_dispatch ( base );
  37. }

Libevent 能够处理信号。信号 event 相关的函数：

  1. // base --- event_base
  2. // signum --- 信号，例如 SIGHUP
  3. // callback --- 信号出现时调用的回调函数
  4. // arg --- 用户自定义数据
  5. #define evsignal_new ( base , signum , callback , arg ) \
  6. event_new ( base , signum , EV_SIGNAL | EV_PERSIST , cb , arg )
  7.  
  8. // 将信号 event 注册到 event_base
  9. #define evsignal_add ( ev , tv ) \
  10. event_add (( ev ),( tv ))
  11.  
  12. // 清理信号 event
  13. #define evsignal_del ( ev ) \
  14. event_del ( ev )

在通常的 POSIX 信号处理函数中，不少函数是不能被调用的（例如，不可重入的函数），但是在 Libevent 中却没有这些限制，因为信号 event 设定的回调函数运行在事件循环中。另外需要注意的是，在同一个进程中 Libevent 只能允许一个 event_base 监听信号。

性能相关问题

Libevent 提供了我们机制来重用 event 用以避免 event 在堆上的频繁分配和释放。相关的接口：

  1. // 此函数用于初始化 event（包括可以初始化栈上和静态存储区中的 event）
  2. // event_assign() 和 event_new() 除了 event 参数之外，使用了一样的参数
  3. // event 参数用于指定一个未初始化的且需要初始化的 event
  4. // 函数成功返回 0 失败返回 -1
  5. int event_assign ( struct event * event , struct event_base * base ,
  6. evutil_socket_t fd , short what ,
  7. void (* callback )( evutil_socket_t , short , void *), void * arg );
  8.  
  9. // 类似上面的函数，此函数被信号 event 使用
  10. #define evsignal_assign ( event , base , signum , callback , arg ) \
  11. event_assign ( event , base , signum , EV_SIGNAL | EV_PERSIST , callback , arg )

已经初始化或者处于 pending 的 event，首先需要调用 event_del() 后再调用 event_assign()。

这里我们进一步认识一下 event_new()、event_assign()、event_free()、event_del()
event_new() 实际上完成了两件事情：

  1. 通过内存分配函数在堆上分配了 event
  2. 使用 event_assign() 初始化了此 event

event_free() 实际上完成了两件事情：

    1. 调用 event_del() 进行 event 的清理工作
    2. 通过内存分配函数在堆上释放此 event

Libevent（2）— event、event_base


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索：z360901061

微信扫一扫加我为好友

QQ号联系： 360901061

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧，狠狠点击下面给点支持吧，站长非常感激您！手机微信长按不能支付解决办法：请将微信支付二维码保存到相册，切换到微信，然后点击微信右上角扫一扫功能，选择支付二维码完成支付。

【本文对您有帮助就好】元

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描上面二维码支持博主2元、5元、10元、自定义金额等您想捐的金额吧，站长会非常 感谢您的哦！！！

发表我的评论
最新评论 总共0条评论