Linux libevent 库基础用法详解

这篇文章小编带小伙伴们详细了解下 libevent 库的基础用法~

小编在之前的项目中用到这个，就回顾下技能点，给小伙伴们分享下~好吧，直接进入主题~

libevent 介绍

libevent 是一个高效的事件驱动库，旨在支持异步 I/O 操作，广泛用于网络编程。它提供了跨平台的 API，支持多种事件通知机制（如 epoll、kqueue 等），允许开发者注册回调函数以处理特定事件，如 TCP/UDP 连接、定时器、信号等。libevent 的事件循环模型使得程序能够在不阻塞的情况下处理大量并发连接，适合构建高性能的服务器和网络应用。

官网地址：打开站点，想要了解更详细的小伙伴，可以去官网逛逛~

libevent 有哪些特点？

1. 事件驱动： libevent 允许程序注册回调函数，这些函数会在特定事件发生时被调用，从而实现非阻塞的 I/O 操作。
2. 跨平台支持： libevent 支持多种操作系统，包括 Linux、macOS、Windows 等，提供统一的 API 接口，方便移植。
3. 多种后端支持： libevent 支持多种事件通知机制，包括 epoll、kqueue、select 和 poll 等，能够根据不同平台选择最优的实现。
4. 高效能： 由于采用了事件驱动的模型，libevent 能够处理大量并发连接，并且具有较低的延迟和高吞吐量。
5. 易用性： libevent 提供了一套简单易用的 API，便于开发者快速上手。

简单了解下 libevent 核心架构

1. 事件循环（Event Loop）： 事件循环是 libevent 的核心部分，负责管理所有事件的调度和处理。它不断检查是否有待处理的事件，并调用相应的回调函数。
2. 事件（Event）： 在 libevent 中，事件表示一个可以被监控的对象，比如文件描述符、定时器等。事件可以注册回调函数，当事件发生时，回调函数将被调用。
3. 上下文（Event Base）：event_base 结构体表示一个事件循环的上下文，所有的事件和回调都与这个上下文相关联。

基本使用

一、event_base

event_base是 libevent 库中的一个重要结构体，它代表了一个事件循环的上下文。这个结构体用于管理和调度所有的事件和回调函数。可以把它看作是事件循环的核心，它帮助管理事件的注册、事件的触发和回调的执行。

主要作用：

• 事件循环管理：event_base控制着事件循环的生命周期，启动事件循环、处理事件以及调度回调函数。
• 事件调度：它管理所有与事件相关的数据结构（如文件描述符、定时器、信号等），并在事件发生时将其调度到相应的回调函数。
• 选择事件通知机制：libevent 可以根据操作系统的特性选择不同的事件通知机制（如 epoll、kqueue、select），event_base 会负责选择和配置合适的机制。

常见操作：

1. 创建和初始化

struct event_base *base = event_base_new();

使用event_base_new()创建一个新的 event_base 对象，初始化事件循环。

2. 释放资源：

当事件循环结束时，使用event_base_free()释放event_base占用的资源。

void event_base_free(struct event_base *base);

3. 运行事件循环

使用event_base_dispatch()启动事件循环，开始处理注册的事件。

int event_base_dispatch(struct event_base *base);

返回值：0 表示成功退出  -1 表示存在错误信息。

事件循环还可以用这个：event_base_loop

#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);

event_base_loop会比event_base_dispatch用起来更加灵活。

• EVLOOP_ONCE： 阻塞直到有一个活跃的 event，然后执行完活跃事件的回调就退出。
• EVLOOP_NONBLOCK: 不阻塞，检查哪个事件准备好，调用优先级最高的那一个，然后退出。

如果 flags 参数填了 0，则只有事件进来的时候才会调用一次事件的回调函数，比较常用。

事件循环停止的情况：

• event_base中没有事件event；
• 调用event_base_loopbreak()；
• 调用event_base_loopexit()；
• 程序错误，异常退出。

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

event_base_loopexit 与 event_base_loopbreak 区别：

• 使用event_base_loopexit()时，事件循环会在当前事件处理完成后退出，或者在指定的超时时间后退出。适用于优雅地退出事件循环。
• 使用event_base_loopbreak()时，事件循环会立即停止，跳出事件循环，适用于紧急退出的场景。

4. 可以查看 IO 模型

IO 多路复用模型中有多种方法，但是这些模型是在不同的平台下面的： select  poll  epoll  kqueue  devpoll  evport  win32。在咱们创建一个event_base的时候，libevent 会自动为我们选择最快的 IO 多路复用模型，Linux 下一般会用 epoll 模型。

下面这个方法主要是用来获取 IO 模型的名称。

const char *event_base_get_method(const struct event_base *base);

举个 envent_base 例子：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>    
#include <sys/socket.h>    
#include <netinet/in.h>    
#include <arpa/inet.h>   
#include <string.h>
#include <fcntl.h>

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

int main() {
printf("init a event_base!");
        struct event_base *eventBase; //定义一个 event_base
	eventBase= event_base_new(); //初始化一个 event_base
const char *x =  event_base_get_method(eventBase); //查看用了哪个 IO 多路复用模型，linux 一下用 epoll
printf("IO mode:%s\n", x);
int y = event_base_dispatch(eventBase); //事件循环。因为没有注册事件，所以会直接退出
event_base_free(eventBase);  //销毁 libevent
return 1;
}

二、 event 事件

在 libevent 中，”事件” 是事件驱动模型的基本单元，通常是指与文件描述符、定时器或信号等资源相关的事件。每个事件会关联一个回调函数，当特定事件发生时，libevent 会触发相应的回调函数来处理该事件。

1. 创建一个事件 event

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

参数说明：

（1）struct event_base *base:

• 类型：struct event_base *
• 作用：事件循环的上下文，表示事件循环的基础。event_base是 libevent 中的核心结构，它管理事件循环和事件的调度。所有与事件循环相关的操作都必须与一个event_base关联。
• 示例：你需要使用event_base_new()创建一个事件循环上下文，传入这个上下文来创建事件。

struct event_base *base = event_base_new();

（2）evutil_socket_t fd:

• 类型：evutil_socket_t
• 作用：事件所监听的文件描述符。它可以是一个网络套接字（如 TCP 或 UDP 套接字）或者其他文件描述符（如标准输入、标准输出）。该文件描述符用于注册具体的事件（如可读、可写等）。
• 示例：传入你希望监听的文件描述符，例如标准输入STDIN_FILENO、网络套接字等。

  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  struct event *ev = event_new(base, sockfd, EV_READ, read_callback, NULL);

（3）short what:

• EV_READ：表示监听可读事件。
• EV_WRITE：表示监听可写事件。
• EV_TIMEOUT：表示监听超时事件。
• EV_SIGNAL：表示监听信号事件。
• EV_PERSIST：表示事件是持久的，即事件触发后不会被移除，直到显式调用event_del()删除它。

示例：例如，如果你想监听文件描述符的可读事件，可以传入EV_READ；如果你还希望这个事件在触发后持续有效，则可以使用EV_PERSIST：

struct event *ev = event_new(base, fd, EV_READ | EV_PERSIST, callback, NULL);

（4）event_callback_fn cb:

• 类型：event_callback_fn，即回调函数类型。
• 作用：当事件发生时（如文件描述符可读、可写，或者超时等），libevent 会调用该回调函数来处理事件。回调函数的签名为：

  void callback(evutil_socket_t fd, short events, void *arg);

  其中：fd 是发生事件的文件描述符。events 是事件类型（如 EV_READ、EV_WRITE）。arg 是你传递给回调函数的附加数据。

• 示例：你可以定义一个回调函数来处理文件描述符的可读事件。例如：

  void read_callback(evutil_socket_t fd, short events, void *arg) {
      char buffer[256];
      ssize_t len = read(fd, buffer, sizeof(buffer) - 1);
      if (len > 0) {
          buffer[len] = '\0';
          printf("Received data: %s\n", buffer);
      }
  }

（5）void *arg:

• 类型：void *
• 作用：这是一个指向用户数据的指针，可以传递任意类型的数据到回调函数。你可以在创建事件时传入一些额外的数据（如上下文、状态信息等），并在回调函数中访问它。
• 示例：如果你想在回调中使用一些自定义的上下文数据，可以传入一个指针：

  int some_data = 42;
  struct event *ev = event_new(base, fd, EV_READ, read_callback, &some_data);

2. 释放 event_free

void event_free(struct event *event);//释放 event 内存

3. 注册 event

作用：向event_base注册事件。

参数：ev 为事件指针；tv 为时间指针。当 tv = NULL 的时候则无超时时间。

函数返回：0 表示成功 -1 表示失败。

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

tv 时间结构例子：

struct timeval timeSeconds= {5, 0};
event_add(ev1, &timeSeconds);

事件注意事项：

1. 每个事件event都需要通过event_new来初始化生成。event_new创建的事件是在堆上分配内存的。
2. 当一个事件通过event_add被注册到event_base时，该事件进入“待处理”（pending）状态，只有在满足事件条件时（例如文件描述符变得可读或可写），该事件才会转变为“激活”（active）状态，此时关联的回调函数会被触发执行。
3. 如果在event_new中为what参数选择了EV_PERSIST标志，表示该事件是持久类型的。持久类型的事件在回调函数被调用之后不会自动解除注册，它会重新进入“待处理”状态，继续等待下一个事件的到来。这意味着持久事件会在每次触发回调后继续保持有效状态，直到显式调用event_del将其移除。
4. 相比之下，非持久类型的事件在回调函数调用完成后会自动变为初始化状态，此时需要再次调用event_add重新将事件注册到event_base中，才能继续监听相应的事件。

使用 C 编了一个 socket 的例子，感兴趣的可以参考下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <fcntl.h>
#include <event2/event.h>
#include <event2/bufferevent.h>
// 处理客户端读取数据并返回
void handle_client_read(evutil_socket_t fd, short events, void *arg) {
    char buffer[1024];
    int bytes_received;
    // 接收数据
    if ((bytes_received = recv(fd, buffer, sizeof(buffer), 0)) > 0) {
        buffer[bytes_received] = '\0';  // 确保字符串结束
        printf("Received: %s\n", buffer);
        // 将接收到的数据发送回客户端
        if (send(fd, buffer, bytes_received, 0) < 0) {
            perror("send");
        }
    }
}
// 处理新的客户端连接
void accept_connection(evutil_socket_t listener_fd, short events, void *arg) {
    struct sockaddr_in client_address;
    socklen_t client_len = sizeof(client_address);
    int client_fd = accept(listener_fd, (struct sockaddr*)&client_address, &client_len);
    if (client_fd < 0) {
        perror("accept");
        return;
    }
    // 获取事件基础结构
    struct event_base *base = (struct event_base *)arg;
    // 发送欢迎信息给客户端
    const char *welcome_msg = "Welcome to My socket";
    send(client_fd, welcome_msg, strlen(welcome_msg), 0);
    // 创建事件，监听客户端数据
    struct event *client_event = event_new(base, client_fd, EV_READ | EV_PERSIST, handle_client_read, base);
    event_add(client_event, NULL);  // 将事件加入事件循环
}
// 设置服务器并开始监听
int setup_server(const char *host, int port) {
    int server_fd;
    struct sockaddr_in server_addr;
    // 创建 socket
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        return -1;
    }
    // 设置地址重用
    evutil_make_listen_socket_reuseable(server_fd);
    evutil_make_socket_nonblocking(server_fd);
    // 初始化服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(host);  // 绑定到特定的 IP
    server_addr.sin_port = htons(port);
    // 绑定服务器地址
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        return -1;
    }
    // 开始监听
    if (listen(server_fd, 10) < 0) {
        perror("listen");
        close(server_fd);
        return -1;
    }
    return server_fd;
}
int main() {
    // 设置监听端口和主机
    const char *host = "0.0.0.0";
    int port = 8001;
    // 初始化事件基础结构
    struct event_base *base = event_base_new();
    if (!base) {
        perror("event_base_new");
        return 1;
    }
    // 获取当前的 IO 复用方法
    const char *method = event_base_get_method(base);
    printf("Using method: %s\n", method);
    // 设置服务器
    int server_fd = setup_server(host, port);
    if (server_fd < 0) {
        event_base_free(base);
        return 1;
    }
    // 创建事件，监听新的客户端连接
    struct event *accept_event = event_new(base, server_fd, EV_READ | EV_PERSIST, accept_connection, base);
    event_add(accept_event, NULL);  // 将事件加入事件循环
    // 启动事件循环
    event_base_dispatch(base);
    // 释放资源
    event_base_free(base);
    close(server_fd);
    return 0;
}

libevent 作为一个轻量级且高效的事件驱动库，为开发者提供了跨平台的异步 I/O 解决方案。通过简洁的 API，它能够轻松管理大量并发连接，适用于构建高性能网络服务。本文从 event_base 核心结构入手，逐步介绍了事件的创建、注册与回调机制，并辅以完整的 socket 示例，帮助读者直观理解 libevent 的基本用法。其底层自动选择最优的 I/O 多路复用模型（如 Linux 下的 epoll），既保证了性能，又降低了开发复杂度。无论是定时器、信号处理还是网络通信，libevent 都能以事件驱动的方式优雅应对。希望这篇入门分享能激发读者对事件驱动编程的兴趣，在实际项目中灵活运用 libevent，打造高效稳定的网络应用。更多高级特性可参考官方文档，持续探索这个成熟库的强大功能。

以上关于Linux libevent 库基础用法详解的文章就介绍到这了，更多相关内容请搜索码云笔记以前的文章或继续浏览下面的相关文章，希望大家以后多多支持码云笔记。