C++ 11 实现定时器

用C++写了个定时器。

项目的需求是原来Windows的程序，用到了windows APi的 SetTimer 和 KillTimer 来创建和销毁定时器，现在要移植代码到Linux，实现与其相似的功能。

首先创建一个Timer类，管理单个定时器。

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

#define TIMER_ID unsigned long
#define INTERVAL unsigned int

class MyTimer{
public:
    MyTimer(TIMER_ID _id, INTERVAL _interval, TimerFunc _func);
    void stopTimer();
    void startTimer();
    ~MyTimer();
private:
    TIMER_ID m_id;
    INTERVAL m_interval;
    bool m_stop;
    TimerFunc m_func;
    std::future<int> m_future;
};

用一个全局hash表来管理Timer，并定义一个全局的mutex实现线程锁

std::unordered_map<TIMER_ID, MyTimer*> TimerMap;
std::mutex g_mutex;

定义一个TimerServer类实现接口：

class TimerService
{
public:
    static TIMER_ID setTimer(INTERVAL _interval, TimerFunc _func);
    static void killTimer(TIMER_ID _id);
};

static TIMER_ID NewTimerID = 0;

TIMER_ID TimerService::setTimer(INTERVAL _interval, TimerFunc _func){
    MyTimer* pTimer = new MyTimer(NewTimerID, _interval, _func);
    TimerMap[NewTimerID] = pTimer;
    pTimer->startTimer();
    return NewTimerID++;
}

void TimerService::killTimer(unsigned long _id)
{
    MyTimer* pTimer = TimerMap.at(_id);
    if (pTimer){
        pTimer->stopTimer();
        delete pTimer;
        TimerMap.erase(_id);
    }
}

Timer内部的方法实现：

MyTimer::MyTimer(unsigned long _id, unsigned int _interval, TimerFunc _func)
{
    m_id = _id;
    m_interval = _interval;
    m_func = _func;
    m_stop = false;
}

void MyTimer::startTimer()
{
    m_future = std::async(std::launch::async, [this](){
        while(true){
            if(m_stop)
                break;
            std::this_thread::sleep_for(std::chrono::milliseconds(m_interval));
            std::lock_guard<std::mutex> lock(g_mutex);
            m_func();
        }
        return 0;
    });
}

void MyTimer::stopTimer()
{
    m_stop = true;
    m_future.wait();
}

MyTimer::~MyTimer()
{

}

测试：

#include <iostream>
#include "mytimer.h"
#include <chrono>
#include <functional>

using namespace std;

void printWorld() {
    cout << "world" << endl;
}

class Router{
public:
    void countSelf() {
        cout << "Count is " << count << endl;
        count++;
    }

    Router(){
        count = 0;
        id = TimerService::setTimer(1000, std::bind(&Router::countSelf, this));
    }
    ~Router() {
        TimerService::killTimer(id);
    }

private:
    unsigned int count;
    unsigned long id;
};

int main()
{
    auto l1 = TimerService::setTimer(1000, [](){cout << "hello" << endl;});
    auto l2 = TimerService::setTimer(1000, std::bind(printWorld));
    Router *r = new Router;

    std::this_thread::sleep_for(std::chrono::seconds(3));
    TimerService::killTimer(l2);
    delete r;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    return 0;
}

Github

 

Edit:

代码做了一些优化，去掉TimerService类，用static替代全局变量

MyTimer.h

#ifndef MYTIMER_H
#define MYTIMER_H

#include <functional>
#include <atomic>
#include <future>
#include <list>
#include <map>

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

#define TIMER_ID unsigned long
#define INTERVAL unsigned int
#define ERRCOUNT unsigned char

class MyTimer{
public:
    MyTimer(TimerFunc _func);

    static MyTimer* GetInstance(TimerFunc _func);
    void stopTimer();
    void startTimer(INTERVAL _interval);
    void setTimerEnabled(bool _enabled);
    ~MyTimer();

private:
    TIMER_ID m_id;
    INTERVAL m_interval;
    bool m_stop;
    bool m_enabled;
    TimerFunc m_func;
    std::future<int> m_future;

    static std::map<TIMER_ID, MyTimer*> s_timerMap;
    static std::mutex s_mutex;
    static TIMER_ID s_id;

};

#endif // MYTIMER_H

MyTimer.cpp

#include "mytimer.h"
#include <chrono>
#include <thread>
#include <utility>
#include <functional>

std::map<TIMER_ID, MyTimer*> MyTimer::s_timerMap;
std::mutex MyTimer::s_mutex;
TIMER_ID MyTimer::s_id = 0;

MyTimer::MyTimer(TimerFunc _func)
{
    m_id = s_id;
    m_interval = 0;
    m_func = _func;
    m_stop = false;
    m_enabled = false;
    s_timerMap[m_id] = this;
}

MyTimer *MyTimer::GetInstance(TimerFunc _func)
{
    return new MyTimer(_func);
}

void MyTimer::startTimer(INTERVAL _interval)
{
    m_interval = _interval;
    m_enabled = true;
    m_future = std::async(std::launch::async, [this](){
        while(true){
            if(m_stop)
                break;
            std::this_thread::sleep_for(std::chrono::milliseconds(m_interval));
            std::lock_guard<std::mutex> lock(s_mutex);
            if(m_enabled && !m_stop)
                m_func();
        }
        return 0;
    });
}

void MyTimer::setTimerEnabled(bool _enabled)
{
    
    m_enabled = _enabled;
}

void MyTimer::stopTimer()
{
    m_stop = true;
    m_future.wait();
}

MyTimer::~MyTimer()
{
    if (m_stop == false)
        stopTimer();
    if (s_timerMap.find(m_id) != s_timerMap.end())
        s_timerMap.erase(m_id);
}

测试：

#include <iostream>
#include "mytimer.h"
#include <chrono>
#include <functional>

using namespace std;

void printWorld() {
    cout << "world" << endl;
}

class Router{
public:
    void countSelf() {
        cout << "Count is " << count << endl;
        count++;
    }

    Router(){
        count = 0;
        pTimer = MyTimer::GetInstance(std::bind(&Router::countSelf, this));
        pTimer->startTimer(500);
    }
    ~Router() {
        pTimer->stopTimer();
    }

private:
    unsigned int count;
    MyTimer* pTimer;
};

int main()
{
    MyTimer* pTimer1;
    MyTimer* pTimer2;
    pTimer1 = MyTimer::GetInstance([](){cout << "hello" << endl;});
    pTimer2 = MyTimer::GetInstance(std::bind(printWorld));
    pTimer1->startTimer(1000);
    pTimer2->startTimer(1000);
    Router *r = new Router;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    pTimer2->setTimerEnabled(false);
    std::this_thread::sleep_for(std::chrono::seconds(3));
    pTimer2->setTimerEnabled(true);
    delete pTimer1;
    delete r;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    return 0;
}