【用示例学习与理解C++系列】eventfd与epoll的使用

已于 2023-05-24 20:09:02 修改
阅读量1.7k 收藏 4
点赞数
分类专栏： C/C++ Android开发之旅 文章标签： 学习 c++ linux
于 2022-10-17 12:19:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SCHOLAR_II/article/details/127361070
版权

应用场景及优势

在这里插入图片描述

引用自 通俗易懂说多路复用（3）eventfd 事件通知

Eventfd在信号通知的场景下，相对比pipe有非常大的资源和性能优势， 本质其实是counter(计数器)和channel(数据信道)的区别。
打开文件数量的差异 由于pipe是半双工的传统IPC实现方式，所有两个线程通信需要两个pipe文件描述符，而用eventfd只需要打开一个文件描述符。 总所周知，文件描述符是系统中非常宝贵的资源，linux的默认值只有1024个而已，pipe只能在两个进程/线程间使用，面向连接，使用之前就需要创建好两个pipe,而eventfd是广播式的通知，可以多对多。
内存使用的差别 eventfd是一个计数器，内核维护的成本非常低，大概是自旋锁+唤醒队列的大小，8个字节的传输成本也微乎其微，而pipe完全不同，一来一回数据在用户空间和内核空间有多达4次的复制，而且最糟糕的是，内核要为每个pipe分配最少4k的虚拟内存页，哪怕传送的数据长度为0.
与epoll完美结合 eventfd设计之初就与epoll完美结合，支持非阻塞读取等，就是为epoll而生的,而pipe是Unix时代就有了，那时候不仅没有epoll,连linux还没诞生。
当pipe只用来发送通知，放弃它，放心的使用eventfd。
eventfd配合epoll才是它存在的原

PS: Andorid的Handler机制的底层实现目前也用eventfd替换原来的pipefd

eventfd的头文档

#include <sys/eventfd.h>
头文件中除了定义eventfd的创建接口，还提供了eventfd的计数器值的读与写的接口 eventfd_write与eventfd_read，它们是对write与read的封装

/**
 * [eventfd(2)](http://man7.org/linux/man-pages/man2/eventfd.2.html) creates a file descriptor
 * for event notification.
 *
 * Returns a new file descriptor on success, and returns -1 and sets `errno` on failure.
 */
int eventfd(unsigned int __initial_value, int __flags);

/** The type used by eventfd_read() and eventfd_write(). */
typedef uint64_t eventfd_t;

/**
 * [eventfd_read(3)](http://man7.org/linux/man-pages/man2/eventfd.2.html) is a convenience
 * wrapper to read an `eventfd_t` from an eventfd file descriptor.
 *
 * Returns 0 on success, or returns -1 otherwise.
 */
int eventfd_read(int __fd, eventfd_t* __value);

/**
 * [eventfd_write(3)](http://man7.org/linux/man-pages/man2/eventfd.2.html) is a convenience
 * wrapper to write an `eventfd_t` to an eventfd file descriptor.
 *
 * Returns 0 on success, or returns -1 otherwise.
 */
int eventfd_write(int __fd, eventfd_t __value);

eventfd的创建

创建eventfd的实例的接口为

int eventfd(unsigned int __initial_value, int __flags);

第一个参数为：eventfd的计数器的初始化
第二个参数为：eventfd的属性，配置参数是bitset的flag

三个bitset如下

/** The eventfd() flag to provide semaphore-like semantics for reads. */
#define EFD_SEMAPHORE (1 << 0)
/** The eventfd() flag for a close-on-exec file descriptor. */
#define EFD_CLOEXEC O_CLOEXEC
/** The eventfd() flag for a non-blocking file descriptor. */
#define EFD_NONBLOCK O_NONBLOCK

EFD_SEMAPHORE: 配置eventfd的计数器形式为信号量，即调一次read接口，计数器减一；如果不是信号量的形式，调一次read接口后计数量清零
EFD_CLOEXEC: 配置进程fork时，父进程的eventfd要关闭
EFD_NONBLOCK: 配置eventfd于非阻塞方式，阻塞与非阻塞体现在对eventfd的读写上

event的读写

event的读写可以用read与write接口，但eventfd也有作了封装，即用 #include <sys/eventfd.h>的读写接口比较方式

计数器的属性与读写

对eventfd的每次写操作，eventfd的计数器都为累加；需要注意的是读操作依赖于计数器的属性，如果信号量方式的eventfd，每次对它做写操作后计数器减1，否侧计数器清零；
还有注意一点是信号量方式下，每次可读操作读出来值是1，而不是具体的计算器的值；

阻塞模式与读写

对eventfd的读写操作，默认是阻塞的。即当eventfd不可读或不可写了时读调用对应的读写接口会阻塞住当前线程；如果是非阻塞模式下，读与写不会阻塞，只是读写失败，接口返回码为-1

  • 在阻塞模式下如果对eventfd作写操作
    计数器最大能存储的值是0xfffffffffffffffe（以MAX表示此值），
    那么写尝试将value累加到计数器上，如果结果超过MAX，侧阻塞住当前线程，直到其它线程成功对eventfd做了读操作

  • 在阻塞模式下对eventfd作读操作的
    如果计数器的值等于零，即阻塞住当前线程，直到它线程成功对evenfd做了写操作

eventfd的示例

eventfd的读写-wirte与read

/**
 * 创建一个非阻塞的eventfd，并使用read与write读写数据
 */
void demo_write_read() {
    int eventfd1 = eventfd(2, EFD_NONBLOCK);
    uint64_t ret = 0;
    int invokeRet = 0;
    uint64_t writeValue = 3;
    write(eventfd1, &writeValue, sizeof(uint64_t));
    invokeRet = read(eventfd1, &ret, sizeof(uint64_t));
    __android_log_print(ANDROID_LOG_INFO, TAG, "invokeRet: %d, read:%u", invokeRet, ret);

    //测试当计数据为零时做读操作
    for (int i = 0; i < 2; i++) {
        ret = 0;
        invokeRet = read(eventfd1, &ret, sizeof(uint64_t));
        __android_log_print(ANDROID_LOG_INFO, TAG, "i: %d, invokeRet: %d, read:%u", i, invokeRet,
                            ret);
    }
    __android_log_print(ANDROID_LOG_INFO, TAG, "demo_write_read end");
}

运行结果
在这里插入图片描述

eventfd的读写-eventfd_write与eventf_read

/**
 * 创建一个非阻塞的eventfd，并使用eventfd_red与eventfd_write 读写数据
 * 设置eventfd为非阻塞是因为示例会在eventfd的值为0时，还尝试从中读取值
 * 如果是阻塞模式下，当eventfd为零时，读操作会阻塞住当时调用线程
 */
void demo_eventfd_write_read() {
    int eventfd1 = eventfd(2, EFD_NONBLOCK);
    uint64_t ret = 0;
    int invokeRet = 0;
    eventfd_write(eventfd1, 3);
    invokeRet = eventfd_read(eventfd1, &ret);
    __android_log_print(ANDROID_LOG_INFO, TAG, "invokeRet: %d, read:%u", invokeRet, ret);

    for (int i = 0; i < 2; i++) {
        ret = 0;
        invokeRet = eventfd_read(eventfd1, &ret);
        __android_log_print(ANDROID_LOG_INFO, TAG, "i: %d, invokeRet: %d, read:%u", i, invokeRet,
                            ret);
    }
    __android_log_print(ANDROID_LOG_INFO, TAG, "demo_eventfd_write end");
}

运行结果
在这里插入图片描述

eventfd与epoll-计数器为普通模式

 demo_epoll_eventfd()

运行结果
在这里插入图片描述

eventfd与epoll-计数器为信号量模式

demo_epoll_eventfd_semaphore（）

运行结果
在这里插入图片描述

eventfd示例主要代码

PS: 用Anddroid A创建一个JNI工程，然后copy如下代码覆盖到native-lib.cpp文件

#include <jni.h>
#include <string>
#include <thread>
#include <unistd.h>
#include <sys/epoll.h>
#include <android/log.h>
#include <sys/eventfd.h>

using namespace std;

static char *TAG = "JNI-DEMO";
static static int MAX_EVENTS_SIZE = 1024;

/**
 * 创建一个非阻塞的eventfd，并使用read与write读写数据
 */
void demo_write_read() {
    int eventfd1 = eventfd(2, EFD_NONBLOCK);
    uint64_t ret = 0;
    int invokeRet = 0;
    uint64_t writeValue = 3;
    write(eventfd1, &writeValue, sizeof(uint64_t));
    invokeRet = read(eventfd1, &ret, sizeof(uint64_t));
    __android_log_print(ANDROID_LOG_INFO, TAG, "invokeRet: %d, read:%u", invokeRet, ret);

    //测试当计数器为零时做读操作，默认的计数器是一次性消费，即作一个读操作后，计数器清零
    for (int i = 0; i < 2; i++) {
        ret = 0;
        invokeRet = read(eventfd1, &ret, sizeof(uint64_t));
        __android_log_print(ANDROID_LOG_INFO, TAG, "i: %d, invokeRet: %d, read:%u", i, invokeRet,
                            ret);
    }
    __android_log_print(ANDROID_LOG_INFO, TAG, "demo_write_read end");
}

/**
 * 创建一个非阻塞的eventfd，并使用eventfd_red与eventfd_write 读写数据
 * 设置eventfd为非阻塞是因为示例会在eventfd的值为0时，还尝试从中读取值
 * 如果是阻塞模式下，当eventfd为零时，读操作会阻塞住当时调用线程
 */
void demo_eventfd_write_read() {
    int eventfd1 = eventfd(2, EFD_NONBLOCK);
    uint64_t ret = 0;
    int invokeRet = 0;
    eventfd_write(eventfd1, 3);
    invokeRet = eventfd_read(eventfd1, &ret);
    __android_log_print(ANDROID_LOG_INFO, TAG, "invokeRet: %d, read:%u", invokeRet, ret);

    for (int i = 0; i < 2; i++) {
        ret = 0;
        invokeRet = eventfd_read(eventfd1, &ret);
        __android_log_print(ANDROID_LOG_INFO, TAG, "i: %d, invokeRet: %d, read:%u", i, invokeRet,
                            ret);
    }
    __android_log_print(ANDROID_LOG_INFO, TAG, "demo_eventfd_write end");
}

void demo_eventfd_write_read_semaphore() {
    int eventfd1 = eventfd(2, EFD_NONBLOCK | EFD_SEMAPHORE);
    uint64_t ret = 0;
    int invokeRet = 0;
    eventfd_write(eventfd1, 3);
    invokeRet = eventfd_read(eventfd1, &ret);
    __android_log_print(ANDROID_LOG_INFO, TAG, "invokeRet: %d, read:%u", invokeRet, ret);

    //由于是信号量的方式，故可以再读4次，上前已经读了一次，读一个计数器减1 （上面计数器初始值为2，然后读操作累加3，然后读一次现在计算器为4）
    for (int i = 0; i < 5; i++) {
        ret = 0;
        invokeRet = eventfd_read(eventfd1, &ret);
        __android_log_print(ANDROID_LOG_INFO, TAG, "i: %d, invokeRet: %d, read:%u", i, invokeRet,
                            ret);
    }
    __android_log_print(ANDROID_LOG_INFO, TAG, "demo_eventfd_write end");
}

/**
 *
 * eventfd与epoll的使用，这里是结合两个线程的通讯为示例，不是进程交互的示例
 * @param semaphore 是否为信号量的工作方式
 */
void demo_epoll_eventfd_imp(bool semaphore) {
    int efd = eventfd(1, EFD_NONBLOCK | (semaphore ? EFD_SEMAPHORE : 0));
    if (efd == -1) {
        __android_log_print(ANDROID_LOG_WARN, TAG, "eventfd fail");
        return;
    }

    int epollFd = epoll_create(1024);
    if (epollFd == -1) {
        __android_log_print(ANDROID_LOG_WARN, TAG, "epoll_create fail");
        return;
    }

    struct epoll_event ev;
    ev.data.fd = efd;
    //水平触发方式，监听可读事件，即管道有数据可以读取了
    ev.events = EPOLLIN | EPOLLET;
    //监听事件
    int result = epoll_ctl(epollFd, EPOLL_CTL_ADD, efd, &ev);
    if (result == -1) {
        __android_log_print(ANDROID_LOG_WARN, TAG, "epoll_ctl fail");
        return;
    }

    thread threadWrite([efd] {
        while (true) {
            int invokeRet = eventfd_write(efd, 2);
            __android_log_print(ANDROID_LOG_INFO, TAG, "write:2, invokeRet:%d", invokeRet);
            invokeRet = eventfd_write(efd, 3);
            __android_log_print(ANDROID_LOG_INFO, TAG, "write:3, invokeRet:%d", invokeRet);
            this_thread::sleep_for(chrono::seconds(2));
        }
    });
    threadWrite.detach();

    thread threadRead([efd, epollFd] {
        struct epoll_event events[MAX_EVENTS_SIZE];
        while (true) {
            uint64_t ret = 0;
            int count = epoll_wait(epollFd, events, MAX_EVENTS_SIZE, 3000);
            __android_log_print(ANDROID_LOG_INFO, TAG, "epoll_wait, count:%d", count);
            for (int i = 0; i < count; i++) {
                if ((events[i].data.fd == efd) && (events[i].events && POLL_IN)) {
                    for (int i = 0; i < 7; i++) {
                        ret = 0;
                        int invokeRet = eventfd_read(efd, &ret);
                        __android_log_print(ANDROID_LOG_INFO, TAG, "[i=%d], read:%u, invokeRet:%d",
                                            i, ret,
                                            invokeRet);
                    }
                }
            }
        }
    });
    threadRead.detach();
}

void demo_epoll_eventfd() {
    demo_epoll_eventfd_imp(false);
}

void demo_epoll_eventfd_semaphore() {
    demo_epoll_eventfd_imp(true);
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_myapplication_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
//    demo_write_read();
//    demo_eventfd_write_read();
//    demo_eventfd_write_read_semaphore();
//    demo_epoll_eventfd();
    demo_epoll_eventfd_semaphore();
    return env->NewStringUTF(hello.c_str());
}

参考文章

喜欢踢足球的老罗
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux使用eventfd进行用户态与内核态通信
12-17
总的来说，理解`eventfd`的工作原理和使用方法对于开发高效、低延迟的Linux系统程序至关重要，特别是在需要与内核进行交互或者需要精确控制线程调度的场景下。同时，正确设置线程亲核性也是优化系统性能的关键一环。...
Linux 新的API signalfd、timerfd、eventfd使用说明
09-15
主要介绍了Linux 新的API signalfd、timerfd、eventfd使用说明的相关资料,非常不错具有参考借鉴价值，需要的朋友可以参考下
eventfd 和 epoll 的结合使用
qq_34888036的博客
05-31 1260
这是因为，假如没有设置EPOLL_CLOEXEC标志的fork将把描述符复制到子进程中的epoll实例,当这些进程中的某一个或者多个进程关闭了其中一个文件描述符，那么可能会导致程序的不可用，或者不在我们的预期之内。size参数向内核指定内核进程需要监控的文件描述符的个数，这有助于内核决定epoll实例的大小。进程通过调用epoll_create来创建epoll实例，后续通过epoll返回的指向epoll实例的文件描述符来进行各种操作，比如添加、删除或者修改它想要件事epoll实例的I/O的其他文件描述符。
Liunx中eventfd简单使用
lsh_sh的博客
05-14 2726
这几天在看eventfd，正好做一下笔记，下次可以在回来复习。 简介 这个函数会创建一个用于事件通知的文件描述符，我们可以利用它来实现进程间的通信。 eventfd的创建 通过eventfd函数，来创建eventfd，该函数会返回eventfd所对应的文件描述符，函数定义如下 #include <sys/eventfd.h> int eventfd(unsigned int initval, int flags); initval：创建eventfd时初始值； flags：e
eventfd
不才的专栏
04-27 1754
1. 简介 eventfd - create a file descriptor for event notification eventfd是通过事件通知机制。 int eventfd(unsigned int initval, int flags); eventfd创建一个“eventfd对象”，可以用作事件等待/通知机制由用户空间应用程序和通知用户空间应用程序事件的内核。这个对象包含由内核维护的无符号64位整数计数器。此计数器已初始化使用参数initval中指定的值。eventfd（）返回一
eventfd函数
Sonic_sTorm的博客
03-21 1093
eventfd是从LINUX 2.6.27版本开始增加的，主要用于进程或者线程间的通信（如通知/等待机制的实现）。实现了线程之间事件通知的方式，也可以用于用户态和内核通信。eventfd的缓冲区大小是sizeof(uint64_t)；向其write可以递增这个计数器，read操作可以读取，并进行清零；eventfd也可以放到监听队列中，当计数器不是0时，有可读事件发生，可以进行读取。函数原型:#i...
一起来感受下eventfd的魅力（一、eventfd使用介绍）
从0到1，突破自己
03-31 4375
写在前面 #include <sys/eventfd.h> int eventfd(unsigned int initval, int flags); eventfd()函数可以创建一个被用户空间应用程序作为“等待/通知”机制使用的eventfd对象，或被内核用于通知用户空间应用程序事件消息。eventfd对象包含一个uint64_t类型计数器，由内核进行维护。该计数器通过参数interval进行初始化。 eventfd()函数返回一个文件描述符，这个fd用
eventfd 函数使用介绍
AlbertoNo1的博客
06-24 4225
从Linux 2.6.27版本开始，新增了不少系统调用，其中包括eventfd，它的主要是用于进程或者线程间的通信(如通知/等待机制的实现)。 函数原型：       #include /* * function: 创建eventfd * @initval: 信号量的初始值 * @flags: （2.6.27以上内核有效）可以设置一下标志位，如果是2.6.26或之前版
详解Linux用户态与内核态通信的几种方式
09-14
主要介绍了详解Linux用户态与内核态通信的几种方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Linux新的API signalfd、timerfd、eventfd使用说明
01-09
　eventfd：2.6.22 　三种fd的意义： 　lsignalfd 　传统的处理信号的方式是注册信号处理函数；由于信号是异步发生的，要解决数据的并发访问，可重入问题。signalfd可以将信号抽象为一个文件描述符，当有信号...
libuev：用于Linux epoll（）系列API的轻量级事件循环库
02-05
6. **eventfd支持**：eventfd是Linux提供的一种同步机制，libuev支持`uv_eventfd_t`，使开发者能用其进行线程间的通信和同步。 7. **timerfd支持**：timerfd是Linux的另一种高级定时器接口，libuev通过`uv_timer_t`...
linux epoll+eventfd实现线程间通信
u011376563的博客
07-13 688
使用linux的epoll和eventfd机制实现的线程间通信示例
Linux·eventfd 原理与实践
m0_64560763的博客
05-22 1699
Linux eventfd 原理与实践
eventfd & epoll & 消费者线程池
新博客：https://aping-dev.com/
08-11 1399
在Linux系统中，eventfd 是一个用来通知事件的文件描述符，timerfd 是定时器事件的文件描述符。二者都是内核向用户空间的应用发送通知的机制，可以有效地被用来实现用户空间的事件/通知驱动的应用程序。 简而言之，就是 eventfd 用来触发事件通知，timerfd 用来触发将来的事件通知。 当仅用于实现信号通知的功能时，eventfd() 完全可以替代 pipe()，对于内核来说，ev...
eventfd（三）
月雲之霄的博客
08-05 220
1. 测试代码： //https://www.jianshu.com/p/d7ebac8dc9f8 #include <stdio.h> #include <unistd.h> #include <stdint.h> #include <pthread.h> #include <sys/eventfd.h> #include &lt...
linux线程同步 eventfd,通过eventfd在线程之间传输数据
weixin_29238147的博客
05-15 210
我希望通过eventfd在线程之间传输数据。所以我写了下面的代码来满足我的需要。我的主机操作系统是openSUSE v12.3 64位。通过eventfd在线程之间传输数据#include "stdio.h"#include "unistd.h"#include "pthread.h"#include "sys/eventfd.h"#include "sys/epoll.h"#define nil...
linux里eventfd的原理及应用,Linux下的eventfd简介
weixin_33023513的博客
05-13 321
#include int eventfd(unsigned int initval, int flags);eventfd创建一个eventfd对象，该对象可用于用户空间的程序实现事件等待、通知机制，也可用于由内核向用户空间的应用进行事件的通知。eventfd对象在内核中包含了一个计数器，该计数器是64位的无符号整数(uint64_t)，该计数器由eventfd函数的initval参数进行初始化。...
Linux eventfd的使用
shuxiaogd的专栏
05-22 5251
eventfd其实是内核为应用程序提供的信号量。它相比于POSIX信号量的优势是，在内核里以文件形式存在，可用于select/epoll循环中，因此可以实现异步的信号量，避免了消费者在资源不可用时的阻塞。这也是为什么取名叫eventfd的原因：event表示它可用来作事件通知（当然是异步的），fd表示它是一个“文件”。
最高效的进(线)程间通信机制--eventfd
FreeeLinux's blog
12-08 6853
我们常用的进程（线程）间通信机制有管道，信号，消息队列，信号量，共享内存，socket等等，其中主要作为进程（线程）间通知/等待的有管道pipe和socketpair。线程还有特别的condition。 今天来看一个liunx较新的系统调用，它是从LINUX 2.6.27版本开始增加的，主要用于进程或者线程间的通信（如通知/等待机制的实现）。 首先来看一下函数原型： #include
eventfd 在写入之后 epoll 会触发一次 还是会一直触发
最新发布
06-11
如果你使用 epoll 监听该 eventfd 的 EPOLLIN 事件，那么当该 eventfd 上的计数器不为0时，epoll 将会触发一次 EPOLLIN 事件，此时你需要读取该 eventfd 的值并将其清零以便下一次监听。如果你不读取该 eventfd 的值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值