任务定时器模块TimerWheel在本项目中的简单使用：

        下面这张图 是channel模块，poller模块，TimerWheel模块，EventLoop模块，LoopThreadPool模块进行组合。便于大家对这个项目的理解，因为代码看起来挺复杂的。

上面右下角就是定时器模块。

TimerTask类的实现：

using TaskFunc = std::function; using ReleaseFunc = std::function; 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>  _wheel;

        当绿色箭头走到_wheel数组某个位置上时，会调用vector中对应的清理函数，将vector中的元素全部释放，但是vector中存储的是智能指针shared_ptr，对于shared_ptr当引用计数减为0时会释放管理的资源，我们只需要将定时任务放到TimerTask类的析构函数中，就实现了定时任务的自动执行。

        黑色三角行表示原有的定时任务，红色三角形表示刷新后的定时任务。当你启动非活跃连接销毁（如果不启动非活跃连接销毁，会存在有些恶意连接，长时间连接不释放，占用资源，导致其他链接无法，对服务器进行连接）。

        那如何刷新定时任务，当客户端连接向文件描述符上发送数据，服务端就会检测到，调用对应的函数，并对定时任务进行刷新，在现在的位置加上设置的定时事件，红色三角形就是加定时事件4s所刷新的位置。每个vector中存的元素个数都是不一样的。

对于容器unordered_map _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 中的一个任务运行时间很长，而后边的任务在规定时间内没有释放。也就是说导致其他任务超时了。

通过设置这个结构体来控制，多长时间算一次超时。他会用八字节存储超时的次数，再通过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; using ReleaseFunc = std::function; 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;         using PtrTask = std::shared_ptr;         int _tick;      //当前的秒针，走到哪里释放哪里，释放哪里，就相当于执行哪里的任务         int _capacity;  //表盘最大数量---其实就是最大延迟时间         std::vector> _wheel;         std::unordered_map _timers;          EventLoop *_loop;         int _timerfd;//定时器描述符--可读事件回调就是读取计数器，执行定时任务         std::unique_ptr _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)); }