Linux线程通信eventfd

最新推荐文章于 2023-05-22 19:34:17 发布

原创最新推荐文章于 2023-05-22 19:34:17 发布 · 448 阅读

1 ·

CC 4.0 BY-SA版权

【Linux】同时被 2 个专栏收录

52 篇文章

订阅专栏

【后端编程】

22 篇文章

订阅专栏

本文深入探讨了Linux系统中eventfd API的功能与应用，包括其作为用户空间程序的等待与通知机制，以及如何与epoll结合使用进行事件监控。通过三个具体实例，详细展示了eventfd在多线程环境下的读写操作特性，以及SEMAPHORE标志的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概述

eventfd是linux新加入的API（2.26.22内核之后），为用户空间应用程序提供等待（wait）和通知（notify）机制，函数eventfd创建的fd可以加入epoll。eventfd()创建一个“eventfd对象”，通过它能够实现用户态程序间(我觉得这里主要指线程而非进程)的等待/通知机制，以及内核态向用户态通知的机制（未考证）。此对象包含了一个被内核所维护的计数（uint64_t）, 初始值由initval来决定。

实验源码：

例一、子线程多次写入多个值，主线程一次读出所有值的和

#include <sys/eventfd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>  

int main(int argc, char**argv[])
{
    int efd, j;
    uint64_t u;
    ssize_t s;
    
    if (argc < 2)
    {
        printf("number of argc is wrong!\n");
        return 0;
    }
    
    efd = eventfd(0,0);
    if (-1 == efd)
    {
        printf("failed to create eventfd\n");
    }
    
    switch(fork())
    {
        case 0:
        {
            for(j=1; j<argc;j++)
            {
                printf("child writing %s to efd\n", argv[j]);
                u = strtoull(argv[j], NULL, 0);
                s = write(efd, &u, sizeof(uint64_t));
                if (s!=sizeof(uint64_t))
                {
                    printf("write efd failed\n");
                }
            }
            printf("Child completed write loop\n");
            exit(0);
        }
        default:
            sleep(2);
            printf("Parents about to read\n");
            s = read(efd, &u, sizeof(uint64_t));
            if (s != sizeof(uint64_t))
            {
                printf("read efd failed\n");
            }
            printf("Parents first read %llu (0x%llx) from efd\n", u, u);
            exit(0);
        case -1:
        {
            printf("fork error\n");
        }
    }
    
    return 0;
}

运行结果
kane@kanelinux:/mnt/hgfs/kanelinuxshare/eventfd$ ./a.out 1 2 3 4
child writing 1 to efd
child writing 2 to efd
child writing 3 to efd
child writing 4 to efd
Child completed write loop
Parents about to read
Parents first read 10 (0xa) from efd

如果有写入操作，但是并没有导致初始值变化，则主线程会一直挂在read操作上
kane@kanelinux:/mnt/hgfs/kanelinuxshare/eventfd$ ./a.out 0 0 0 0
child writing 0 to efd
child writing 0 to efd
child writing 0 to efd
child writing 0 to efd
Child completed write loop
Parents about to read

例二、eventfd可以被epoll监控，一旦有状态变化，可以触发通知

#include <sys/eventfd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>  
#include <sys/epoll.h>  
#include <string.h>  
#include <pthread.h>  

int g_iEvtfd = -1;

void *eventfd_child_Task(void *pArg)
{
    uint64_t uiWrite = 1;
    
    while(1)
    {
        sleep(2);
        if (0 != eventfd_write(g_iEvtfd, uiWrite))
        {
            printf("child write iEvtfd failed\n");
        }    
    }

    return;
}

int main(int argc, char**argv[])
{
    int iEvtfd, j;
    uint64_t uiWrite = 1;
    uint64_t uiRead;
    ssize_t s;
    int iEpfd;
    struct epoll_event stEvent;
    int iRet = 0;
    struct epoll_event stEpEvent;
    pthread_t stWthread;
    
    iEpfd = epoll_create(1);
    if (-1 == iEpfd)
    {
        printf("Create epoll failed.\n");
        return 0;
    }
    
    iEvtfd = eventfd(0,0);
    if (-1 == iEvtfd)
    {
        printf("failed to create eventfd\n");
        return 0;
    }
    
    g_iEvtfd = iEvtfd;
    
    memset(&stEvent, 0, sizeof(struct epoll_event));
    stEvent.events = (unsigned long) EPOLLIN;
    stEvent.data.fd = iEvtfd;
    iRet = epoll_ctl(iEpfd, EPOLL_CTL_ADD, g_iEvtfd, &stEvent);
    if (0 != iRet)
    {
        printf("failed to add iEvtfd to epoll\n");
        close(g_iEvtfd);
        close(iEpfd);
        return 0;
    }
    
    iRet = pthread_create(&stWthread, NULL, eventfd_child_Task, NULL);
    if (0 != iRet)
    {
        close(g_iEvtfd);
        close(iEpfd);
        return;
    }
    
    for(;;)
    {
        iRet = epoll_wait(iEpfd, &stEpEvent, 1, -1);
        if (iRet > 0)
        {
            s = eventfd_read(iEvtfd, &uiRead);
            if (s != 0)
            {
                printf("read iEvtfd failed\n");
                break;
            }
            printf("Read %llu (0x%llx) from iEvtfd\n", uiRead, uiRead);
        }
    }
    
    close(g_iEvtfd);
    close(iEpfd);
    return 0;
}

运行结果
kane@kanelinux:/mnt/hgfs/kanelinuxshare/eventfd$ ./a.out
Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd

例三、被epoll监控的eventfd，如果在子线程中被多次写入，在主线程中是怎么读的？

#include <sys/eventfd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>  
#include <sys/epoll.h>  
#include <string.h>  
#include <pthread.h>  

int g_iEvtfd = -1;

void *eventfd_child_Task(void *pArg)
{
    uint64_t uiWrite = 1;
    
        while(1)
        {
            sleep(2);
            eventfd_write(g_iEvtfd, uiWrite);
            eventfd_write(g_iEvtfd, uiWrite);
        }

    return;
}

int main(int argc, char**argv[])
{
    int iEvtfd, j;
    uint64_t uiWrite = 1;
    uint64_t uiRead;
    ssize_t s;
    int iEpfd;
    struct epoll_event stEvent;
    int iRet = 0;
    struct epoll_event stEpEvent;
    pthread_t stWthread;
    
    iEpfd = epoll_create(1);
    if (-1 == iEpfd)
    {
        printf("Create epoll failed.\n");
        return 0;
    }
    
    iEvtfd = eventfd(0,0);
    if (-1 == iEvtfd)
    {
        printf("failed to create eventfd\n");
        return 0;
    }
    
    g_iEvtfd = iEvtfd;
    
    memset(&stEvent, 0, sizeof(struct epoll_event));
    stEvent.events = (unsigned long) EPOLLIN;
    stEvent.data.fd = iEvtfd;
    iRet = epoll_ctl(iEpfd, EPOLL_CTL_ADD, g_iEvtfd, &stEvent);
    if (0 != iRet)
    {
        printf("failed to add iEvtfd to epoll\n");
        close(g_iEvtfd);
        close(iEpfd);
        return 0;
    }
    
    iRet = pthread_create(&stWthread, NULL, eventfd_child_Task, NULL);
    if (0 != iRet)
    {
        close(g_iEvtfd);
        close(iEpfd);
        return;
    }
    
    for(;;)
    {
        iRet = epoll_wait(iEpfd, &stEpEvent, 1, -1);
        if (iRet > 0)
        {
            s = eventfd_read(iEvtfd, &uiRead);
            if (s != 0)
            {
                printf("read iEvtfd failed\n");
                break;
            }
            printf("Read %llu (0x%llx) from iEvtfd\n", uiRead, uiRead);
        }
    }
    
    close(g_iEvtfd);
    close(iEpfd);
    return 0;
}

运行结果：
kane@kanelinux:/mnt/hgfs/kanelinuxshare/eventfd$ ./a.out
Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd

Read 1 (0x1) from iEvtfd
Read 1 (0x1) from iEvtfd

例一中并没有epoll做监控，
因此在read前，如果eventfd被写多次，在read的时候也是一次全部读出。

注：eventfd中的SEMAPHORE标志用法

* If EFD_SEMAPHORE was not specified and the eventfd counter
has a nonzero value, then a read(2) returns 8 bytes contain‐
ing that value, and the counter's value is reset to zero.

* If EFD_SEMAPHORE was specified and the eventfd counter has a
nonzero value, then a read(2) returns 8 bytes containing the
value 1, and the counter's value is decremented by 1.

通过测试发现。如果eventfd在创建的时候传入EFD_SEMAPHORE 标志，则会按上面man手册中提到的那样，每次在eventfd_read的时候只减一，并不是把值一次性全部读出。见下例

#include <sys/eventfd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>  
#include <sys/epoll.h>  
#include <string.h>  
#include <pthread.h>  

int g_iEvtfd = -1;

void *eventfd_child_Task(void *pArg)
{
    uint64_t uiWrite = 1;
    int i=10;

    while(i>0)
    {
        eventfd_write(g_iEvtfd, uiWrite);
        i--;
    }
    

    return;
}

int main(int argc, char**argv[])
{
    int iEvtfd, j;
    uint64_t uiWrite = 1;
    uint64_t uiRead;
    ssize_t s;
    int iEpfd;
    struct epoll_event stEvent;
    int iRet = 0;
    struct epoll_event stEpEvent;
    pthread_t stWthread;
    
    iEpfd = epoll_create(1);
    if (-1 == iEpfd)
    {
        printf("Create epoll failed.\n");
        return 0;
    }
    
    iEvtfd = eventfd(0,EFD_SEMAPHORE);
    if (-1 == iEvtfd)
    {
        printf("failed to create eventfd\n");
        return 0;
    }
    
    g_iEvtfd = iEvtfd;
    
    memset(&stEvent, 0, sizeof(struct epoll_event));
    stEvent.events = (unsigned long) EPOLLIN;
    stEvent.data.fd = iEvtfd;
    iRet = epoll_ctl(iEpfd, EPOLL_CTL_ADD, g_iEvtfd, &stEvent);
    if (0 != iRet)
    {
        printf("failed to add iEvtfd to epoll\n");
        close(g_iEvtfd);
        close(iEpfd);
        return 0;
    }
    
    iRet = pthread_create(&stWthread, NULL, eventfd_child_Task, NULL);
    if (0 != iRet)
    {
        close(g_iEvtfd);
        close(iEpfd);
        return;
    }
    
    for(;;)
    {
        sleep(2);
        iRet = epoll_wait(iEpfd, &stEpEvent, 1, -1);
        if (iRet > 0)
        {
            s = eventfd_read(iEvtfd, &uiRead);
            if (s != 0)
            {
                printf("read iEvtfd failed\n");
                break;
            }
            printf("Read %llu (0x%llx) from iEvtfd\n", uiRead, uiRead);
        }
    }
    
    close(g_iEvtfd);
    close(iEpfd);
    return 0;
}

eventfd_SEMAPHORE