转载请注明出处：http://blog.csdn.net/luotuo44/article/details/39344743
和之前的《Libevent工作流程探究》一样，这里也是用一个例子来探究bufferevent的工作流程。具体的例子可以参考《Libevent使用例子，从简单到复杂》，这里就不列出了。其实要做的例子也就是bufferevent_socket_new、bufferevent_setcb、bufferevent_enable这几个函数。
因为本文会用到《 Libevent工作流程探究》中提到的说法，比如将一个event插入到event_base中。所以读者最好先读一下那篇博文。此外，因为bufferevent结构体本身会使用evbuffer结构体和还会调用相应的一些操作，所以读者还应该先阅读《 evbuffer结构与基本操作》和《 更多evbuffer操作函数》。
bufferevent其实也就是在event_base的基础上再进行一层封装，其本质还是离不开event和event_base，从bufferevent的结构体就可以看到这一点。
bufferevent结构体中有两个event，分别用来监听同一个fd的可读事件和可写事件。为什么不用一个event同时监听可读和可写呢？这是因为监听可写是困难的，下面会说到原因。读者也可以自问一下，自己之前有没有试过用最原始的event监听一个fd的可写。
由于socket 是全双工的，所以在bufferevent结构体中，也有两个evbuffer成员，分别是读缓冲区和写缓冲区。 bufferevent结构体定义如下：
[cpp] view plain copy //bufferevent_struct.h文件 struct bufferevent { struct event_base *ev_base; //操作结构体，成员有一些函数指针。类似struct eventop结构体 const struct bufferevent_ops *be_ops; struct event ev_read;//读事件event struct event ev_write;//写事件event struct evbuffer *input;//读缓冲区 struct evbuffer *output; //写缓冲区 struct event_watermark wm_read;//读水位 struct event_watermark wm_write;//写水位 bufferevent_data_cb readcb;//可读时的回调函数指针 bufferevent_data_cb writecb;//可写时的回调函数指针 bufferevent_event_cb errorcb;//错误发生时的回调函数指针 void *cbarg;//回调函数的参数 struct timeval timeout_read;//读事件event的超时值 struct timeval timeout_write;//写事件event的超时值 /** Events that are currently enabled: currently EV_READ and EV_WRITE are supported. */ short enabled; };
如果看过Libevent的参考手册的话，应该还会知道bufferevent除了用于socket外，还可以用于socketpair 和 filter。如果用面向对象的思维，应从这个三个应用中抽出相同的部分作为父类，然后派生出三个子类。
Libevent虽然是用C语言写的，不过它还是提取出一些公共部分，然后定义一个bufferevent_private结构体，用于保存这些公共部分成员。从集合的角度来说，bufferevent_private应该是bufferevent的一个子集，即一部分。但在Libevent中，bufferevent确实bufferevent_private的一个成员。下面是bufferevent_private结构体。
[cpp] view plain copy //bufferevent-internal.h文件 struct bufferevent_private { struct bufferevent bev; //设置input evbuffer的高水位时，需要一个evbuffer回调函数配合工作 struct evbuffer_cb_entry *read_watermarks_cb; /** If set, we should free the lock when we free the bufferevent. */ //锁是Libevent自动分配的，还是用户分配的 unsigned own_lock : 1; ... //这个socket是否处理正在连接服务器状态 unsigned connecting : 1; //标志连接被拒绝 unsigned connection_refused : 1; //标志是什么原因把 读 挂起来 bufferevent_suspend_flags read_suspended; //标志是什么原因把 写 挂起来 bufferevent_suspend_flags write_suspended; enum bufferevent_options options; int refcnt;// bufferevent的引用计数 //锁变量 void *lock; };函数bufferevent_socket_new可以完成这个工作。
[cpp] view plain copy //bufferevent-internal.h文件 struct bufferevent_ops { const char *type;//类型名称 off_t mem_offset;//成员bev的偏移量 //启动。将event加入到event_base中 int (*enable)(struct bufferevent *, short); //关闭。将event从event_base中删除 int (*disable)(struct bufferevent *, short); //销毁 void (*destruct)(struct bufferevent *); //调整event的超时值 int (*adj_timeouts)(struct bufferevent *); /** Called to flush data. */ int (*flush)(struct bufferevent *, short, enum bufferevent_flush_mode); //获取成员的值。具体看实现 int (*ctrl)(struct bufferevent *, enum bufferevent_ctrl_op, union bufferevent_ctrl_data *); }; //bufferevent_sock.c文件 const struct bufferevent_ops bufferevent_ops_socket = { "socket", evutil_offsetof(struct bufferevent_private, bev), be_socket_enable, be_socket_disable, be_socket_destruct, be_socket_adj_timeouts, be_socket_flush, be_socket_ctrl, }; //由于有几个不同类型的bufferevent，而且它们的enable、disable等操作是不同的。所以 //需要的一些函数指针指明某个类型的bufferevent应该使用哪些操作函数。结构体bufferevent_ops_socket //就应运而生。对于socket，其操作函数如上。 //bufferevent_sock.c文件 struct bufferevent * bufferevent_socket_new(struct event_base *base, evutil_socket_t fd, int options) { struct bufferevent_private *bufev_p; struct bufferevent *bufev; ...//win32 //结构体内存清零，所有成员都为0 if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL) return NULL; //如果options中需要线程安全，那么就会申请锁 //会新建一个输入和输出缓存区 if (bufferevent_init_common(bufev_p, base, &bufferevent_ops_socket, options) < 0) { mm_free(bufev_p); return NULL; } bufev = &bufev_p->bev; //设置将evbuffer的数据向fd传 evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD); //将fd与event相关联。同一个fd关联两个event event_assign(&bufev->ev_read, bufev->ev_base, fd, EV_READ|EV_PERSIST, bufferevent_readcb, bufev); event_assign(&bufev->ev_write, bufev->ev_base, fd, EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev); //设置evbuffer的回调函数，使得外界给写缓冲区添加数据时，能触发 //写操作，这个回调对于写事件的监听是很重要的 evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev); //冻结读缓冲区的尾部，未解冻之前不能往读缓冲区追加数据 //也就是说不能从socket fd中读取数据 evbuffer_freeze(bufev->input, 0); //冻结写缓冲区的头部，未解冻之前不能把写缓冲区的头部数据删除 //也就是说不能把数据写到socket fd evbuffer_freeze(bufev->output, 1); return bufev; } 留意函数里面的evbuffer_add_cb调用，后面会说到。
函数在最后面会冻结两个缓冲区。其实，虽然这里冻结了，但实际上Libevent在读数据或者写数据之前会解冻的读完或者写完数据后，又会马上冻结。这主要防止数据被意外修改。用户一般不会直接调用evbuffer_freeze或者evbuffer_unfreeze函数。一切的冻结和解冻操作都由Libevent内部完成。还有一点要注意，因为这里只是把写缓冲区的头部冻结了。所以还是可以往写缓冲区的尾部追加数据。同样，此时也是可以从读缓冲区读取数据。这个是必须的。因为在Libevent内部不解冻的时候，用户需要从读缓冲区中获取数据(这相当于从socket fd中读取数据)，用户也需要把数据写到写缓冲区中(这相当于把数据写入到socket fd中)。
在bufferevent_socket_new函数里面会调用函数bufferevent_init_common完成公有部分的初始化。
[cpp] view plain copy //bufferevent.c文件 int bufferevent_init_common(struct bufferevent_private *bufev_private, struct event_base *base, const struct bufferevent_ops *ops, enum bufferevent_options options) { struct bufferevent *bufev = &bufev_private->bev; //分配输入缓冲区 if (!bufev->input) { if ((bufev->input = evbuffer_new()) == NULL) return -1; } //分配输出缓冲区 if (!bufev->output) { if ((bufev->output = evbuffer_new()) == NULL) { evbuffer_free(bufev->input); return -1; } } bufev_private->refcnt = 1;//引用次数为1 bufev->ev_base = base; /* Disable timeouts. */ //默认情况下,读和写event都是不支持超时的 evutil_timerclear(&bufev->timeout_read); evutil_timerclear(&bufev->timeout_write); bufev->be_ops = ops; /* * Set to EV_WRITE so that using bufferevent_write is going to * trigger a callback. Reading needs to be explicitly enabled * because otherwise no data will be available. */ //可写是默认支持的 bufev->enabled = EV_WRITE; #ifndef _EVENT_DISABLE_THREAD_SUPPORT if (options & BEV_OPT_THREADSAFE) { //申请锁。 if (bufferevent_enable_locking(bufev, NULL) < 0) { /* cleanup */ evbuffer_free(bufev->input); evbuffer_free(bufev->output); bufev->input = NULL; bufev->output = NULL; return -1; } } #endif ...//延迟调用的初始化，一般不需要用到 bufev_private->options = options; //将evbuffer和bufferevent相关联 evbuffer_set_parent(bufev->input, bufev); evbuffer_set_parent(bufev->output, bufev); return 0; }代码中可以看到，默认是enable EV_WRITE的。
函数bufferevent_setcb完成这个工作。该函数相当简单，也就是进行一些赋值操作。
[cpp] view plain copy //bufferevent.c文件 void bufferevent_setcb(struct bufferevent *bufev, bufferevent_data_cb readcb, bufferevent_data_cb writecb, bufferevent_event_cb eventcb, void *cbarg) { //bufferevent结构体内部有一个锁变量 BEV_LOCK(bufev); bufev->readcb = readcb; bufev->writecb = writecb; bufev->errorcb = eventcb; bufev->cbarg = cbarg; BEV_UNLOCK(bufev); }如果不想设置某个操作的回调函数，直接设置为NULL即可。
相信读者也知道，即使调用了bufferevent_socket_new和bufferevent_setcb，这个bufferevent还是不能工作，必须调用bufferevent_enable。为什么会这样的呢？
如果看过之前的那些博文，相信读者知道，一个event能够工作，不仅仅需要new出来，还要调用event_add函数，把这个event添加到event_base中。在本文前面的代码中，并没有看到event_add函数的调用。所以还需要调用一个函数，把event添加到event_base中。函数bufferevent_enable就是完成这个工作的。
[cpp] view plain copy //bufferevent.c文件 int bufferevent_enable(struct bufferevent *bufev, short event) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); short impl_events = event; int r = 0; //增加引用并加锁 //增加引用是为了防止其他线程调用bufferevent_free，释放了bufferevent _bufferevent_incref_and_lock(bufev); //挂起了读，此时不能监听读事件 if (bufev_private->read_suspended) impl_events &= ~EV_READ; //挂起了写，此时不能监听写事情 if (bufev_private->write_suspended) impl_events &= ~EV_WRITE; bufev->enabled |= event; //调用对应类型的enbale函数。因为不同类型的bufferevent有不同的enable函数 if (impl_events && bufev->be_ops->enable(bufev, impl_events) < 0) r = -1; //减少引用并解锁 _bufferevent_decref_and_unlock(bufev); return r; }上面代码可以看到，最终会调用对应bufferevent类型的enable函数，对于socket bufferevent，其enable函数是be_socket_enable，代码如下：
[cpp] view plain copy //bufferevent.c文件 int _bufferevent_add_event(struct event *ev, const struct timeval *tv) { if (tv->tv_sec == 0 && tv->tv_usec == 0) return event_add(ev, NULL); else return event_add(ev, tv); } //bufferevent_sock.c文件 #define be_socket_add(ev, t) \ _bufferevent_add_event((ev), (t)) static int be_socket_enable(struct bufferevent *bufev, short event) { if (event & EV_READ) { if (be_socket_add(&bufev->ev_read,&bufev->timeout_read) == -1) return -1; } if (event & EV_WRITE) { if (be_socket_add(&bufev->ev_write,&bufev->timeout_write) == -1) return -1; } return 0; }
如果读者熟悉Libevent的超时事件，那么可以知道Libevent是在event_add函数里面确定一个event的超时的。上面代码也展示了这一点，如果读或者写event设置了超时(即其超时值不为0)，那么就会作为参数传给event_add函数。如果读者不熟悉的Libevent的超时事件的话，可以参考《超时event的处理》。
用户可以调用函数bufferevent_set_timeouts，设置读或者写事件的超时。代码如下：
[cpp] view plain copy //bufferevent.c文件 int bufferevent_set_timeouts(struct bufferevent *bufev, const struct timeval *tv_read, const struct timeval *tv_write) { int r = 0; BEV_LOCK(bufev); if (tv_read) { bufev->timeout_read = *tv_read; } else { evutil_timerclear(&bufev->timeout_read); } if (tv_write) { bufev->timeout_write = *tv_write; } else { evutil_timerclear(&bufev->timeout_write); } if (bufev->be_ops->adj_timeouts) r = bufev->be_ops->adj_timeouts(bufev); BEV_UNLOCK(bufev); return r; } //bufferevent_sock.c文件 static int be_socket_adj_timeouts(struct bufferevent *bufev) { int r = 0; //用户监听了读事件 if (event_pending(&bufev->ev_read, EV_READ, NULL)) if (be_socket_add(&bufev->ev_read, &bufev->timeout_read) < 0) r = -1; //用户监听了写事件 if (event_pending(&bufev->ev_write, EV_WRITE, NULL)) { if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) < 0) r = -1; } return r; }从上面代码可以看到：用户不仅仅可以设置超时值，还可以修改超时值，也是通过这个函数进行修的。当然也是可以删除超时的，直接把超时参数设置成NULL即可。
至此，已经完成了bufferevent的初始化工作，只需调用event_base_dispatch函数，启动发动机就可以工作了。
接下来的任务：底层的socket fd接收数据后，bufferevent是怎么工作的。
在讲解读事件之前，先来看一下水位问题，函数bufferevent_setwatermark可以设置读和写的水位。这里只讲解读事件的水位。
水位有两个：低水位和高水位。
低水位比较容易懂，就是当可读的数据量到达这个低水位后，才会调用用户设置的回调函数。比如用户想每次读取100字节，那么就可以把低水位设置为100。当可读数据的字节数小于100时，即使有数据都不会打扰用户(即不会调用用户设置的回调函数)。可读数据大于等于100字节后，才会调用用户的回调函数。
高水位是什么呢？其实，这和用户的回调函数没有关系。它的意义是：把读事件的evbuffer的数据量限制在高水位之下。比如，用户认为读缓冲区不能太大(太大的话，链表会很长)。那么用户就会设置读事件的高水位。当读缓冲区的数据量达到这个高水位后，即使socket fd还有数据没有读，也不会读进这个读缓冲区里面。一句话说，就是控制evbuffer的大小。
虽然控制了evbuffer的大小，但socket fd可能还有数据。有数据就会触发可读事件，但处理可读的时候，又会发现设置了高水位，不能读取数据evbuffer。socket fd的数据没有被读完，又触发……。这个貌似是一个死循环。实际上是不会出现这个死循环的，因为Libevent发现evbuffer的数据量到达高水位后，就会把可读事件给挂起来，让它不能再触发了。Libevent使用函数bufferevent_wm_suspend_read把监听读事件的event挂起来。下面看一下Libevent是怎么把一个event挂起来的。
[cpp] view plain copy //bufferevent-internal.h文件 #define bufferevent_wm_suspend_read(b) \ bufferevent_suspend_read((b), BEV_SUSPEND_WM) //bufferevent.c文件 void bufferevent_suspend_read(struct bufferevent *bufev, bufferevent_suspend_flags what) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); BEV_LOCK(bufev); if (!bufev_private->read_suspended)//不能挂多次 bufev->be_ops->disable(bufev, EV_READ);//实际调用be_socket_disable函数 bufev_private->read_suspended |= what;//因何而被挂起 BEV_UNLOCK(bufev); } //bufferevent_sock.c文件 static int be_socket_disable(struct bufferevent *bufev, short event) { struct bufferevent_private *bufev_p = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); if (event & EV_READ) { if (event_del(&bufev->ev_read) == -1) return -1; } /* Don't actually disable the write if we are trying to connect. */ if ((event & EV_WRITE) && ! bufev_p->connecting) { if (event_del(&bufev->ev_write) == -1)//删掉这个event return -1; } return 0; }居然是直接删除这个监听读事件的event，真的是挂了!!!
看来不能随便设置高水位，因为它会暂停读。如果只想设置低水位而不想设置高水位，那么在调用bufferevent_setwatermark函数时，高水位的参数设为0即可。
那么什么时候取消挂起，让bufferevent可以继续读socket 数据呢？从高水位的意义来说，当然是当evbuffer里面的数据量小于高水位时，就能再次读取socket数据了。现在来看一下Libevent是怎么恢复读的。看一下设置水位的函数bufferevent_setwatermark吧，它进行了一些为高水位埋下了一个回调函数。对，就是evbuffer的回调函数。前一篇博文说到，当evbuffer里面的数据添加或者删除时，是会触发一些回调函数的。当用户移除evbuffer的一些数据量时，Libevent就会检查这个evbuffer的数据量是否小于高水位，如果小于的话，那么就恢复 读事件。
不说这么多了，上代码。
[cpp] view plain copy //bufferevent.c文件 void bufferevent_setwatermark(struct bufferevent *bufev, short events, size_t lowmark, size_t highmark) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); BEV_LOCK(bufev); if (events & EV_READ) { bufev->wm_read.low = lowmark; bufev->wm_read.high = highmark; if (highmark) {//高水位 /* There is now a new high-water mark for read. enable the callback if needed, and see if we should suspend/bufferevent_wm_unsuspend. */ //还没设置高水位的回调函数 if (bufev_private->read_watermarks_cb == NULL) { bufev_private->read_watermarks_cb = evbuffer_add_cb(bufev->input, bufferevent_inbuf_wm_cb, bufev);//添加回调函数 } evbuffer_cb_set_flags(bufev->input, bufev_private->read_watermarks_cb, EVBUFFER_CB_ENABLED|EVBUFFER_CB_NODEFER); //设置(修改)高水位时，evbuffer的数据量已经超过了水位值 //可能是把之前的高水位调高或者调低 //挂起操作和取消挂起操作都是幂等的(即多次挂起的作用等同于挂起一次) if (evbuffer_get_length(bufev->input) > highmark) bufferevent_wm_suspend_read(bufev); else if (evbuffer_get_length(bufev->input) < highmark)//调低了 bufferevent_wm_unsuspend_read(bufev); } else { //高水位值等于0，那么就要取消挂起 读事件 //取消挂起操作是幂等的 /* There is now no high-water mark for read. */ if (bufev_private->read_watermarks_cb) evbuffer_cb_clear_flags(bufev->input, bufev_private->read_watermarks_cb, EVBUFFER_CB_ENABLED); bufferevent_wm_unsuspend_read(bufev); } } BEV_UNLOCK(bufev); }这个函数，不仅仅为高水位设置回调函数，还会检查当前evbuffer的数据量是否超过了高水位。因为这个设置水位函数可能是在bufferevent工作一段时间后才添加的，所以evbuffer是有可能已经有数据的了，因此需要检查。如果超过了水位值，那么就需要挂起读。当然也存在另外一种可能：用户之前设置过了一个比较大的高水位，挂起了读。现在发现错了，就把高水位调低一点，此时就需要恢复读。
现在假设用户移除了一些evbuffer的数据，进而触发了evbuffer的回调函数，当然也就调用了函数bufferevent_inbuf_wm_cb。下面看一下这个函数是怎么恢复读的。
[cpp] view plain copy //bufferevent.c文件 static void bufferevent_inbuf_wm_cb(struct evbuffer *buf, const struct evbuffer_cb_info *cbinfo, void *arg) { struct bufferevent *bufev = arg; size_t size; size = evbuffer_get_length(buf); if (size >= bufev->wm_read.high) bufferevent_wm_suspend_read(bufev); else bufferevent_wm_unsuspend_read(bufev); } //bufferevent-internal.h文件 #define bufferevent_wm_unsuspend_read(b) \ bufferevent_unsuspend_read((b), BEV_SUSPEND_WM) //bufferevent.c文件 void bufferevent_unsuspend_read(struct bufferevent *bufev, bufferevent_suspend_flags what) { struct bufferevent_private *bufev_private = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); BEV_LOCK(bufev); bufev_private->read_suspended &= ~what; if (!bufev_private->read_suspended && (bufev->enabled & EV_READ)) bufev->be_ops->enable(bufev, EV_READ);//重新把event插入到event_base中 BEV_UNLOCK(bufev); }因为用户可以手动为这个evbuffer添加数据，此时也会调用bufferevent_inbuf_wm_cb函数。此时就要检查evbuffer的数据量是否已经超过高水位了，而不能仅仅检查是否低于高水位。
高水位导致读的挂起和之后读的恢复，一切工作都是由Libevent内部完成的，用户不用做任何工作。
从前面的一系列博文可以知道，如果一个socket可读了，那么监听可读事件的event的回调函数就会被调用。这个回调函数是在bufferevent_socket_new函数中被Libevent内部设置的，设置为bufferevent_readcb函数，用户并不知情。
当socket有数据可读时，Libevent就会监听到，然后调用bufferevent_readcb函数处理。该函数会调用evbuffer_read函数，把数据从socket fd中读取到evbuffer中。然后再调用用户在bufferevent_setcb函数中设置的读事件回调函数。所以，当用户的读事件回调函数被调用时，数据已经在evbuffer中了，用户拿来就用，无需调用read这类会阻塞的函数。
下面看一下bufferevent_readcb函数的具体实现。 [cpp] view plain copy static void bufferevent_readcb(evutil_socket_t fd, short event, void *arg) { struct bufferevent *bufev = arg; struct bufferevent_private *bufev_p = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); struct evbuffer *input; int res = 0; short what = BEV_EVENT_READING; ev_ssize_t howmuch = -1, readmax=-1; _bufferevent_incref_and_lock(bufev); if (event == EV_TIMEOUT) { /* Note that we only check for event==EV_TIMEOUT. If * event==EV_TIMEOUT|EV_READ, we can safely ignore the * timeout, since a read has occurred */ what |= BEV_EVENT_TIMEOUT; goto error; } input = bufev->input; //用户设置了高水位 if (bufev->wm_read.high != 0) { howmuch = bufev->wm_read.high - evbuffer_get_length(input); /* we somehow lowered the watermark, stop reading */ if (howmuch <= 0) { bufferevent_wm_suspend_read(bufev); goto done; } } //因为用户可以限速，所以这么要检测最大的可读大小。 //如果没有限速的话，那么将返回16384字节，即16K //默认情况下是没有限速的。 readmax = _bufferevent_get_read_max(bufev_p); if (howmuch < 0 || howmuch > readmax) /* The use of -1 for "unlimited" * uglifies this code. XXXX */ howmuch = readmax; //一些原因导致读 被挂起，比如加锁了。 if (bufev_p->read_suspended) goto done; //解冻，使得可以在input的后面追加数据 evbuffer_unfreeze(input, 0); res = evbuffer_read(input, fd, (int)howmuch); //从socket fd中读取数据 evbuffer_freeze(input, 0);//冻结 if (res == -1) { int err = evutil_socket_geterror(fd); if (EVUTIL_ERR_RW_RETRIABLE(err))//EINTER or EAGAIN goto reschedule; //不是 EINTER or EAGAIN 这两个可以重试的错误，那么就应该是其他致命的错误 //此时，应该报告给用户 what |= BEV_EVENT_ERROR;/**< unrecoverable error encountered */ } else if (res == 0) {//断开了连接 what |= BEV_EVENT_EOF; } if (res <= 0) goto error; //速率相关的操作 _bufferevent_decrement_read_buckets(bufev_p, res); //evbuffer的数据量大于低水位值。 if (evbuffer_get_length(input) >= bufev->wm_read.low) _bufferevent_run_readcb(bufev);//调用用户设置的回调函数 goto done; reschedule: goto done; error: //把监听可读事件的event从event_base的事件队列中删除掉.event_del bufferevent_disable(bufev, EV_READ);//会调用be_socket_disable函数 _bufferevent_run_eventcb(bufev, what);//会调用用户设置的错误处理函数 done: _bufferevent_decref_and_unlock(bufev); }细心的读者可能会发现：对用户的读事件回调函数的触发是边缘触发的。这也就要求，在回调函数中，用户应该尽可能地把evbuffer的所有数据都读出来。如果想等到下一次回调时再读，那么需要等到下一次socketfd接收到数据才会触发用户的回调函数。如果之后socket fd一直收不到任何数据，那么即使evbuffer还有数据，用户的回调函数也不会被调用了。
对一个可读事件进行监听是比较容易的，但对于一个可写事件进行监听则比较困难。为什么呢？因为可读监听是监听fd的读缓冲区是否有数据了，如果没有数据那么就一直等待。对于可写，首先要明白“什么是可写”，可写就是fd的写缓冲区(这个缓冲区在内核)还没满，可以往里面放数据。这就有一个问题，如果写缓冲区没有满，那么就一直是可写状态。如果一个event监听了可写事件，那么这个event就会一直被触发（死循环）。因为一般情况下，如果不是发大量的数据这个写缓冲区是不会满的。
也就是说，不能监听可写事件。但我们确实要往fd中写数据，那怎么办？Libevent的做法是：当我们确实要写入数据时，才监听可写事件。也就是说我们调用bufferevent_write写入数据时，Libevent才会把监听可写事件的那个event注册到event_base中。当Libevent把数据都写入到fd的缓冲区后，Libevent又会把这个event从event_base中删除。比较烦琐。
bufferevent_writecb函数不仅仅要处理上面说到的那个问题，还要处理另外一个坑爹的问题。那就是：判断socket fd是不是已经连接上服务器了。这是因为这个socket fd是非阻塞的，所以它调用connect时，可能还没连接上就返回了。对于非阻塞socket fd，一般是通过判断这个socket是否可写，从而得知这个socket是否已经连接上服务器。如果可写，那么它就已经成功连接上服务器了。这个问题，这里先提一下，后面会详细讲。
同前面的监听可读一样，Libevent是在bufferevent_socket_new函数设置可写的回调函数，为bufferevent_writecb。
[cpp] view plain copy //bufferevent_sock.c文件 static void bufferevent_writecb(evutil_socket_t fd, short event, void *arg) { struct bufferevent *bufev = arg; struct bufferevent_private *bufev_p = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); int res = 0; short what = BEV_EVENT_WRITING; int connected = 0; ev_ssize_t atmost = -1; _bufferevent_incref_and_lock(bufev); if (event == EV_TIMEOUT) { /* Note that we only check for event==EV_TIMEOUT. If * event==EV_TIMEOUT|EV_WRITE, we can safely ignore the * timeout, since a read has occurred */ what |= BEV_EVENT_TIMEOUT; goto error; } ...//判断这个socket是否已经连接上服务器了 //用户可能设置了限速，如果没有限速，那么atmost将返回16384(16K) atmost = _bufferevent_get_write_max(bufev_p); //一些原因导致写被挂起来了 if (bufev_p->write_suspended) goto done; //如果evbuffer有数据可以写到sockfd中 if (evbuffer_get_length(bufev->output)) { //解冻链表头 evbuffer_unfreeze(bufev->output, 1); //将output这个evbuffer的数据写到socket fd 的缓冲区中 //会把已经写到socket fd缓冲区的数据，从evbuffer中删除 res = evbuffer_write_atmost(bufev->output, fd, atmost); evbuffer_freeze(bufev->output, 1); if (res == -1) { int err = evutil_socket_geterror(fd); if (EVUTIL_ERR_RW_RETRIABLE(err))//可以恢复的错误。一般是EINTR或者EAGAIN goto reschedule; what |= BEV_EVENT_ERROR; } else if (res == 0) {//该socket已经断开连接了 what |= BEV_EVENT_EOF; } if (res <= 0) goto error; } //如果把写缓冲区的数据都写完成了。为了防止event_base不断地触发可写 //事件，此时要把这个监听可写的event删除。 //前面的atmost限制了一次最大的可写数据。如果还没写所有的数据 //那么就不能delete这个event，而是要继续监听可写事情，知道把所有的 //数据都写到socket fd中。 if (evbuffer_get_length(bufev->output) == 0) { event_del(&bufev->ev_write); } //如果evbuffer里面的数据量已经写得七七八八了，小于设置的低水位值，那么 //就会调用用户设置的写事件回调函数 if ((res || !connected) && evbuffer_get_length(bufev->output) <= bufev->wm_write.low) { _bufferevent_run_writecb(bufev); } goto done; reschedule: if (evbuffer_get_length(bufev->output) == 0) { event_del(&bufev->ev_write); } goto done; error: bufferevent_disable(bufev, EV_WRITE);//有错误。把这个写event删除 _bufferevent_run_eventcb(bufev, what); done: _bufferevent_decref_and_unlock(bufev); }上面代码的逻辑比较清晰，调用evbuffer_write_atmost函数把数据从evbuffer中写到evbuffer缓冲区中，此时要注意函数的返回值，因为可能写的时候发生错误。如果发生了错误，就要调用用户设置的event回调函数(网上也有人称其为错误处理函数)。
之后，还要判断evbuffer的数据是否已经全部写到socket 的缓冲区了。如果已经全部写了，那么就要把监听写事件的event从event_base的插入队列中删除。如果还没写完，那么就不能删除，因为还要继续监听可写事件，下次接着写。
现在来看一下，把监听写事件的event从event_base的插入队列中删除后，如果下次用户有数据要写的时候，怎么把这个event添加到event_base的插入队列。
用户一般是通过bufferevent_write函数把数据写入到evbuffer(写入evbuffer后，接着就会被写入socket，所以调用bufferevent_write就相当于把数据写入到socket。)。而这个bufferevent_write函数是直接调用evbuffer_add函数的。函数evbuffer_add没有调用什么可疑的函数，能够把监听可写的event添加到event_base中。唯一的可能就是那个回调函数。对就是evbuffer的回调函数。关于evbuffer的回调函数，可以参考这里。
[cpp] view plain copy //bufferevent.c文件 int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size) { if (evbuffer_add(bufev->output, data, size) == -1) return (-1); return 0; } //buffer.c文件 int evbuffer_add(struct evbuffer *buf, const void *data_in, size_t datlen) { ... out: evbuffer_invoke_callbacks(buf);//调用回调函数 result = 0; done: return result; }还记得本文前面的bufferevent_socket_new函数吗？该函数里面会有
[cpp] view plain copy evbuffer_add_cb(bufev->output,bufferevent_socket_outbuf_cb, bufev);当bufferevent的写缓冲区output的数据发生变化时，函数bufferevent_socket_outbuf_cb就会被调用。现在马上飞到这个函数。
[cpp] view plain copy //bufferevent_sock.c文件 static void bufferevent_socket_outbuf_cb(struct evbuffer *buf, const struct evbuffer_cb_info *cbinfo, void *arg) { struct bufferevent *bufev = arg; struct bufferevent_private *bufev_p = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); if (cbinfo->n_added && //evbuffer添加了数据 (bufev->enabled & EV_WRITE) && //默认情况下是enable EV_WRITE的 !event_pending(&bufev->ev_write, EV_WRITE, NULL) &&//这个event已经被踢出event_base了 !bufev_p->write_suspended) {//这个bufferevent的写并没有被挂起 //把这个event添加到event_base中 if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) == -1) { /* Should we log this? */ } } }这个函数首先进行一些判断，满足条件后就会把这个监听写事件的event添加到event_base中。其中event_pending函数就是判断这个bufev->ev_write是否已经被event_base删除了。关于event_pending，可以参考这里。
对于bufferevent_write，初次使用该函数的读者可能会有疑问：调用该函数后，参数data指向的内存空间能不能马上释放，还是要等到Libevent把data指向的数据都写到socket 缓存区才能删除？其实，从前一篇博文可以看到，evbuffer_add是直接复制一份用户要发送的数据到evbuffer缓存区的。所以，调用完bufferevent_write，就可以马上释放参数data指向的内存空间。
网上的关于Libevent的一些使用例子，包括我写的《 Libevent使用例子，从简单到复杂》，都是在主线程中调用bufferevent_write函数写入数据的。从上面的分析可以得知，是可以马上把监听可写事件的event添加到event_base中。如果是在次线程调用该函数写入数据呢？此时，主线程可能还睡眠在poll、epoll这类的多路IO复用函数上。这种情况下能不能及时唤醒主线程呢？其实是可以的，只要你的Libevent在一开始使用了线程功能。具体的分析过程可以参考《evthread_notify_base通知主线程》。上面代码中的be_socket_add会调用event_add，而在次线程调用event_add就会调用evthread_notify_base通知主线程。
用户可以在调用bufferevent_socket_new函数时，传一个-1作为socket的文件描述符，然后调用bufferevent_socket_connect函数连接服务器，无需自己写代码调用connect函数连接服务器。
bufferevent_socket_connect函数会调用socket函数申请一个套接字fd，然后把这个fd设置成非阻塞的(这就导致了一些坑爹的事情)。接着就connect服务器，因为该socket fd是非阻塞的，所以不会等待，而是马上返回，连接这工作交给内核来完成。所以，返回后这个socket还没有真正连接上服务器。那么什么时候连接上呢？内核又是怎么通知通知用户呢？
一般来说，当可以往socket fd写东西了，那就说明已经连接上了。也就是说这个socket fd变成可写状态，就连接上了。
所以，对于“非阻塞connect”比较流行的做法是：用select或者poll这类多路IO复用函数监听该socket的可写事件。当这个socket触发了可写事件，然后再对这个socket调用getsockopt函数，做进一步的判断。
Libevent也是这样实现的，下面来看一下bufferevent_socket_connect函数。 [cpp] view plain copy //bufferevent_sock.c文件 int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *sa, int socklen) { struct bufferevent_private *bufev_p = EVUTIL_UPCAST(bev, struct bufferevent_private, bev); evutil_socket_t fd; int r = 0; int result=-1; int ownfd = 0; _bufferevent_incref_and_lock(bev); if (!bufev_p) goto done; fd = bufferevent_getfd(bev); if (fd < 0) {//该bufferevent还没有设置fd if (!sa) goto done; fd = socket(sa->sa_family, SOCK_STREAM, 0); if (fd < 0) goto done; if (evutil_make_socket_nonblocking(fd)<0)//设置为非阻塞 goto done; ownfd = 1; } if (sa) { r = evutil_socket_connect(&fd, sa, socklen);//非阻塞connect if (r < 0) goto freesock; } ... //为bufferevent里面的两个event设置监听的fd //后面会调用bufferevent_enable bufferevent_setfd(bev, fd); if (r == 0) {//暂时还没连接上，因为fd是非阻塞的 //此时需要监听可写事件，当可写了，并且没有错误的话，就成功连接上了 if (! be_socket_enable(bev, EV_WRITE)) { bufev_p->connecting = 1;//标志这个sockfd正在连接 result = 0; goto done; } } else if (r == 1) {//已经连接上了 /* The connect succeeded already. How very BSD of it. */ result = 0; bufev_p->connecting = 1; event_active(&bev->ev_write, EV_WRITE, 1);//手动激活这个event } else {// connection refused /* The connect failed already. How very BSD of it. */ bufev_p->connection_refused = 1; bufev_p->connecting = 1; result = 0; event_active(&bev->ev_write, EV_WRITE, 1);//手动激活这个event } goto done; freesock: _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);//出现错误 if (ownfd) evutil_closesocket(fd); done: _bufferevent_decref_and_unlock(bev); return result; }这个函数比较多错误处理的代码，大致看一下就行了。有几个地方要注意，即使connect的时候被拒绝，或者已经连接上了，都会手动激活这个event。一个event即使没有加入event_base，也是可以手动激活的。具体原理参考这里。
无论是手动激活event，或者监听到这个event可写了，都是会调用bufferevent_writecb函数。现在再次看一下该函数，只看connect部分。
[cpp] view plain copy //bufferevent_sock.c文件 static void bufferevent_writecb(evutil_socket_t fd, short event, void *arg) { struct bufferevent_private *bufev_p = EVUTIL_UPCAST(bufev, struct bufferevent_private, bev); int connected = 0; _bufferevent_incref_and_lock(bufev); ... //正在连接。因为这个sockfd可能是非阻塞的，所以可能之前的connect还没 //连接上。而判断该sockfd是否成功连接上了的一个方法是判断这个sockfd是否可写 if (bufev_p->connecting) { //c等于1，说明已经连接成功 //c等于0，说明还没连接上 //c等于-1，说明发生错误 int c = evutil_socket_finished_connecting(fd); if (bufev_p->connection_refused) {//在bufferevent_socket_connect中被设置 bufev_p->connection_refused = 0; c = -1; } if (c == 0)//还没连接上，继续监听可写吧 goto done; //错误，或者已经连接上了 bufev_p->connecting = 0;//修改标志值 if (c < 0) {//错误 event_del(&bufev->ev_write); event_del(&bufev->ev_read); _bufferevent_run_eventcb(bufev, BEV_EVENT_ERROR); goto done; } else {//连接上了。 connected = 1; ...//win32 //居然会调用用户设置的错误处理函数。太神奇了 _bufferevent_run_eventcb(bufev, BEV_EVENT_CONNECTED); if (!(bufev->enabled & EV_WRITE) || //默认都是enable EV_WRITE的 bufev_p->write_suspended) { event_del(&bufev->ev_write);//不再需要监听可写。因为已经连接上了 goto done; } } } ... done: _bufferevent_decref_and_unlock(bufev); }可以看到无论是connect被拒绝、发生错误或者连接上了，都在这里做统一的处理。
如果已经连接上了，那么会调用用户设置event回调函数(网上也称之为错误处理函数)，通知用户已经连接上了。并且，还会把监听可写事件的event从event_base中删除，其理由在前面已经说过了。
函数evutil_socket_finished_connecting会检查这个socket，从而得知这个socket是处于什么状态。在bufferevent_socket_connect函数中，出现的一些错误，比如被拒绝，也是能通过这个函数检查出来的。所以可以在这里做统一的处理。该函数的内部是使用。贴一下这个函数的代码吧。
[cpp] view plain copy //evutil.c文件 //Return 1 for connected, 0 for not yet, -1 for error. int evutil_socket_finished_connecting(evutil_socket_t fd) { int e; ev_socklen_t elen = sizeof(e); //用来检测这个fd是否已经连接上了，这个fd是非阻塞的 //如果e的值被设为0，那么就说明连接上了。 //否则e被设置为对应的错误值。 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&e, &elen) < 0) return -1; if (e) { if (EVUTIL_ERR_CONNECT_RETRIABLE(e))//还没连接上 return 0; EVUTIL_SET_SOCKET_ERROR(e); return -1; } return 1; }