Linux下的多线程定时器实现

Linux下编写一个程序库，实现定时器的功能,它能为用户提供在同一进程中多次使用的定时器。

二、实现

#include
#include
#include
#include
#include
#include
#include #include
#define DEFAULT_INTERVAL 1

int TIMER_CNT = 0;
class Timer;                //定时器
class TimerManager;        //定时器管理器

class TimerManager {

    friend class Timer;    //友元类,Timer类可分享此类的方法
public:
    typedef enum {

        TIMER_MANAGER_STOP=0,
        TIMER_MANAGER_START
    }TimerManagerState;
    static TimerManager *instance();    //当前实例
    void start();                      //启动当前线程，运行process函数
    void stop();                        //终止当前线程
    void dump();                        //清理当前剩下的无用定时器
    void add_timer(Timer *vtimer);      //线程安全的增加定时器
    void remove_timer(Timer *vtimer);  //线程安全的移除定时器
protected:
    static void *process(void *);

private:
    TimerManager();
    void add_timer_unsafe(Timer *vtimer);  //线程非安全的增加定时器，本类使用
    void remove_timer_unsafe(Timer *vtimer);//线程非安全的移除定时器，本类使用

    static TimerManager *m_instance;
    static pthread_mutex_t workmutex;
    TimerManagerState m_state;
    LIST_HEAD(,Timer) list_;                //链表头
    static int mark;
};
class Timer {

    friend class TimerManager;
public:
    typedef enum {

        TIMER_IDLE = 0,
        TIMER_ALIVE,
        TIMER_TIMEOUT
    }TimerState;
    Timer(int vinterval,void (*vfunc)(void *),void *vdata);
    void start();                          //把自己添加进定时器管理器的链表里
    void stop();                            //把自己从定时器管理器的链表里移除
    void reset(int vinterval);              //重置
    ~Timer();

private:
    int id;                                //当前定时器的ID
    int m_interval;                        //定时器的定时时间，单位为秒
    int m_counter;                          //还剩下多少时间，单位为微秒
    TimerState m_state;                    //当前定时器的状态
    void (*m_func)(void *);
    void *m_data;
    LIST_ENTRY(Timer) entry_;              //当前定时器在链表中的地址
};

TimerManager *TimerManager::m_instance;
pthread_mutex_t TimerManager::workmutex;

TimerManager::TimerManager() {

    pthread_mutex_init(&workmutex,NULL);
}
TimerManager *TimerManager::instance() {

    if (m_instance == NULL) {

        pthread_mutex_lock(&workmutex);
        if (m_instance == NULL)
            m_instance = new TimerManager();
        pthread_mutex_unlock(&workmutex);
    }
    return m_instance;
}
void TimerManager::start() {

    if (m_state == TIMER_MANAGER_STOP) {

        m_state = TIMER_MANAGER_START;
        pthread_t pid;
        int res = pthread_create(&pid,NULL,process,this);
        if (res != 0) {

            printf(“pthread_create is failed\n”);
            exit(EXIT_FAILURE);
        }
    }
}
void TimerManager::stop() {

    this->m_state = TIMER_MANAGER_STOP;
}
void TimerManager::dump() {

    Timer *item;
    pthread_mutex_lock(&workmutex);
    LIST_FOREACH(item,&(this->list_),entry_) {

        if (item->m_counter == 0) {

            printf(“Timer%d will be dumped!\n”,(int)item->m_data);
            item->stop();
        }
    }
    pthread_mutex_unlock(&workmutex);
}
void *TimerManager::process(void *arg) {

    pthread_detach(pthread_self());

    TimerManager *manage = (TimerManager *)arg;
    Timer *item;
    struct timeval start,end;
    int delay;
    struct timeval tm;
    gettimeofday(&end,0);

    while (manage->m_state == TIMER_MANAGER_START) {

        tm.tv_sec = 0;
        tm.tv_usec = DEFAULT_INTERVAL * 1000;
        start.tv_sec = end.tv_sec;
        start.tv_usec = end.tv_usec;
        while (select(0,0,0,0,&tm) < 0 && errno == EINTR);
        gettimeofday(&end,0);

        delay = (end.tv_sec – start.tv_sec) * 1000;
        delay += (end.tv_usec – start.tv_usec);
        pthread_mutex_lock(&manage->workmutex);
        LIST_FOREACH(item, &(manage->list_), entry_) {

            //printf(“m_data = %d m_counter = %d “,item->m_data,item->m_counter);
            if ( item->m_counter < delay)
                item->m_counter = 0;
            else
                item->m_counter -= delay;
            //printf(“m_data = %d m_counter = %d\n”,item->m_data,item->m_counter);

            if (item->m_counter == 0) {

                if (item->m_func)
                    item->m_func(item->m_data);
                manage->remove_timer_unsafe(item);
                item->m_state = Timer::TIMER_TIMEOUT;
            }
        }
        pthread_mutex_unlock(&manage->workmutex);
    }
}
void TimerManager::add_timer(Timer* vtimer) {

    pthread_mutex_lock(&workmutex);
    LIST_INSERT_HEAD(&(this->list_),vtimer,entry_);
    pthread_mutex_unlock(&workmutex);
}
void TimerManager::remove_timer(Timer* vtimer) {

    pthread_mutex_lock(&workmutex);
    LIST_REMOVE(vtimer, entry_);
    pthread_mutex_unlock(&workmutex);
}
void TimerManager::add_timer_unsafe(Timer* vtimer) {

    LIST_INSERT_HEAD(&(this->list_),vtimer,entry_);
}
void TimerManager::remove_timer_unsafe(Timer* vtimer) {

    LIST_REMOVE(vtimer, entry_);
}

还有一个类的代码先不上传，这是我们正在学的Linux一个实验，上传的话万人都交这个代码给老师了。

三、总结:

1、按照之前我写代码的习惯，都是先声明一个类A,，接着依次实现A的方法，然后再声明一个类B，接着依次实现B的方法。

按照这个习惯，如果类A在类B的前面声明，如果类A要调用类B中的方法，就必须在定义之前声明class A，class B，接着把类A声明为类B的友元类，还要把实现放在两个类定义的后面，才不会出错。

按照这个习惯，如果类A要调用类B的方法，类B要调用A的方法，这个要怎么办？到底哪个类放在前面？和上面的情况相似。我们一定要保证某个类在调用另一个类的对象，另一个类的方法都已经实现。否则会出现类似invalid use of incomplete type ‘struct Timer’这样的错误。

2、当类中声明了静态变量，而且未初始化。这时候要在类外单独再声明一次静态变量，这样系统会自动给这些变量分配全局内存空间。这样，后面就可以放心地对静态变量进行赋值了。不然会出现类似于undefined reference to `TimerManager::m_instance’这样的错误。

3、程序中出现了死锁，process中用lock和unlock锁起一段代码，而这段代码中又有用lock和unlock锁起一段断码，这样后一段代码无法执行切程序处于挂起等待状态。

4、我的实现是通过select不断的检查时间，可是select这个函数调用占用了一些时间导致精度误差。如果我尽量少调用select函数，那么实时性不够，如果调用次数很多，那么精确度又不够。在我的代码中折中，选取1s作为调用select的间隔。

5、当Timermanage