基于时间轮的定时器

原理

图片是一个单层时间轮，当指针走到某一格上，就获取那一格上挂的任务将其执行。

当时如果时间跨度大的时候，格子数明显不够，那么就可以做成多级时间轮。

其实就是当低层的时间轮走了一圈，将它高一层的时间轮走一格，并且将挂在高层时间轮上的任务分配下来。

实现

文件#include"TimeWheel.h"

#include

#include

#include

#include

struct TimeStamp //时间戳

{

int ms;

int s;

int min;

bool operator==(TimeStamp timeStamp)

{

return timeStamp.ms==ms&&timeStamp.s==s&&timeStamp.min==min;

}

};

struct Event //挂在时间槽上的事件

{

std::function call_back;

TimeStamp tri_time; //事件触发的时间

int dur; //多久触发

};

class TimeWheel //时间轮

{

public:

TimeWheel();

~TimeWheel();

void Start(); //启动

int AddTimer(int space,std::function& call_back); //添加定期器

private:

void DoLoop();//主循环

void InsertTimer(Event &event); //插入事件到时间槽

int getMS(const TimeStamp &timeStamp);

void solvingEvents(std::listl); //解决时间槽上的事件

void getNextTime(TimeStamp &nowTimeStamp,int dur); //得到下个时间

private:

std::list *callBackList = nullptr; //当做时间槽上，每一个槽都是一个链表

std::mutex _mutex; //互斥量

TimeStamp timeStamp; //事件轮的时间

int slot_ms; //毫秒的时间槽数量

int slot_s; //秒的时间槽数量

int slot_min; //分的时间槽数量

int step; //最小的间隔时间

};

文件#include"TimeWheel.cpp"

#include"TimeWheel.h"

#include

using namespace std;

TimeWheel::TimeWheel()

{

cout<

timeStamp.ms = timeStamp.s = timeStamp.min = 0;

slot_ms=10;

slot_s=60;

slot_min=60;

step = 100;

callBackList = new list[slot_ms+slot_s+slot_min];

}

TimeWheel::~TimeWheel()

{

delete[] callBackList;

}

void TimeWheel::Start() //开启一个线程

{

cout<

std::thread myThread([&]{

this->DoLoop();

});

myThread.detach();

}

void TimeWheel::DoLoop() //主循环

{

cout<

while(true)

{

this_thread::sleep_for(chrono::milliseconds(step)); //让线程休息step毫秒的时间

unique_lock<:mutex> lock(_mutex);

cout<

TimeStamp per = timeStamp; //per是原来的时间

getNextTime(timeStamp,step); //timeStamp向后走一步

if(per.min!=timeStamp.min) //分针有进位

{

//cout<

list& l = callBackList[slot_ms+slot_s+timeStamp.min];

solvingEvents(l);

l.clear();

}

else if(per.s!=timeStamp.s) //秒针有进位

{

//cout<

list& l = callBackList[slot_ms+timeStamp.s];

solvingEvents(l);

l.clear();

}

else if(per.ms!=timeStamp.ms) //毫秒有进位

{

//cout<

list& l = callBackList[timeStamp.ms];

solvingEvents(l);

l.clear();

}

lock.unlock();

}

}

int TimeWheel::getMS(const TimeStamp &timeStamp) //得到时间戳timeStamp一共多少ms

{

return step * timeStamp.ms + timeStamp.s * 1000 + timeStamp.min * 60 * 1000;

}

void TimeWheel::solvingEvents(listl)

{

for (auto item = l.begin(); item != l.end(); item++)

{

if(timeStamp == item->tri_time) //触发时间到了

{

item->call_back(); //执行函数

//如果需要发生多次加入下面两行

getNextTime(item->tri_time,item->dur);

InsertTimer(*item);

}

else

{

InsertTimer(*item);

}

}

}

void TimeWheel::getNextTime(TimeStamp &nowTimeStamp,int dur)//获得下一个时间

{

int next_ms = getMS(nowTimeStamp)+dur;

nowTimeStamp.min = next_ms/1000/60%slot_min;

nowTimeStamp.s = (next_ms%(1000*60))/1000;

nowTimeStamp.ms = (next_ms%1000)/step;

}

//添加定时器

int TimeWheel::AddTimer(int space,function& call_back)

{

if(space

if(space%step!=0)return -1;

unique_lock<:mutex> lock(_mutex);

Event event;

event.call_back = call_back;

event.tri_time.ms = timeStamp.ms;

event.tri_time.s = timeStamp.s;

event.tri_time.min = timeStamp.min;

event.dur = space;

getNextTime(event.tri_time,event.dur);

//cout<

cout<

InsertTimer(event);

lock.unlock();

return 0;

}

//先时间轮内插入事件

void TimeWheel::InsertTimer(Event &event)

{

if(event.tri_time.min != timeStamp.min) //分钟与现在不同的分钟就插入分的槽

callBackList[slot_ms + slot_s + event.tri_time.min].push_back(event);

else if(event.tri_time.s != timeStamp.s)

callBackList[slot_ms + event.tri_time.s].push_back(event);

else if(event.tri_time.ms != timeStamp.ms)

callBackList[event.tri_time.ms].push_back(event);

}

测试文件Main.cpp

#include

#include

#include"TimeWheel.h"

#include

using namespace std;

void fun100()

{

cout << "------------fun 100--------------" << endl;

}

void fun200()

{

cout << "------------fun 200--------------" << endl;

}

void fun500()

{

cout << "------------fun 500--------------" << endl;

}

void fun1500()

{

cout << "------------fun 1500-------------" << endl;

}

int main()

{

function f100 = std::bind(&fun100);

function f200 = std::bind(&fun200);

function f500 = std::bind(&fun500);

function f1500 = std::bind(&fun1500);

TimeWheel timeWheel;

timeWheel.Start();

//加入定时器

timeWheel.AddTimer(100,f100);

timeWheel.AddTimer(200,f200);

timeWheel.AddTimer(500,f500);

timeWheel.AddTimer(1500,f1500);

while(true){}

return 0;

}

实现效果