基于时间轮的定时器
基于时间轮的定时器
原理
图片是一个单层时间轮，当指针走到某一格上，就获取那一格上挂的任务将其执行。
当时如果时间跨度大的时候，格子数明显不够，那么就可以做成多级时间轮。
其实就是当低层的时间轮走了一圈，将它高一层的时间轮走一格，并且将挂在高层时间轮上的任务分配下来。
实现
文件#include"TimeWheel.h"
#include<functional>
#include<list>
#include<thread>
#include<mutex>
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<void(void)> call_back;
TimeStamp tri_time; //事件触发的时间
int dur; //多久触发
};
class TimeWheel //时间轮
{
public:
TimeWheel();
~TimeWheel();
void Start(); //启动
int AddTimer(int space,std::function<void(void)>& call_back); //添加定期器
private:
void DoLoop();//主循环
void InsertTimer(Event &event); //插入事件到时间槽
int getMS(const TimeStamp &timeStamp);
void solvingEvents(std::list<Event>l); //解决时间槽上的事件
void getNextTime(TimeStamp &nowTimeStamp,int dur); //得到下个时间
private:
std::list<Event> *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<iostream>
using namespace std;
TimeWheel::TimeWheel()
{
cout<<"TimeWheel()"<<endl;
timeStamp.ms = timeStamp.s = timeStamp.min = 0;
slot_ms=10;
slot_s=60;
slot_min=60;
step = 100;
callBackList = new list<Event>[slot_ms+slot_s+slot_min];
}
TimeWheel::~TimeWheel()
{
delete[] callBackList;
}
void TimeWheel::Start() //开启一个线程
{
cout<<"Start()"<<endl;
std::thread myThread([&]{
this->DoLoop();
});
myThread.detach();
}
void TimeWheel::DoLoop() //主循环
{
cout<<"start"<<endl;
while(true)
{
this_thread::sleep_for(chrono::milliseconds(step)); //让线程休息step毫秒的时间
unique_lock<std::mutex> lock(_mutex);
cout<<"time:"<<timeStamp.min <<" "<<timeStamp.s <<" "<<timeStamp.ms<<endl;
TimeStamp per = timeStamp; //per是原来的时间
getNextTime(timeStamp,step); //timeStamp向后走一步
if(per.min!=timeStamp.min) //分针有进位
{
//cout<<"(check min :" << slot_ms+slot_s+timeStamp.min <<")"<<endl;
list<Event>& l = callBackList[slot_ms+slot_s+timeStamp.min];
solvingEvents(l);
l.clear();
}
else if(per.s!=timeStamp.s) //秒针有进位
{
//cout<<"(check s :" << slot_ms+timeStamp.s <<")"<<endl;
list<Event>& l = callBackList[slot_ms+timeStamp.s];
solvingEvents(l);
l.clear();
}
else if(per.ms!=timeStamp.ms) //毫秒有进位
{
//cout<<"(check ms :" << timeStamp.ms <<")"<<endl;
list<Event>& 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(list<Event>l)
{
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<void(void)>& call_back)
{
if(space<step)return -1; //发生事件小于最小间隔
if(space%step!=0)return -1;
unique_lock<std::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<<"add a "<<space<<" clock"<<endl;
cout<<event.tri_time.min<<":"<<event.tri_time.s<<":"<<event.tri_time.ms<<endl;
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<cstdio>
#include<cstring>
#include"TimeWheel.h"
#include<iostream>
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<void(void)> f100 = std::bind(&fun100);
function<void(void)> f200 = std::bind(&fun200);
function<void(void)> f500 = std::bind(&fun500);
function<void(void)> 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;
}
实现效果
搬砖啦
