基于时间轮的定时器

基于时间轮的定时器

目录

• 基于时间轮的定时器
  • 原理
  • 实现
  • 实现效果

原理

图片是一个单层时间轮，当指针走到某一格上，就获取那一格上挂的任务将其执行。
当时如果时间跨度大的时候，格子数明显不够，那么就可以做成多级时间轮。
其实就是当低层的时间轮走了一圈，将它高一层的时间轮走一格，并且将挂在高层时间轮上的任务分配下来。

实现

文件#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;
}

实现效果