事件驱动模型Libev（一）

时间  2019-11-12
标签 事件 驱动 模型 libev 繁體版
原文   原文链接

 

Libev的做者写了一份很好的官方Manual,比较的齐全，即介绍了Libev的设计思想，也介绍了基本使用还包括内部各种事件详细介绍。这里略微赘述一下。Libev经过一个 ·struct ev_loop· 结结构表示一个事件驱动的框架。在这个框架里面经过ev_xxx结构，ev_init、ev_xxx_set、ev_xxx_start接口箱这个事件驱动的框架里面注册事件监控器，当相应的事件监控器的事件出现时，便会触发该事件监控器的处理逻辑，去处理该事件。处理完以后，这些监控器进入到下一轮的监控中。符合一个标准的事件驱动状态的模型。数据结构

Libev 除了提供了基本的三大类事件（IO事件、定时器事件、信号事件）外还提供了周期事件、子进程事件、文件状态改变事件等多个事件，这里咱们用三大基本事件写一个例子，和Manual上的相似，可是没有作收尾工做，为的是将事件的框架清晰的呈现出来。框架

#include<ev.h>
#include <stdio.h>
#include <signal.h>
#include <sys/unistd.h>

ev_io io_w;
ev_timer timer_w;
ev_signal signal_w;

void io_action(struct ev_loop *main_loop,ev_io *io_w,int e)
{
        int rst;
        char buf[1024] = {'\0'};
        puts("in io cb\n");
        read(STDIN_FILENO,buf,sizeof(buf));
        buf[1023] = '\0';
        printf("Read in a string %s \n",buf);
        ev_io_stop(main_loop,io_w);

}

void timer_action(struct ev_loop *main_loop,ev_timer *timer_w,int e)
{
        puts("in tiemr cb \n");
        ev_timer_stop(main_loop,timer_w);

}

void signal_action(struct ev_loop *main_loop,ev_signal signal_w,int e)
{
        puts("in signal cb \n");
        ev_signal_stop(main_loop,signal_w);
        ev_break(main_loop,EVBREAK_ALL);
}

int main(int argc ,char *argv[])
{
        struct ev_loop *main_loop = ev_default_loop(0);
        ev_init(&io_w,io_action);
        ev_io_set(&io_w,STDIN_FILENO,EV_READ);  
        ev_init(&timer_w,timer_action);
        ev_timer_set(&timer_w,2,0);       
        ev_init(&signal_w,signal_action);
        ev_signal_set(&signal_w,SIGINT); 

        ev_io_start(main_loop,&io_w);
        ev_timer_start(main_loop,&timer_w);
        ev_signal_start(main_loop,&signal_w);

        ev_run(main_loop,0);

return 0;
}

 

下面对使用到的这些API进行说明。运维

这里使用了3种事件监控器，分别监控IO事件、定时器事件以及信号事件。所以定义了3个监控器(watcher)，以及触发监控器时要执行动做的回调函数。Libev定义了多种监控器，命名方式为 ev_xxx 这里xxx表明监控器类型，其实现是一个结构体，async

typedef struct ev_io { .... } ev_io;

经过宏定义能够简写为 ev_xxx。回调函数的类型为 void cb_name(struct ev_loop *main_loop,ev_xxx *io_w,int event) 。函数

在main中，首先定义了一个事件驱动器的结构 struct ev_loop *main_loop 这里调用 ev_default_loop(0) 生成一个预制的全局驱动器。这里能够参考Manual中的选择。而后依次初始化各个监控器以及设置监控器的触发条件。oop

初始化监控器的过程是将相应的回调函数即触发时的动做注册到监控器上。布局

设置触发条件则是该条件产生时才去执行注册到监控器上的动做。对于IO事件，通常是设置特定fd上的的可读或可写事件，定时器则是多久后触发。这里定时器的触发条件中还有第三参数，表示第一次触发后，是否循环，若为0则吧循环，不然按该值循环。信号触发器则是设置触发的信号。学习

在初始化并设置好触发条件后，先调用ev_xxx_start 将监控器注册到事件驱动器上。接着调用 ev_run 开始事件驱动器。spa

在事件的触发动做里面。我加入了一个 ev_xxx_stop 函数，与上面对应，也就是讲改监控器从事件驱动器里面注销掉。使其再也不起做用。而在信号触发的动做中还加入了一个 ev_break 该函数可使进程跳出 main_loop 事件驱动器循环,也就是关闭事件驱动器。结束这一逻辑。.net

libev最简单的示例就是这样的一个结构。定义一个监控器、书写触发动做逻辑、初始化监控器、设置监控器触发条件、将监控器加入大事件驱动器的循环中便可。一个比较清晰的事件驱动框架。

libev的事件驱动过程能够想象成以下的伪代码：

do_some_init()
is_run = True
while is_run:
    t = caculate_loop_time()
    deal_loop(t)
    deal_with_pending_event()
do_some_clear()

 

首先作一些初始化操做，而后进入到循环中，该循环经过一个状态位来控制是否执行。在循环中，计算出下一次轮询的时间，这里轮询的实现就采用了系统提供的epoll、kqueue等机制。再轮询结束后检查有哪些监控器的被触发了，依次执行触发动做。这里不要纠结信号事件、定时器时间咋都通过了 deal_loop libev是如何实现的这里暂且不讨论，这个伪代码只是大体表示下libev的总体框架。

 

 

Libev源代码结构

对于毕业生，尤为是没有接触过一些已有工程代码的新人。拿到一份源码，怎么去熟悉它是首要解决的问题。我通常把会把源码进行分类：一类是产品类的，就好比Redis、Ngnix这一类自己是一个完整的能够运维的成熟产品；另外一类就是Libev这样的组件类的。对于组件类的项目，我通常就是分红这样几步：

  1. 有文档看文档，没有文档问相关人员（包括Google），这个组件主要提供什么服务
  2. 结合上述信息使用组件的AIP写个示例程序，跑起来
  3. 大体浏览下源码，分析一下代码的组织结构
  4. 根据使用的API，进到源码中看看主干是怎么样实现的，从而了解总体思路
  5. 再搜刮源码，把一些辅助的功能看下，并在例子中尝试
  6. 以后将整个理解用文字记录下来。提炼两大块内容：实现思想和技巧tips

这里我对Libev的学习就是依照这样的一个逻辑一步一步走的。

ev.c代码结构

在“使用Libev” 这篇文章中提到了一个Libev的官方文档，并根据该文档写了个简单的示例，包括了IO事件、定时器事件以及信号事件这3个最经常使用的事件类型。在本篇文章中将对Libev的代码结构进行分析。

首先下载Libev的源码包，下载回来后进行解压，Libev的源码都放在同一个目录中,除去autoconfig产生的文件，代码文件仍是比较直观的。主要的.c和.h文件从命名上也查很少能猜出来干吗呢。根据咱们的例子，主要抽出其中的"ev.c ev_epoll.c ev_select.c ev.h ev_wrap.c ev_vars.c"结合咱们的例子进行梳理。

“ev_epoll.c"和"ev_select.c"是对系统提供的IO复用机制“epoll”、“select"的支持，还有"poll”、“kqueue” Solaris的"port"的支持，分别是"ev_poll.c”、“ev_kqueue.c”、“ev_port.c”。具体的框架是相似的，所以只要分析一个其余的就都了解了。

“ev.h” 是对一些API和变量、常量的定义，“ev.c"是Libev的主要逻辑，其中在类型的定义的时候用了一个宏的包装来声明成员变量，在文件"ev_vars.c” 中。为了对成员变量使用的语句进行简化，就又写了一个"ev_wrap.c”。所以咱们能够这样去看待这些文件，主要逻辑都在"ev.c”,其中部分常量、变量的定义能够在"ev.h"中，有个结构的成员变量部分的定义在"ev_vars.c"中，同时对该结构成员变量的引用经过"ev_wrap.c"文件作了个简写的宏定义；当须要系统提供底层的事件接口时，按分类分别在"ev_epoll.c”、“ev_select.c"等文件中。

接着打开"ev.c"文件，“ev.h"里面的各类定义，在须要的时候去查询便可，经过IDE或者Vim/Emacs结合cscope/ctag均可以很好的解决。经过浏览能够发现这些代码大概能够分红三部分：

代码结构

所以能够直接跳到代码部分。分隔点有ecb结束的注释。这能够不用担忧略过的部分，等须要的时候回过去查阅便可。其中ecb的部分，只要知道其API做用便可，无需深究，若是将来须要的时候能够到这边来作一个参考。

对于逻辑结构能够能够把他分红几个部分：

逻辑结构

这样对总体的布局有个大概的了解，就能够有选择性的逐个突破了。这里还能够结合官方的文档去了解下每一个函数做用。从而对Libev的总体提供的服务有个大概的了解。

主要数据结构

浏览的过程当中梳理下几个重要的数据结构

1.时间类型

typedef double ev_tstamp;

2.坑爹的 EV_XX_

Libev用ev_tstamp表示时间单位，其实质就是一个double类型变量。

struct ev_loop;
# define EV_P  struct ev_loop *loop       /* a loop as sole parameter in a declaration */
# define EV_P_ EV_P,                     /* a loop as first of multiple parameters */
# define EV_A  loop                       /* a loop as sole argument to a function call */
# define EV_A_ EV_A,                     /* a loop as first of multiple arguments */
# define EV_DEFAULT_UC  ev_default_loop_uc_ ()        /* the default loop, if initialised, as sole arg */
# define EV_DEFAULT_UC_ EV_DEFAULT_UC,   /* the default loop as first of multiple arguments */
# define EV_DEFAULT  ev_default_loop (0)          /* the default loop as sole arg */
# define EV_DEFAULT_  EV_DEFAULT, /* the default loop as first of multiple arguments */

 

这里的定义仍是比较让人无解的。“EV_XXX” 等同于 EV_XXX,,这样在后续的API使用中，会显的更简洁一些，好比针对第一个参数是struct ev_loop *loop 的回调函数的书写，就能够写成 · void io_action(EV_P ev_io *io_w,int e)· 。这里不知道做者还有没有其余用以，这里我不是很推荐，可是要知道，后面再看代码的时候才更容易理解。

3.各类watcher

基类

首先看一个ev_watcher，这个咱们能够用OO思想去理解他，他就至关于一个基类，后续的ev_io什么的都是派生自该机构，这里利用了编译器的一个“潜规则”就是变量的定义顺序与声明顺序一致。这一点在libuv里面也用了，而后大神云风哥还对其吐槽了一番，能够参见云风的blog。这里我尽可能吧全部宏包裹的部分都拨出来，方便理解和看。看过Libev的代码，我想在惊叹其宏的高明之余必定也吐槽过。

typedef struct ev_watcher { int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher *w, int revents); } ev_watcher;

与基类配套的还有个装监控器的List。

typedef struct ev_watcher_list { int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher_list *w, int revents); struct ev_watcher_list *next; } ev_watcher_list;
IO监控器
typedef struct ev_io { int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_io *w, int revents); struct ev_watcher_list *next; int fd; /* 这里的fd，events就是派生类的私有成员，分别表示监听的文件fd和触发的事件（可读仍是可写） */ int events; } ev_io;

在这里，经过从宏中剥离出来后，能够看到将派生类的私有变量放在了共有部分的后面。这样，当使用C的指针强制转换后，一个指向 struct ev_io对象的基类 ev_watcher 的指针p就能够经过 p->active 访问到派生类中一样表示active的成员了。

定时器watcher
typedef struct ev_watcher_time { int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher_time *w, int revents); ev_tstamp at; /* 这个at就是派生类中新的自有成员 ，表示的是at时间触发 */ } ev_watcher_time;

这里定时器事件watcher和IO的不同的地方在于，对于定时器会用专门的最小堆去管理。而IO和信号等其余事件的监控器则是经过单链表挂起来的，所以他没有next成员。

信号watcher
typedef struct ev_signal { int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_signal *w, int revents); struct ev_watcher_list *next; int signum; /* 这个signum就是派生类中新的自有成员 ，表示的是接收到的信号，和定时器中的at相似 */ } ev_signal;

还有其余的事件watcher的数据结构也是和这个相似的，能够对着"ev.h"的代码找一下，这里再也不赘述了。最后看一个能够容纳全部监控器对象的类型：

union ev_any_watcher
{
  struct ev_watcher w; struct ev_watcher_list wl; struct ev_io io; struct ev_timer timer; struct ev_periodic periodic; struct ev_signal signal; struct ev_child child; struct ev_stat stat; struct ev_idle idle; struct ev_prepare prepare; struct ev_check check; struct ev_fork fork; struct ev_cleanup cleanup; struct ev_embed embed; struct ev_async async; };

4.最重要的 ev_loop

在上面就已经看到了 struct ev_loop 的前向声明了，那么他究竟是怎样的一个结构的？在“ev.c”里面能够看到这样的定义:

struct ev_loop { ev_tstamp ev_rt_now; #define ev_rt_now ((loop)->ev_rt_now) #define VAR(name,decl) decl; #include "ev_vars.h" #undef VAR }; #include "ev_wrap.h"

以前说过的 “ev_vars.h"和"ev_wrap.h"是为了定义一个数据结构及简化访问其成员的，就是说的这个 ev_loop 结构体。 这里用的宏为：

#define VAR(name,decl) decl; #define VARx(type,name) VAR(name, type name)

展开就是

#define VARx(type,name) type name

而后再看"ev_vars.h” ,里面都是 类型-变量的 VARx的宏，这样再将其include 到结构体的定义中。这样就能够当作该结构定义为：

struct ev_loop
{
    ev_tstamp ev_rt_now;
    ev_tstamp now_floor;
    int rfeedmax;
    ... .........; }

不知道做者的用意何在，目前尚未看到这样作的好处在哪里。

而后 #define ev_rt_now ((loop)->ev_rt_now) 能够和后面的 “ev_warp.h"一块儿看。实际上就是 #define xxx ((loop)->xxx) 这样在要用struct ev_loop 的一个实例对象loop的成员时，就能够直接写成xxx了，这里再联想到以前的 EV_P EV_P_ EV_A EV_A_ ,就会发现，在Libev的内部函数中，这样的配套就可使代码简洁很多。不过这样也增长了第一次阅读其的门槛。相信没有看过Libev不说其晦涩的。

5.重要的全局变量

default_loop_struct

在"ev.c"中有

static struct ev_loop default_loop_struct;

这个就是strct loop的一个实例对象，表示的是预制事件驱动器。若是在代码中使用的是预制事件驱动器，那么后续的操做就都围绕着这个数据结构展开了。

为了操做方便，还定义了指向该对象的一个全局指针：

struct ev_loop *ev_default_loop_ptr

代码的框架和主要的数据结构梳理出来了，还有ANFD、ANHEAP等数据结构在后面分析具体监控器是的时候在详细介绍。后面就要跟进程序的逻辑从而了解其设计思想，这样即可以深刻的了解一款组件型的开源软件了。

 

转载：http://my.oschina.net/u/917596/blog/176915

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程