Libevent源码分析-----与event相关的一些函数和操作
2017-06-06 21:14
531 查看
转载请注明出处: http://blog.csdn.net/luotuo44/article/details/38739549
Libevent提供了一些与event相关的操作函数和操作。本文就重点讲一下这方面的源代码。
在Libevent中，无论是event还是event_base，都是使用指针而不会使用变量。实际上，如果查看Libevent不同的版本，就可以发现event和event_base这两个结构体的成员是不同的。对比libevent-2.0.21-stable和libevent-1.4.13-stable这两个版本，就可以发现其具有相当大的区别。
[cpp]
view plain
copy
//event.c文件
evutil_socket_t //监听的文件描述符fd
event_get_fd(const struct event *ev)
{
return ev->ev_fd;
}
struct event_base * //获取event_base
event_get_base(const struct event *ev)
{
return ev->ev_base;
}
short //获取该event监听的事件
event_get_events(const struct event *ev)
{
return ev->ev_events;
}
event_callback_fn //获取回调函数的函数指针
event_get_callback(const struct event *ev)
{
return ev->ev_callback;
}
void * //获取回调函数参数
event_get_callback_arg(const struct event *ev)
{
return ev->ev_arg;
}
void //一个函数获取所有
event_get_assignment(const struct event *event, struct event_base **base_out, evutil_socket_t *fd_out,
short *events_out, event_callback_fn *callback_out, void **arg_out)
{
if (base_out)
*base_out = event->ev_base;
if (fd_out)
*fd_out = event->ev_fd;
if (events_out)
*events_out = event->ev_events;
if (callback_out)
*callback_out = event->ev_callback;
if (arg_out)
*arg_out = event->ev_arg;
}
前面的那些函数是获取单个参数的，最后那个函数可以同时获取多个参数。并且如果不想获取某个参数，可以对应地传入一个NULL。
可以用event_initialized函数检测一个event是否处于已初始化状态：
[cpp]
view plain
copy
//event.c文件
int
event_initialized(const struct event *ev)
{
if (!(ev->ev_flags & EVLIST_INIT))
return 0;
return 1;
}
可以看到event_initialized只是检查event的ev_flags是否有EVLIST_INIT标志。从之前的博文可以知道，当用户调用event_new后，就会为event加入该标志，所以用event_new创建的even都是处于已初始化状态的。
当用户调用event_new创建一个event后，它还没处于未决状态(non-pending)，当用户调用event_add函数，将一个event插入到event_base队列后，就处于未决状态(pending)。
如果event监听的事件发生了或者超时了，那么该event就会被激活，处于激活状态。当event的回调函数被调用后，它就不再是激活状态了，但还是处于未决状态。如果用户调用了event_del或者event_free(该函数内部调用event_del)，那么该event就不再是未决状态了。
可以调用event_pending函数来检查event处于哪种事件的未决状态。但是该函数不仅仅会检查event的未决状态，还会检查event的激活状态。名不副实啊！！下面就看一下这个函数吧。
[cpp]
view plain
copy
//event.c文件
int
event_pending(const struct event *ev, short event, struct timeval *tv)
{
int flags = 0;
if (EVUTIL_FAILURE_CHECK(ev->ev_base == NULL)) {
event_warnx("%s: event has no event_base set.", __func__);
return 0;
}
EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
//flags记录用户监听了哪些事件
if (ev->ev_flags & EVLIST_INSERTED)
flags |= (ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL));
//flags记录event被什么事件激活了.用户可以调用event_active
//手动激活event，并且可以使用之前用户没有监听的事件作为激活原因
if (ev->ev_flags & EVLIST_ACTIVE)
flags |= ev->ev_res;
//记录该event是否还有超时属性
if (ev->ev_flags & EVLIST_TIMEOUT)
flags |= EV_TIMEOUT;
//event可以被用户乱设值，然后作为参数。这里为了保证
//其值只能是下面的事件。
event &= (EV_TIMEOUT|EV_READ|EV_WRITE|EV_SIGNAL);
/* See if there is a timeout that we should report */
if (tv != NULL && (flags & event & EV_TIMEOUT)) {
struct timeval tmp = ev->ev_timeout;
tmp.tv_usec &= MICROSECONDS_MASK;
#if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
/* correctly remamp to real time */
evutil_timeradd(&ev->ev_base->tv_clock_diff, &tmp, tv);
#else
*tv = tmp;
#endif
}
EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
return (flags & event);
}
该函数的作用是检查某个事件(由第二个参数指定)是否处于未决或者激活状态。
由flags的几个 |= 操作可知，它会把event监听的事件种类都记录下来。并且还会把event被激活的原因(也是一个事件)记录下来。下面会讲到手动激活一个event。所以event可能会被一个没有监听的事件锁激活。
如果该函数的第三个参数不为NULL，并且用户之前也让这个event监听了超时事件，而且用户在第二个参数中指明了要检查超时事件，那么将第三个参数将被赋值为该event的下次超时时间(绝对时间)。
event_pending函数的一个作用是可以判断一个event是否已经从event_base中删除了。比如说，某个event监听写事件而加入了event_base，但可能在某个时刻被删除。那么可以用下面的代码判断这个event是否已经被删除了。
[cpp]
view plain
copy
if( event_pending(ev, EV_WRITE, NULL) == 0 )
printf("delete\n");
else
printf("no delete\n");
[cpp]
view plain
copy
//event.c文件
//res是激活的原因，是诸如EV_READ EV_TIMEOUT之类的宏.
//ncalls只对EV_SIGNAL信号有用，表示信号的次数
//因为IO事件不讲究次数，信号才讲究次数
void
event_active(struct event *ev, int res, short ncalls)
{
//加锁，可以线程安全地手动激活一个event
EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
event_active_nolock(ev, res, ncalls);
EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
}
void
event_active_nolock(struct event *ev, int res, short ncalls)
{
struct event_base *base;
//该event已经是激活状态
if (ev->ev_flags & EVLIST_ACTIVE) {
ev->ev_res |= res;
return;
}
base = ev->ev_base;
ev->ev_res = res;//记录被激活原因。以后会用到
...
if (ev->ev_events & EV_SIGNAL) {
#ifndef _EVENT_DISABLE_THREAD_SUPPORT
if (base->current_event == ev && !EVBASE_IN_THREAD(base)) {
++base->current_event_waiters;
EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
}
#endif
ev->ev_ncalls = ncalls;
ev->ev_pncalls = NULL;
}
//将event插入到激活队列
event_queue_insert(base, ev, EVLIST_ACTIVE);
//调用本函数的线程不是主线程的话，就会通知主线程。使得主线程能赶快处理激活event
if (EVBASE_NEED_NOTIFY(base))
evthread_notify_base(base);
}
手动激活一个event的原理是：把event插入到激活队列。如果执行激活动作的线程不是主线程，那么还要唤醒主线程，让主线程及时处理激活event，不再睡眠在多路IO复用函数中。
由于手动激活一个event是直接把这个event插入到激活队列的，所以event的被激活原因(由res参数所指定)可以不是该event监听的事件。比如说该event只监听了EV_READ事件，那么可以调用event_active(ev,EV_SIGNAL, 1);用信号事件激活该event。
[cpp]
view plain
copy
void
event_free(struct event *ev)
{
event_del(ev);
mm_free(ev);//释放内存
}
int
event_del(struct event *ev)
{
int res;
//加锁保证线程安全
EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
res = event_del_internal(ev);
EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
return (res);
}
static inline int
event_del_internal(struct event *ev)
{
struct event_base *base;
int res = 0, notify = 0;
base = ev->ev_base;
/* See if we are just active executing this event in a loop */
if (ev->ev_events & EV_SIGNAL) {
if (ev->ev_ncalls && ev->ev_pncalls) {
/* Abort loop *///终止循环
*ev->ev_pncalls = 0;
}
}
//从超时集合中删除.超时集合可能是小根堆也可能是common-timeout
if (ev->ev_flags & EVLIST_TIMEOUT) {
//删除超时event并不需要通知主线程。如果该event不是最早超时的，
//那肯定不用通知了。如果是的话，那么主线程会醒来。醒来后，
//主线程还是会再次检查超时集合中有哪些超时event超时了。这个被
//删除的超时event自然也检查不出来。主线程只会空手而回。
event_queue_remove(base, ev, EVLIST_TIMEOUT);
}
//该event已经在active队列中了。那么需要在active队列中删除之
if (ev->ev_flags & EVLIST_ACTIVE)
event_queue_remove(base, ev, EVLIST_ACTIVE);
//该event已经在注册队列(eventqueue)中了，那么需要在注册队列中删除之
if (ev->ev_flags & EVLIST_INSERTED) {
event_queue_remove(base, ev, EVLIST_INSERTED);
//此外还要在该fd或者sig队列中删除之。同一个fd可以有多个event。
//所以这里还有一个队列
if (ev->ev_events & (EV_READ|EV_WRITE))
res = evmap_io_del(base, ev->ev_fd, ev);
else
res = evmap_signal_del(base, (int)ev->ev_fd, ev);
if (res == 1) {
/* evmap says we need to notify the main thread. */
notify = 1;
res = 0;
}
}
//可能需要通知主线程
if (res != -1 && notify && EVBASE_NEED_NOTIFY(base))
evthread_notify_base(base);
return (res);
}
虽然要调用三个函数才能删除一个event，不过思路还是挺清晰的。删除的时候要加锁，删除完后要释放内存。从之前的博文也可以知道，一个event是会被加入到各种队列中的。所以将一个event删除，所做的工作主要是：将这个event从各种队列中删除掉。
删除一个event这个操作可能不是主线程调用的，这时就可能需要通知主线程。关于通知主线程的原理可以参考博文《evthread_notify_base通知主线程》。
Libevent提供了一些与event相关的操作函数和操作。本文就重点讲一下这方面的源代码。
在Libevent中，无论是event还是event_base，都是使用指针而不会使用变量。实际上，如果查看Libevent不同的版本，就可以发现event和event_base这两个结构体的成员是不同的。对比libevent-2.0.21-stable和libevent-1.4.13-stable这两个版本，就可以发现其具有相当大的区别。
event的参数:
一个event结构体和很多东西相关联，比如event_base、文件描述符fd、回调函数、回调参数等等，下文把这些东西统一称为参数。这些参数都是在调用event_new创建一个event时指定的。如果在后面需要再次获取这些参数时，可以通过一些函数来获取，而不应该直接访问event结构体的成员。[cpp]
view plain
copy
//event.c文件
evutil_socket_t //监听的文件描述符fd
event_get_fd(const struct event *ev)
{
return ev->ev_fd;
}
struct event_base * //获取event_base
event_get_base(const struct event *ev)
{
return ev->ev_base;
}
short //获取该event监听的事件
event_get_events(const struct event *ev)
{
return ev->ev_events;
}
event_callback_fn //获取回调函数的函数指针
event_get_callback(const struct event *ev)
{
return ev->ev_callback;
}
void * //获取回调函数参数
event_get_callback_arg(const struct event *ev)
{
return ev->ev_arg;
}
void //一个函数获取所有
event_get_assignment(const struct event *event, struct event_base **base_out, evutil_socket_t *fd_out,
short *events_out, event_callback_fn *callback_out, void **arg_out)
{
if (base_out)
*base_out = event->ev_base;
if (fd_out)
*fd_out = event->ev_fd;
if (events_out)
*events_out = event->ev_events;
if (callback_out)
*callback_out = event->ev_callback;
if (arg_out)
*arg_out = event->ev_arg;
}
前面的那些函数是获取单个参数的，最后那个函数可以同时获取多个参数。并且如果不想获取某个参数，可以对应地传入一个NULL。
event的状态:
一个event是可以有多个状态的，比如已初始化状态(initialized)、未决状态(pending)、激活状态(active)。可以用event_initialized函数检测一个event是否处于已初始化状态：
[cpp]
view plain
copy
//event.c文件
int
event_initialized(const struct event *ev)
{
if (!(ev->ev_flags & EVLIST_INIT))
return 0;
return 1;
}
可以看到event_initialized只是检查event的ev_flags是否有EVLIST_INIT标志。从之前的博文可以知道，当用户调用event_new后，就会为event加入该标志，所以用event_new创建的even都是处于已初始化状态的。
当用户调用event_new创建一个event后，它还没处于未决状态(non-pending)，当用户调用event_add函数，将一个event插入到event_base队列后，就处于未决状态(pending)。
如果event监听的事件发生了或者超时了，那么该event就会被激活，处于激活状态。当event的回调函数被调用后，它就不再是激活状态了，但还是处于未决状态。如果用户调用了event_del或者event_free(该函数内部调用event_del)，那么该event就不再是未决状态了。
可以调用event_pending函数来检查event处于哪种事件的未决状态。但是该函数不仅仅会检查event的未决状态，还会检查event的激活状态。名不副实啊！！下面就看一下这个函数吧。
[cpp]
view plain
copy
//event.c文件
int
event_pending(const struct event *ev, short event, struct timeval *tv)
{
int flags = 0;
if (EVUTIL_FAILURE_CHECK(ev->ev_base == NULL)) {
event_warnx("%s: event has no event_base set.", __func__);
return 0;
}
EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
//flags记录用户监听了哪些事件
if (ev->ev_flags & EVLIST_INSERTED)
flags |= (ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL));
//flags记录event被什么事件激活了.用户可以调用event_active
//手动激活event，并且可以使用之前用户没有监听的事件作为激活原因
if (ev->ev_flags & EVLIST_ACTIVE)
flags |= ev->ev_res;
//记录该event是否还有超时属性
if (ev->ev_flags & EVLIST_TIMEOUT)
flags |= EV_TIMEOUT;
//event可以被用户乱设值，然后作为参数。这里为了保证
//其值只能是下面的事件。
event &= (EV_TIMEOUT|EV_READ|EV_WRITE|EV_SIGNAL);
/* See if there is a timeout that we should report */
if (tv != NULL && (flags & event & EV_TIMEOUT)) {
struct timeval tmp = ev->ev_timeout;
tmp.tv_usec &= MICROSECONDS_MASK;
#if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
/* correctly remamp to real time */
evutil_timeradd(&ev->ev_base->tv_clock_diff, &tmp, tv);
#else
*tv = tmp;
#endif
}
EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
return (flags & event);
}
该函数的作用是检查某个事件(由第二个参数指定)是否处于未决或者激活状态。
由flags的几个 |= 操作可知，它会把event监听的事件种类都记录下来。并且还会把event被激活的原因(也是一个事件)记录下来。下面会讲到手动激活一个event。所以event可能会被一个没有监听的事件锁激活。
如果该函数的第三个参数不为NULL，并且用户之前也让这个event监听了超时事件，而且用户在第二个参数中指明了要检查超时事件，那么将第三个参数将被赋值为该event的下次超时时间(绝对时间)。
event_pending函数的一个作用是可以判断一个event是否已经从event_base中删除了。比如说，某个event监听写事件而加入了event_base，但可能在某个时刻被删除。那么可以用下面的代码判断这个event是否已经被删除了。
[cpp]
view plain
copy
if( event_pending(ev, EV_WRITE, NULL) == 0 )
printf("delete\n");
else
printf("no delete\n");
手动激活event：
除了运行event_base_dispatch死等外界条件把event激活外，Libevent还提供了一个API函数event_active，可以手动地把一个event激活。[cpp]
view plain
copy
//event.c文件
//res是激活的原因，是诸如EV_READ EV_TIMEOUT之类的宏.
//ncalls只对EV_SIGNAL信号有用，表示信号的次数
//因为IO事件不讲究次数，信号才讲究次数
void
event_active(struct event *ev, int res, short ncalls)
{
//加锁，可以线程安全地手动激活一个event
EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
event_active_nolock(ev, res, ncalls);
EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
}
void
event_active_nolock(struct event *ev, int res, short ncalls)
{
struct event_base *base;
//该event已经是激活状态
if (ev->ev_flags & EVLIST_ACTIVE) {
ev->ev_res |= res;
return;
}
base = ev->ev_base;
ev->ev_res = res;//记录被激活原因。以后会用到
...
if (ev->ev_events & EV_SIGNAL) {
#ifndef _EVENT_DISABLE_THREAD_SUPPORT
if (base->current_event == ev && !EVBASE_IN_THREAD(base)) {
++base->current_event_waiters;
EVTHREAD_COND_WAIT(base->current_event_cond, base->th_base_lock);
}
#endif
ev->ev_ncalls = ncalls;
ev->ev_pncalls = NULL;
}
//将event插入到激活队列
event_queue_insert(base, ev, EVLIST_ACTIVE);
//调用本函数的线程不是主线程的话，就会通知主线程。使得主线程能赶快处理激活event
if (EVBASE_NEED_NOTIFY(base))
evthread_notify_base(base);
}
手动激活一个event的原理是：把event插入到激活队列。如果执行激活动作的线程不是主线程，那么还要唤醒主线程，让主线程及时处理激活event，不再睡眠在多路IO复用函数中。
由于手动激活一个event是直接把这个event插入到激活队列的，所以event的被激活原因(由res参数所指定)可以不是该event监听的事件。比如说该event只监听了EV_READ事件，那么可以调用event_active(ev,EV_SIGNAL, 1);用信号事件激活该event。
删除event：
之前的博文都只是讲怎么创建event和将之add到event_base中。现在来讲一下怎么删除一个event。[cpp]
view plain
copy
void
event_free(struct event *ev)
{
event_del(ev);
mm_free(ev);//释放内存
}
int
event_del(struct event *ev)
{
int res;
//加锁保证线程安全
EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
res = event_del_internal(ev);
EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
return (res);
}
static inline int
event_del_internal(struct event *ev)
{
struct event_base *base;
int res = 0, notify = 0;
base = ev->ev_base;
/* See if we are just active executing this event in a loop */
if (ev->ev_events & EV_SIGNAL) {
if (ev->ev_ncalls && ev->ev_pncalls) {
/* Abort loop *///终止循环
*ev->ev_pncalls = 0;
}
}
//从超时集合中删除.超时集合可能是小根堆也可能是common-timeout
if (ev->ev_flags & EVLIST_TIMEOUT) {
//删除超时event并不需要通知主线程。如果该event不是最早超时的，
//那肯定不用通知了。如果是的话，那么主线程会醒来。醒来后，
//主线程还是会再次检查超时集合中有哪些超时event超时了。这个被
//删除的超时event自然也检查不出来。主线程只会空手而回。
event_queue_remove(base, ev, EVLIST_TIMEOUT);
}
//该event已经在active队列中了。那么需要在active队列中删除之
if (ev->ev_flags & EVLIST_ACTIVE)
event_queue_remove(base, ev, EVLIST_ACTIVE);
//该event已经在注册队列(eventqueue)中了，那么需要在注册队列中删除之
if (ev->ev_flags & EVLIST_INSERTED) {
event_queue_remove(base, ev, EVLIST_INSERTED);
//此外还要在该fd或者sig队列中删除之。同一个fd可以有多个event。
//所以这里还有一个队列
if (ev->ev_events & (EV_READ|EV_WRITE))
res = evmap_io_del(base, ev->ev_fd, ev);
else
res = evmap_signal_del(base, (int)ev->ev_fd, ev);
if (res == 1) {
/* evmap says we need to notify the main thread. */
notify = 1;
res = 0;
}
}
//可能需要通知主线程
if (res != -1 && notify && EVBASE_NEED_NOTIFY(base))
evthread_notify_base(base);
return (res);
}
虽然要调用三个函数才能删除一个event，不过思路还是挺清晰的。删除的时候要加锁，删除完后要释放内存。从之前的博文也可以知道，一个event是会被加入到各种队列中的。所以将一个event删除，所做的工作主要是：将这个event从各种队列中删除掉。
删除一个event这个操作可能不是主线程调用的，这时就可能需要通知主线程。关于通知主线程的原理可以参考博文《evthread_notify_base通知主线程》。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Libevent源码分析-----与event相关的一些函数和操作
- Libevent源码分析-----与event相关的一些函数和操作
- 【libevent】源码分析（4）--与event相关的一些函数和操作
- libevent源码分析（6）－－2.1.8－－创建和释放libevent句柄event_base的相关函数
- Libevent源码分析-----与event相关的一些函数和操作
- libevent源码分析--event_set()函数
- Libevent源码分析-----更多evbuffer操作函数
- libevent源码分析--event_add()函数
- libevent源码分析--event_init()函数
- Libevent源码分析-----更多evbuffer操作函数
- libevent源码分析（5）－－2.1.8－－libevent配置信息对象struct event_config的申请和释放函数分析
- jQuery源码分析-12 DOM操作-Manipulation-核心函数jQuery.clean()
- Libevent源码分析-----通用类型和函数
- WINCE 串口驱动相关一些函数分析
- libevent源码分析--evbuffer和bufferevent的关系
- Libevent源码分析-----信号event的处理
- Libevent源码分析-----event_io_map哈希表
- Libevent源码分析-----event优先级设置
- jQuery源码分析-12 DOM操作-Manipulation-核心函数jQuery.buildFragment()
- arm架构下的原子操作（atomic）函数源码分析