记录——时间轮定时器（lua 实现）

　　很长一段时间里，我错误的认识了定时器。无意中，我发现了“时间轮”这个名词，让我对定时器有了新的看法。

　　我错误的认为，定时器只需要一个 tick 队列，按指定的时间周期遍历队列，检查 tick 倒计时满足触发条件就触发回调。

tick 定义如下：

 struct Tick {
     int_t n;
     func_t func;
 };

遍历触发实现如下：

 void Update()
 {
     for (auto & tick: _ticks)
     {
         if (Check(tick))
         {
             tick.func();
             Remove(tick);
         }
     }
 }

实现很简洁，但效率却出奇的慢。

假设有100个tick，依次触发时间是100～10000毫秒，也就是每一个tick的触发间隔为100毫秒

可以想象，在头100毫秒内，不会有任何tick被触发，但是Update却傻乎乎对100个tick进行Check。

当时间达到100毫秒的时候，只有第一个 tick 达到了触发条件，但是Update依旧会对余下99个进行Check。

时间轮很好的解决了这个问题。

思路是这样的：

需要一个轮盘，轮盘上有若干个插槽，

把 tick 放进合适的插槽，

每次轮询直接触发插槽里的 tick。

假设要实现一个最低刻度为毫秒，最大上限为1天的定时器（最长延时23点59分59秒999毫秒）

假设要在 3点30分25秒600毫秒 处安插一个 tick。

首先这个轮盘需要 24 × 60 x 60 x 1000 个插槽，

其次把 3点30分25秒600毫秒 转化为定时器最低刻度（毫秒），也就是 11005600 = 600 + 25000 + 180000 + 10800000.

也就是说，在这个轮盘的 11005600 刻度位置，安插上这个 tick。

就是这么简单粗暴！

这是一个错误例子。

其实不需要那么多插槽，如果你见过水表，你应该知道该怎么做，继续前面的假设。

我们为每一个时间单位准备一个时间轮，就是 时（24），分（60），秒（60），毫秒（1000）

因此只需要 1144 = 24 + 60 + 60 + 1000 个插槽就够了。

在 3点30分25秒600毫秒 处安插一个 tick，

首先在 时(3) 安插上这个 tick，

当执行到 时(3) 的时候，删除这个 tick，检查到该 tick 还有 30分25秒600毫秒

于是在 分（30）安插上这个 tick，

当执行到 分（30）的时候，删除这个 tick，检查到该 tick 还有 25秒600毫秒

于是在 秒（25）安插上这个 tick，

当执行到 秒（25）的时候，删除这个tick，检查到该 tick 还有 600毫秒

于是在 毫秒（600）安插上这个 tick，

当执行到 毫秒（600）的时候，删除这个tick，触发这个 tick。

因为只是为了理解算法，我只是用lua实现了一遍，算法本身大概只有90行不到，吐个槽，lua索引从1开始很蛋疼。

 sformat = string.format
 tinsert = table.insert
 tremove = table.remove
 tconcat = table.concat
 mfloor = math.floor
 local utils = require("utils")
 local _M = {    _slots = nil,
                 _cycle = nil,    }

 function _M.Init(self, cycle)
     if not self._slots then
         self._slots = {}
         self.] = {}
         self.] = {}
         self.] = {}
         self.] = {}
         utils.tinsert_n(self.], {}, )
         utils.tinsert_n(self.], {}, )
         utils.tinsert_n(self.], {}, )
         utils.tinsert_n(self.], {}, )
     end
     if not self._cycle then
         self._cycle = cycle
     end
 end

 function _M.Update(self, cycle)
     local h1, m1, s1, ms1 = utils.ms2t(self._cycle)
     self._cycle = cycle
     local h2, m2, s2, ms2 = utils.ms2t(self._cycle)
     self:__UpdateT__(, , h1, h2, utils.bind(self.__UpdateH__, self))
     self:__UpdateT__(, , m1, m2, utils.bind(self.__UpdateM__, self))
     self:__UpdateT__(, , s1, s2, utils.bind(self.__UpdateS__, self))
     self:__UpdateT__(, , ms1, ms2, utils.bind(self.__UpdateMS__, self))
 end

 function _M.AddTimer(self, delay, func)
     self:__Insert__(delay + , func)
 end

 function _M.__Insert__(self, delay, func)
      == delay then
         func()
     else
         local h1, m1, s1, ms1 = utils.ms2t(delay)
         local h2, m2, s2, ms2 = utils.ms2t(delay + self._cycle)
         local tick = {    func = func,
                         time = { h = h2, m = m2, s = s2, ms = ms2 } }
          then
             tinsert(self.][h2 ==   or h2], tick)
          then
             tinsert(self.][m2 ==   or m2], tick)
          then
             tinsert(self.][s2 ==   or s2], tick)
          then
             tinsert(self.][ms2 ==   or ms2], tick)
         end
     end
 end

 function _M.__UpdateT__(self, cycle, index, first, last, func)
     local slots = self._slots[index]
     while first ~= last do
         first = first +
         , #slots[first] do
             func(slots[first][i])
         end
         slots[first] = {}
         first = first % cycle
     end
 end

 function _M.__UpdateH__(self, v)
     self:__Insert__(utils.t2ms(, v.time.m, v.time.s, v.time.ms), v.func)
 end

 function _M.__UpdateM__(self, v)
     self:__Insert__(utils.t2ms(, , v.time.s, v.time.ms), v.func)
 end

 function _M.__UpdateS__(self, v)
     self:__Insert__(utils.t2ms(, , , v.time.ms), v.func)
 end

 function _M.__UpdateMS__(self, v)
     self:__Insert__(utils.t2ms(, , , ), v.func)
 end

 return _M

源码下载