Libevent网络库的原理与应用
1. Libevent介绍
Libevent 是一个用C语言编写的、轻量级的开源高性能事件通知库，主要有以下几个亮点：
- 事件驱动（ event-driven），高性能;
- 轻量级，专注于网络；
- 源代码相当精炼、易读；
- 支持多种 I/O 多路复用技术， epoll、 poll、 select 和 kqueue 等；
- 支持注册事件优先级。
1.1 安装Libevent
下载地址: http://http://libevent.org/
安装步骤 -> 源码安装的方式（终端打开下载目录）
1. 可执行程序: configure
./configure // 检测安装环境, 并且生成一个makefile文件
2. 根据makefile中的构建规则编译源代码
make
3. 安装
sudo make install //将得到可执行程序/动态库/静态库/头文件拷贝到系统目录
动态库找不到问题解决：
- 通过find命令查找对应的库的位置
find 搜索目录 -name "http://libevent.so"
得到结果: /usr/local/lib/libevent.so
- 通过vi 打开/etc/ld.so.conf文件
sudo /etc/ld.so.conf
将/usr/local/lib/放到文件的最后一行, 保存
- 执行命令: sudo ldconfig
编译要加上动态库event hello.c
gcc hello.c -o hello -levent
2. 事件处理框架 - event_base
使用 libevent函数之前需要分配一个或者多个 event_base 结构体。每个event_base 结构体持有一个事件集合，可以检测以确定哪个事件是激活的。每个 event_base 都有一种用于检测哪种事件已经就绪的 “方法”。
2.1 event_base API函数
// 头文件
#include < event2/event.h >
// 操作函数
struct event_base * event_base_new（void）; //创建事件处理框架
void event_base_free（struct event_base * base）; //释放事件处理框架
// 检查event_base的后端方法
const char** event_get_supported_methods(void）;
const char *event_base_get_method(const struct event_base *base);
event_base和fork（进程）关系：
- 子进程创建成功之后, 父进程可以继续使用event_base
- 子进程中需要继续使用event_base需要用下面函数，重新初始化
int event_reinit(struct event_base* base);
例子：
#include < stdio.h >
#include < stdlib.h >
#include < unistd.h >
#include < string.h >
#include < event2/event.h >
int main()
{
// 1. 创建事件处理框架
struct event_base* base = event_base_new();
// 打印支持的IO转接函数
const char** method = event_get_supported_methods();
for(int i=0; method[i] != NULL; ++i)
{
printf("%sn", method[i]);
}
printf("current method: %sn", event_base_get_method(base));
// 创建子进程
pid_t pid = fork();
if(pid == 0)
{
// 子进程中event_base也会被复制,在使用这个base时候要重新初始化
event_reinit(base);
}
// 2. 释放资源
event_base_free(base);
return 0;
}
3. 事件循环
event_base不停的检测委托的检测是实际是不是发生了, 如果发生了, event_base会调用对应的回调函数, 这个回调函数的用户委托检测事件的时候给的.
3.1 设置事件循环
如果委托了event_base检测某些事件, 不停的进行循环检测
结束检测时间: 所有要检测的事件都被触发, 并且处理完毕。
// 头文件
#include < event2/event.h >
// 操作函数
#define EVLOOP_ONCE 0x01
#define EVLOOP_NONBLOCK 0x02
#define EVLOOP_NO_EXIT_ON_EMPTY 0x04
int event_base_loop(struct event_base *base, int flags);
参数:
- base: 通过 event_base_new（void）得到的
- flags:
- EVLOOP_ONCE: 一直检测某个事件, 当事件被触发了, 停止事件循环
- EVLOOP_NONBLOCK: 非阻塞的方式检测, 当事件被触发了, 停止事件循环
- EVLOOP_NO_EXIT_ON_EMPTY: 一直进行事件检测, 如果没有要检测的事件, 不退出
int event_base_dispatch(struct event_base* base); // 一般使用这个函数
参数:
- base: 通过 event_base_new（void）得到的
3.2 终止事件循环
// 头文件
#include < event2/event.h >
struct timeval {
long tv_sec;
long tv_usec; // 微秒
};
// 在 tv 时长之后退出循环, 如果这个参数为空NULL, 直接退出事件循环
// 事件循环: 检测对应的事件是否被触发了
// 如果事件处理函数正在被执行, 执行完毕之后才终止
int event_base_loopexit(struct event_base * base, const struct timeval * tv);
// 马上终止
int event_base_loopbreak(struct event_base * base);
4. 事件
4.1 事件基本操作
- 事件的创建 event_new
#include < event2/event.h >
//要检测事件 what：
#define EV_TIMEOUT 0x01
#define EV_READ 0x02
#define EV_WRITE 0x04
#define EV_SIGNAL 0x08
#define EV_PERSIST 0x10 // 修饰某个事件是持续触发的
#define EV_ET 0x20 // 边沿模式
//回调函数格式：
typedef void (*event_callback_fn)(evutil_socket_t，short，void *);
参数:
- 第一个参数: event_new的第二个参数
- 第二个参数: 实际触发的事件
- 第三个参数: event_new的最后一个参数
// 创建事件
struct event* event_new(struct event_base * base，evutil_socket_t fd，
short what，event_callback_fn cb，void * arg);
参数:
- base: event_base_new得到的
- fd: 文件描述符, 检测这个fd对应的事件
- what: 监测fd的什么事件
- cb: 回调函数, 当前检测的事件被触发, 这个函数被调用
- arg: 给回调函数传参
- 事件的释放
#include < event2/event.h >
// 释放事件资源
void event_free(struct event * event);
- 事件的添加、删除
事件被new出之后, 不能直接被event_base进行检测event_add之后event_base就可以对事件进行检测
#include < event2/event.h >
int event_add(struct event * ev，const struct timeval * tv);
参数: tv- > 超时时间,
如果这个值 > 0, 比如 == 3
检测fd的读事件, 在三秒之内没有触发该事件 - > 超时- > 超时之后, 事件对应的回调函数会被强制调用
如果该参数为NULL, 不会做超时检测
// 删除要检测的事件
int event_del(struct event * ev);
4.2 事件的优先级设置
// 头文件
#include < event2/event.h >
// EVENT_MAX_PRIORITIES == 256 最大的初始化事件优先级
int event_base_priority_init(struct event_base * base，int n_priorities);
参数:
- n_priorities: 等级的个数, 假设 == 6
也就是说有6个等级: 0,1,2,3,4,5, 0优先级最高
// 获取当前可用的等的个数
int event_base_get_npriorities(struct event_base * base);
// 给事件设置等级
int event_priority_set(struct event *event, int priority);
参数:
- event: 创建的事件
- priority: 要设置的等级
例子：使用event实现有名管道的进程间通信myfifo
myfifo管道文件要提前创造好
读端：
#include < stdio.h >
#include < stdlib.h >
#include < unistd.h >
#include < string.h >
#include < event2/event.h >
#include < fcntl.h >
//读的回调函数
void read_cb(evutil_socket_t fd, short what, void* arg)
{
char buf[128];
int count = read(fd, buf, sizeof(buf)+1);
printf("read data: %s, %dn", buf, count);
printf("read event: %sn", what & EV_READ ? "yes" : "no");
printf("what: %dnn", what);
}
int main()
{
int fd = open("myfifo", O_RDONLY);
if (fd == -1)
{
perror("open");
exit(0);
}
struct event_base* base = event_base_new();
//创建事件
struct event* ev = event_new(base, fd, EV_READ|EV_PERSIST, read_cb, NULL);
//添加事件
event_add(ev, NULL);
//事件循环检测
event_base_dispatch(base);
//释放资源
event_free(ev);
event_base_free(base);
return 0;
}
写端：
#include < stdio.h >
#include < stdlib.h >
#include < unistd.h >
#include < string.h >
#include < event2/event.h >
#include < fcntl.h >
//读的回调函数
void write_cb(evutil_socket_t fd, short what, void* arg)
{
char buf[128];
static int num = 0;
sprintf(buf, "hello, %dn", num++);
int count = write(fd, buf, sizeof(buf)+1);
printf("wirte data: %s, %dn", buf, count);
printf("wirte event: %sn", what & EV_WRITE ? "yes" : "no");
printf("what: %dnn", what);
sleep(3);
}
int main()
{
int fd = open("myfifo", O_WRONLY);
if (fd == -1)
{
perror("open");
exit(0);
}
struct event_base* base = event_base_new();
//创建事件
struct event* ev = event_new(base, fd, EV_WRITE|EV_PERSIST, write_cb, NULL);
//添加事件
event_add(ev, NULL);
//事件循环检测
event_base_dispatch(base);
//释放资源
event_free(ev);
event_base_free(base);
return 0;
}
5. 带缓冲区的事件
概念理解：
- bufferevent 理解:
- 是libevent为IO缓冲区操作提供的一种通用机制
- bufferevent 由一个底层的传输端口(如套接字 ), 一个读取缓冲区和一个写入缓冲区组成。
- 与通常的事件在底层传输端口已经就绪, 可以读取或者写入的时候执行回调不同的是, bufferevent在读取或者写入了足够量的数据之后调用用户提供的回调。
- 每个 bufferevent 有两个数据相关的回调
- 读取回调: 从底层传输端口读取了任意量的数据之后会调用读取回调(默认)
- 写入回调: 输出缓冲区中足够量的数据被清空到底层传输端口后写入回调会被调用(默认)
创建/释放基于套接字的bufferevent bufferevent_socket_new
主要应用于网络套接字通信 -> socket()
struct bufferevent *bufferevent_socket_new(
struct event_base *base,
evutil_socket_t fd,
enum bufferevent_options options
);
参数:
- base: 处理事件的
- fd: 通信的文件描述符
- options: BEV_OPT_CLOSE_ON_FREE - > 自动释放底层资源
返回值: 得到带缓冲区的事件变量
// 释放资源
void bufferevent_free(struct bufferevent *bev);
在bufferevent上启动连接服务器函数 bufferevent_socket_connect
- 如果还没有为bufferevent 设置套接字,调用函数将为其分配一个新的流套接字,并且设置为非阻塞的
例子：bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
- 如果已经为 bufferevent 设置套接字,调用bufferevent_socket_connect() 将告知 libevent 套接字还未连接,直到连接成功之前不应该对其进行读取或者写入操作。
- 连接完成之前可以向输出缓冲区添加数据。
int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *address, int addrlen);
参数:
- bev: 带缓冲区的事件, 里边封装 fd
- address: 要连接的服务器的IP和端口
- addrlen: address结构体的内存大小
bufferevent读写缓冲区回调操作 bufferevent_setcb
//读、写事件触发之后的回调函数格式
typedef void (*bufferevent_data_cb)(struct bufferevent *bev, void *ctx);
参数:
- bev: 从bufferevent_setcb函数中的第一个参数传入的
- ctx: 从bufferevent_setcb函数中的最后第一个参数传入的
//特殊事件的回调函数格式
typedef void (*bufferevent_event_cb)(struct bufferevent *bev, short events, void *ctx);
参数:
- bev: 从bufferevent_setcb函数中的第一个参数传入的
- events: 可以检测到的事件
EV_EVENT_READING：读取操作时发生某事件，具体是哪种事件请看其他标志。
BEV_EVENT_WRITING：写入操作时发生某事件，具体是哪种事件请看其他标志。
BEV_EVENT_ERROR：操作时发生错误。关于错误的更多信息，请调用 EVUTIL_SOCKET_ERROR()。
BEV_EVENT_TIMEOUT：发生超时。
BEV_EVENT_EOF：遇到文件结束指示。
BEV_EVENT_CONNECTED：请求的连接过程已经完成
void bufferevent_setcb(struct bufferevent *bufev,
bufferevent_data_cb readcb,
bufferevent_data_cb writecb,
bufferevent_event_cb eventcb, void *cbarg
);
参数:
- bufev: 带缓冲区的事件
- readcb: 读事件触发之后的回调函数
- writecb: 写事件触发之后的回调函数
- eventcb: 特殊事件的回调函数
- cbarg: 给回调函数传参
禁用、启用缓冲区
可以启用或者禁用 bufferevent 上的 EV_READ、EV_WRITE 或者 EV_READ | EV_WRITE 事件。
没有启用读取或者写入事件时, bufferevent 将不会试图进行数据读取或者写入。
写缓冲区默认是有效的，读缓冲区默认无效
// 设置某个事件有效
void bufferevent_enable(struct bufferevent *bufev, short events);
// 设置某个事件无效
void bufferevent_disable(struct bufferevent *bufev, short events);
// 获取缓冲区对应的有效事件
short bufferevent_get_enabled(struct bufferevent *bufev);
操作bufferevent中的数据 bufferevent_write bufferevent_read
// 向bufferevent的输出缓冲区添加数据
int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size);
// 从bufferevent的输入缓冲区移除数据
size_t bufferevent_read(struct bufferevent *bufev, void *data, size_t size);
6. 链接监听器
- 创建和释放evconnlistener
#include < event2/listener.h >
//回调函数格式
typedef void (*evconnlistener_cb)(
struct evconnlistener *listener,
evutil_socket_t sock,
struct sockaddr *addr,
int len,
void *ptr
);
参数:
- listener: evconnlistener_new_bind 返回的地址
- sock: 用于通信的fd
- addr: 客户端的地址信息
- ptr: 外部传进来的参数, evconnlistener_new_bind的第三个参数
// 创建监听的套接字, 绑定, 设置监听, 等待并接受连接请求
struct evconnlistener *evconnlistener_new_bind(
struct event_base *base,
evconnlistener_cb cb, // 接受新连接之后的回调函数
void *ptr, // 回调函数参数
unsigned flags,
int backlog, // listen()中的第二参数，最多的监听数量，小于128的整数
const struct sockaddr *sa, // 本地的IP和端口
int socklen // struct sockaddr结构体大小
);
参数:
- flags:
LEV_OPT_CLOSE_ON_FREE: 自动关闭底层套接字
LEV_OPT_REUSEABLE: 设置端口复用
// 释放
void evconnlistener_free(struct evconnlistener *lev);
- 启用和禁用 evconnlistener
设置无效之后, 就不监听连接请求了
#include < event2/listener.h >
int evconnlistener_disable(struct evconnlistener *lev);
int evconnlistener_enable(struct evconnlistener *lev);
- 调整 evconnlistener 的回调函数
#include < event2/listener.h >
void evconnlistener_set_cb(struct evconnlistener *lev, evconnlistener_cb cb, void *arg);
7. 例子：用event实现服务器和客户端tcp通信
服务器使用链接监听器、带缓冲区的事件
客户端使用带缓冲区的事件
服务器server代码：
#include < stdio.h >
#include < stdlib.h >
#include < unistd.h >
#include < string.h >
#include < arpa/inet.h >
#include < event2/event.h >
#include < event2/bufferevent.h >
#include < event2/listener.h >
// read缓冲区的回调
void read_cb(struct bufferevent* bev, void* arg)
{
// 读缓冲区的数据
char buf[128];
int len = bufferevent_read(bev, buf, sizeof(buf));
printf("read data: len = %d, str = %sn", len, buf);
// 回复数据
bufferevent_write(bev, buf, len);
printf("数据发送完毕...n");
}
// 写缓冲区的回调
// 调用的时机: 写缓冲区中的数据被发送出去之后, 该函数被调用
void write_cb(struct bufferevent* bev, void* arg)
{
printf("arg value: %sn", (char*)arg);
printf("数据已经发送完毕...xxxxxxxxxxxxn");
}
// 事件回调
void events_cb(struct bufferevent* bev, short event, void* arg)
{
if(event & BEV_EVENT_ERROR)
{
printf("some error happened ...n");
}
else if(event & BEV_EVENT_EOF)
{
printf("server disconnect ...n");
}
// 终止连接
bufferevent_free(bev);
}
// 接收连接请求之后的回调
void listener_cb(struct evconnlistener *listener,
evutil_socket_t sock,
struct sockaddr *addr,
int len,
void *ptr)
{
// 通信
// 使用带缓冲区的事件对sock进行包装
struct event_base* base = (struct event_base*)ptr;
struct bufferevent* bev = bufferevent_socket_new(base, sock, BEV_OPT_CLOSE_ON_FREE);
// 设置回调
bufferevent_setcb(bev, read_cb, write_cb, events_cb, NULL);
bufferevent_enable(bev, EV_READ);
}
int main()
{
struct event_base * base = event_base_new();
// 1. 创建监听的套接字, 绑定, 设置监听, 等待并接受连接请求
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(9898); // 服务器监听的端口
addr.sin_addr.s_addr = INADDR_ANY;
struct evconnlistener* listener = evconnlistener_new_bind(base, listener_cb, base,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
100, (struct sockaddr*)&addr, sizeof(addr));
event_base_dispatch(base);
evconnlistener_free(listener);
event_base_free(base);
return 0;
}
客户端client代码：
#include < stdio.h >
#include < stdlib.h >
#include < unistd.h >
#include < string.h >
#include < arpa/inet.h >
#include < event2/event.h >
#include < event2/bufferevent.h >
// read缓冲区的回调
void read_cb(struct bufferevent* bev, void* arg)
{
printf("arg value: %sn", (char*)arg);
// 读缓冲区的数据
char buf[128];
int len = bufferevent_read(bev, buf, sizeof(buf));
printf("read data: len = %d, str = %sn", len, buf);
// 回复数据
bufferevent_write(bev, buf, len);
printf("数据发送完毕...n");
}
// 写缓冲区的回调
// 调用的时机: 写缓冲区中的数据被发送出去之后, 该函数被调用
void write_cb(struct bufferevent* bev, void* arg)
{
printf("arg value: %sn", (char*)arg);
printf("数据已经发送完毕...xxxxxxxxxxxxn");
}
// 事件回调
void events_cb(struct bufferevent* bev, short event, void* arg)
{
if(event & BEV_EVENT_ERROR)
{
printf("some error happened ...n");
}
else if(event & BEV_EVENT_EOF)
{
printf("server disconnect ...n");
}
// 终止连接
bufferevent_free(bev);
}
void send_msg(evutil_socket_t fd, short ev, void * arg)
{
// 将写入到终端的数据读出
char buf[128];
int len = read(fd, buf, sizeof(buf));
// 发送给服务器
struct bufferevent* bev = (struct bufferevent*)arg;
bufferevent_write(bev, buf, len);
}
int main()
{
struct event_base * base = event_base_new();
// 1. 创建通信的套接字
struct bufferevent* bufev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
// 2. 连接服务器
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(9898); // 服务器监听的端口
inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr.s_addr);
// 这个函数调用成功, == 服务器已经成功连接
bufferevent_socket_connect(bufev, (struct sockaddr*)&addr, sizeof(addr));
// 3. 通信
// 给bufferevent的缓冲区设置回调
bufferevent_setcb(bufev, read_cb, write_cb, events_cb, (void*)"hello, world");
bufferevent_enable(bufev, EV_READ);
// 创建一个普通的输入事件
struct event* myev = event_new(base, STDIN_FILENO, EV_READ|EV_PERSIST, send_msg, bufev);
event_add(myev, NULL);
event_base_dispatch(base);
event_free(myev);
event_base_free(base);
return 0;
}
8. 总结：
处理不带缓冲区的事件：
- 创建事件处理框架event_base event_base_new（）
- 创建新事件event event_new（）
- 将事件添加到事件处理框架event_base上 event_add（）
- 启动事件循环检测 event_base_dispatch（）
- 循环结束之后释放资源 event_base_free（） 、event_free（）
处理带缓冲区的事件：
1、创建事件处理框架event_base event_base_new（）
2、服务器端：
- 创建连接监听器（在回调函数得到fd） evconnlistener_new_bind（）
- 将通信fd包装 bufferevent_socket_new（）
- 使用bufferevent通信：给bufferevent读写缓冲区设置回调函数 bufferevent_setcb（）
- 设置读缓冲区可用 bufferevent_enable（）
- 对缓冲区数据操作 bufferevent_write（）、bufferevent_rea（）
3、客户端：
- 创建通信用的fd并且使用bufferevent包装 bufferevent_socket_new（）
- 连接服务器 bufferevent_socket_connect（）
- 使用bufferevent通信：给bufferevent读写缓冲区设置回调函数 bufferevent_setcb（）
- 设置读缓冲区可用 bufferevent_enable（）
- 对缓冲区数据操作 bufferevent_write（）、bufferevent_read（）
声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。
举报投诉
-
C语言
+关注
关注
180文章
7591浏览量
135770 -
源码
+关注
关注
8文章
632浏览量
29100 -
网络库
+关注
关注
0文章
7浏览量
1282
发布评论请先 登录
相关推荐
鸿蒙开发实战：网络请求库【axios】
[Axios] ，是一个基于 promise 的网络请求库，可以运行 node.js 和浏览器中。本库基于[Axios]原库v1.3.4版本进行适配，使其可以运行在 OpenHarmo
安装libevent报错
[dudu@localhost libevent-1.3]# makemakeall-recursivemake[1]: 进入目录“/tmp/libevent-1.3”Making all
发表于 07-30 08:22
Linux经典书籍介绍
Libevent 是一个用C语言编写的、轻量级的开源高性能事件通知库，主要有以下几个亮点：事件驱动（ event-driven），高性能;轻量级，专注于网络，不如 ACE 那么臃肿庞大；源代码相当
发表于 07-26 07:34
怎样去移植在ARM嵌入式平台的libevent呢
libevent-2.1.8-stable.tar.gz 下载openssl-1.1.1a.tar.gz 下载openssl 交叉编译在《arm-linux 交叉编译wget支持openssl, 使
发表于 12-14 07:15
如何将交叉编译libevent源码移植到RK1126平台上
程序中需要起一个http服务来与主控进行交互，正好之前海思平台用的是libevent现在需要移植到RK平台 。把libevent源码下下来之后 随便放一个目录然后建一个build.sh内容如下
发表于 10-08 16:40
Oracle数据库网络安全访问机制
本文主要分析了Oracle 客户端通过Net8 访问数据库服务器过程，阐述了Oracle 数据库的网络访问机制以及Net8 在实现Oracle 数据库的服务器和客户端之间安全的数据通信
发表于 08-29 10:20
•20次下载
Java数据库连接及网络程序设计
Java数据库连接及网络程序设计
一、实验目的： 通过Socket编程，掌握网络应用程序的开发方法；完成数据库的连接；掌握利用Ja
发表于 12-05 23:56
•1443次阅读
NVIDIA深度神经网络加速库cuDNN软件安装教程
计基于GPU的加速库 。cuDNN为深度神经网络中的标准流程提供了高度优化的实现方式，例如convolution、pooling、normalization以及activation layers的前向以及后向过程。 cuDNN只是NVIDIA深度神经
发表于 12-08 10:40
•2260次阅读
一个最简单的事件驱动的IO libevent编程例子
本文演示一个最简单的基于libevent编程的例子。libevent是事件驱动的IO，适用于“好莱坞原则”。
OHosAsync底层网络协议库的教程案例
OHosAsync 是一个底层网络协议库。如果您正在寻找一个易于使用、更高级别、支持 Ohos 的 http 请求库，请查看 Ion（它构建在 OhosAsync 之上）。典型的 Ohos 应用程序
发表于 04-12 10:01
•2次下载
OHOS库反应网络的使用教程
ReactiveNetwork ：ReactiveNetwork 是一个 OHOS 库，通过 RxJava Observables 监听网络连接状态和互联网连接。它是用反应式编程方法编写
发表于 04-12 10:11
•2次下载
Libevent框架库简介
一、Libevent简介 Libevent是开源社区一款高性能的I/O框架库，其具有如下特点： 1、跨平台支持。Libevent支持Linux、UNIX和Windows。 2、统一事件
工商网监
评论