Libevent

了解libevent

什么是libevent

Libevent 是一个用C语言编写的、轻量级的开源高性能事件通知库，主要有以下几个亮点：

事件驱动（ event-driven），高性能;
轻量级，专注于网络，不如 ACE 那么臃肿庞大；
源代码相当精炼、易读；
跨平台，支持 Windows、 Linux、 *BSD 和 Mac Os；
支持多种 I/O 多路复用技术， epoll、 poll、 dev/poll、 select 和 kqueue 等；
支持 I/O，定时器和信号等事件；
注册事件优先级。

Chromium、Memcached、NTP、HTTPSQS等著名的开源程序都使用libevent库，足见libevent的稳定。更多使用libevent的程序可以到libevent的官网查看。

Libevent主要组成

libevent包括事件管理、缓存管理、DNS、HTTP、缓存事件几大部分。

事件管理包括各种IO（socket）、定时器、信号等事件；
缓存管理是指evbuffer功能；
DNS是libevent提供的一个异步DNS查询功能；
HTTP是libevent的一个轻量级http实现，包括服务器和客户端。

libevent也支持ssl，这对于有安全需求的网络程序非常的重要，但是其支持不是很完善，比如http server的实现就不支持ssl。

Libevent的核心实现

Reactor（反应堆）模式是libevent的核心框架，libevent以事件驱动，自动触发回调功能。之前介绍的epoll反应堆的源码，就是从libevent中抽取出来的。

安装libevent

官方网站: http://libevent.org

源码下载主要分2个大版本：

1.4.x 系列，较为早期版本，适合源码学习
2.x 系列，较新的版本，代码量比1.4版本多很多，功能也更完善。

源码包的安装，以2.0.22版本为例，在官网可以下载到源码包libevent-2.0.22-stable.tar.gz，基本安装步骤与第三方库源码包安装方式基本一致。

解压源码包
shell
tar -xzvf libevent-2.0.22-stable.tar.gz
进入到源码目录
shell
cd libevent-2.0.22-stable
执行配置./configure，生成makefile
shell
./configure
执行配置./configure的时间遇到错误
shell
checking for openssl/ssl.h... no
configure: error: openssl is a must but can not be found. You should add the directory containing `openssl.pc' to the `PKG_CONFIG_PATH' environment variable, or set `CFLAGS' and `LDFLAGS' directly for openssl, or use `--disable-openssl' to disable support for openssl encryption
此时需要安装ssl库
shell
sudo apt install libssl-dev
安装完成以后再次执行配置./configure即可
也可以指定具体路径，这样安装的时候，将统一安装到指定路径例如：./configure --prefix=/usr/local/libevent，这样的好处是以后打包安装好的文件方便，不好的地方是由于安装的目录有可能不是系统头文件或库文件的目录，使用的时候需要增加gcc选项来包含头文件路径和库文件路径，以及需要解决动态库不能加载的问题，参考第三天内容，动态库不能加载怎么办?
编译源码
shell
make
编译后安装，输入本用户的密码
shell
sudo make install
安装后验证，简单的先编译一个文件
cpp
#include <event.h>
#include <stdio.h>
                    
int main(int argc, char* argv[]) {
    char ** methods = event_get_supported_methods();//获取libevent后端支持的方法
    int i =0;
    for(i = 0;methods[i] != NULL ;i++) {
        printf("%s\n",methods[i]);
    }
                    
    return 0;
}
编译：
shell
$ gcc testInstall.c -o a -levent
$ ./a
epoll
poll
select
能看到libevent在当前主机上后端支持的多路IO方法。

Libevent的基础使用

Libevent的地基-event_base

在使用libevent的函数之前，需要先申请一个或event_base结构，相当于盖房子时的地基。在event_base基础上会有一个事件集合，可以检测哪个事件是激活的（就绪）。

通常情况下可以通过event_base_new函数获得event_base结构。

struct event_base *event_base_new(void);

申请到event_base结构指针可以通过event_base_free进行释放。

void event_base_free(struct event_base *);

如果fork出子进程，想在子进程继续使用event_base，那么子进程需要对event_base重新初始化，函数如下：

int event_reinit(struct event_base *base);

对于不同系统而言，event_base就是调用不同的多路IO接口去判断事件是否已经被激活，对于linux系统而言，核心调用的就是epoll，同时支持poll和select。

等待事件产生-循环等待event_loop

Libevent在地基打好之后，需要等待事件的产生，也就是等待想要等待的事件的激活，那么程序不能退出，对于epoll来说，我们需要自己控制循环，而在libevent中也给我们提供了api接口，类似where(1)的功能。函数如下：

int event_base_loop(struct event_base *base, int flags);

flags的取值：

#define EVLOOP_ONCE 0x01

只触发一次，如果事件没有被触发，阻塞等待

#define EVLOOP_NONBLOCK 0x02

非阻塞方式检测事件是否被触发，不管事件触发与否，都会立即返回

而大多数我们都调用libevent给我们提供的另外一个api：

int event_base_dispatch(struct event_base *base);

调用该函数，相当于没有设置标志位的event_base_loop。程序将会一直运行，直到没有需要检测的事件了，或者被结束循环的api终止。

int event_base_loopexit(struct event_base *base, const struct timeval *tv);
int event_base_loopbreak(struct event_base *base);

struct timeval {
    long    tv_sec;                    
    long    tv_usec;            
};

两个函数的区别是如果正在执行激活事件的回调函数，那么event_base_loopexit将在事件回调执行结束后终止循环（如果tv时间非NULL，那么将等待tv设置的时间后立即结束循环），而event_base_loopbreak会立即终止循环。

事件驱动-event

事件驱动实际上是libevent的核心思想，本小节主要介绍基本的事件event。

主要的状态转化：

主要几个状态：

无效的指针此时仅仅是定义了 struct event *ptr；

非未决：相当于创建了事件，但是事件还没有处于被监听状态，类似于我们使用epoll的时候定义了struct epoll_event ev并且对ev的两个字段进行了赋值，但是此时尚未调用epoll_ctl。
未决：就是对事件开始监听，暂时未有事件产生。相当于调用epoll_ctl。
激活：代表监听的事件已经产生，这时需要处理，相当于我们epoll所说的事件就绪。

Libevent的事件驱动对应的结构体为struct event，对应的函数在图上也比较清晰，下面介绍一下主要的函数

event_new

 struct event *event_new(struct event_base *base, evutil_socket_t fd, short events, event_callback_fn cb, void *arg);

event_new负责新创建event结构指针，同时指定对应的地基base，还有对应的文件描述符，事件，以及回调函数和回调函数的参数。参数说明：

base 对应的根节点
fd 要监听的文件描述符
events 要监听的事件

  #define  EV_TIMEOUT         0x01   //超时事件
  #define  EV_READ            0x02 //读事件
  #define  EV_WRITE           0x04  //写事件
  #define  EV_SIGNAL          0x08     //信号事件
  #define  EV_PERSIST         0x10   //周期性触发
  #define  EV_ET              0x20 //边缘触发，如果底层模型支持

cb 回调函数，原型如下：

typedef void (*event_callback_fn)(evutil_socket_t fd, short events, void *arg);

arg 回调函数的参数

event_add
c
```
int event_add(struct event *ev, const struct timeval *timeout);
```
将非未决态事件转为未决态，相当于调用epoll_ctl函数，开始监听事件是否产生。
参数说明：
- Ev 就是前面event_new创建的事件
- Timeout 限时等待事件的产生，也可以设置为NULL，没有限时。
event_del
c
```
int event_del(struct event *ev);
```
将事件从未决态变为非未决态，相当于epoll的下树（epoll_ctl调用EPOLL_CTL_DEL操作）操作。
event_free
c
```
void event_free(struct event *ev);
```
释放event_new申请的event节点。

基于以上函数，可以写一个简易的事件驱动的网络服务器端程序。

//02_event_server.c
//用libevent写一下简易的服务器
#include <event.h>
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

struct event *readev = NULL;

void readcb(evutil_socket_t fd, short event, void * arg) {
    //处理读事件
    char buf[256] = { 0 };
    int ret = read(fd, buf, sizeof(buf));
    if (ret < 0){
        perror("read err");
        close(fd);
        event_del(readev);
    }
    else if (ret == 0){
        printf("client closed\n");
        close(fd);
        event_del(readev);
    }
    else{
        write(fd, buf, ret);//反射
    }
}

void conncb(evutil_socket_t fd, short event, void * arg) {
    //处理连接
    struct event_base *base = (struct event_base*)arg;
    struct sockaddr_in client;
    socklen_t  len = sizeof(client);
    int cfd = accept(fd, (struct sockaddr*)&client, &len);
    if (cfd > 0){
        //连接成功
        //需要将新的文件描述符上树
        readev = event_new(base, cfd, EV_READ | EV_PERSIST, readcb, base);
        event_add(readev, NULL);
    }
}

int main(int argc, char* argv[]) {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in serv;
    bzero(&serv, sizeof(serv));
    serv.sin_addr.s_addr = htonl(INADDR_ANY);
    serv.sin_port = htons(8888);
    serv.sin_family = AF_INET;

    bind(fd, (struct sockaddr*)&serv, sizeof(serv));

    listen(fd, 120);
    struct event_base *base = event_base_new();//创建根节点

    //struct event *event_new(struct event_base *, evutil_socket_t, short, event_callback_fn, void *);
    struct event *connev = event_new(base, fd, EV_READ | EV_PERSIST, conncb, base);
    event_add(connev, NULL);//开始监听
    //循环
    event_base_dispatch(base);
    event_base_free(base);//释放
    event_free(connev);
    event_free(readev);
    
    return 0;
}

自带buffer的事件-bufferevent

Bufferevent实际上也是一个event，只不过比普通的event高级一些，它的内部有两个缓冲区，以及一个文件描述符（网络套接字）。我们都知道一个网络套接字有读和写两个缓冲区，bufferevent同样也带有两个缓冲区，还有就是libevent事件驱动的核心回调函数，那么四个缓冲区以及触发回调的关系如下：

bufferevent

bufferevent有三个回调函数：

读回调 – 当bufferevent将底层读缓冲区的数据读到自身的读缓冲区时触发读事件回调
写回调 – 当bufferevent将自身写缓冲的数据写到底层写缓冲区的时候出发写事件回调
事件回调 – 当bufferevent绑定的socket连接，断开或者异常的时候触发事件回调

主要使用的函数如下：
struct bufferevent *bufferevent_socket_new(struct event_base *base, evutil_socket_t fd, int options);
bufferevent_socket_new对已经存在socket创建bufferevent事件，可用于后面讲到的链接监听器的回调函数中，参数说明：
base – 对应根节点
fd -- 文件描述符
options – bufferevent的选项
BEV_OPT_CLOSE_ON_FREE -- 释放bufferevent自动关闭底层接口
BEV_OPT_THREADSAFE -- 使bufferevent能够在多线程下是安全的
int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *serv, int socklen);
bufferevent_socket_connect封装了底层的socket与connect接口，通过调用此函数，可以将bufferevent事件与通信的socket进行绑定，参数如下：
bev – 需要提前初始化的bufferevent事件
serv – 对端的ip地址，端口，协议的结构指针
socklen – 描述serv的长度
void bufferevent_free(struct bufferevent *bufev);
释放bufferevent
void bufferevent_setcb(struct bufferevent *bufev, bufferevent_data_cb readcb, bufferevent_data_cb writecb, bufferevent_event_cb eventcb, void *cbarg);
bufferevent_setcb用于设置bufferevent的回调函数，readcb，writecb，eventcb分别对应了读回调，写回调，事件回调，cbarg代表回调函数的参数。
回调函数的原型：
c
typedef void (*bufferevent_data_cb)(struct bufferevent *bev, void *ctx);
typedef void (*bufferevent_event_cb)(struct bufferevent *bev, short what, void *ctx);
What 代表对应的事件BEV_EVENT_EOF, BEV_EVENT_ERROR，BEV_EVENT_TIMEOUT, BEV_EVENT_CONNECTED
int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size);
bufferevent_write是将data的数据写到bufferevent的写缓冲区
int bufferevent_write_buffer(struct bufferevent *bufev, struct evbuffer *buf);
bufferevent_write_buffer 是将数据写到写缓冲区另外一个写法，实际上bufferevent的内部的两个缓冲区结构就是struct evbuffer。
size_t bufferevent_read(struct bufferevent *bufev, void *data, size_t size);bufferevent_read 是将bufferevent的读缓冲区数据读到data中，同时将读到的数据从bufferevent的读缓冲清除。
int bufferevent_read_buffer(struct bufferevent *bufev, struct evbuffer *buf);bufferevent_read_buffer 将bufferevent读缓冲数据读到buf中，接口的另外一种。
int bufferevent_enable(struct bufferevent *bufev, short event);
int bufferevent_disable(struct bufferevent *bufev, short event);bufferevent_enable与bufferevent_disable是设置事件是否生效，如果设置为disable，事件回调将不会被触发。

链接监听器-evconnlistener

链接监听器封装了底层的socket通信相关函数，比如socket，bind，listen，accept这几个函数。链接监听器创建后实际上相当于调用了socket，bind，listen，此时等待新的客户端连接到来，如果有新的客户端连接，那么内部先进行accept处理，然后调用用户指定的回调函数。可以先看看函数原型，了解一下它是怎么运作的：

c
```
 struct evconnlistener *evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb, void *ptr, unsigned flags, int backlog, const struct sockaddr *sa, int socklen);
```
- evconnlistener_new_bind是在当前没有套接字的情况下对链接监听器进行初始化，看最后2个参数实际上就是bind使用的关键参数，backlog是listen函数的关键参数（略有不同的是，如果backlog是-1，那么监听器会自动选择一个合适的值，如果填0，那么监听器会认为listen函数已经被调用过了），ptr是回调函数的参数，cb是有新连接之后的回调函数，但是注意这个回调函数触发的时候，链接器已经处理好新连接了，并将与新连接通信的描述符交给回调函数。Flags 需要参考几个值：
  - LEV_OPT_LEAVE_SOCKETS_BLOCKING 文件描述符为阻塞的
  - LEV_OPT_CLOSE_ON_FREE 关闭时自动释放
  - LEV_OPT_REUSEABLE 端口复用
  - LEV_OPT_THREADSAFE 分配锁，线程安全
c
```
 struct evconnlistener *evconnlistener_new(struct event_base *base,evconnlistener_cb cb, void *ptr, unsigned flags, int backlog, evutil_socket_t fd);
```
- evconnlistener_new函数与前一个函数不同的地方在与后2个参数，使用本函数时，认为socket已经初始化好，并且bind完成，甚至也可以做完listen，所以大多数时候，我们都可以使用第一个函数。
两个函数的回调函数
c
```
typedef void (*evconnlistener_cb)(struct evconnlistener *evl, evutil_socket_t fd, struct sockaddr *cliaddr, int socklen, void *ptr);
```
- 主要回调函数fd参数会与客户端通信的描述符，并非是等待连接的监听的那个描述符，所以cliaddr对应的也是新连接的对端地址信息，已经是accept处理好的。
void evconnlistener_free(struct evconnlistener *lev);释放链接监听器
int evconnlistener_enable(struct evconnlistener *lev);使链接监听器生效
int evconnlistener_disable(struct evconnlistener *lev);使链接监听器失效

如果上述函数都较为了解了，可以尝试去看懂hello-world.c的代码，在安装包的sample目录下，其中有涉及到信号的函数，看看自己能否找到函数的原型在哪？实际上就是一个宏定义，也是我们之前介绍的event_new函数，只是对应一个信号事件而已，处理机制略有不同。

#define evsignal_new(b, x, cb, arg)             \
    event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))

基于bufferevent的服务器和客户端实现

基于bufferevent的服务器

// 03_bufferevent_server.c
#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <event2/buffer.h>
#include <event2/bufferevent.h>
#include <event2/event.h>
#include <event2/listener.h>
#include <event2/util.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>

static const char MESSAGE[] = "Hello, World!\n";

static const int PORT = 9995;

static void listener_cb(struct evconnlistener *, evutil_socket_t,
                        struct sockaddr *, int socklen, void *);
static void conn_writecb(struct bufferevent *, void *);
static void conn_readcb(struct bufferevent *, void *);
static void conn_eventcb(struct bufferevent *, short, void *);
static void signal_cb(evutil_socket_t, short, void *);

int main(int argc, char **argv) {
    struct event_base *base;        //根节点定义
    struct evconnlistener *listener;//监听器定义
    struct event *signal_event;     //信号事件

    struct sockaddr_in sin;

    base = event_base_new();//创建根节点
    if (!base) {
        fprintf(stderr, "Could not initialize libevent!\n");
        return 1;
    }

    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_port = htons(PORT);

    //创建监听器-端口复用-关闭自动释放
    listener = evconnlistener_new_bind(base, listener_cb, (void *) base,
                                       LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE, -1,
                                       (struct sockaddr *) &sin,
                                       sizeof(sin));

    if (!listener) {
        fprintf(stderr, "Could not create a listener!\n");
        return 1;
    }

    //定义信号回调事件 -SIGINT
    signal_event = evsignal_new(base, SIGINT, signal_cb, (void *) base);
    //event_add上树 -开始监听信号事件
    if (!signal_event || event_add(signal_event, NULL) < 0) {
        fprintf(stderr, "Could not create/add a signal event!\n");
        return 1;
    }

    //循环等待事件
    event_base_dispatch(base);
    //释放链接侦听器
    evconnlistener_free(listener);
    event_free(signal_event);
    event_base_free(base);

    printf("done\n");
    return 0;
}

//链接监听器帮助处理了 accept连接，得到新的文件描述符，作为参数传入
static void listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data) {
    printf("---call------%s----\n", __FUNCTION__);
    struct event_base *base = user_data;
    struct bufferevent *bev;//定义bufferevent事件

    //创建新的bufferevent事件，对应的与客户端通信的socket
    bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    if (!bev) {
        fprintf(stderr, "Error constructing bufferevent!");
        event_base_loopbreak(base);
        return;
    }
    //设置回调函数 只设置了写回调和事件产生回调
    bufferevent_setcb(bev, conn_readcb, conn_writecb, conn_eventcb, NULL);
    //启用读写缓冲区
    bufferevent_enable(bev, EV_WRITE | EV_READ);
    //禁用读缓冲
    //bufferevent_disable(bev, EV_READ);
    //将MESSAGE 写到输出缓冲区
    //bufferevent_write(bev, MESSAGE, strlen(MESSAGE));
}

//自定义读回调函数
static void conn_readcb(struct bufferevent *bev, void *user_data) {
    printf("---calll-----%s\n", __FUNCTION__);
    //何时被触发？读入缓冲区有数据的时候，非底层的
    char buf[256] = {0};
    size_t ret = bufferevent_read(bev, buf, sizeof(buf));
    if (ret > 0) {
        //转为大写
        int i;
        for (i = 0; i < ret; i++) {
            buf[i] = toupper(buf[i]);
        }
        //写到bufferevent的输出缓冲区
        bufferevent_write(bev, buf, ret);
    }
}

static void conn_writecb(struct bufferevent *bev, void *user_data) {

    printf("---call------%s----\n", __FUNCTION__);
    struct evbuffer *output = bufferevent_get_output(bev);
    if (evbuffer_get_length(output) == 0) {
        printf("flushed answer\n");
        //  bufferevent_free(bev);
    }
}

static void conn_eventcb(struct bufferevent *bev, short events, void *user_data) {
    printf("---call------%s----\n", __FUNCTION__);
    if (events & BEV_EVENT_EOF) {
        printf("Connection closed.\n");
    } else if (events & BEV_EVENT_ERROR) {
        printf("Got an error on the connection: %s\n",
               strerror(errno)); /*XXX win32*/
    }
    /* None of the other events can happen here, since we haven't enabled
     * timeouts */
    bufferevent_free(bev);
}

static void signal_cb(evutil_socket_t sig, short events, void *user_data) {
    printf("---call------%s----\n", __FUNCTION__);
    struct event_base *base = user_data;
    struct timeval delay = {2, 0};//设置延迟时间 2s

    printf("Caught an interrupt signal; exiting cleanly in two seconds.\n");

    event_base_loopexit(base, &delay);//延时2s退出
}

基于bufferevent的客户端

//bufferevent建立客户端的过程
#include <arpa/inet.h>
#include <errno.h>
#include <event.h>
#include <event2/buffer.h>
#include <event2/bufferevent.h>
#include <event2/util.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

int tcp_connect_server(const char *server_ip, int port);
void cmd_msg_cb(int fd, short events, void *arg);
void server_msg_cb(struct bufferevent *bev, void *arg);
void event_cb(struct bufferevent *bev, short event, void *arg);

int main(int argc, char **argv) {
    if (argc < 3) {
        //两个参数依次是服务器端的IP地址、端口号
        printf("please input 2 parameter\n");

        return -1;
    }

    //创建根节点
    struct event_base *base = event_base_new();
    //创建并且初始化buffer缓冲区
    struct bufferevent *bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);

    //监听终端输入事件
    struct event *ev_cmd = event_new(base, STDIN_FILENO, EV_READ | EV_PERSIST, cmd_msg_cb, (void *) bev);

    //上树 开始监听标准输入的读事件
    event_add(ev_cmd, NULL);

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(atoi(argv[2]));
    //将ip地址转换为网络字节序
    inet_aton(argv[1], &server_addr.sin_addr);

    //连接到 服务器ip地址和端口 初始化了 socket文件描述符
    bufferevent_socket_connect(bev, (struct sockaddr *) &server_addr,
                               sizeof(server_addr));
    //设置buffer的回调函数 主要设置了读回调 server_msg_cb ,传入参数是标准输入的读事件
    bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void *) ev_cmd);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);

    event_base_dispatch(base);

    printf("finished \n");
    return 0;
}
//终端输入回调
void cmd_msg_cb(int fd, short events, void *arg) {
    char msg[1024];

    int ret = read(fd, msg, sizeof(msg));
    if (ret < 0) {
        perror("read fail ");
        exit(1);
    }

    struct bufferevent *bev = (struct bufferevent *) arg;

    //把终端的消息发送给服务器端
    bufferevent_write(bev, msg, ret);
}

void server_msg_cb(struct bufferevent *bev, void *arg) {
    char msg[1024];

    size_t len = bufferevent_read(bev, msg, sizeof(msg));
    msg[len] = '\0';

    printf("recv %s from server\n", msg);
}

void event_cb(struct bufferevent *bev, short event, void *arg) {

    if (event & BEV_EVENT_EOF)
        printf("connection closed\n");
    else if (event & BEV_EVENT_ERROR)
        printf("some other error\n");
    else if (event & BEV_EVENT_CONNECTED) {
        printf("the client has connected to server\n");
        return;
    }

    //这将自动close套接字和free读写缓冲区
    bufferevent_free(bev);
    //释放event事件 监控读终端
    struct event *ev = (struct event *) arg;
    event_free(ev);
}

文本编辑器

编译工具链

文件系统

进程

进程间通信

信号

线程

网络基础

socket编程

高并发服务器

服务器架构模型

Libevent

了解libevent

什么是libevent

Libevent主要组成

Libevent的核心实现

安装libevent

Libevent的基础使用

Libevent的地基-event_base

等待事件产生-循环等待event_loop

事件驱动-event

自带buffer的事件-bufferevent

链接监听器-evconnlistener

基于bufferevent的服务器和客户端实现

基于bufferevent的服务器

基于bufferevent的客户端

Libevent ​

了解libevent ​

什么是libevent ​

Libevent主要组成 ​

Libevent的核心实现 ​

安装libevent ​

Libevent的基础使用 ​

Libevent的地基-event_base ​

等待事件产生-循环等待event_loop ​

事件驱动-event ​

自带buffer的事件-bufferevent ​

链接监听器-evconnlistener ​

基于bufferevent的服务器和客户端实现 ​

基于bufferevent的服务器 ​

基于bufferevent的客户端 ​

Libevent

了解libevent

什么是libevent

Libevent主要组成

Libevent的核心实现

安装libevent

Libevent的基础使用

Libevent的地基-event_base

等待事件产生-循环等待event_loop

事件驱动-event

自带buffer的事件-bufferevent

链接监听器-evconnlistener

基于bufferevent的服务器和客户端实现

基于bufferevent的服务器

基于bufferevent的客户端