Libevent的使用

        2、进入到源码目录：cd libevent-2.0.22-stable

        

        3、执行配置./configure，生成makefile

        4、编译源码 :执行make

        5、编译后安装，输入本用户的密码: sudo make install

6、安装后验证，简单的先编译一个文件：demo.c

#include <event.h>
#include <stdio.h>

int main()
{
    char ** methods = event_get_supported_methods();//获取libevent后端支持的方法
    int i =0;
    for(i = 0;methods[i] != NULL ;i++)
    {
        printf("%s\n",methods[i]);
    }

    //获取当前平台支持的方法
	struct event_base * base = event_base_new();
		printf("%s\n",event_base_get_method(base));
    return 0;
}

编译：编译时需要指定库名  -levent    (可以忽略该警告，代表编译完成)

执行：./demo     (同时也能看到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的核心思想，对比epoll服务器流程

主要几个状态：

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

        非未决：相当于创建了事件，但是事件还没有处于被监听状态，类似于我们使用epoll的时候定义了struct epoll_event ev并且对ev的两个字段进行了赋值，但是此时尚未调用epoll_ctl。

        未决：就是对事件开始监听，暂时未有事件产生。相当于调用epoll_ctl。

        激活：代表监听的事件已经产生，这时需要处理，相当于我们epoll所说的事件就绪。

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

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

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 回调函数的参数

2、将非未决态事件转为未决态，相当于调用epoll_ctl函数，开始监听事件是否产生。

int event_add(struct event *ev, const struct timeval *timeout);

//将非未决态事件转为未决态，相当于调用epoll_ctl函数，开始监听事件是否产生。

参数说明：
	Ev 就是前面event_new创建的事件
    Timeout 限时等待事件的产生，也可以设置为NULL，没有限时。

3、将事件从未决态变为非未决态，相当于epoll的下树（epoll_ctl调用EPOLL_CTL_DEL操作）操作。

int event_del(struct event *ev);

//将事件从未决态变为非未决态，相当于epoll的下树（epoll_ctl调用EPOLL_CTL_DEL操作）操作。

4、释放event_new申请的event节点

void event_free(struct event *ev);

//释放event_new申请的event节点。

用libevent写一下简易的事件驱动的网络服务器端程序：

//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 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事件驱动的核心回调函数，那么四个缓冲区以及触发回调的关系如下：

核心:  一个文件描述符  两个缓冲区  3个回调

有三个回调函数：

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

主要使用的函数如下：

        1、bufferevent_socket_new 对已经存在socket创建bufferevent事件，可用于后面讲到的链接监听器的回调函数中

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能够在多线程下是安全的

        2、bufferevent_socket_connect封装了底层的socket与connect接口，通过调用此函数，可以将bufferevent事件与通信的socket进行绑定

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的长度

3、释放bufferevent

void bufferevent_free(struct bufferevent *bufev);

//释放bufferevent

4、bufferevent_setcb用于设置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代表回调函数的参数。

	回调函数的原型：
	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

5、bufferevent_write是将data的数据写到bufferevent的写缓冲区

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。

6、bufferevent_read 是将bufferevent的读缓冲区数据读到data中，同时将读到的数据从bufferevent的读缓冲清除。

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中，接口的另外一种。

7、bufferevent_enable与bufferevent_disable是设置事件是否生效，如果设置为disable，事件回调将不会被触发。

int bufferevent_enable(struct bufferevent *bufev, short event);


int bufferevent_disable(struct bufferevent *bufev, short event);

链接监听器-evconnlistener 

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

 1、evconnlistener_new_bind是在当前没有套接字的情况下对链接监听器进行初始化，看最后2个参数实际上就是bind使用的关键参数，backlog是listen函数的关键参数（略有不同的是，如果backlog是-1，那么监听器会自动选择一个合适的值，如果填0，那么监听器会认为listen函数已经被调用过了），ptr是回调函数的参数，cb是有新连接之后的回调函数，但是注意这个回调函数触发的时候，链接器已经处理好新连接了，并将与新连接通信的描述符交给回调函数。

struct evconnlistener *evconnlistener_new_bind(struct event_base *base,
    evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
const struct sockaddr *sa, int socklen);



Flags 需要参考几个值：
	LEV_OPT_LEAVE_SOCKETS_BLOCKING   文件描述符为阻塞的
	LEV_OPT_CLOSE_ON_FREE            关闭时自动释放
	LEV_OPT_REUSEABLE                端口复用
	LEV_OPT_THREADSAFE               分配锁，线程安全

2、evconnlistener_new函数与前一个函数不同的地方在与后2个参数，使用本函数时，认为socket已经初始化好，并且bind完成，甚至也可以做完listen，所以大多数时候，我们都可以使用第一个函数。

struct evconnlistener *evconnlistener_new(struct event_base *base,
    evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
evutil_socket_t fd);


//两个函数的回调函数
typedef void (*evconnlistener_cb)(struct evconnlistener *evl, evutil_socket_t fd, struct sockaddr *cliaddr, int socklen, void *ptr);
主要回调函数fd参数会与客户端通信的描述符，并非是等待连接的监听的那个描述符，所以cliaddr对应的也是新连接的对端地址信息，已经是accept处理好的。

3、操作链接监听器

void evconnlistener_free(struct evconnlistener *lev);
//释放链接监听器


int evconnlistener_enable(struct evconnlistener *lev);
//使链接监听器生效


int evconnlistener_disable(struct evconnlistener *lev);
//使链接监听器失效

bufferveent事件的监听流程