Linux组件封装(六)——定时器的简单封装

在Linux中，有一种简单的定时器——timerfd，它通过查看fd是否可读来判断定时器时候到时。

timerfd中常用的函数有timerfd_create、timerfd_settime、timerfd_gettime，这些函数都相对简单，我们可以到man手册来查看用法。

值得注意的是:create中的参数CLOCK_REALTIME是一个相对时间，我们可以通过调整系统时间对其进行调整，而CLOCK_MONOTIC是一个绝对时间，系统时间的改变不会影响它。在create中，flags一般设置为0。

下面是一个简单的例子:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/timerfd.h>
#include <stdint.h>
#include <poll.h>
#define ERR_EXIT(m) 
    do { 
        perror(m);
        exit(EXIT_FAILURE);
    }while(0)

void foo()
{
    printf("foo
");
}


int main(int argc, const char *argv[])
{
    //创建fd

    int timerfd = timerfd_create(CLOCK_REALTIME, 0);
    if(timerfd == -1)
        ERR_EXIT("timerfd_create");

    //设置时间
    struct itimerspec tv;
    memset(&tv, 0, sizeof tv);
    tv.it_value.tv_sec = 3;
    tv.it_interval.tv_sec = 1;
    if(timerfd_settime(timerfd, 0, &tv, NULL) == -1)
        ERR_EXIT("timerfd_settime");

    char buf[1024] = {0}; 
    int ret; 
    while((ret = read(timerfd, buf, sizeof buf)) > 0){ 
        printf("ret = %d, read data:%s
", ret, buf); // 
    } 

    close(timerfd);

    return 0;
}

这里需要注意:一旦定时器到期，fd中就有数据可读，这个时候，我们一定要将fd中的数据read出来，否则定时器会产生异常，无法正常工作。

我们可以将timerfd和poll一起使用，将timerfd加入到poll的监听数组中，这样当timerfd可读时，我们就调用相应的函数，来完成定时任务。

然而当我们不将timerfd中的数据读出时，poll监听到timerfd一直可读，这样就会一直触发相应函数，就失去了定时器的左右。

所以，我们一定要注意将timerfd中的数据读出。

将timerfd与poll结合:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/timerfd.h>
#include <stdint.h>
#include <poll.h>
#define ERR_EXIT(m) 
    do { 
        perror(m);
        exit(EXIT_FAILURE);
    }while(0)

void foo()
{
    printf("foo
");
}


int main(int argc, const char *argv[])
{
    //创建fd

    int timerfd = timerfd_create(CLOCK_REALTIME, 0);
    if(timerfd == -1)
        ERR_EXIT("timerfd_create");

    //设置时间
    struct itimerspec tv;
    memset(&tv, 0, sizeof tv);
    tv.it_value.tv_sec = 3;
    tv.it_interval.tv_sec = 1;
    if(timerfd_settime(timerfd, 0, &tv, NULL) == -1)
        ERR_EXIT("timerfd_settime");

    //判断fd可读

    //int poll(struct pollfd *fds, nfds_t nfds, int timeout);

    struct pollfd pfd;
    pfd.fd = timerfd;
    pfd.events = POLLIN; //监听输入事件

    uint64_t val;
    int ret;
    while(1)
    {
        ret = poll(&pfd, 1, 5000);
        if(ret == -1)
        {
            if(errno == EINTR)
                continue;
            ERR_EXIT("poll");
        }
        else if(ret == 0)
        {
            printf("timeout
"); //超时
        }

        if(pfd.revents == POLLIN) //此fd是否监听的read事件
        {
            read(timerfd, &val, sizeof val);
            foo();
        }
            
    }


    close(timerfd);

    return 0;
}

我们可以将timerfd类的函数封装到一个Timer类中，提供一个接口来接受用户要执行的函数(即回调函数)，这样做，可以使我们的定时器更加安全、实用。
声明代码如下:

#ifndef TIMER_H
#define TIMER_H
#include <boost/noncopyable.hpp>
#include <functional>
#include <sys/timerfd.h>

class Timer : boost::noncopyable
{
public:

    typedef std::function<void()> TimerCallback;

    Timer(int val, int interval, TimerCallback cb);
    ~Timer();

    void start();
    void stop();

private:

    int _timerfd;
    int _val;
    int _interval;
    TimerCallback _callback;
    bool _isStart;
};



#endif  /*TIMER_H*/

实现代码如下:

#include "Timer.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/timerfd.h>
#include <stdint.h>
#include <poll.h>
#define ERR_EXIT(m) 
        do { 
            perror(m);
            exit(EXIT_FAILURE);
        }while(0)
namespace
{
    int createTimer()
    {
        int timerfd = ::timerfd_create(CLOCK_REALTIME, 0);
        if(timerfd == -1)
            ERR_EXIT("create");

        return timerfd;
    }

    void setTimer(int timerfd, int val, int interval)
    {
        struct itimerspec t;
        memset(&t, 0, sizeof t);
        t.it_value.tv_sec = val;
        t.it_interval.tv_sec = interval;

        if(::timerfd_settime(timerfd, 0, &t, NULL) == -1)
            ERR_EXIT("settime");
    }

    void stopTimer(int timerfd)
    {
        setTimer(timerfd, 0, 0);
    }

    void readTimer(int timerfd)
    {
        uint64_t howmany;
        if(::read(timerfd, &howmany, sizeof howmany) != sizeof(howmany))
            ERR_EXIT("read");
    }

}
Timer::Timer(int val, int interval, TimerCallback cb)
    :_timerfd(createTimer()),
     _val(val),
     _interval(interval),
     _callback(std::move(cb)),
     _isStart(false)
{

}


Timer::~Timer()
{
    if(_isStart)
    {
        stop();
        ::close(_timerfd);
    }
}


void Timer::start()
{
    setTimer(_timerfd, _val, _interval);
    _isStart = true;

    struct pollfd pfd;
    pfd.fd = _timerfd;
    pfd.events = POLLIN;

    uint64_t val;
    int ret;
    while(_isStart)
    {
        ret = ::poll(&pfd, 1, 5000);
        if(ret == -1)
        {
            if(errno == EINTR)
                continue;
            ERR_EXIT("poll");
        }
        else if(ret == 0)
        {
            printf("timeout
");
            continue;
        }

        if(pfd.revents == POLLIN)
        {
            readTimer(_timerfd);
            _callback();
        }
    }
}

void Timer::stop()
{
    _isStart = false;
    stopTimer(_timerfd);
}

我们可以将定时器与线程封装到一起，这样，每个线程就是一个定时器。

线程的封装如下:

#ifndef THREAD_H
#define THREAD_H
#include <boost/noncopyable.hpp>
#include <functional>
#include <pthread.h>
class Thread : boost::noncopyable
{
public:

    typedef std::function<void()> ThreadCallback;

    Thread(ThreadCallback cb);
    ~Thread();

    void start();
    void join();

    static void *runInThread(void *);


private:

    pthread_t _threadId;
    bool _isRun;
    ThreadCallback _callback;
};


#endif  /*THREAD_H*/

#include "Thread.h"

Thread::Thread(ThreadCallback cb)
    :_threadId(0),
     _isRun(false),
     _callback(cb)
{

}

Thread::~Thread()
{
    if(_isRun)
        pthread_detach(_threadId);
}


void Thread::start()
{
    pthread_create(&_threadId, NULL, runInThread, this);
    _isRun = true;
}

void Thread::join()
{
    pthread_join(_threadId, NULL);
    _isRun = false;
}

void *Thread::runInThread(void *arg)
{
    Thread *p = static_cast<Thread *>(arg);
    p->_callback();
    return NULL;
}

TimerThread的封装如下:

#ifndef TIMER_THREAD_H
#define TIMER_THREAD_H
#include <boost/noncopyable.hpp>
#include <functional>
#include "Timer.h"
#include "Thread.h"

class TimerThread : boost::noncopyable
{
public:
    typedef std::function<void()> Callback;
    TimerThread(int val, int interval, Callback cb);

    void start();
    void stop();

private:
    Timer _timer;
    Thread _thread;

};


#endif  /*TIMER_THREAD_H*/

#include "TimerThread.h"

TimerThread::TimerThread(int val, int interval, Callback cb)
    :_timer(val, interval, std::move(cb)),
     _thread(std::bind(&Timer::start, &_timer))
{

}

void TimerThread::start()
{
    _thread.start();
}

void TimerThread::stop()
{
    _timer.stop();
    _thread.join();
}

测试函数如下:

#include "TimerThread.h"
#include <stdio.h>
#include <unistd.h>

void foo()
{
    printf("foo
");
}

int main(int argc, const char *argv[])
{
    TimerThread a(3, 1, &foo);
    a.start();
    sleep(10);
    a.stop();
    return 0;
}

在将Timer与Thread结合封装中，我们需要注意:
　　a)首先，将用户要执行的任务函数bind到Timer中。

　　b)然后，我们将Timer的start函数bind到Thread中。

这样，当我们开启一个该类的线程就相当于开启了一个定时器。