服务器设计笔记(2)-----定时器的实现(C++)

   很久之前听著名页游服务器主程讲座时，讲到过定时器的实现，基本思路如下（易语言）

       while(true)

       {

             对定时器进行排序。

             for(遍历定时器)

             {

                   if 如果定时器到：

                          callback;

                   else

                           break;

             }

             usleep(20);

         }

        按照这个思路，我们继续我们的设计：

1： 首先 定义一个Thread类：

/*
 * Thread.h
 *
 *  Created on: Sep 11, 2012
 *      Author: root
 */

#ifndef THREAD_H_
#define THREAD_H_

#include <pthread.h>

class Thread {

public:
    enum THREADSTATE
    {
        IDLE,
        WORK,
        BUSY,
    };

public:

    Thread();

    virtual ~Thread();

    virtual void* run(void) = 0;

    virtual int start(void);

    virtual int cancel(void);

    pthread_t get_pid() const
    {
        return pid;
    }

protected:

    THREADSTATE _thread_state;

private:

    pthread_t pid;

    static void* thread_entry(void* para);
};

#endif /* THREAD_H_ */

        实现代码Thread.cpp:

/*
 * Thread.cpp
 *
 *  Created on: Sep 11, 2012
 *      Author: root
 */

#include "Thread.h"

Thread::Thread() {
    // TODO Auto-generated constructor stub

}

Thread::~Thread() {
    // TODO Auto-generated destructor stub
}

void* Thread::thread_entry(void* para)
{
    Thread *pThread = static_cast<Thread *>(para);
    return pThread->run();
}

int Thread::start(void)
{
    if(pthread_create(&pid,0,thread_entry,static_cast<void *>(this)) < 0)
    {
        pthread_detach(this->pid);
        return -1;
    }
    return 0;
}

int Thread::cancel(void)
{
    pthread_cancel(this->pid);
    return 0;
}

 2:定义定时器，和定时器线程：

         TimerThread.h

/*
 * Timer.h
 *
 *  Created on: Sep 11, 2012
 *      Author: root
 */

#ifndef TIMER_H_
#define TIMER_H_

#include "Thread.h"
#include <list>

using namespace std;

struct Timer
{

    void *_args;
    int (*_callback)();
    int _interval;
    int leftsecs;
    void open(int interval,int (*callback)())
    {
        _interval = interval * 1000;
        leftsecs = _interval;
        _callback = callback;
    }

    bool operator < (Timer _timer)
    {
        return _timer.leftsecs < this->leftsecs;
    }

    bool operator == (Timer _timer)
    {
        return _timer.leftsecs == this->leftsecs;
    }

};

class TimerThread : public Thread
{

public:

    static TimerThread* _instance;

    static TimerThread* get_instance();

    virtual void* run(void);

    virtual ~TimerThread();

    void Register(Timer _timer);

    void unRegister(Timer _timer);

private:

    TimerThread();

    list<Timer> _timer_list;

};

extern unsigned int get_systime_clock();



#define TIMERMANAGE TimerThread::get_instance()

#endif /* TIMER_H_ */

           实现代码：TimerThread.cpp

/*
 * Timer.cpp
 *
 *  Created on: Sep 11, 2012
 *      Author: root
 */

#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include "Timer.h"


TimerThread* TimerThread::_instance;



TimerThread::TimerThread()
{

}

TimerThread::~TimerThread()
{

}

void* TimerThread::run(void)
{
    while(true)
    {
        unsigned int start_clock = get_systime_clock();
        this->_timer_list.sort();
        list<Timer>::iterator iter;
        for(iter = this->_timer_list.begin();
                iter != this->_timer_list.end();
                    iter ++)
        {
            iter->leftsecs --;
            if(iter->leftsecs == 0)
            {
                iter->_callback();
                iter->leftsecs = iter->_interval;
            }
        }
        unsigned int end_clock = get_systime_clock();

        usleep(1000 + start_clock - end_clock);
    }
    return (void*)0;
}

void TimerThread::Register(Timer _timer)
{
    this->_timer_list.push_back(_timer);
}

void TimerThread::unRegister(Timer _timer)
{
    this->_timer_list.remove(_timer);
}

TimerThread* TimerThread::get_instance()
{
    if(_instance == NULL)
    {
        _instance = new TimerThread();
    }
    return _instance;
}



unsigned int get_systime_clock()
{
    struct timeval now;
    gettimeofday(&now,NULL);
    return now.tv_sec*1000 + now.tv_usec/1000;
}

 3: 测试函数：

//============================================================================
// Name        : test.cpp
// Author      : archy
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <string>
#include <stdio.h>
#include <sys/types.h>

#include "Timer.h"


using namespace std;

int handle_timeout()
{
    unsigned int time = get_systime_clock();
    printf("time out,%u\n",time);
    return 0;
}

int main()
{
    Timer _timer;
    _timer.open(1,handle_timeout);
    TIMERMANAGE->Register(_timer);
    TIMERMANAGE->start();
    getchar();
    return 0;
}

目前存在的问题：定时不准，主要是由于usleep()之后 ，不能及时醒，这个是因为Linux线程调度引起的。

改进的方向：1. TimerThread 里面的list换成优先队列

                 2. 添加时间纠正，在测试中发现，每次大概慢100us左右，这对于长时间的定时器是致命。

也想听听广大网友的意见，感激不尽。