Libevent官方代码样例学习(一)

在Ubuntu16.04中, libevent的默认安装位置为

#在 trusty 发行版中 amd64 硬件架构下的 libevent-2.0- 软件包文件清单
/usr/lib/x86_64-linux-gnu/libevent-2.0.so.
/usr/lib/x86_64-linux-gnu/libevent-2.0.so.5.1.
/usr/share/doc/libevent-2.0-/changelog.Debian.gz
/usr/share/doc/libevent-2.0-/copyright

https://github.com/libevent/libevent/blob/master/sample/time-test.c

这是一个定时触发事件的例子, 根据输入参数的不同, 单次执行或持续执行.

在main方法中, 通过以下的方法调用将timeout_event加入到将来的事件中.

base = event_base_new();
struct event timeout;
event_assign(&timeout_event, base, -, flags, timeout_callback, (void *) &timeout_event);
event_add(timeout_event, &tv);
event_base_dispatch(base);

将timeout_event作为参数传入callback方法, 然后在callback方法中再次将timeout_event加入到将来的事件中

struct event *timeout_event = arg;
// ...
event_add(timeout_event, &tv);

在这种情况下, 原代码中的flags = EV_PERSIST其实是不起作用的, 因为callback中复用了原来的内存地址, 设置为flags = 0一样能持续执行.

如果将event_assign改为event_new, 则调用变为

base = event_base_new();
// 注意此处不传入event而传入event_base, 因为event在当前方法中new并alloca空间, 所以传入的event指针是无效的.
struct event *timeout_event = event_new(base, -, flags, timeout_callback, base);
event_add(timeout_event, &tv);
evutil_gettimeofday(&lasttime, NULL);
event_base_dispatch(base);

而callback中的处理变为

struct event_base *base = arg;
struct event *timeout_event = event_new(base, -, , timeout_callback, base);
event_add(timeout_event, &tv);

这时候, 如果代码中使用flags = EV_PERSIST就会产生内存泄漏, 因为在触发后并不释放, 会持续的每隔1秒调用callback, 这时候要么在callback中不新增event, 要么flag设为0.

修改后的代码:

/*
 * XXX This sample code was once meant to show how to use the basic Libevent
 * interfaces, but it never worked on non-Unix platforms, and some of the
 * interfaces have changed since it was first written.  It should probably
 * be removed or replaced with something better.
 *
 * Compile with:
 * cc -I/usr/local/include -o time-test time-test.c -L/usr/local/lib -levent
 */

#include <sys/types.h>

#ifndef _WIN32
#include <sys/queue.h>
#include <unistd.h>
#endif
#ifdef EVENT__HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#include <stdio.h>
#include <string.h>

#include <event2/event.h>
#include <event2/event_struct.h>

#ifdef _WIN32
#include <winsock2.h>
#endif

struct timeval lasttime;
int event_is_persistent;

static void
timeout_callback(evutil_socket_t fd, short event, void *arg) {
    struct timeval newtime, difference;
    struct event_base *base = arg;
    double elapsed;

    // The evutil_gettimeofday function sets tv to the current time. The second argument is unused.
    evutil_gettimeofday(&newtime, NULL);
    // This macro subtract (respectively) their first two arguments, and stores the result in the third.
    evutil_timersub(&newtime, &lasttime, &difference);
    elapsed = difference.tv_sec + (difference.tv_usec / 1.0e6);
    printf("timeout_callback called at %d: %.3f seconds elapsed.\n", (int) newtime.tv_sec, elapsed);
    lasttime = newtime;
    if (event_is_persistent == ) {
        struct event *timeout_event = event_new(base, -, , timeout_callback, base);
        struct timeval tv;
        evutil_timerclear(&tv);
        tv.tv_sec = ;
        tv.tv_usec = ;
        event_add(timeout_event, &tv);
    }
}

int
main(int argc, char **argv) {
    struct timeval tv;
    struct event_base *base;
    int flags;
    // strcmp: <0 the first character that does not match has a lower value in ptr1 than in ptr2
    // 0 the contents of both strings are equal
    // >0 the first character that does not match has a greater value in ptr1 than in ptr2
    if (argc ==  && !strcmp(argv[], "-p")) {
        event_is_persistent = ;
        // Use this if you use event_new instead of event_assign
        flags = 0;
    } else {
        event_is_persistent = ;
        flags = ;
    }
    /* Initalize the event library */
    base = event_base_new();
    /*
     * Prepare a new, already-allocated event structure to be added.
     * The function event_assign() prepares the event structure ev to be used in future calls to event_add() and event_del().
     * Unlike event_new(), it doesn't allocate memory itself: it requires that you have already allocated a struct event,
     * probably on the heap. Doing this will typically make your code depend on the size of the event structure, and thereby
     * create incompatibility with future versions of Libevent.
     * The easiest way to avoid this problem is just to use event_new() and event_free() instead.
     * A slightly harder way to future-proof your code is to use event_get_struct_event_size() to determine the required size
     * of an event at runtime.
     * Note that it is NOT safe to call this function on an event that is active or pending. Doing so WILL corrupt internal
     * data structures in Libevent, and lead to strange, hard-to-diagnose bugs. You can use event_assign to change an existing
     * event, but only if it is not active or pending!
     */
    //event_assign(&timeout_event, base, -1, flags, timeout_callback, (void *) &timeout_event);
    struct event *timeout_event = event_new(base, -, flags, timeout_callback, base);

    // Set (tvp)->tv_sec and (tvp)->tv_usec to 0
    evutil_timerclear(&tv);
    tv.tv_sec = ;
    // Add an event to the set of pending events.
    // The function event_add() schedules the execution of the ev event when the event specified in event_assign()/event_new() occurs,
    // or when the time specified in timeout has elapesed. If atimeout is NULL, no timeout occurs and the function will only be called
    // if a matching event occurs. The event in the ev argument must be already initialized by event_assign() or event_new() and may
    // not be used in calls to event_assign() until it is no longer pending.
    // If the event in the ev argument already has a scheduled timeout, calling event_add() replaces the old timeout with the new one,
    // or clears the old timeout if the timeout argument is NULL.
    event_add(timeout_event, &tv);
    evutil_gettimeofday(&lasttime, NULL);
    event_base_dispatch(base);

    return ();
}

Update 2017-12-05:

如果使用的是libevent 2.1.1以后的版本, 可以使用event_self_cbarg()方法. 在event_new中通过 event_self_cbarg() 方法传入自身指针.

#include <event2/event.h>
static int n_calls = ;

void cb_func(evutil_socket_t fd, short what, void *arg){
    struct event *me = arg;
    printf("cb_func called %d times so far.\n", ++n_calls);
    if (n_calls > )
       event_del(me);
}

void run(struct event_base *base){
    struct timeval one_sec = { ,  };
    struct event *ev;
    /* We're going to set up a repeating timer to get called called 100 times. */
    ev = event_new(base, -, EV_PERSIST, cb_func, event_self_cbarg());
    event_add(ev, &one_sec);
    event_base_dispatch(base);
}