libevent简述

一。libevent概念

Libevent 是一个用C语言编写的、轻量级的开源高性能事件通知库，主要有以下几个亮点：事件驱动（ event-driven），高性能;轻量级，专注于网络，不如 ACE 那么臃肿庞大；源代码相当精炼、易读；跨平台，支持 Windows、 Linux、 *BSD 和 Mac Os；支持多种 I/O 多路复用技术， epoll、 poll、 dev/poll、 select 和 kqueue 等；支持 I/O，定时器和信号等事件；注册事件优先级。

二。安装

1.从官网下载安装包libevent-2.1.8-stable.tar.gz

2.解压 jar zxvf libevent-2.1.8-stable.tar.gz

3.进入解压目录 

4. ./congifure

5. make

5.sudo make install

6.以上完成后会在/usr/local/lib下生成库文件，将/usr/local/lib加入到 /etc/ls.so.conf内

7.sudo ldconfig -v

三。基本函数

1.创建事件处理框架

2.创建事件

what的参数可以设为：

 

3.将事件加入到事件处理框架中（让事件处于未决状态）

4.事件处理框架循环处理事件(事件触发后执行事件的回调函数)

5.将事件从事件处理框架中卸下（将事件设置为非未决）

6.释放事件

 7.释放事件处理 框架

 

8.libevent读写管道

 //写管道
 1 #include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#include<fcntl.h>
#include<event2/event.h>

//事件回调函数
void write_call_back(evutil_socket_t fd,short what,void *arg)
{
    //写管道
    char buf[BUFSIZ];
    static int num=0;
    sprintf(buf,"this is the %d data
",++num);
    write(fd,buf,sizeof(buf));
    return ;
}
//写管道
int main()
{
    //openfile
    int fd=open("myfifo",O_WRONLY|O_NONBLOCK);
    if(fd==-1)
    {
        perror("open err");
        exit(1);
    }
    //写管道
    struct event_base* base=NULL;
    base=event_base_new();
    //创建事件
    struct event* event=NULL;
//检测写缓冲区是否有空间写
        event=event_new(base,fd,EV_WRITE|EV_PERSIST,write_call_back,NULL);
    //添加事件
    event_add(event,NULL); //阻塞等待事件发生
    //事件循环
    event_base_dispatch(base);
    //释放事件
    event_free(event);
    //释放框架
    event_base_free(base);
    close(fd);
    return 0;
}

 //读管道
 1 #include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#include<fcntl.h>
#include<event2/event.h>

//事件回调函数
void read_call_back(evutil_socket_t fd,short what,void *arg)
{
    //读管道
    char buf[BUFSIZ];
    int len=read(fd,buf,sizeof(buf));
    printf("buf:%s
",buf);
    printf("read event:%s
",what&EV_READ?"yes":"no");
    return ;
}
//读管道
int main()
{
    unlink("myfifo");
    //创建有名管道
    mkfifo("myfifo",0664);

    //openfile
    int fd=open("myfifo",O_RDONLY|O_NONBLOCK);
    if(fd==-1)
    {
        perror("open err");
        exit(1);
    }
    //读管道
    struct event_base* base=NULL;
    base=event_base_new();
    //创建事件
    struct event* event=NULL;
        event=event_new(base,fd,EV_READ|EV_PERSIST,read_call_back,NULL);
    //添加事件
    event_add(event,NULL); //阻塞等待事件发生
    //事件循环
    event_base_dispatch(base);
    //释放事件
    event_free(event);
    //释放框架
    event_base_free(base);
    close(fd);
    return 0;
}

四。bufferevent

1。概念

bufferevent是libevent基于套接字创建的IO缓冲区，分为读缓冲区和写缓冲区。

　　　当读缓冲区有数据时，会调用相应的读回调函数。

　　　当有数据写入写缓冲区时，会调用相应的写回调函数

bufferevent相当于服务器与客户端建立连接之后（accept之后），对读写事件进行监听并处理。

2.函数

1.创建带缓冲区的事件

2.缓冲区链接（客户端）

3.设置事件回调函数

4.设置缓冲区可读，可写

5.释放缓冲区

 

五。evconnlistener 连接监听器

1.简述

evconnlistener在服务端可以代替socket，bind，listen，accept的操作，并且可以设置监听的回调函数，当有客户端连接后执行回调函数。

2.函数

1.创建连接监听器

 2.启用和禁用evconnlistener

服务端实现

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#include<ctype.h>
#include<event2/event.h>  
#include<event2/bufferevent.h> //带缓冲区的事件
#include<event2/listener.h> //连接监听器
#define PORT 8888 

//读回调
void readcb(struct bufferevent* bev,void* arg)
{
    char buf[1024]={0};
    //读缓冲区的数据
    bufferevent_read(bev,buf,sizeof(buf));
    int i=0;
    while(buf[i]!='')
    {
        buf[i]=toupper(buf[i]);
        i++;
    }
    //往缓冲区发送数据
    bufferevent_write(bev,buf,sizeof(buf));

}

//写回调
void writecb(struct bufferevent* bev,void* arg)
{
    printf("数据已发送
");
}

//事件回调
void eventcb(struct bufferevent* bev,short events,void *arg)
{
    if(events&BEV_EVENT_EOF)
    {
        printf("connection cloased");
    }else if(events&BEV_EVENT_ERROR)
    {
        printf("err
");
    }
    //释放bufferevent资源
    bufferevent_free(bev);
}

//连接完成之后对应的通信操作
void listen_call_back(struct evconnlistener* listener,evutil_socket_t fd,struct sockaddr* addr,int len,void *ptr)
{
    //接收base
    struct event_base *base=(struct event_base*)ptr;
    //接收数据 - 发送数据
    //将fd封装成带缓冲区的事件
    struct bufferevent* bev=bufferevent_socket_new(base,fd,BEV_OPT_CLOSE_ON_FREE);
    //给bufferevent对应的读写缓冲区设置回调函数
    bufferevent_setcb(bev,readcb,writecb,eventcb,NULL);
    //设置独缓冲区的回调可用
    bufferevent_enable(bev,EV_READ);
}
int main()
{
    //创建事件处理框架
    struct event_base* base=event_base_new();
    //设置服务器地址信息
    struct sockaddr_in serv;
    memset(&serv,0,sizeof(serv));
    serv.sin_family=AF_INET;
    serv.sin_port=htons(PORT);
    serv.sin_addr.s_addr=htonl(INADDR_ANY);
    //创建监听的套接字
    //绑定
    //监听
    //等待并接收连接
    //有连接时listen_call_back被调用
    struct evconnlistener* listen=evconnlistener_new_bind(base,listen_call_back,base,LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE,-1,(struct sockaddr*)&serv,sizeof(serv));
    //开始事件循环
    event_base_dispatch(base);
    //释放资源
    evconnlistener_free(listen);
    event_base_free(base);    
    return 0;
}

客户端

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <event2/event.h>
#include <event2/bufferevent.h>


void read_cb(struct bufferevent *bev, void *arg)
{
    char buf[1024] = {0}; 
    bufferevent_read(bev, buf, sizeof(buf));
    printf("Server say: %s
", buf);
}

void write_cb(struct bufferevent *bev, void *arg)
{
    printf("I am Write_cb function....
");
}

void event_cb(struct bufferevent *bev, short events, void *arg)
{
    if (events & BEV_EVENT_EOF)
    {
        printf("connection closed
");  
    }
    else if(events & BEV_EVENT_ERROR)   
    {
        printf("some other error
");
    }
    else if(events & BEV_EVENT_CONNECTED)
    {
        printf("成功连接到服务器, O(∩_∩)O哈哈~
");
        return;
    }
    
    bufferevent_free(bev);
    printf("free bufferevent...
");
}

void send_cb(evutil_socket_t fd, short what, void *arg)
{
    char buf[1024] = {0}; 
    struct bufferevent* bev = (struct bufferevent*)arg;
    printf("请输入要发送的数据: 
");
    read(fd, buf, sizeof(buf));
    bufferevent_write(bev, buf, strlen(buf)+1);
}


int main(int argc, const char* argv[])
{
    struct event_base* base;
    base = event_base_new();


    struct bufferevent* bev;
    bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);

    // 连接服务器
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(9876);
    evutil_inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);
    bufferevent_socket_connect(bev, (struct sockaddr*)&serv, sizeof(serv));

    // 设置回调
    bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);

    // 创建一个事件
    struct event* ev = event_new(base, STDIN_FILENO, 
                                 EV_READ | EV_PERSIST, 
                                 send_cb, bev);
    event_add(ev, NULL);
    
    event_base_dispatch(base);

    event_base_free(base);

    return 0;
}