任务定时器模块TimerWheel在本项目中的简单使用:
下面这张图 是channel模块,poller模块,TimerWheel模块,EventLoop模块,LoopThreadPool模块进行组合。便于大家对这个项目的理解,因为代码看起来挺复杂的。
上面右下角就是定时器模块。
TimerTask类的实现:
using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask{
private:
uint64_t _id; // 定时器任务对象ID
uint32_t _timeout; //定时任务的超时时间
bool _canceled; // false-表示没有被取消, true-表示被取消
TaskFunc _task_cb; //定时器对象要执行的定时任务
ReleaseFunc _release; //用于删除TimerWheel中保存的定时器对象信息
public:
TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb):
_id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
~TimerTask() {
if (_canceled == false) _task_cb();
_release();
}
void Cancel() { _canceled = true; }
void SetRelease(const ReleaseFunc &cb) { _release = cb; }
uint32_t DelayTime() { return _timeout; }
};
TimerWheel模块中的成员:
红色方框:是定义的智能指针,将来要存储到下面绿色方框中的。
对于容器 vector<vector<PtrTask>> _wheel;
当绿色箭头走到_wheel数组某个位置上时,会调用vector中对应的清理函数,将vector中的元素全部释放,但是vector中存储的是智能指针shared_ptr,对于shared_ptr当引用计数减为0时会释放管理的资源,我们只需要将定时任务放到TimerTask类的析构函数中,就实现了定时任务的自动执行。
黑色三角行表示原有的定时任务,红色三角形表示刷新后的定时任务。当你启动非活跃连接销毁(如果不启动非活跃连接销毁,会存在有些恶意连接,长时间连接不释放,占用资源,导致其他链接无法,对服务器进行连接)。
那如何刷新定时任务,当客户端连接向文件描述符上发送数据,服务端就会检测到,调用对应的函数,并对定时任务进行刷新,在现在的位置加上设置的定时事件,红色三角形就是加定时事件4s所刷新的位置。每个vector<PtrTask>中存的元素个数都是不一样的。
对于容器unordered_map<uint64_t, WeakTask> _timers;
有人就会问,这个绿色箭头都还没走到,黑色三角形所在位置,如何将黑色三角形进行刷新的呢?
这是个好问题,那么weakptr就是管理shared_ptr的,用shared_ptr对weak_ptr进行初始化,并不会造成shared_ptr引用计数的增加。同时你可以通过weak_ptr通过的调用接口获取,他所管理的shared_ptr, 我只需在存储weak_ptr的容器中去寻找对应的weak_ptr就可以了。
他是利用哈希桶实现的,下面就是简单的容器实现图。
数组中的每个位置都存有一个链表,该链表中存放weak_ptr,之所以选用unorder_map作为容器是因为他查询效率比较快,删除效率高。
如何删除定时任务:
其实这个并不难,你想shared_ptr是可以自动释放所管理的资源的,那不就相当于删除了嘛,但是定时任务还是执行了。这是就要用一个变量来控制这个定时任务是否需要执行。
你不想执行就对这个变量进行设置就行。就比如一个连接被用户强制断开,那个绿色箭头还没有走到对应的定时任务位置,就断开连接,那么箭头后续就不要执行那个定时任务,因为执行了也没有意义。
void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb) {
PtrTask pt(new TimerTask(id, delay, cb));
pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
int pos = (_tick + delay) % _capacity;
_wheel[pos].push_back(pt);
_timers[id] = WeakTask(pt);
}
void TimerRefreshInLoop(uint64_t id) {
//通过保存的定时器对象的weak_ptr构造一个shared_ptr出来,添加到轮子中
auto it = _timers.find(id);
if (it == _timers.end()) {
return;//没找着定时任务,没法刷新,没法延迟
}
PtrTask pt = it->second.lock();//lock获取weak_ptr管理的对象对应的shared_ptr
int delay = pt->DelayTime();
int pos = (_tick + delay) % _capacity;
_wheel[pos].push_back(pt);
}
void TimerCancelInLoop(uint64_t id) {
auto it = _timers.find(id);
if (it == _timers.end()) {
return;//没找着定时任务,没法刷新,没法延迟
}
PtrTask pt = it->second.lock();
if (pt) pt->Cancel();
}
看完这两容器的相关解释,我想上面这段 对定时器模块的增添 刷新 删除应该就不会陌生了。
TimerWheel模块中为什么会有EventLoop对象:
因为定时器模块也是事件,是事件就需要被EventLoop模块管理,我们如果想添加定时任务,就在EventLoop对象中调用,方便。
定时器模块如何运行
在Channel模块中,我就提及到了这个文件描述符,他是如何添加到Poller模块中的。
这里介绍一下为什么要使用这个文件描述符,首先,我们要想到代码运行的场景。
如果一个定时任务执行时间很长,那么就会导致,vector<PtrTask> 中的一个任务运行时间很长,而后边的任务在规定时间内没有释放。也就是说导致其他任务超时了。
通过设置这个结构体来控制,多长时间算一次超时。他会用八字节存储超时的次数,再通过poller来通知channel对象,调用对应的读就绪回调函数。
static int CreateTimerfd() {
int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
if (timerfd < 0) {
ERR_LOG("TIMERFD CREATE FAILED!");
abort();
}
//int timerfd_settime(int fd, int flags, struct itimerspec *new, struct itimerspec *old);
struct itimerspec itime;
itime.it_value.tv_sec = 1;
itime.it_value.tv_nsec = 0;//第一次超时时间为1s后
itime.it_interval.tv_sec = 1;
itime.it_interval.tv_nsec = 0; //第一次超时后,每次超时的间隔时
timerfd_settime(timerfd, 0, &itime, NULL);
return timerfd;
}
int ReadTimefd() {
uint64_t times;
//有可能因为其他描述符的事件处理花费事件比较长,然后在处理定时器描述符事件的时候,有可能就已经超时了很多次
//read读取到的数据times就是从上一次read之后超时的次数
int ret = read(_timerfd, ×, 8);
if (ret < 0) {
ERR_LOG("READ TIMEFD FAILED!");
abort();
}
return times;
}
//这个函数应该每秒钟被执行一次,相当于秒针向后走了一步
void RunTimerTask() {
_tick = (_tick + 1) % _capacity;
_wheel[_tick].clear();//清空指定位置的数组,就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
}
void OnTime() {
//根据实际超时的次数,执行对应的超时任务
int times = ReadTimefd();
for (int i = 0; i < times; i++) {
RunTimerTask();
}
}
注意:这部分代码就是定时器如何运行的,但是只是个框架,并没有设置时间,你可以通过sleep函数在RunTimerTask中进行设置。_capacity就是定时的最大时间,如果超出,就不能实现大于_capacity的定时效果,所以说这里需要根据具体的实际情况进行设置。
好了,到这里我认为已经没什么难度了,顶多你就是不熟悉那个 定时文件描述符,不过没关系,我刚开始接触也不知道,查查资料了解就行。
总体代码:
using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask{
private:
uint64_t _id; // 定时器任务对象ID
uint32_t _timeout; //定时任务的超时时间
bool _canceled; // false-表示没有被取消, true-表示被取消
TaskFunc _task_cb; //定时器对象要执行的定时任务
ReleaseFunc _release; //用于删除TimerWheel中保存的定时器对象信息
public:
TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb):
_id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
~TimerTask() {
if (_canceled == false) _task_cb();
_release();
}
void Cancel() { _canceled = true; }
void SetRelease(const ReleaseFunc &cb) { _release = cb; }
uint32_t DelayTime() { return _timeout; }
};
class TimerWheel {
private:
using WeakTask = std::weak_ptr<TimerTask>;
using PtrTask = std::shared_ptr<TimerTask>;
int _tick; //当前的秒针,走到哪里释放哪里,释放哪里,就相当于执行哪里的任务
int _capacity; //表盘最大数量---其实就是最大延迟时间
std::vector<std::vector<PtrTask>> _wheel;
std::unordered_map<uint64_t, WeakTask> _timers;
EventLoop *_loop;
int _timerfd;//定时器描述符--可读事件回调就是读取计数器,执行定时任务
std::unique_ptr<Channel> _timer_channel;
private:
void RemoveTimer(uint64_t id) {
auto it = _timers.find(id);
if (it != _timers.end()) {
_timers.erase(it);
}
}
static int CreateTimerfd() {
int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
if (timerfd < 0) {
ERR_LOG("TIMERFD CREATE FAILED!");
abort();
}
//int timerfd_settime(int fd, int flags, struct itimerspec *new, struct itimerspec *old);
struct itimerspec itime;
itime.it_value.tv_sec = 1;
itime.it_value.tv_nsec = 0;//第一次超时时间为1s后
itime.it_interval.tv_sec = 1;
itime.it_interval.tv_nsec = 0; //第一次超时后,每次超时的间隔时
timerfd_settime(timerfd, 0, &itime, NULL);
return timerfd;
}
int ReadTimefd() {
uint64_t times;
//有可能因为其他描述符的事件处理花费事件比较长,然后在处理定时器描述符事件的时候,有可能就已经超时了很多次
//read读取到的数据times就是从上一次read之后超时的次数
int ret = read(_timerfd, ×, 8);
if (ret < 0) {
ERR_LOG("READ TIMEFD FAILED!");
abort();
}
return times;
}
//这个函数应该每秒钟被执行一次,相当于秒针向后走了一步
void RunTimerTask() {
_tick = (_tick + 1) % _capacity;
_wheel[_tick].clear();//清空指定位置的数组,就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
}
void OnTime() {
//根据实际超时的次数,执行对应的超时任务
int times = ReadTimefd();
for (int i = 0; i < times; i++) {
RunTimerTask();
}
}
void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb) {
PtrTask pt(new TimerTask(id, delay, cb));
pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
int pos = (_tick + delay) % _capacity;
_wheel[pos].push_back(pt);
_timers[id] = WeakTask(pt);
}
void TimerRefreshInLoop(uint64_t id) {
//通过保存的定时器对象的weak_ptr构造一个shared_ptr出来,添加到轮子中
auto it = _timers.find(id);
if (it == _timers.end()) {
return;//没找着定时任务,没法刷新,没法延迟
}
PtrTask pt = it->second.lock();//lock获取weak_ptr管理的对象对应的shared_ptr
int delay = pt->DelayTime();
int pos = (_tick + delay) % _capacity;
_wheel[pos].push_back(pt);
}
void TimerCancelInLoop(uint64_t id) {
auto it = _timers.find(id);
if (it == _timers.end()) {
return;//没找着定时任务,没法刷新,没法延迟
}
PtrTask pt = it->second.lock();
if (pt) pt->Cancel();
}
public:
TimerWheel(EventLoop *loop):_capacity(60), _tick(0), _wheel(_capacity), _loop(loop),
_timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd)) {
_timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
_timer_channel->EnableRead();//启动读事件监控
}
/*定时器中有个_timers成员,定时器信息的操作有可能在多线程中进行,因此需要考虑线程安全问题*/
/*如果不想加锁,那就把对定期的所有操作,都放到一个线程中进行*/
void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
//刷新/延迟定时任务
void TimerRefresh(uint64_t id);
void TimerCancel(uint64_t id);
/*这个接口存在线程安全问题--这个接口实际上不能被外界使用者调用,只能在模块内,在对应的EventLoop线程内执行*/
bool HasTimer(uint64_t id) {
auto it = _timers.find(id);
if (it == _timers.end()) {
return false;
}
return true;
}
};
void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) {
_loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}
//刷新/延迟定时任务
void TimerWheel::TimerRefresh(uint64_t id) {
_loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id) {
_loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}