epoll 定时器

参考：

Linux下使用epoll监听定时器-CSDN博客

但是这个用的是gettimeofday。

本人使用的是clock_gettime，此外后续还增加了多线程的使用方法。

#include <stdlib.h>
#include<stdio.h>
#include <sys/timerfd.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <sys/time.h>
#include <stdint.h>

void timer_expires(void)
{
    struct timespec curr;
    static struct timespec start;
    static int first_call = 1;
    if (first_call)
    {
        first_call = 0;
        if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
            perror("clock_gettime");
    }
    if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1)
        perror("clock_gettime");
    int secs, nsecs;
    secs = curr.tv_sec - start.tv_sec;
    nsecs = curr.tv_nsec - start.tv_nsec;
    if (nsecs < 0)
    {
        secs--;
        nsecs += 1000000000;
    }
    printf("%d.%03d \n", secs, (nsecs + 500000) / 1000000);  //四舍五入纳秒转换为毫秒
}

int main(int argc, char const *argv[])
{
    int timefd = timerfd_create(CLOCK_MONOTONIC, 0);
    if (timefd == -1)
    {
        perror("timerfd_create failed");
    }

    struct itimerspec new_value = {};
    new_value.it_value.tv_sec = 1;
    new_value.it_value.tv_nsec = 0;

    new_value.it_interval.tv_sec = 5;
    new_value.it_interval.tv_nsec = 0;

    if (timerfd_settime(timefd, 0, &new_value, NULL) == -1)
    {
        perror("timerfd_settime failed");
    }
    printf("time start-----------\n");
    timer_expires();
    /*-------------------------------------------------------------------------*/
    struct epoll_event ev;
    ev.data.fd = timefd;
    ev.events = EPOLLIN; // 文件描述符可读的时候就触发

    int epollfd = epoll_create(EPOLL_CLOEXEC);
    if (epollfd == -1)
    {
        perror("epoll_create failed");
    }

    epoll_ctl(epollfd, EPOLL_CTL_ADD, timefd, &ev);

    /* int epoll_wait（int epfd，struct epoll_event * events， int maxevents，int timeout）;
         epfd ：epoll文件描述符
　　events ：接口的返回参数，一般都是一个数组，数组长度大于等于maxevents。
　　maxevents：期望捕获的事件的个数。
　　timeout ：超时时间(>=0)，单位是毫秒ms，-1表示阻塞，0表示不阻塞
   */
    const int maxEvents = 1; // 必须大于1
    struct epoll_event events[maxEvents];
    int buf[2];
    int ret = 0;
    int i =0;
    while (1)
    {
        int nfd = epoll_wait(epollfd, events, maxEvents, -1);
        if (nfd == -1)
            perror("epoll_wait failed");
        for (i = 0; i < nfd; ++i)
        {
            ret = read(events[i].data.fd, buf, sizeof(buf));
            if (ret < 0)
                perror("epoll callback read error");
            timer_expires();
        }
    }

    return 0;
}

会发现有0.1 的输出，是因为四舍五入的原因，如果要很精确，建议用gettimeofday(未处理）

在Linux中常用的时间结构有struct timespec 和struct timeval 。
下面是两个结构的定义

struct timespec
{
    __time_t tv_sec;        /* Seconds. */
    long   tv_nsec;       /* Nanoseconds. */
};
struct timeval {
　　      time_t tv_sec;  
　　      suseconds_t tv_usec;
}; 

两者的区别是timespec的第二个参数是纳秒数，而timeval的第二个参数是毫秒数。
 

补充：

在实际应用过程中也可以这么写（多线程回调）

void timer_expires(void)
{
    int ret_val = 0;

    ret_val = clock_gettime(CLOCK_MONOTONIC, &pt->timer_start);

    ret_val = timerfd_settime(pt->fd, 0, &pt->timer_val, NULL);//重新开始定时

}
static void setting_timer_expires(struct listnode *head)
{

    //处理数据
    timer_expires();
    
}
int time_register_event(struct listnode *head, timer_expired_callback handler)
{
    data->callback = handler;
    
}

static void *timer_thread_start(void *arg)
{

    const int maxEvents = 1; // 必须大于1
    struct epoll_event events[maxEvents];
    int buf[2];
    int ret = 0;
    int i =0;
    while (1)
    {
        int nfd = epoll_wait(epollfd, events, maxEvents, -1);
        if (nfd == -1)
            perror("epoll_wait failed");
        for (i = 0; i < nfd; ++i)
        {
            ret = read(events[i].data.fd, buf, sizeof(buf));
            if (ret < 0)
                perror("epoll callback read error");
            if (data->callback)
                (*(void (*)(struct listnode *head))data->callback)(data->head);
        }
    }
}

流程图：