epoll的用法

示例如下：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <unistd.h>
#include <cstdint>

/* epoll event callback function */
void evt_proc(struct epoll_event *trig_event);
/* write fd thread,trigger EPOLLIN event */
void *thread_a(void *arg);
/* callback function pointer */
typedef void (*callback_fun)(epoll_event*);

/* epoll data */
struct EPOLL_DATA
{       
        /* file descriptor */
        int fd;
        /* callback pointer */
        callback_fun clb_func;
};

int main(void)
{
        /* create a file descriptor for event notification */
        int evtfd=eventfd(0,0);
        /* open an epoll file descriptor */
        int epfd = epoll_create(1);
        if (epfd < 0)
        {
                printf("epoll_create() error,%d:%s!\n", errno, strerror(errno));
                exit(errno);
        }

        EPOLL_DATA epldata;
        epldata.fd=evtfd;
        epldata.clb_func=evt_proc;
        epoll_event ep_ev;
        /*
        The associated file is available for read operations,
        and sets the Edge Triggered behavior for the associated file descriptor
        */
        ep_ev.events=EPOLLIN|EPOLLET;
        ep_ev.data.ptr=&epldata;

        /* Register the target file descriptor fd on the epoll instance */
        epoll_ctl(epfd, EPOLL_CTL_ADD, evtfd, &ep_ev);

        /* available events */
        epoll_event trig_event;
        /* the number of milliseconds that epoll_wait() will block */
        int timeout = 500;

        /* create thread to write evtfd */
        pthread_t a_thread;
        int crt_res=pthread_create(&a_thread,nullptr,thread_a,(void*)&evtfd);
        if(crt_res!=0)
        {
                printf("create thread error,%d:%s!\n", errno, strerror(errno));
        }

        int evt_wt_res=0;
        while (true)
        {
                evt_wt_res = epoll_wait(epfd, &trig_event, 1, timeout);
                switch (evt_wt_res)
                {
                case 0:
                        /* no file descriptor became ready */
                        /*printf("epoll_wait timeout\n");*/
                        break;
                case -1:
                        /* some error occurred */
                        printf("epoll_wait error!\n");
                        break;
                default:
                        callback_fun pfnc=((EPOLL_DATA*)(trig_event.data.ptr))->clb_func;
                        (*pfnc)(&trig_event);
                        break;
                }
        }
        close(epfd);
        close(evtfd);
        return 0;
}

void evt_proc(struct epoll_event *trig_event)
{
        if (trig_event->events & EPOLLIN)
        {
                uint64_t int_val=-1;
                int res=read(((EPOLL_DATA*)(trig_event->data.ptr))->fd,&int_val,sizeof(uint64_t));
                if(res<0)
                {
                        printf("read fd error:fd=%d,%d:%s!\n",((EPOLL_DATA*)(trig_event->data.ptr))->fd,errno, strerror(errno));
                }
                else
                {
                        printf("read value=%ld\n",int_val);
                }
        }
        else
        {
                printf("unknown event!\n");
        }
}

void *thread_a(void *arg)
{
        int fd=*(int*)arg;
        for(uint64_t i=0;i<50;++i)
        {
                int res=write(fd,&i,sizeof(uint64_t));
                if(res<0)
                {
                        printf("write fd error,%d:%s!\n", errno, strerror(errno));
                }
                sleep(1);
        }
}

编译运行