linux新API--eventfd的使用方法

eventfd 在内核版本，2.6.22以后有效。查看内核版本可以用命令 uname -r 。

 #include<sys/eventfd.h>
int eventfd(unsigned int initval,int flags);

这个函数会创建一个 事件对象 (eventfd object), 用来实现，进程(线程)间的等待/通知(wait/notify) 机制. 内核会为这个对象维护一个64位的计数器(uint64_t)。
并且使用第一个参数(initval)初始化这个计数器。调用这个函数就会返回一个新的文件描述符(event object)。2.6.27版本开始可以按位设置第二个参数(flags)。
有如下的一些宏可以使用：

EFD_NONBLOCK , 功能同open(2) 的O_NONBLOCK，设置对象为非阻塞状态，如果没有设置这个状态的话，read(2)读eventfd,并且计数器的值为0 就一直堵塞在read调用当中，要是设置了这个标志， 就会返回一个 EAGAIN 错误(errno = EAGAIN)。效果也如同 额外调用select(2)达到的效果。

EFD_CLOEXEC 我的理解是，这个标识被设置的话，调用exec后会自动关闭文件描述符，防止泄漏。

如果是2.6.26或之前版本的内核，flags 必须设置为0。

创建这个对象后，可以对其做如下操作。

write 将缓冲区写入的8字节整形值加到内核计数器上。

read 读取8字节值， 并把计数器重设为0. 如果调用read的时候计数器为0， 要是eventfd是阻塞的， read就一直阻塞在这里，否则就得到 一个EAGAIN错误。
如果buffer的长度小于8那么read会失败， 错误代码被设置成 EINVAL。

poll select epoll

close 当不需要eventfd的时候可以调用close关闭， 当这个对象的所有句柄都被关闭的时候，内核会释放资源。 为什么不是close就直接释放呢， 如果调用fork 创建

进程的时候会复制这个句柄到新的进程，并继承所有的状态。

（ps:也就是说，在write之后没有read，但是又write新的数据，那么读取的是这两次的8个字节的和，在read之后再write，可以完成read和write之间的交互）

一个例子：

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

    int efd = -1;

    void *read_thread(void *dummy)
    {
        int ret = 0;
        uint64_t count = 0;
        int ep_fd = -1;
        struct epoll_event events[10];

        if (efd < 0)
        {
            printf("efd not inited.\n");
            goto fail;
        }

        ep_fd = epoll_create(1024);
        if (ep_fd < 0)
        {
            perror("epoll_create fail: ");
            goto fail;
        }

        {
            struct epoll_event read_event;

            read_event.events = EPOLLHUP | EPOLLERR | EPOLLIN;
            read_event.data.fd = efd;

            ret = epoll_ctl(ep_fd, EPOLL_CTL_ADD, efd, &read_event);
            if (ret < 0)
            {
                perror("epoll ctl failed:");
                goto fail;
            }
        }

        while (1)
        {
            ret = epoll_wait(ep_fd, &events[0], 10, 5000);
            if (ret > 0)
            {
                int i = 0;
                for (; i < ret; i++)
                {
                    if (events[i].events & EPOLLHUP)
                    {
                        printf("epoll eventfd has epoll hup.\n");
                        goto fail;
                    }
                    else if (events[i].events & EPOLLERR)
                    {
                        printf("epoll eventfd has epoll error.\n");
                        goto fail;
                    }
                    else if (events[i].events & EPOLLIN)
                    {
                        int event_fd = events[i].data.fd;
                        ret = read(event_fd, &count, sizeof(count));
                        if (ret < 0)
                        {
                            perror("read fail:");
                            goto fail;
                        }
                        else
                        {
                            struct timeval tv;

                            gettimeofday(&tv, NULL);
                            printf("success read from efd, read %d bytes(%llu) at %lds %ldus\n",
                                   ret, count, tv.tv_sec, tv.tv_usec);
                        }
                    }
                }
            }
            else if (ret == 0)
            {
                /* time out */
                printf("epoll wait timed out.\n");
                break;
            }
            else
            {
                perror("epoll wait error:");
                goto fail;
            }
        }

    fail:
        if (ep_fd >= 0)
        {
            close(ep_fd);
            ep_fd = -1;
        }

        return NULL;
    }

    int main(int argc, char *argv[])
    {
        pthread_t pid = 0;
        uint64_t count = 0;
        int ret = 0;
        int i = 0;

        efd = eventfd(0, 0);
        if (efd < 0)
        {
            perror("eventfd failed.");
            goto fail;
        }

        ret = pthread_create(&pid, NULL, read_thread, NULL);
        if (ret < 0)
        {
            perror("pthread create:");
            goto fail;
        }

        for (i = 0; i < 5; i++)
        {
            count = 4;
            ret = write(efd, &count, sizeof(count));
            if (ret < 0)
            {
                perror("write event fd fail:");
                goto fail;
            }
            else
            {
                struct timeval tv;

                gettimeofday(&tv, NULL);
                printf("success write to efd, write %d bytes(%llu) at %lds %ldus\n",
                       ret, count, tv.tv_sec, tv.tv_usec);
            }

            sleep(1);
        }

    fail:
        if (0 != pid)
        {
            pthread_join(pid, NULL);
            pid = 0;
        }

        if (efd >= 0)
        {
            close(efd);
            efd = -1;
        }
        return ret;
    }

    success write to efd, write 8 bytes(4) at 1328805612s 21939us
    success read from efd, read 8 bytes(4) at 1328805612s 21997us
    success write to efd, write 8 bytes(4) at 1328805613s 22247us
    success read from efd, read 8 bytes(4) at 1328805613s 22287us
    success write to efd, write 8 bytes(4) at 1328805614s 22462us
    success read from efd, read 8 bytes(4) at 1328805614s 22503us
    success write to efd, write 8 bytes(4) at 1328805615s 22688us
    success read from efd, read 8 bytes(4) at 1328805615s 22726us
    success write to efd, write 8 bytes(4) at 1328805616s 22973us
    success read from efd, read 8 bytes(4) at 1328805616s 23007us
    epoll wait timed out.

同时他也是支持进程间通信的，过程和这个差不多。但是这里的进程间通信并不是在两个main函数中的进程，而是一个进程通过调用fork函数产生的进程