muduo网络库定时器的实现

一：函数介绍

常见的与时间相关的函数有：sleep，alarm，usleep，nanosleep，clock_nanosleep，gettimer/settitimer，timer_create/timer_settime/timer_gettime/timer_delete，还有muduo使用的timerfd_create/timerfd_gettime/timerfd_settime函数。

为什么选择timerfd_*函数呢？

>>>sleep/alarm/usleep在实现时有可能用了信号SIGALRM，在多线程程序中处理信号是个相当麻烦的事情，应该尽量避免。

>>>nanosleep和clock_nanosleep是线程安全的，但是在非阻塞网络编程中，绝对不能用让线程挂起的方式来等待一段时间。程序会失去响应，正确的做法是注册一个时间回调函数。

>>>getitimer和timer_create也是用信号来deliver超时，在多线程程序中也会有麻烦。

>>>timer_create可以指定信号的接收方是进程还是线程，算是一个进步，不过在信号处理函数（signal handler）中能做的事情实在是很受限。

>>>timerfd_create把时间变成了一个文件描述符，该“文件”在定时器超时的那一刻变得可读，这样就能很方便的融入到select/poll框架中，用统一的方式来处理I/O和超时事件，这正是Reactor模式的长处。实际上如果非要处理信号的话，使用signalfd将信号转变成文件描述符处理。

比较：libevent定时器采用本地unix域通信，当时间最小堆中超时事件发生后，写一个字节给本地socket，使得描述符可读，epoll检测到并处理该事件。

首先看timerfd_create()函数：

 int timerfd_create(int clockid, int flags);

1.参数1的clockid是指，CLOCK_REALTIME or CLOCK_MONOTONIC时间。前者是我们平时所看到的时间，后者是石英钟时间也就是晶振决定的时间。所以假如我们制订了3分钟的定时，如果我们直接修改时间到三分钟后，那么前者会触发，而后者不会触发，它是晶振决定的相对时间，不取决于外部更改。所以一般定时器采用后者

2.参数2有两个选项TFD_NONBLOCK和TFD_CLOEXEC，这个就不用解释了。

第二个函数是timerfd_settime()函数

  int timerfd_settime(int fd, int flags,
                           const struct itimerspec *new_value,
                           struct itimerspec *old_value);

1.参数1是文件描述符。

2.参数2是参加timerfd_create()函数。

3.参数3是新值，itermerspec结构体有两个字段，解释见下面。

4.参数4是旧值，结构体见下面。

           struct timespec { 
               time_t tv_sec;                /* Seconds */ 
               long   tv_nsec;               /* Nanoseconds */ 
           }; 
           struct itimerspec { 
               struct timespec it_interval;  /* Interval for periodic timer */   //定时间隔，如果只发生一次，可设置为0 
               struct timespec it_value;     /* Initial expiration */  //最初的过期值 
           }; 

new_value.it_value  specifies  the  initial  expiration  of the timer, in seconds and nanoseconds.  Setting either field of      new_value.it_value to a nonzero value arms the timer.  Setting both fields of new_value.it_value to zero disarms the timer.

二：定时器

为什么网络编程中需要定时器呢？ 

在开发Linux网络程序时，通常需要维护多个定时器，如维护客户端心跳时间、检查多个数据包的超时重传等。如果采用Linux的SIGALARM信号实现，则会带来较大的系统开销，且不便于管理。 

Muduo 的 TimerQueue 采用了最简单的实现（链表）来管理定时器，它的效率比不上常见的 binary heap 的做法，如果程序中大量（10 个以上）使用重复触发的定时器，或许值得考虑改用更高级的实现。由于目前还没有在一个程序里用过这么多定时器，暂时也不需要优化 TimerQueue。 

mudo的定时器由三个类实现，TimerId，Timer，TimerQueue，用户只能看到第一个类，其它两个类都是内部实现细节。

（1）TimerId被设计用来取消Timer的，它的结构很简单，只有一个Timer指针和其序列号。其中还声明了TimerQueue为其友元，可以操作其私有数据。

它的实现如下：

class TimerId : public muduo::copyable
{
 public:
  TimerId()
    : timer_(NULL),
      sequence_(0)
  {
  }
  TimerId(Timer* timer, int64_t seq)
    : timer_(timer),
      sequence_(seq)
  {
  }
  // default copy-ctor, dtor and assignment are okay
  friend class TimerQueue;

 private:
  Timer* timer_;
  int64_t sequence_;
};

（2）Timer类Timer是对定时器的高层次抽象，封装了定时器的一些参数，例如超时回调函数、超时时间、超时时间间隔、定时器是否重复、定时器的序列号。其函数大都是设置这些参数，run()用来调用回调函数，restart()用来重启定时器（如果设置为重复）。主要实现：

class Timer : boost::noncopyable
{
 public:
  Timer(const TimerCallback& cb, Timestamp when, double interval)
    : callback_(cb),
      expiration_(when),
      interval_(interval),
      repeat_(interval > 0.0),   //如果大于0就重复
      sequence_(s_numCreated_.incrementAndGet())  //先加后获取，由于初始值s_numCreated为0，所以序号这里从1开始
  { }

#ifdef __GXX_EXPERIMENTAL_CXX0X__
  Timer(TimerCallback&& cb, Timestamp when, double interval)
    : callback_(std::move(cb)),
      expiration_(when),
      interval_(interval),
      repeat_(interval > 0.0),
      sequence_(s_numCreated_.incrementAndGet())
  { }
#endif

  void run() const  //调用回调函数
  {
    callback_();
  }

  Timestamp expiration() const  { return expiration_; }
  bool repeat() const { return repeat_; }
  int64_t sequence() const { return sequence_; }

  void restart(Timestamp now);

  static int64_t numCreated() { return s_numCreated_.get(); }

 private:
  const TimerCallback callback_;  //定时器回调函数，TimerCallback在callback.h文件中定义，类型void()
  Timestamp expiration_;   //下一次的超时时刻
  const double interval_;     //超时时间间隔，如果是一次定时器，该值为0
  const bool repeat_;          //是否重复
  const int64_t sequence_;     //定时器序号

  static AtomicInt64 s_numCreated_;   //定时器计数，当前已创建的定时器数量，原子int64_t类型，初始值为0
};

#include <muduo/net/Timer.h>

using namespace muduo;
using namespace muduo::net;

AtomicInt64 Timer::s_numCreated_;

void Timer::restart(Timestamp now)   //重启
{
  if (repeat_)   //如果是重复的，那么就从当前时间计算下一次的超时时刻
  {
    expiration_ = addTime(now, interval_);  //当前时间加上时间间隔?
  }
  else
  {
    expiration_ = Timestamp::invalid();   //获取一个无效事件戳，即值为0
  }
}

实际上最重要的是接下来要介绍的这个类。

（3）TimerQueue数据结构的选择 

TimerQueue的接口很简单，只有两个函数addTimer()和cancel()。它的内部有channel，和timerfd相关联。添加新的Timer后，在超时后，timerfd可读，会处理channel事件，之后调用Timer的回调函数；在timerfd的事件处理后，还有检查一遍超时定时器，如果其属性为重复还有再次添加到定时器集合中。

时序图：

TimerQueue需要高效地组织目前尚未到期的Timer，能快速地根据当前时间找到已经到期的Timer，也要能高效地添加和删除Timer。因而可以用二叉搜索树(例如std::set/std::map)，把Timer按到期时间先后排好序，其操作的复杂度是O(logN)，但我们使用时还要处理两个Timer到期时间相同的情况(map不支持key相同的情况)，做法如下： 
//两种类型的set，一种按时间戳排序，一种按Timer的地址排序 
//实际上，这两个set保存的是相同的定时器列表 

typedef std::pair<Timestamp, Timer*> Entry;
typedef std::set<Entry> TimerList;

typedef std::pair<Timer*, int64_t> ActiveTimer;
typedef std::set<ActiveTimer> ActiveTimerSet;
看它的头文件：

class TimerQueue : boost::noncopyable
{
 public:
  TimerQueue(EventLoop* loop);
  ~TimerQueue();

  ///
  /// Schedules the callback to be run at given time,
  /// repeats if @c interval > 0.0.
  ///
  /// Must be thread safe. Usually be called from other threads.
  //一定是线程安全的，可以跨线程调用。通常情况下被其他线程调用
  TimerId addTimer(const TimerCallback& cb,
                   Timestamp when,
                   double interval);
#ifdef __GXX_EXPERIMENTAL_CXX0X__
  TimerId addTimer(TimerCallback&& cb,
                   Timestamp when,
                   double interval);
#endif

  void cancel(TimerId timerId);  //可以跨线程调用

 private:

  // FIXME: use unique_ptr<Timer> instead of raw pointers.
  //下面两个set可以说保存的是相同的东西，都是定时器，只不过排序方式不同
  typedef std::pair<Timestamp, Timer*> Entry;  //set的key，是一个时间戳和定时器地址的pair
  typedef std::set<Entry> TimerList;    //按照时间戳排序
  typedef std::pair<Timer*, int64_t> ActiveTimer;  //定时器地址和序号
  typedef std::set<ActiveTimer> ActiveTimerSet;  //按照定时器地址排序

  //以下成员函数只可能在其所属的I/O线程中调用，因而不必加锁
  //服务器性能杀手之一就是锁竞争，要尽可能少使用锁
  void addTimerInLoop(Timer* timer);
  void cancelInLoop(TimerId timerId);
  // called when timerfd alarms
  void handleRead();  //定时器事件产生回调函数
  // move out all expired timers
  std::vector<Entry> getExpired(Timestamp now);  //返回超时的定时器列表
  void reset(const std::vector<Entry>& expired, Timestamp now);   //对超时的定时器进行重置，因为超时的定时器可能是重复的定时器

  bool insert(Timer* timer);  //插入定时器

  EventLoop* loop_;    //所属的event_loop
  const int timerfd_;    //就是timefd_create()所创建的定时器描述符?
  Channel timerfdChannel_;   //这是定时器事件的通道
  // Timer list sorted by expiration
  TimerList timers_;   //定时器set，按时间戳排序

  // for cancel()
  ActiveTimerSet activeTimers_;  //活跃定时器列表，按定时器地址排序
  bool callingExpiredTimers_; /* atomic */  //是否处于调用处理超时定时器当中
  ActiveTimerSet cancelingTimers_;    //保存的是被取消的定时器
};

 

#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#endif

#include <muduo/net/TimerQueue.h>

#include <muduo/base/Logging.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/Timer.h>
#include <muduo/net/TimerId.h>

#include <boost/bind.hpp>

#include <sys/timerfd.h>

namespace muduo
{
namespace net
{
namespace detail
{

int createTimerfd()
{
  int timerfd = ::timerfd_create(CLOCK_MONOTONIC,
                                 TFD_NONBLOCK | TFD_CLOEXEC);
  if (timerfd < 0)
  {
    LOG_SYSFATAL << "Failed in timerfd_create";
  }
  return timerfd;
}

//计算超时时刻与当前时间的时间差
struct timespec howMuchTimeFromNow(Timestamp when)
{
  int64_t microseconds = when.microSecondsSinceEpoch()
                         - Timestamp::now().microSecondsSinceEpoch();  //超时时刻微秒数-当前时间微秒数
  if (microseconds < 100)  //不能小于100，精确度不需要
  {
    microseconds = 100;
  }
  struct timespec ts;  //转换成这个结构体返回
  ts.tv_sec = static_cast<time_t>(
      microseconds / Timestamp::kMicroSecondsPerSecond);
  ts.tv_nsec = static_cast<long>(
      (microseconds % Timestamp::kMicroSecondsPerSecond) * 1000);
  return ts;
}

//从timerfd读取，避免定时器事件一直触发
void readTimerfd(int timerfd, Timestamp now)
{
  uint64_t howmany;
  ssize_t n = ::read(timerfd, &howmany, sizeof howmany);  //从timerfd读取4个字节，这样timerfd就不会一直触发了  
  LOG_TRACE << "TimerQueue::handleRead() " << howmany << " at " << now.toString();
  if (n != sizeof howmany)
  {
    LOG_ERROR << "TimerQueue::handleRead() reads " << n << " bytes instead of 8";
  }
}

//重置定时器超时时刻
void resetTimerfd(int timerfd, Timestamp expiration)  
{
  // wake up loop by timerfd_settime()
  struct itimerspec newValue;   
  struct itimerspec oldValue;
  bzero(&newValue, sizeof newValue);
  bzero(&oldValue, sizeof oldValue);
  newValue.it_value = howMuchTimeFromNow(expiration);   //将时间戳类转换成it_value的形式
  int ret = ::timerfd_settime(timerfd, 0, &newValue, &oldValue);  //设置进去，到期之后会产生一个定时器事件
  if (ret)
  {
    LOG_SYSERR << "timerfd_settime()";
  }
}

}
}
}

using namespace muduo;
using namespace muduo::net;
using namespace muduo::net::detail;

TimerQueue::TimerQueue(EventLoop* loop)
  : loop_(loop),
    timerfd_(createTimerfd()),    //创建定时器，调用timerfd_create，返回timerfd
    timerfdChannel_(loop, timerfd_),
    timers_(),
    callingExpiredTimers_(false)
{
/*Channel timerfdChannel_;   //这是定时器事件的通道*/
	//设置定时器类型通道的读回调函数。
  timerfdChannel_.setReadCallback(
      boost::bind(&TimerQueue::handleRead, this));   
  // we are always reading the timerfd, we disarm it with timerfd_settime.
  timerfdChannel_.enableReading();  //注册，底层是一系列update，你懂的。
}

TimerQueue::~TimerQueue()
{
  timerfdChannel_.disableAll();
  timerfdChannel_.remove();
  ::close(timerfd_);
  // do not remove channel, since we're in EventLoop::dtor();
  for (TimerList::iterator it = timers_.begin();
      it != timers_.end(); ++it)
  {
    delete it->second;  //析构函数只释放一次，因为两个set保存的是一样的
  }
}

//增加一个定时器
TimerId TimerQueue::addTimer(const TimerCallback& cb,
                             Timestamp when,
                             double interval)
{
  Timer* timer = new Timer(cb, when, interval);   //构造一个定时器对象，interval>0就是重复定时器
  loop_->runInLoop(
      boost::bind(&TimerQueue::addTimerInLoop, this, timer));
  return TimerId(timer, timer->sequence());
}

#ifdef __GXX_EXPERIMENTAL_CXX0X__
TimerId TimerQueue::addTimer(TimerCallback&& cb,
                             Timestamp when,
                             double interval)
{
  Timer* timer = new Timer(std::move(cb), when, interval);
  loop_->runInLoop(
      boost::bind(&TimerQueue::addTimerInLoop, this, timer));
  return TimerId(timer, timer->sequence());
}
#endif

//执行线程退出的回调函数
void TimerQueue::cancel(TimerId timerId)
{
  loop_->runInLoop(
      boost::bind(&TimerQueue::cancelInLoop, this, timerId)); 
}

void TimerQueue::addTimerInLoop(Timer* timer)
{
  loop_->assertInLoopThread();
  //插入一个定时器游客能会使得最早到期的定时器发生改变，比如当前插入一个最早到期的，那就要重置定时器超时时刻
  bool earliestChanged = insert(timer);

  if (earliestChanged)  //如果改变了
  {
    resetTimerfd(timerfd_, timer->expiration());  //重置定时器超时时刻
  }
}

void TimerQueue::cancelInLoop(TimerId timerId)
{
  loop_->assertInLoopThread();
  assert(timers_.size() == activeTimers_.size());
  ActiveTimer timer(timerId.timer_, timerId.sequence_);
  //查找该定时器
  ActiveTimerSet::iterator it = activeTimers_.find(timer);
  if (it != activeTimers_.end())
  {
  	//删除该定时器
    size_t n = timers_.erase(Entry(it->first->expiration(), it->first));
    assert(n == 1); (void)n;
    //如果用unique_ptr这里就不需要手工删除了
    delete it->first; // FIXME: no delete please
    activeTimers_.erase(it);
  }
  else if (callingExpiredTimers_)   //如果在定时器列表中没有找到，可能已经到期，且正在处理的定时器
  {
    //已经到期，并且正在调用回调函数的定时器
    cancelingTimers_.insert(timer);
  }
  assert(timers_.size() == activeTimers_.size());
}

//可读事件处理
void TimerQueue::handleRead()
{
  loop_->assertInLoopThread();  //断言I/O线程中调用
  Timestamp now(Timestamp::now());
  readTimerfd(timerfd_, now);   //清除该事件，避免一直触发，实际上是对timerfd做了read

  //获取该时刻之前所有的定时器列表，即超时定时器列表，因为实际上可能有多个定时器超时，存在定时器的时间设定是一样的这种情况
  std::vector<Entry> expired = getExpired(now);

  callingExpiredTimers_ = true;  //处于处理定时器状态中
  cancelingTimers_.clear();  
  // safe to callback outside critical section
  for (std::vector<Entry>::iterator it = expired.begin();
      it != expired.end(); ++it)
  {
    it->second->run();   //调用所有的run()函数，底层调用Timer类的设置了的超时回调函数
  }
  callingExpiredTimers_ = false;

  reset(expired, now);   //如果移除的不是一次性定时器，那么重新启动它们
}

//返回当前所有超时的定时器列表
//返回值由于rvo优化，不会拷贝构造vector，直接返回它
std::vector<TimerQueue::Entry> TimerQueue::getExpired(Timestamp now)
{
  assert(timers_.size() == activeTimers_.size());
  std::vector<Entry> expired;
  Entry sentry(now, reinterpret_cast<Timer*>(UINTPTR_MAX));//创建一个时间戳和定时器地址的集合
  //返回第一个未到期的Timer的迭代器
  //lower_bound返回第一个值>=sentry的
  //即*end>=sentry，从而end->first > now，而不是>=now，因为pair比较的第一个相等后会比较第二个，而sentry的第二个是UINTPTR_MAX最大
  //所以用lower_bound没有用upper_bound
  TimerList::iterator end = timers_.lower_bound(sentry);
  assert(end == timers_.end() || now < end->first);  //now < end->first
  std::copy(timers_.begin(), end, back_inserter(expired));  //将到期的定时器插入到expired中
  timers_.erase(timers_.begin(), end);  //删除已到期的所有定时器

  //从activeTimers_中也要移除到期的定时器
  for (std::vector<Entry>::iterator it = expired.begin();
      it != expired.end(); ++it)
  {
    ActiveTimer timer(it->second, it->second->sequence());
    size_t n = activeTimers_.erase(timer);
    assert(n == 1); (void)n;
  }

  assert(timers_.size() == activeTimers_.size());
  return expired;
}

void TimerQueue::reset(const std::vector<Entry>& expired, Timestamp now)
{
  Timestamp nextExpire;

  for (std::vector<Entry>::const_iterator it = expired.begin();
      it != expired.end(); ++it)
  {
    ActiveTimer timer(it->second, it->second->sequence());
    //如果是重复的定时器，并且是未取消定时器，则重启该定时器
    if (it->second->repeat()
        && cancelingTimers_.find(timer) == cancelingTimers_.end())
    {
      it->second->restart(now);  //restart()函数中会重新计算下一个超时时刻
      insert(it->second);
    }
    else
    {
    	//一次性定时器或者已被取消的定时器是不能重置的，因此删除该定时器
      // FIXME move to a free list
      delete it->second; // FIXME: no delete please  
    }
  }

  if (!timers_.empty()) 
  {
    //获取最早到期的超时时间
    nextExpire = timers_.begin()->second->expiration();
  }

  if (nextExpire.valid())
  {
  	//重新设定timerfd的超时时间
    resetTimerfd(timerfd_, nextExpire);
  }
}

bool TimerQueue::insert(Timer* timer)
{
  loop_->assertInLoopThread();
  assert(timers_.size() == activeTimers_.size());  //这两个存的是同样的定时器列表，成员函数中分析过了
  bool earliestChanged = false;
  //检测最早到期时间是否改变
  Timestamp when = timer->expiration();
  TimerList::iterator it = timers_.begin();   //第一个定时器，timers是set实现的，所以第一个就是最早，空的也算
  if (it == timers_.end() || when < it->first)
  {
    earliestChanged = true;  //如果插入定时器时间小于最早到期时间
  }
  //下面两个插入的set保存的是一样的，都是定时器，只不过对组的另一个辅助成员不一样
  {
    //利用RAII机制
    //插入到timers_中，result是临时对象，需要用它来保证插入成功
    std::pair<TimerList::iterator, bool> result
      = timers_.insert(Entry(when, timer));
    assert(result.second); (void)result;
  }
  {
    //插入到activeTimers中
    std::pair<ActiveTimerSet::iterator, bool> result
      = activeTimers_.insert(ActiveTimer(timer, timer->sequence()));
    assert(result.second); (void)result;
  }

  assert(timers_.size() == activeTimers_.size());
  return earliestChanged;  //返回是否最早到期时间改变
}

三：定时器的使用

主要是在EventLoop中使用，EventLoop中为我们提供了四个函数，供用户使用，我们来看一下:

/在时间戳为time的时间执行，0.0表示一次性不重复
TimerId EventLoop::runAt(const Timestamp& time, const TimerCallback& cb)
{
  return timerQueue_->addTimer(cb, time, 0.0);  
}

//延迟delay时间执行的定时器
TimerId EventLoop::runAfter(double delay, const TimerCallback& cb)
{
  Timestamp time(addTime(Timestamp::now(), delay));  //合成一个时间戳
  return runAt(time, cb);
}

//间隔性的定时器，起始就是重复定时器，间隔interval需要大于0
TimerId EventLoop::runEvery(double interval, const TimerCallback& cb)
{
  Timestamp time(addTime(Timestamp::now(), interval));
  return timerQueue_->addTimer(cb, time, interval);
}
//直接调用timerQueue的cancle
void EventLoop::cancel(TimerId timerId)
{
  return timerQueue_->cancel(timerId);  
}
而timerQueue是EventLoop类的成员：

 boost::scoped_ptr<TimerQueue> timerQueue_;
所以用户操作这几个函数就可以利用定时器实现相应的功能。