【libevent】libevent快速入门

最新推荐文章于 2023-02-26 14:04:06 发布
最新推荐文章于 2023-02-26 14:04:06 发布
阅读量590 收藏 1
点赞数
分类专栏： C/C++ 网络编程 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bandaoyu/article/details/105686949
版权
C/C++ 同时被 3 个专栏收录
206 篇文章 77 订阅
订阅专栏
网络编程
125 篇文章 68 订阅
订阅专栏
物联网
40 篇文章 28 订阅
订阅专栏

目录

简介

libevent和epoll区别?

原理简介

简易版QuickStart

安装

在线安装

编译安装

实战

查看libevent库是否存在

编写代码

使用BufferEvent

笔记

文档翻译

简介

基本的socket编程是阻塞/同步的，每个操作除非已经完成，出错，或者超时才会返回，这样对于每一个请求，要使用一个线程或者单独的进程去处理，系统资源没有办法支撑大量的请求。posix定义了可以使用异步的select系统调用，但是因为它采用了轮询的方式来判断某个fd是否变成active，效率不高。于是各系统就分别提出了基于异步的系统调用，例如Linux的epoll，由于在内核层面做了支持，所以可以用O(1)的效率查找到active的fd。基本上，libevent就是对这些高效IO的封装，提供统一的API，简化开发。

libevent和epoll区别?

epoll是Linux提供的一个事件检测api或者说一种检测机制，libevent是一个事件处理框架。

libevent支持多种事件检测机制，比如select,poll,epoll等，epoll只是其中一种机制，是Linux平台上效率最高的，也是Linux平台特有的。其他平台有和epoll类似的对应物件，比如bsd的kqueue，Windows的iocp...

一句话，libevent是一个开源库，epoll是一个Linux系统调用。
链接：https://www.zhihu.com/question/56908845/answer/494680014

struct event_base *base; 相当于声明epoll_fd

base = event_base_new(); 创建epoll_create

struct event; 相当于socket

event = event_new();创建epoll_event，绑定回调

event_add(); 相当于epoll_ctl,fd加入对应epoll_fd ,epoll_ctl_add,同时指定超时

evtimer_new(base,cb,arg);  创建超时事件  然后event_add()加入循环

最小堆保存时间事件，相同时长的事件保存在同一个队列中，不加入堆。

event_base_dispatch();  相当于while(1){epoll_wait()}

被触发的各种event会被放入active队列，统一执行

 https://blog.csdn.net/welongfor/article/details/86689224

原理简介

libevent默认情况下是单线程的，可以配置成多线程，每个线程有且只有一个event_base，对应一个struct event_base结构体以及附于其上的事件管理器，用来调度托管给它的一系列event，可以和操作系统的进程管理类比。当一个事件发生后，event_base会在合适的时间，不一定是立即去调用绑定在这个事件上的函数，直到这个函数执行完，再去调度其他的事件。

 

//创建一个event_base
struct event_base *base = event_base_new();
assert(base != NULL);

event_base内部有一个循环，循环阻塞在epoll等系统调用上，直到有一个/一些时间发生，然后去处理这些事件。当然，这些事件要被绑定在这个event_base上，每个事件对应一个struct event，可以是监听一个fd或者信号量之类的，struct event使用event_new来创建和绑定，使用event_add来将event绑定到event_base中。

 

// 创建并绑定一个event
struct event* listen_event;

//参数：event_base,监听的对象，需要监听的事件，事件发生后的回调函数，传给回调函数的参数
listen_event = event_new(base, listener, EV_READ | EV_PERSIST, callback_func, (void*)base);
//参数：event，超时时间，NULL表示无超时设置
event_add(listen_event, NULL);

注：libevent支持的事件及属性包括（使用bitfield实现）

  1. EV_TIMEOUT:超时；
  2. EV_READ:只要网络缓冲中还有数据，回调函数就会被触发；
  3. EV_WRITE:只要塞给网络缓冲的数据被写完，回调函数就会被触发；
  4. EV_SIGNAL:POSIX信号量；
  5. EV_PERSIST:不指定这个属性，回调函数被触发后事件会被删除；
  6. EV_ET:Edge-Trigger边缘触发（这个还不懂是什么意思）

然后启动event_base的循环，开始处理事件。循环地启动使用event_base_dispatch，循环将一直持续，找到不再有需要关注的事件，或者是遇到event_loopbreak()/event_loopexit()函数。

 

//启动循环，开始处理事件
event_base_dispatch(base);

接下来再来关注事件发生时的回调函数callback_func，callback_func的原型如下所示

 

typedef void(* event_callback_fn)(evutil_socket_t sockfd, short event_type, void *arg)

传给callback_func的是一个监听的fd，监听的事件类型，以及event_new中最后一个参数。在上述程序中，是将event_base传给了callback_func，实际中更常用的是构造一个结构体，把需要传给回调函数的参数都放进来，然后传给event_new，event_new再传给回调函数。

所以总结一下，对于一个服务器而言，流程大致如下：

  1. 获取待监听的内容的fd；
  2. 创建一个event_base；
  3. 创建一个event,指定待监听的fd，待监听事件的类型，以及事件放生时的回调函数及传给回调函数的参数；
  4. 将event添加到event_base的事件管理器中；
  5. 开启event_base的事件处理循环；
  6. （异步）当事件发生的时候，调用前面设置的回调函数。

简易版QuickStart

 

安装

在线安装

yum  install  libevent

编译安装

1. 下载
官方网站：http://libevent.org/，目前最新版是2.1
下载压缩包名为 libevent-2.1.11-stable.tar.gz
2. 解压

tar -zxvf libevent-2.1.11-stable.tar.gz

3. 配置安装路径

cd libevent-2.1.11-stable
./autogen.sh  #生成configure
./configure

也可以指定后缀，比如路径为./configure -prefix=/usr

4. 编译安装

make
make install

5. 测试是否已安装

ls -al /usr/local/lib | grep libevent

6. 使用样例程序进行测试

cd sample/

此目录下，有很多样例，可以进行测试，也可以进行学习

 

实战

https://www.cnblogs.com/WindSun/p/12142656.html

查看libevent库是否存在

使用Libevent编写简单的程序和编译

使用libevent库开发的程序，默认编译需要加入-levent
问题：如果在编译或运行时候发现出现：error while loading shared libraries: libevent-2.1.so.7: cannot open shared object file: No such file or directory
则需要查看libevent-2.1.so.7是否存在，需要先安装mlocate

locate libevent-2.1.so.7

结果： 系统已经安装了该模块，在路径 /usr/local/lib/
映射libevent-2.1.so.7到lib64下即可

ln -s /usr/local/lib/libevent-2.1.so.7 /usr/lib64/libevent-2.1.so.7

然后就可以正常的运行了

编写代码

下面的代码实现了一个简单的echo server，server启动后，client端启动并连接，在cmd中输入文字，server端收到后，将文字再返回给client。
server端代码：

/**
You need libevent2 to compile this piece of code
Please see: http://libevent.org/
Or you can simply run this command to install on Mac: brew install libevent
Cmd to compile this piece of code: g++ LibeventQuickStartServer.c  -o  LibeventQuickStartServer /usr/local/lib/libevent.a
**/
#include<stdio.h>  
#include<string.h>  
#include<errno.h>  
  
#include<unistd.h>  
#include<event.h>

void accept_cb(int fd, short events, void* arg);
void socket_read_cb(int fd, short events, void* arg);

int tcp_server_init(int port, int listen_num);

int main(int argc, char const *argv[])
{
    /* code */
    int listener = tcp_server_init(9999, 10);
    if (listener == -1)
    {
        perror("tcp_server_init error");
        return -1;
    }

    struct event_base* base = event_base_new();

    // 监听客户端请求链接事件
    struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST, accept_cb, base);

    event_add(ev_listen, NULL);

    event_base_dispatch(base);

    return 0;
}

void accept_cb(int fd, short events, void* arg)
{
    evutil_socket_t sockfd;

    struct sockaddr_in client;
    socklen_t len = sizeof(client);

    sockfd = ::accept(fd, (struct sockaddr*)&client, &len);
    evutil_make_socket_nonblocking(sockfd);

    printf("accept a client %d\n", sockfd);

    struct event_base* base = (event_base*)arg;

    //动态创建一个event结构体，并将其作为回调参数传递给
    struct event* ev = event_new(NULL, -1, 0, NULL, NULL);
    event_assign(ev, base, sockfd, EV_READ | EV_PERSIST, socket_read_cb, (void*)ev);

    event_add(ev, NULL);
}


void socket_read_cb(int fd, short events, void* arg)
{
    char msg[4096];
    struct event* ev = (struct event*)arg;
    int len = read(fd, msg, sizeof(msg) - 1);

    if(len <= 0)
    {
        printf("some error happen when read\n");
        event_free(ev);
        close(fd);
        return;
    }

    msg[len] = '\0';
    printf("recv the client msg : %s\n", msg);

    char reply_msg[4096] = "I have received the msg: ";
    strcat(reply_msg + strlen(reply_msg), msg);

    write(fd, reply_msg, strlen(reply_msg));
}

typedef struct sockaddr SA;  
int tcp_server_init(int port, int listen_num)  
{  
    int errno_save;  
    evutil_socket_t listener;  
  
    listener = ::socket(AF_INET, SOCK_STREAM, 0);  
    if( listener == -1 )  
        return -1;  
  
    //允许多次绑定同一个地址。要用在socket和bind之间  
    evutil_make_listen_socket_reuseable(listener);  
  
    struct sockaddr_in sin;  
    sin.sin_family = AF_INET;  
    sin.sin_addr.s_addr = 0;  
    sin.sin_port = htons(port);  
  
    if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 )  
        goto error;  
  
    if( ::listen(listener, listen_num) < 0)  
        goto error;  
  
  
    //跨平台统一接口，将套接字设置为非阻塞状态  
    evutil_make_socket_nonblocking(listener);  
  
    return listener;  
  
    error:  
        errno_save = errno;  
        evutil_closesocket(listener);  
        errno = errno_save;  
  
        return -1;  
}

client端代码：


/**
You need libevent2 to compile this piece of code
Please see: http://libevent.org/
Or you can simply run this command to install on Mac: brew install libevent
Cmd to compile this piece of code: g++ LibeventQuickStartClient.c -o LibeventQuickStartClient /usr/local/lib/libevent.a
**/
#include<sys/types.h>  
#include<sys/socket.h>  
#include<netinet/in.h>  
#include<arpa/inet.h>  
#include<errno.h>  
#include<unistd.h>  
  
#include<stdio.h>  
#include<string.h>  
#include<stdlib.h>  
  
#include<event.h>  
#include<event2/util.h>  
  
  
  
  
int tcp_connect_server(const char* server_ip, int port);  
  
  
void cmd_msg_cb(int fd, short events, void* arg);  
void socket_read_cb(int fd, short events, void *arg);  
  
int main(int argc, char** argv)  
{  
    if( argc < 3 )  
    {  
        printf("please input 2 parameter\n");  
        return -1;  
    }  
  
  
    //两个参数依次是服务器端的IP地址、端口号  
    int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));  
    if( sockfd == -1)  
    {  
        perror("tcp_connect error ");  
        return -1;  
    }  
  
    printf("connect to server successful\n");  
  
    struct event_base* base = event_base_new();  
  
    struct event *ev_sockfd = event_new(base, sockfd,  
                                        EV_READ | EV_PERSIST,  
                                        socket_read_cb, NULL);  
    event_add(ev_sockfd, NULL);  
  
    //监听终端输入事件  
    struct event* ev_cmd = event_new(base, STDIN_FILENO,  
                                      EV_READ | EV_PERSIST, cmd_msg_cb,  
                                      (void*)&sockfd);  
  
  
    event_add(ev_cmd, NULL);  
  
    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);  
    }  
  
    int sockfd = *((int*)arg);  
  
    //把终端的消息发送给服务器端  
    //为了简单起见，不考虑写一半数据的情况  
    write(sockfd, msg, ret);  
}  
  
  
void socket_read_cb(int fd, short events, void *arg)  
{  
    char msg[1024];  
  
    //为了简单起见，不考虑读一半数据的情况  
    int len = read(fd, msg, sizeof(msg)-1);  
    if( len <= 0 )  
    {  
        perror("read fail ");  
        exit(1);  
    }  
  
    msg[len] = '\0';  
  
    printf("recv %s from server\n", msg);  
}  
  
  
  
typedef struct sockaddr SA;  
int tcp_connect_server(const char* server_ip, int port)  
{  
    int sockfd, status, save_errno;  
    struct sockaddr_in server_addr;  
  
    memset(&server_addr, 0, sizeof(server_addr) );  
  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_port = htons(port);  
    status = inet_aton(server_ip, &server_addr.sin_addr);  
  
    if( status == 0 ) //the server_ip is not valid value  
    {  
        errno = EINVAL;  
        return -1;  
    }  
  
    sockfd = ::socket(PF_INET, SOCK_STREAM, 0);  
    if( sockfd == -1 )  
        return sockfd;  
  
  
    status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );  
  
    if( status == -1 )  
    {  
        save_errno = errno;  
        ::close(sockfd);  
        errno = save_errno; //the close may be error  
        return -1;  
    }  
  
    evutil_make_socket_nonblocking(sockfd);  
  
    return sockfd;  
}

程序运行截图

客户端

 

Paste_Image.png

服务端

Paste_Image.png

 

使用BufferEvent

在上面的代码中，client的cmd中有信息输入时，client直接将数据写入到fd中，server中收到信息后，也是直接将信息写入到fd中，因为fd是非阻塞的，所以不能保证正确。那么需要一个自己管理的缓存来管理自己的数据。那么步骤将稍微有些变化，如下所示：

  1. 设置scokfd为nonblocking；
  2. 使用bufferevent_socket_new创建一个struct bufferevent* bev，关联上面的sockfd，并托管给event_base;
  3. 使用bufferevent_setcb(bev, read_cb, write_cb, error_cb, (void*)arg)；
  4. 使用buffevent_enable(bev, EV_READ|EV_WRITE|EV_PERSIST)来启动read/write事件

代码如下所示：

使用bufferevent的server端代码

 

#include<stdio.h>
#include<string.h>
#include<errno.h>

#include<event.h>
#include<event2/bufferevent.h>



void accept_cb(int fd, short events, void* arg);
void socket_read_cb(bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);
int tcp_server_init(int port, int listen_num);

int main(int argc, char** argv)
{

    int listener = tcp_server_init(9999, 10);
    if( listener == -1 )
    {
        perror(" tcp_server_init error ");
        return -1;
    }

    struct event_base* base = event_base_new();

    //添加监听客户端请求连接事件
    struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
                                        accept_cb, base);
    event_add(ev_listen, NULL);


    event_base_dispatch(base);
    event_base_free(base);


    return 0;
}



void accept_cb(int fd, short events, void* arg)
{
    evutil_socket_t sockfd;

    struct sockaddr_in client;
    socklen_t len = sizeof(client);

    sockfd = ::accept(fd, (struct sockaddr*)&client, &len );
    evutil_make_socket_nonblocking(sockfd);

    printf("accept a client %d\n", sockfd);

    struct event_base* base = (event_base*)arg;

    bufferevent* bev = bufferevent_socket_new(base, sockfd, BEV_OPT_CLOSE_ON_FREE);
    bufferevent_setcb(bev, socket_read_cb, NULL, event_cb, arg);

    bufferevent_enable(bev, EV_READ | EV_PERSIST);
}



void socket_read_cb(bufferevent* bev, void* arg)
{
    char msg[4096];

    size_t len = bufferevent_read(bev, msg, sizeof(msg));

    msg[len] = '\0';
    printf("recv the client msg: %s", msg);


    char reply_msg[4096] = "I have recvieced the msg: ";

    strcat(reply_msg + strlen(reply_msg), msg);
    bufferevent_write(bev, reply_msg, strlen(reply_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");

    //这将自动close套接字和free读写缓冲区
    bufferevent_free(bev);
}


typedef struct sockaddr SA;
int tcp_server_init(int port, int listen_num)
{
    int errno_save;
    evutil_socket_t listener;

    listener = ::socket(AF_INET, SOCK_STREAM, 0);
    if( listener == -1 )
        return -1;

    //允许多次绑定同一个地址。要用在socket和bind之间
    evutil_make_listen_socket_reuseable(listener);

    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(port);

    if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 )
        goto error;

    if( ::listen(listener, listen_num) < 0)
        goto error;


    //跨平台统一接口，将套接字设置为非阻塞状态
    evutil_make_socket_nonblocking(listener);

    return listener;

    error:
        errno_save = errno;
        evutil_closesocket(listener);
        errno = errno_save;

        return -1;
}

使用bufferevent的client端代码

#include<sys/types.h>  
#include<sys/socket.h>  
#include<netinet/in.h>  
#include<arpa/inet.h>  
#include<errno.h>  
#include<unistd.h>  
  
#include<stdio.h>  
#include<string.h>  
#include<stdlib.h>  
  
#include<event.h>  
#include<event2/bufferevent.h>  
#include<event2/buffer.h>  
#include<event2/util.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 )  
    {  
        printf("please input 2 parameter\n");  
        return -1;  
    }  
  
  
    //两个参数依次是服务器端的IP地址、端口号  
    int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));  
    if( sockfd == -1)  
    {  
        perror("tcp_connect error ");  
        return -1;  
    }  
  
    printf("connect to server successful\n");  
  
    struct event_base* base = event_base_new();  
  
    struct bufferevent* bev = bufferevent_socket_new(base, sockfd,  
                                                     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);  
  
    //当socket关闭时会用到回调参数  
    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");  
  
    //这将自动close套接字和free读写缓冲区  
    bufferevent_free(bev);  
  
    struct event *ev = (struct event*)arg;  
    //因为socket已经没有，所以这个event也没有存在的必要了  
    event_free(ev);  
}  
  
  
typedef struct sockaddr SA;  
int tcp_connect_server(const char* server_ip, int port)  
{  
    int sockfd, status, save_errno;  
    struct sockaddr_in server_addr;  
  
    memset(&server_addr, 0, sizeof(server_addr) );  
  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_port = htons(port);  
    status = inet_aton(server_ip, &server_addr.sin_addr);  
  
    if( status == 0 ) //the server_ip is not valid value  
    {  
        errno = EINVAL;  
        return -1;  
    }  
  
    sockfd = ::socket(PF_INET, SOCK_STREAM, 0);  
    if( sockfd == -1 )  
        return sockfd;  
  
  
    status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );  
  
    if( status == -1 )  
    {  
        save_errno = errno;  
        ::close(sockfd);  
        errno = save_errno; //the close may be error  
        return -1;  
    }  
  
    evutil_make_socket_nonblocking(sockfd);  
  
    return sockfd;  
}

欢迎留言交流学习
参考链接：
https://www.felix021.com/blog/read.php?2068
http://blog.csdn.net/luotuo44/article/details/39670221



作者：shareLin
链接：https://www.jianshu.com/p/8ea60a8d3abb
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

/**
   Allocate a new evconnlistener object to listen for incoming TCP connections
   on a given address.

   @param base The event base to associate the listener with.
   @param cb A callback to be invoked when a new connection arrives. If the
      callback is NULL, the listener will be treated as disabled until the
      callback is set.
   @param ptr A user-supplied pointer to give to the callback.
   @param flags Any number of LEV_OPT_* flags
   @param backlog Passed to the listen() call to determine the length of the
      acceptable connection backlog.  Set to -1 for a reasonable default.
   @param addr The address to listen for connections on.
   @param socklen The length of the address.
 */
EVENT2_EXPORT_SYMBOL
struct evconnlistener *evconnlistener_new_bind(
    struct event_base *base,  //事件基座
    evconnlistener_cb cb,     //回调函数
    void *ptr,                //回调函数的参数
    unsigned flags,           //flags参数控制回调函数的行为
    int backlog,              //backlog是任何时刻网络栈允许处于还未接受状态的最大未决连接数
    const struct sockaddr *sa, 
    int socklen);

flags取值：http://www.cppblog.com/mysileng/archive/2013/02/07/197763.aspx
backlog是任何时刻网络栈允许处于还未接受状态的最大未决连接数。更多细节请查看系统的listen()函数文档。如果backlog是负的，libevent会试图挑选一个较好的值；如果为0，libevent认为已经对提供的套接字调用了listen()。

使用bufferevent的server端代码（libevent-2.1.10-stable）


/********************************************************
Copyright (C),  2016-2018,
FileName:		main
Author:        	woniu201
Email:         	wangpengfei.201@163.com
Created:       	2018/11/21
Description:    使用libevent实现TCP Server
********************************************************/
#include <iostream>
#include <string.h>
#include <event2/event.h>
#include <event2/bufferevent.h>
#include <event2/listener.h>

#ifdef _WIN32
#include <windows.h>
#include <time.h>
#include <ws2tcpip.h>
#else
#include <unistd.h>
#include <arpa/inet.h>
#endif

#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "wsock32.lib")


using namespace std;

char IPdotdec[20]; //存放点分十进制IP地址
struct in_addr s; // IPv4地址结构体

/************************************
@ Brief:		读缓冲区回调
@ Author:		woniu201
@ Created:		2018/11/21
@ Return:
************************************/
void read_cb(struct bufferevent* bev, void* arg)
{
	char buf[1024] = { 0 };
	char* ip = (char*)arg;

	bufferevent_read(bev, buf, sizeof(buf));

	cout << "client " << ip << " say:" << buf << endl;


	//写数据给客户端
	const char* p = "i am server, i received your msg!";
	bufferevent_write(bev, p, strlen(p) + 1);
}


/************************************
@ Brief:		写缓冲区回调
@ Author:		woniu201
@ Created:		2018/11/21
@ Return:
************************************/
void write_cb(struct bufferevent* bev, void* arg)
{
	cout << "I'm 服务器，成功写数据给客户端，写缓冲回调函数被调用..." << endl;
}

/************************************
@ Brief:		事件回调
@ Author:		woniu201
@ Created:		2018/11/21
@ Return:
************************************/
void event_cb(struct bufferevent* bev, short events, void* arg)
{
	char* ip = (char*)arg;
	if (events & BEV_EVENT_EOF)
	{
		cout << "connection closed:" << ip << endl;
	}
	else if (events & BEV_EVENT_ERROR)
	{
		cout << "some other error !" << endl;
	}

	bufferevent_free(bev);
	cout << "bufferevent 资源已经被释放..." << endl;
}

/************************************
@ Brief:		监听回调
@ Author:		woniu201
@ Created:		2018/11/21
@ Return:
************************************/
void cb_listener(struct evconnlistener* listener, evutil_socket_t fd, struct sockaddr* addr, int len, void* ptr)
{
	struct sockaddr_in* client = (sockaddr_in*)addr;
	

	inet_ntop(AF_INET, (void*)&(client->sin_addr), IPdotdec, 16);
	cout << "connect new client: " << IPdotdec << "::" << ntohs(client->sin_port) << endl;

	struct event_base* base = (struct event_base*)ptr;

	//添加新事件
	struct bufferevent* bev;
	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

	//给bufferevent缓冲区设置回调
	bufferevent_setcb(bev, read_cb, write_cb, event_cb, IPdotdec);

	//启动 bufferevent的 读缓冲区。默认是disable 的
	bufferevent_enable(bev, EV_READ);
}

int main()
{
#ifdef WIN32
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD(2, 2);
	(void)WSAStartup(wVersionRequested, &wsaData);
#endif
	//init server
	struct sockaddr_in serv;

	memset(&serv, 0, sizeof(serv));
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	serv.sin_addr.s_addr = htonl(INADDR_ANY);

	//创建 event_base
	struct event_base* base;
	base = event_base_new();

	//创建套接字
	//绑定
	//接收连接请求
	struct evconnlistener* listener;
	listener = evconnlistener_new_bind(base, cb_listener, base, LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, 36, (struct  sockaddr*) & serv, sizeof(serv));

	//启动循环监听
	event_base_dispatch(base);
	evconnlistener_free(listener);
	event_base_free(base);
	return 0;
}

 

笔记

当有可读事件时会调用readcb函数，当有可写事件时调用writecb函数，发生错误时调用eventcb函数。

 

libevent有个机制大家要注意，bufferevent_socket读写事件和普通的描述符读写事件。如果是带有bufferevent的，bufferevent本身又带有一层，为什么能设置高水位和低水位，就是通过bufferevent这一层来的；至于回调函数，

readcb是当套接字缓冲区有数据，对于bufferevent这种，如果超过低水位之类的才会触发；对于普通的描述符会立即触发(使用epool的LT模式的话）；

writecb是能够写到缓冲区中才会触发，是一个后续的操作，可以理解成write-complete

也就是 writecb 是 bufferevent_write(bev, p, strlen(p) + 1);的数据真正的写到发送缓冲区 完成了才触发 

这个writecb是 bufferevent_write 写完之后, 触发的, 

文档翻译

http://www.cppblog.com/mysileng/category/20374.html

bandaoyu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libevent安装配置
yao5hed的专栏
08-29 778
Libevent的特点: 1. 基于事件驱动 2. 轻量级，源码精炼，不像ACE那样庞大臃肿 3. 跨平台 4. 支持多路I/O 从网上下载安装包后放到目录解压，到libevent-2.1.8-stable目录下依次执行: ./configure make sudo make install 编译完成的库文件在libevent-2.1.8-stable/.libs中，有libev...
学习libevent入门电子书
12-28
《学习libevent入门电子书》是一本针对libevent这一开源事件库的学习资料，它对于深入理解和使用libevent具有极大的价值。libevent是一个高度可移植的库，它为编写高性能、异步网络应用提供了基础。在现代软件开发，...
libevent——简单介绍
最新发布
czw
02-26 950
libevent简单介绍
memcached的学习（2）
Zuoerfeng
11-20 215
2018.6.11 今天主要看memecached服务器端的安装 memcached两种安装方法，一种直接通过yum安装，一种通过源码安装，准备都尝试下这两种方法 ———————————————————————————————————————————— 第一种，通过yum进行安装 Yum安装Memcache 1.查找memcached yum search memcached 该命令可以查询...
libevent简单的入门
lwei2的博客
04-17 517
1.1 libevent简介 Libevent 是一个用C语言编写的、轻量级的开源高性能网络库。具有以下特点： 事件驱动（ event-driven） 高性能 轻量级 专注于网络 源代码相当精炼、易读 跨平台，支持多种 I/O 多路复用技术， 支持 I/O，定时器和信号等事件 注册事件优先级 1.2 libevent安装 1)下载libevent源码，即从libevent官网下...
libevent学习笔记 一、基础知识
热门推荐
【码农在新加坡】的专栏
06-14 4万+
1.   Libevent是什么？ Libevent是一个轻量级的开源的高性能的网络库，被众多的开源项目使用，例如大名鼎鼎的memcached等。具有如下的显著的特点：事件驱动，轻量级（和ACE相比的话），跨平台，支持多路的IO复用技术，支持定时器、信号等事件。 2.   Libevent功能 Libevent提供了事件通知，io缓存事件，定时器，超时，异步解析dns，事件驱动的ht
libevent入门学习资料
09-10
附件为本人整理的libevent的入门学习资料，时候零基础学习。
Libevent资料.zip
02-18
- 该手册详细介绍了 Libevent 的基本概念、API 使用方法和示例，对于初学者来说是一份很好的入门资料，能够快速理解和上手使用 Libevent。 - 手册涵盖了事件模型、事件基础结构、事件类型、事件处理等关键主题，...
libevent源码分析
05-04
libevent是非常著名的开源网络库，可以作为服务端开发入门研究资料
libevent参考手册(中文版).rar
08-25
这份中文版的手册不仅适合初学者入门，也对有经验的开发者有很高的参考价值，因为它深入浅出地讲解了Libevent的各个方面，有助于读者快速掌握这一强大的网络编程工具。通过阅读和实践，你将能够利用Libevent构建出高...
libevent2.1.7在Linux安装过程
03-14
libevent2.1.7在Linux安装过程
libevent入门篇
u011412619的专栏
07-20 781
libevent作为一个c网络库具有很好的可移植性。因为他包含了很多可移植的接口封装如linux支持的epoll、select，BSD支持的kqueue,window select等。 学习libevent最好的方式就是阅读源码，首先我们需要看一下libevent的官方网站介绍首先对其有一个了解，介绍是英文写的很好，这里给个链接http://libevent.org/。         看完这
Linux动态库的下载与配置（以libevent库为例）
weixin_52259848的博客
04-28 4176
** Linux动态库的下载与配置 ** 本章以下载、安装、配置libevent库为例(安装libevent的前提是已经成功安装openssl库) 一、libevent的下载 https://libevent.org/ //官网下载源码包 如果学习下载1.0版本为好，使用可以下载2.0版本 1.如果Linux已经进行桥接联网，直接在虚拟机上下载安装包即可 2如果Linux没有进行联网，可以在Windows上下载好安装包，在通过Xftp-5传发过去也可 3.libevent的安装包如下图所示 二安装lib
libevent-2.1.11-stable.tar.gz 版本Windows编译问题
lyd_253261362的专栏
11-28 764
官方网站下载地址：http://libevent.org/ 下载地址：https://github.com/libevent/libevent/releases/download/release-2.1.11-stable/libevent-2.1.11-stable.tar.gz 编译出现的问题： libevent-2.1.11 出现UINT32_MAX 未声明； 解决方式：...
安装libevent
Nuan_Feng的博客
09-30 453
文章目录 安装gcc yum -y install gcc 安装 openssl yum install -y openssl openssl-devel 安装nc,用于tcp/udp连接 yum install nmap-ncat.x86_64 -y 下载libevent wget https://github.com/libevent/libevent.git 解压libevent tar -xzvf libevent-2.1.12-stable.tar.gz 测试demo cd libeven
【Linux】error while loading shared libraries: libevent-2.1.so.6 的解决办法|动态库.so找不到的解决办法
bandaoyu的note
08-30 2390
执行memcached启动命令时，报错，提示：error while loading shared libraries: libevent-2.1.so.6: cannot open shared object file: No such file or directory 查看 memcached 命令缺失什么库 ldd /usr/local/memcached/bin/memcached 结果： libevent-2.1.so.6 模块找不到 查看 libevent-2.1.so.6 是否存..
libevent for echo server and client
heer17640765的专栏
01-07 434
echo server and client code for libevent

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值