任务定时器模块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));
}