事件集合（struct event_base）
struct event_base *event_base_new(void)
其中有很多的函数已经追踪阅读，但是没有展示，设计思想不难，但是代码由于#define的存在，有点复杂。
Order 0：struct event_base *event_base_new(void)
struct event_base * event_base_new(void)
{
struct event_base *base = NULL;
struct event_config *cfg = event_config_new(); //获取一个struct event_config对象
if (cfg) { //如果对象获取成功，根据config对struct event_base对象进行设置，然后free config object
base = event_base_new_with_config(cfg);
event_config_free(cfg);
}
return base;
}
Order 1：struct event_config* event_config_new(void)和void event_config_free(struct event_config *cfg)
struct event_config* event_config_new(void)
{
struct event_config *cfg = mm_calloc(1, sizeof(*cfg)); //从自定义的alloc中分配一块空间用于存放config object
if (cfg == NULL) //如果分配失败，返回NULL
return (NULL);
TAILQ_INIT(&cfg->entries); //初始化config object的双向队列
cfg->max_dispatch_interval.tv_sec = -1; //如果为-1，则在没有事件时陷入等待，直到有事件发生。
cfg->max_dispatch_callbacks = INT_MAX; //将callback的处理限制为INT_MAX
cfg->limit_callbacks_after_prio = 1; //优先级默认为1，就是全局只有这么一个优先级
return (cfg);
}
void event_config_free(struct event_config *cfg)
{
struct event_config_entry *entry; //从config object中逐个取出struct event_config_entry对象（这个对象中没啥实际的东西）并删除
while ((entry = TAILQ_FIRST(&cfg->entries)) != NULL) {
TAILQ_REMOVE(&cfg->entries, entry, next);
event_config_entry_free(entry);
}
mm_free(cfg); //归还config Object内存
}
Order 1：struct event_base * event_base_new_with_config(const struct event_config *cfg)
struct event_base * event_base_new_with_config(const struct event_config *cfg)
{
int i;
struct event_base *base;
int should_check_environment;
#ifndef EVENT__DISABLE_DEBUG_MODE
event_debug_mode_too_late = 1;
#endif
if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) { //获取存储struct event_base的对象
event_warn("%s: calloc", __func__);
return NULL;
}
if (cfg) //根据config对象设置event_base
base->flags = cfg->flags;
should_check_environment =
!(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV)); //判断是否需要检查当前环境
{
struct timeval tmp;
int precise_time =
cfg && (cfg->flags & EVENT_BASE_FLAG_PRECISE_TIMER); //检查是否设置了精确时间的选项
int flags;
if (should_check_environment && !precise_time) {
precise_time = evutil_getenv_("EVENT_PRECISE_TIMER") != NULL;
base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER;
}
flags = precise_time ? EV_MONOT_PRECISE : 0; //判断是否需要精确时间选项
evutil_configure_monotonic_time_(&base->monotonic_timer, flags); //配置那个为空的对象
gettime(base, &tmp); //获取时间
}
min_heap_ctor_(&base->timeheap); //将超时时间以最小堆组织起来
base->sig.ev_signal_pair[0] = -1; //将sockpair处理的事件机制的fd初始化为-1
base->sig.ev_signal_pair[1] = -1;
base->th_notify_fd[0] = -1;
base->th_notify_fd[1] = -1;
TAILQ_INIT(&base->active_later_queue); //初始化下一轮循环通知的事件初始化
evmap_io_initmap_(&base->io); //初始化IO事件map（HASH）
evmap_signal_initmap_(&base->sigmap); //初始化信号事件（HASH）
event_changelist_init_(&base->changelist); //初始化事件修改链表
base->evbase = NULL; //将指向特定数据的指针初始化为NULL
if (cfg) {
memcpy(&base->max_dispatch_time,
&cfg->max_dispatch_interval, sizeof(struct timeval)); //根据config对象，初始化struct event_base的：
base->limit_callbacks_after_prio =
cfg->limit_callbacks_after_prio;
} else {
base->max_dispatch_time.tv_sec = -1; //事件循环时间
base->limit_callbacks_after_prio = 1; //事件优先级
}
if (cfg && cfg->max_dispatch_callbacks >= 0) { //初始化事件处理的最大数量
base->max_dispatch_callbacks = cfg->max_dispatch_callbacks;
} else {
base->max_dispatch_callbacks = INT_MAX;
}
if (base->max_dispatch_callbacks == INT_MAX &&
base->max_dispatch_time.tv_sec == -1)
base->limit_callbacks_after_prio = INT_MAX; //初始化优先级数量
for (i = 0; eventops[i] && !base->evbase; i++) { //eventops是一个全局数据结构，如果全局数据结构存在并且base的私有数据不存在，就执行代码
if (cfg != NULL) { //如果有config object
if (event_config_is_avoided_method(cfg,
eventops[i]->name)) //将eventop中的name字符串，传递给配置对象
continue;
if ((eventops[i]->features & cfg->require_features)
!= cfg->require_features)
continue;
}
/* also obey the environment variables */
if (should_check_environment &&
event_is_method_disabled(eventops[i]->name))
continue;
base->evsel = eventops[i]; //将信号处理ops注册给base的信号处理ops
base->evbase = base->evsel->init(base); //私有数据 = struct event_base对象？？有可能是反向获取struct event_base的方式之一
}
if (base->evbase == NULL) { //如果反向获取指针处理失败，直接返回
event_warnx("%s: no event mechanism available",
__func__);
base->evsel = NULL;
event_base_free(base);
return NULL;
}
if (evutil_getenv_("EVENT_SHOW_METHOD"))
event_msgx("libevent using: %s", base->evsel->name);
/* allocate a single active event queue */
if (event_base_priority_init(base, 1) < 0) { //初始化事件处理的优先级队列
event_base_free(base);
return NULL;
}
/* prepare for threading */
#if !defined(EVENT__DISABLE_THREAD_SUPPORT) && !defined(EVENT__DISABLE_DEBUG_MODE)
event_debug_created_threadable_ctx_ = 1;
#endif
if (EVTHREAD_LOCKING_ENABLED() &&
(!cfg || !(cfg->flags & EVENT_BASE_FLAG_NOLOCK))) {
int r;
EVTHREAD_ALLOC_LOCK(base->th_base_lock, 0); //初始化互斥锁
EVTHREAD_ALLOC_COND(base->current_event_cond); //初始化条件变量
r = evthread_make_base_notifiable(base); //这个函数会初始化与唤醒主线程的sockpair以及注册唤醒主线程的函数，都不难，可以很快用C++实现
if (r<0) {
event_warnx("%s: Unable to make base notifiable.", __func__);
event_base_free(base);
return NULL;
}
}
return (base); //返回已经初始化的struct event_base对象
}
void event_base_free(struct event_base *base)
Order 0：void event_base_free(struct event_base *base)
void event_base_free(struct event_base *base)
{
event_base_free_(base, 1);
}
Order 1：static void event_base_free_(struct event_base *base, int run_finalizers)
static void event_base_free_(struct event_base *base, int run_finalizers)
{
int i, n_deleted=0;
struct event *ev;
if (base == NULL && current_base) //获取现有的struct event_base对象
base = current_base;
if (base == NULL) {
event_warnx("%s: no base to free", __func__);
return;
}
if (base->th_notify_fd[0] != -1) { //在事件库中存在多个线程，终止时需要合理的处理这些线程
event_del(&base->th_notify); //从事件队列中删除与多线程通信的事件
EVUTIL_CLOSESOCKET(base->th_notify_fd[0]); //关闭管道fd
if (base->th_notify_fd[1] != -1)
EVUTIL_CLOSESOCKET(base->th_notify_fd[1]); //关闭管道fd
base->th_notify_fd[0] = -1;
base->th_notify_fd[1] = -1;
event_debug_unassign(&base->th_notify); //测试这个event是否已经取消注册
}
evmap_delete_all_(base); //删除事件链表中所有的IO事件与信号事件
while ((ev = min_heap_top_(&base->timeheap)) != NULL) { //从最小堆中删除所有的超时事件
event_del(ev);
++n_deleted;
}
for (i = 0; i < base->n_common_timeouts; ++i) { //这个管理超时事件的common没有搞懂
struct common_timeout_list *ctl =
base->common_timeout_queues[i];
event_del(&ctl->timeout_event); /* Internal; doesn't count */
event_debug_unassign(&ctl->timeout_event);
for (ev = TAILQ_FIRST(&ctl->events); ev; ) {
struct event *next = TAILQ_NEXT(ev,
ev_timeout_pos.ev_next_with_common_timeout);
if (!(ev->ev_flags & EVLIST_INTERNAL)) {
event_del(ev);
++n_deleted;
}
ev = next;
}
mm_free(ctl);
}
if (base->common_timeout_queues) //释放公共超时事件队列
mm_free(base->common_timeout_queues);
for (;;) { //回收处理事件的线程资源
int i = event_base_free_queues_(base, run_finalizers);
if (!i) {
break;
}
n_deleted += i;
}
if (n_deleted)
event_debug(("%s: %d events were still set in base",
__func__, n_deleted));
while (LIST_FIRST(&base->once_events)) { //从只注册一次的事件，但是事件还没有发生的链表中，逐个删除事件
struct event_once *eonce = LIST_FIRST(&base->once_events);
LIST_REMOVE(eonce, next_once);
mm_free(eonce);
}
if (base->evsel != NULL && base->evsel->dealloc != NULL)
base->evsel->dealloc(base); //使用注册的函数清理base
for (i = 0; i < base->nactivequeues; ++i) //在销毁struct event_base对象之前，逐个清理
EVUTIL_ASSERT(TAILQ_EMPTY(&base->activequeues[i]));
EVUTIL_ASSERT(min_heap_empty_(&base->timeheap)); //在销毁之前，确保最小堆已经被清理干净
min_heap_dtor_(&base->timeheap); //销毁最小堆
mm_free(base->activequeues); //释放活动事件队列
evmap_io_clear_(&base->io); //清理IO事件队列
evmap_signal_clear_(&base->sigmap); //清理信号事件队列
event_changelist_freemem_(&base->changelist); //清理改变事件队列
EVTHREAD_FREE_LOCK(base->th_base_lock, 0); //释放锁与条件变量
EVTHREAD_FREE_COND(base->current_event_cond);
if (base == current_base)
current_base = NULL;
mm_free(base);
}
int event_reinit(struct event_base *base)
Order 0：int event_reinit(struct event_base *base)
int event_reinit(struct event_base *base)
{
const struct eventop *evsel;
int res = 0;
int was_notifiable = 0;
int had_signal_added = 0;
EVBASE_ACQUIRE_LOCK(base, th_base_lock); //获取锁
evsel = base->evsel; //获取处理事件的ops
if (evsel->need_reinit) { //如果struct event_base对象在fork之后需要重新进行处理
base->evsel = &nil_eventop; //获取信号处理
}
if (base->sig.ev_signal_added) {
event_del_nolock_(&base->sig.ev_signal, EVENT_DEL_AUTOBLOCK);
event_debug_unassign(&base->sig.ev_signal);
memset(&base->sig.ev_signal, 0, sizeof(base->sig.ev_signal));
had_signal_added = 1;
base->sig.ev_signal_added = 0;
}
if (base->sig.ev_signal_pair[0] != -1)
EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[0]);
if (base->sig.ev_signal_pair[1] != -1)
EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[1]);
if (base->th_notify_fn != NULL) {
was_notifiable = 1;
base->th_notify_fn = NULL;
}
if (base->th_notify_fd[0] != -1) {
event_del_nolock_(&base->th_notify, EVENT_DEL_AUTOBLOCK);
EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);
if (base->th_notify_fd[1] != -1)
EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);
base->th_notify_fd[0] = -1;
base->th_notify_fd[1] = -1;
event_debug_unassign(&base->th_notify);
}
/* Replace the original evsel. */
base->evsel = evsel;
if (evsel->need_reinit) {
/* Reconstruct the backend through brute-force, so that we do
* not share any structures with the parent process. For some
* backends, this is necessary: epoll and kqueue, for
* instance, have events associated with a kernel
* structure. If didn't reinitialize, we'd share that
* structure with the parent process, and any changes made by
* the parent would affect our backend's behavior (and vice
* versa).
*/
if (base->evsel->dealloc != NULL)
base->evsel->dealloc(base);
base->evbase = evsel->init(base);
if (base->evbase == NULL) {
event_errx(1,
"%s: could not reinitialize event mechanism",
__func__);
res = -1;
goto done;
}
/* Empty out the changelist (if any): we are starting from a
* blank slate. */
event_changelist_freemem_(&base->changelist);
/* Tell the event maps to re-inform the backend about all
* pending events. This will make the signal notification
* event get re-created if necessary. */
if (evmap_reinit_(base) < 0)
res = -1;
} else {
res = evsig_init_(base);
if (res == 0 && had_signal_added) {
res = event_add_nolock_(&base->sig.ev_signal, NULL, 0);
if (res == 0)
base->sig.ev_signal_added = 1;
}
}
/* If we were notifiable before, and nothing just exploded, become
* notifiable again. */
if (was_notifiable && res == 0)
res = evthread_make_base_notifiable_nolock_(base);
done:
EVBASE_RELEASE_LOCK(base, th_base_lock);
return (res);
}