Linux中eventfd的讲解

什么是 eventfd？

eventfd 是 Linux 内核中用于线程或进程间通信的一种机制。它提供了一种简单的方式，让一个线程或进程可以通知另一个线程或进程某个事件已经发生。eventfd 是基于文件描述符的，因此可以与 select、poll 或 epoll 等 I/O 多路复用机制一起使用。

如何使用 eventfd？

创建 eventfd

int eventfd(unsigned int initval, int flags);

• initval：初始化计数器的值。
• flags：可以是 EFD_NONBLOCK（非阻塞模式）和/或 EFD_CLOEXEC（设置文件描述符在执行exec函数时关闭,禁止进程复制）。

返回一个新的文件描述符，若失败则返回-1。

读取 eventfd

通过 read 函数读取 eventfd 中的计数器值。

uint64_t count;
read(fd, &count, sizeof(count));

写入 eventfd

通过 write 函数向 eventfd 写入一个 64 位的无符号整数，表示事件的数量。

uint64_t count = 1;
write(fd, &count, sizeof(count));

eventfd 的原理

eventfd 的原理可以简单理解为通过文件描述符进行事件通知和计数管理。下面是更详细的解释：

基本原理

1. 文件描述符（File Descriptor）：
   • eventfd 是通过文件描述符来进行操作的。文件描述符是一种抽象的表示，用于访问文件或其他输入/输出资源（如管道、套接字）。
2. 计数器：
   • eventfd 内部维护了一个 64 位的无符号整数计数器。这个计数器的值可以通过 write 函数增加，通过 read 函数读取并重置。
3. 事件通知：
   • 当线程或进程需要通知另一个线程或进程某个事件发生时，它会向 eventfd 写入一个值（通常是 1）。这会增加 eventfd 内部的计数器。
   • 被通知的线程或进程则通过 read 函数读取这个计数器的值，从而得知事件发生的次数。

内部机制

• 原子性：

  • eventfd 保证了写入和读取操作的原子性，即操作是不可分割的。这意味着多个线程可以安全地进行并发操作而无需额外的同步机制。

• 阻塞与非阻塞：

  • eventfd 可以在阻塞模式和非阻塞模式下工作。在阻塞模式下，如果没有事件发生，read 操作会阻塞，直到有事件发生。在非阻塞模式下，read 操作会立即返回。

使用场景

1. 线程间同步：
   • 在线程池中，主线程可以使用 eventfd 通知工作线程有新任务要处理，工作线程通过等待 eventfd 事件来同步处理任务。
2. 进程间通信：
   • 两个独立的进程可以使用 eventfd 进行简单的事件通知，而无需复杂的 IPC 机制。
3. 与 I/O 多路复用结合使用：
   • eventfd 可以与 select、poll 或 epoll 等 I/O 多路复用机制结合使用，适合用于事件驱动的服务器程序中。例如，网络服务器可以使用 eventfd 在处理网络 I/O 时进行事件通知。
4. 实现事件计数：
   • 通过 eventfd 的计数器特性，可以实现事件的计数功能，如统计某个事件发生的次数。
5. 高效的事件通知：
   • 在高并发场景下，eventfd 提供了一种高效的事件通知机制，可以替代基于信号量或条件变量的传统同步方式。

例子

结合 epoll 使用 eventfd

#include <iostream>
#include <unistd.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <pthread.h>

void* thread_func(void* arg) {
    int efd = *reinterpret_cast<int*>(arg);
    uint64_t u = 1;

    for (int i = 0; i < 5; ++i) {
        sleep(1);
        write(efd, &u, sizeof(uint64_t));
        std::cout << "子线程：发送第 " << (i + 1) << " 个事件" << std::endl;
    }

    return nullptr;
}

int main() {
    int efd = eventfd(0, EFD_NONBLOCK);
    if (efd == -1) {
        perror("eventfd");
        exit(EXIT_FAILURE);
    }

    int epfd = epoll_create1(0);
    if (epfd == -1) {
        perror("epoll_create1");
        close(efd);
        exit(EXIT_FAILURE);
    }

    struct epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = efd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, efd, &event) == -1) {
        perror("epoll_ctl");
        close(epfd);
        close(efd);
        exit(EXIT_FAILURE);
    }

    pthread_t thread;
    pthread_create(&thread, nullptr, thread_func, &efd);

    for (int i = 0; i < 5; ++i) {
        struct epoll_event events[1];
        int n = epoll_wait(epfd, events, 1, -1);
        if (n == -1) {
            perror("epoll_wait");
            break;
        }

        if (events[0].data.fd == efd) {
            uint64_t u;
            read(efd, &u, sizeof(uint64_t));
            std::cout << "主线程：接收到第 " << (i + 1) << " 个事件，计数：" << u << std::endl;
        }
    }

    pthread_join(thread, nullptr);
    close(epfd);
    close(efd);
    return 0;
}

解释

1. 创建 eventfd 和 epoll 实例：
   • 使用 eventfd 创建一个事件文件描述符，并使用 epoll_create1 创建一个 epoll 实例。
2. 将 eventfd 添加到 epoll 监视列表：
   • 使用 epoll_ctl 将 eventfd 添加到 epoll 的监视列表中。
3. 启动子线程：
   • 使用 pthread_create 启动一个子线程，子线程每秒钟向 eventfd 写入一个事件。
4. 主线程等待事件：
   • 主线程使用 epoll_wait 等待 eventfd 的事件，每次事件发生时读取 eventfd 的计数器值并输出。
5. 清理资源：
   • 使用 pthread_join 等待子线程结束，关闭 epoll 和 eventfd 文件描述符以释放资源。