libev的使用——结合Socket编程

港控/mmm° 2023-06-09 14:22 15阅读 0赞

首先推荐几个我认为学习libev比较好的blog，最后一个地址是官方文档，给了我很多帮助:

http://vimersu.win/blog/2014/03/06/libev-study/  
http://www.cnblogs.com/dirlt/archive/2011/09/07/2169344.html\#sec-1  
http://blog.csdn.net/woxiaozhi/article/details/16963641  
http://www.cnblogs.com/wunaozai/p/3950249.html  
http://wenku.baidu.com/link?url=z021OoHoevOJDNP1IVTmEcWvTKRoNKlfzi96k8gUKvcnvdZxlvW4diCihYlxFYRJVjtHSVtYrN451MIqlyznsmO0wUvjRslNPGOZopSIhP\_

一.libev原理  
　　之前简单写过一篇libev的学习：http://blog.csdn.net/cxy450019566/article/details/52416349，有时间可以看看，没时间直接看这一篇文章。

*  需要理解的第一句话：Libev的核心是一个event loop。一个event loop，通俗讲就是一个不停在循环运行的事件。
 *  需要理解的第二句话：Libev通过分配和注册watcher对不同类型的事件进行监听，当监听被触发时，进行相应的操作。在一个event　loop中，我们可以设定对很多libev支持的事件(见上一篇博客)的监听watcher，这些事件的监听是异步进行的，触发任意一个监听的事件，都可以根据我们的设定进行某些操作。

理解了这两句话，你就可以理解libev的作用，以及怎样来使用libev。

二.通过简单示例了解libev基本用法  
我们从官方示例，来学习libev的基本用法。

// libev需要的头文件
    #include <ev.h>
    #include <stdio.h>
     
    // 建立我们刚刚说的需要监听的事件，这些事件类型是libev提供的
    // with the name ev_TYPE
    //ev_io和ev_timer最为常用，ev_io为监听控制台输入，ev_timer为时间事件
    ev_io stdin_watcher;
    ev_timer timeout_watcher;
     
    // 以下为自定义的回调函数，当触发监听事件时，调用执行对应的函数
     
    // ev_io事件的回调函数，当有输入流stdin时，调用函数
    static void stdin_cb (EV_P_ ev_io *w, int revents)
    {
    puts ("stdin ready");
    //对ev_io事件的监控不会自动停止，需要手动在需要的时候停止
    ev_io_stop (EV_A_ w);
     
    //整体的loop事件在所有监控停止时停止，也可以手动关闭全部的ev_run
    ev_break (EV_A_ EVBREAK_ALL);
    }
     
    // 时间事件的自定义回调函数，可定时触发
    static void timeout_cb (EV_P_ ev_timer *w, intrevents)
    {
    puts ("timeout");
    //关闭最早的一个还在运行的ev_run
    ev_break (EV_A_ EVBREAK_ONE);
    }
     
    int main (void)
    {
    //定义默认的 event loop，它就像一个大容器，可以装载着很多事件不停运行
    struct ev_loop *loop = EV_DEFAULT;
     
    // 初始化ev_io事件监控，设置它的回调函数，和stdin
    ev_io_init (&stdin_watcher, stdin_cb,/*STDIN_FILENO*/ 0, EV_READ);
    //将ev_io事件放到event loop里面运行
    ev_io_start (loop, &stdin_watcher);
     
    // 初始化ev_timer事件监控，设置它的回调函数，间隔时间，是否重复
    ev_timer_init (&timeout_watcher, timeout_cb, 5.5,0.);
    //将ev_timer事件放到event loop里面运行
    ev_timer_start (loop, &timeout_watcher);
     
    // 将我们的大容器event loop整体运行起来
    ev_run (loop, 0);
     
    // ev_run运行结束之后，才会运行到这里
    return 0;
    }

通过上面的例子，就可以知道libev使用的思路：

首先，定义一个eventloop大容器 struct ev\_loop，和想要的监控事件ev\_XXX。

其次，初始化想要监控的事件，设置好回调函数和相应的参数ev\_XXX\_init 。

接下来，让想要监控的事件都投身到大容器中ev\_XXX\_start。

最后，让大容器带着小容器一起运行起来 ev\_run 。

三.常用函数详解  
1.`event loop` 相关  
(1)从创建说起：  
我们默认使用`EV_DEFAULT`类型的`loop`，使用一下语句来创建：`struct ev_loop *loop = EV_DEFAULT;`

`EV_DEFAULT`宏是以下指令：

ev_default_loop(EVBACKEND_POLL | EVBACKEND_SELECT | EVFLAG_NOENV);

返回一个最基础的`ev_loop`，并自动完成它的初始化，注意，如果程序中已经执行过该创建，将直接返回之前的创建。除此之外，更多自定义loop，可以使用该函数：`struct ev_loop*ev_loop_new (unsigned int flags)`。

(2)让`ev_loop`运行起来  
使用函数`ev_run(loop, int flags)`。

这里解释一下`flags`的作用，用于设置`ev_loop`的运行方式：

通常设置为0，表示该`ev_loop`在所有`watcher`结束后停止，也可以手动`break`，官方鼓励手动break。

除了0之外，还有一些选择，如`EVRUN_NOWAIT`、`EVRUN_ONCE`。具体请看官方文档。

ev\_run函数的源码说明。推荐博文：http://www.cnblogs.com/xiangshancuizhu/archive/2013/08/10/3250558.html

(3)`ev_loop`的停止  
前面已经说过，在flags设置为0的情况下，停止主要靠全部watcher停止或者手动break。

手动break用以下函数：ev\_break (loop,how)

其中，how代表停止的方式：

EVBREAK\_ONE：停止最久远的那个ev\_run

EVBREAK\_ALL：停止所有的ev\_run

2.ev\_TYPE公共基础  
(1)watcher对应的几种状态  
　　 initialiased：调用init函数初始化

active：调用start进行注册

pending：已经触发事件但是没有处理

inactive：调用stop注销。这个状态等同于initialised这个状态。

(2)ev\_TYPE对应不同类型的时间监控，共有的标准化函数主要如下：

typedef void (*)(struct ev_loop *loop, ev_TYPE*watcher, int revents) callback; // 回调函数都是这种类型
    ev_init (ev_TYPE *watcher, callback); // 初始化watcher
    ev_TYPE_set (ev_TYPE *watcher, [args]); // 设置watcher
    ev_TYPE_init (ev_TYPE *watcher, callback, [args]); // 这个函数综合了前两个函数功能
    ev_TYPE_start (loop, ev_TYPE *watcher); // 在ev_loop中注册watcher
    ev_TYPE_stop (loop, ev_TYPE *watcher); // 在ev_loop中注销watcher
    ev_set_priority (ev_TYPE *watcher, int priority); // 设置watcher优先级，值域为[-2,2]，大而优先
    ev_feed_event (loop, ev_TYPE *watcher, int revents);// 这个做跨线程通知非常有用，相当于触发了某个事件。
    bool ev_is_active (ev_TYPE *watcher); // watcher是否active.
    bool ev_is_pending (ev_TYPE *watcher); // watcher是否pending.
    int ev_clear_pending (loop, ev_TYPE *watcher); // 清除watcher pending状态并且返回事件

3.ev\_io相关  
(1)ev\_io结构  
ev\_io用来监听io事件，当有标准输入或输出时，则会触发事件，执行回调函数。

typedef structev\_io  
\{  
EV\_WATCHER\_LIST (ev\_io)  
int fd; /\* 所监听io事件的文件描述符（file descriptor，非负数） \*/  
int events; /\*所监听的事件，包括EV\_READ, EV\_WRITE 或 EV\_READ | EV\_WRITE \*/  
\} ev\_io;  
(2)初始化  
两种方式：

方式一：ev\_init(ev\_TYPE \*watcher, callback) ，ev\_io\_set(ev\_io \*ev, intfd, int events)

方式二：ev\_io\_init(ev\_io\*ev, callback,int fd, int events)

即需要设置监听watcher，回调函数callback，文件描述符fd，监听的事件events。

(3)运行和停止  
ev\_io\_start(EV\_P\_ev\_io \* w)：绑定到ev\_loop上

ev\_io\_stop(EV\_P\_ev\_io \* w)：从ev\_loop上撤离

4.ev\_timer相关  
(1)ev\_timer结构  
ev\_timer是一个相对时间的定时器，会在给定的时间点触发事件，还可以在固定的时间间隔之后再次触发超时事件。

typedef structev\_timer  
\{  
int active;  
int pending;  
int priority; /\*优先级 */  
void data; / 参数*/  
void (\*cb)(struct ev\_loop \*loop, struct ev\_timer \*w,int revents); /*回调函数 /  
ev\_tstamp at; / 定时器时间，单位为s*/  
ev\_tstamp repeat; /\*是否重复 \*/  
\} ev\_timer;  
(2)初始化  
同样两种方式：

方式一：ev\_init(ev\_TYPE \*watcher, callback) ，ev\_timer\_set (ev\_timer \*,ev\_tstamp after, ev\_tstamp repeat)

方式二：ev\_timer\_init(ev\_timer \*, callback, ev\_tstamp after, ev\_tstamp repeat)

即需要设置监听watcher，回调函数callback，定时器时间after,是否重复repeat。

其中，repeat设置为0表示定时器只触发一次，设置为正整数则间隔after秒一直不断触发。

(3)运行和停止  
ev\_timer\_start(EV\_P\_ev\_io \* w)：绑定到ev\_loop上

ev\_timer\_stop(EV\_P\_ev\_io \* w)：从ev\_loop上撤离

(4)其它函数  
ev\_timer\_again(loop, ev\_timer \*) :重启，对于不同状态的timer效果不同。

ev\_tstampev\_timer\_remaining (loop, ev\_timer \*)：返回现在到下一次触发定时器之间的时间。

四.在Socket编程的应用实例  
libev用在Socket编程上有几个好处，用ev\_timer可以控制发送频率，用ev\_io可以方便地异步进行包的接收。下面的实例就实现的这个流程，直接用代码解释了：

double time\_span = 1.0; //发送消息的时间间隔  
int test\_num = 5; //发送消息的次数  
int send\_num = 0; //已发送消息的次数  
int rev\_num = 0; //已收到回复的次数  
int fd = -1; //文件描述符

struct ev\_loop \*loop = EV\_DEFAULT;  
ev\_io io\_watcher;  
ev\_timer timer\_watcher;

//ev\_io的回调函数，用于异步接受回复  
void io\_action(struct ev\_loop *main\_loop,ev\_io*io\_w,int e)  
\{  
char buf\[4096\];  
char \*ptr = (char \*)buf;  
int ret = 0;  
//接收消息  
ret = ::recv(fd, ptr, 4096, 0);

std::cout << buf << “\\n”;

//接收到所有消息，停止ev\_io事件  
if(rev\_num >= test\_num)\{  
ev\_io\_stop(main\_loop,io\_w);  
\}  
\}

//ev\_timer的回调函数，用于定时发送消息  
void timer\_action(struct ev\_loop *main\_loop,ev\_timer*time\_w,int e)  
\{  
int ret;  
std::string msg\_send = “send msg”;  
//发送消息  
ret = ::send(fd, msg\_send.c\_str(),strlen(msg\_send.c\_str()), 0);  
std::cout << msg\_send << “\\n”;

//发送足够数量的消息后，停止事件  
if(send\_num >= test\_num)\{  
ev\_timer\_stop(main\_loop,time\_w);  
\}  
\}

int main(int argc, char \*argv\[\])  
\{  
fd = socket(AF\_INET, SOCK\_STREAM, 0);  
ret = ::connect(fd, (struct sockaddr \*)&addr,sizeof(addr));

ev\_init(&io\_watcher,io\_action);  
ev\_io\_set(&io\_watcher,fd,EV\_READ);

ev\_init(&timer\_watcher,timer\_action);  
ev\_timer\_set(&timer\_watcher,time\_span,1);

ev\_io\_start(loop,&io\_watcher);  
ev\_timer\_start(loop,&timer\_watcher);

ev\_run(loop,0);  
return 0;  
\}