muduo源码分析之定时器TimerQueue
(muduo源码系列大多是我在看muduo源码的时候结合网上博客总结的，我尽可能多的是对源码注释)
简介
Muduo的定时器功能主要由三个class实现，TimerId，Timer，TimerQueue，TimerQueue的接口只有两个addTimer()和cancel()，addTimer()是提供给EventLoop使用的， EventLoop会把它封装成更好用的三个函数：runAt()、runAfter()、runEvery()。
大体实现
muduo 定时器封装了 Timer.h 里面保存的是超时时间和回调函数, TimerQueue.h 使用set容器保存多个定时器, 然后在TimerQueue中使用timerfd_create创建一个timerfd句柄, 插入定时器A后先比较A的触发时间和TimerQueue的触发时间, 如果A的触发时间比其小就使用timerfd_settime重置TimerQueue的timerfd的触发时间, TimerQueue中的timerfd的触发时间永远与保存的定时器中触发时间最小的那个相同, 然后timerfd触发可读后, 遍历保存的多个定时器, 看看有没有同时到期的, 有执行回调函数
TimerQueue的封装是为了让未到期的时间Timer有序的排列起来，这样，能够更具当前时间找到已经到期的Timer也能高效的添加和删除Timer。
所谓的到期与未到期，与当前在当前时间之前表示已经到期，之后则是未到期。为了方便计算，muduo重载了operator<主要是用来比较微秒大小。
到期的时间应该被清除去执行相应的回调，未到期的时间则应该有序的排列起来。
对于TimerQueue的数据结构，作者提出了几个方案。
1.传统线性表，查找复杂度为O(n)
2.二叉堆实现优先级队列，不过C++标准的make_heap()不能高效地完成删除操作。
最终，为了防止时间相同所导致的Key相同的情况，使用set和pair
typedef std::pair<Timestamp, Timer*>Entry; typedef std::set<Entry>TimerList; TimerList timers_;
Linux时间函数介绍
linux中用以获取当前时间的的函数有：
time(2) / time_t（秒)
ftime(3) / struct timeb(毫秒)
gettimeofday(2) / struct timeval(微秒)
clock_gettime(2) / struct timespec(微秒)
还有gmtime / localtime / timegm / mktime / strftime / struct tm等与当前时间无关的时间格式转换函数。
定时函数
sleep(3)
alarm(3)
usleep(3)
nanosleep(2)
clock_nanosleep(2)
gettimer(2) / settitimer(2)
timer_create(2) / timer_settime(2) / tiemr_gettime(2) / timer_delete(2)
timerfd_create(2) / timerfd_gettime(2) / timerfd_settime(2)
取舍如下：
1、计时只使用gettimeofday(2)来获取当前时间。
2、定时只使用timerfd_*系列函数来处理定时任务。
timerfd介绍
这节介绍muduo中定时器的实现。先看一个2.6内核新增的有关定时的系统调用，基于这几个系统调用可以实现基于文件描述符的定时器。即可是定时，使文件描述符在某一特定时间可读。
#include <sys/timerfd.h>
int timerfd_create(int clockid, int flags);
int timerfd_settime(int fd, int flags,
const struct itimerspec * new_value,
struct itimerspec * old_value);
int timerfd_gettime(int fd, struct itimerspec *curr_value);
1、timerfd_create用于创建一个定时器文件，函数返回值是一个文件句柄fd。
2、timerfd_settime用于设置新的超时时间，并开始计时。flag为0表示相对时间，为1表示绝对时间。new_value为这次设置的新时间，old_value为上次设置的时间。返回0表示设置成功。
3、timerfd_gettime用于获得定时器距离下次超时还剩下的时间。如果调用时定时器已经到期，并且该定时器处于循环模式（设置超时时间时struct itimerspec::it_interval不为0），那么调用此函数之后定时器重新开始计时。
TimerId介绍
TimerId非常简单，它被设计用来取消Timer的，它的结构很简单，只有一个Timer指针和其序列号。
// Copyright 2010, Shuo Chen. All rights reserved. // http://code.google.com/p/muduo/ // // Use of this source code is governed by a BSD-style license // that can be found in the License file. // Author: Shuo Chen (chenshuo at chenshuo dot com) // // This is a public header file, it must only include public header files. /*封装了timer类到构造和析构函数中，我的理解就是RAII的思想 * TimerId非常简单，它被设计用来取消Timer的，它的结构很简单，只有一个Timer指针和其序列号。*/ #ifndef MUDUO_NET_TIMERID_H #define MUDUO_NET_TIMERID_H #include <muduo/base/copyable.h> namespace muduo { namespace net { class Timer; /// /// An opaque identifier, for canceling Timer. /// 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_; }; } } #endif // MUDUO_NET_TIMERID_H
Timer
Timer封装了定时器的一些参数，例如超时回调函数、超时时间、定时器是否重复、重复间隔时间、定时器的序列号。其函数大都是设置这些参数，run()用来调用回调函数，restart()用来重启定时器（如果设置为重复）。其源码相对简单
// Copyright 2010, Shuo Chen. All rights reserved. // http://code.google.com/p/muduo/ // // Use of this source code is governed by a BSD-style license // that can be found in the License file. // Author: Shuo Chen (chenshuo at chenshuo dot com) // // This is an internal header file, you should not include this. /*计时器类*/ #ifndef MUDUO_NET_TIMER_H #define MUDUO_NET_TIMER_H #include <boost/noncopyable.hpp> #include <muduo/base/Atomic.h> #include <muduo/base/Timestamp.h> #include <muduo/net/Callbacks.h> namespace muduo { namespace net { /// /// Internal class for timer event. /// 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()) {}//当前定时器的序列号 //调用回调函数. 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_; // 定时器回调函数 Timestamp expiration_; // 下一次的超时时间戳类 const double interval_; // 超时时间间隔，如果是一次性定时器，该值为0 const bool repeat_; // 是否重复 const int64_t sequence_; // 定时器序号，不会重复 static AtomicInt64 s_numCreated_; // 定时器计数，当前已经创建的定时器数量 }; } } #endif // MUDUO_NET_TIMER_H
Timestamp
时间戳一般用来唯一地标识某一刻的时间，通常是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总毫秒数。
Timestamp类的参数有一个常量kMicroSecondsPerSecond表示每秒所对应的微秒数，成员变量microSecondsSinceEpoch_表示到1970-01-01 00:00:00 UTC的微秒数。成员函数包括swap()交换操作，toString()、toFormattedString()将时间转换为string类型或指定格式，valid()判断Timestamp是否有效，invalid()返回一个无效的Timestamp，now()返回当前时间的Timestamp，secondsSinceEpoch()/microSecondsSinceEpoch()返回到1970-01-01 00:00:00 UTC的秒数/微秒数。
Timestamp.h源码（带注释）
#ifndef MUDUO_BASE_TIMESTAMP_H #define MUDUO_BASE_TIMESTAMP_H /*时间戳函数，我的理解是创建一个microSecondsSinceEpoch_为0的结构体， *然后每次通过这个结构体创建子的microSecondsSinceEpoch_为当前时间的结构体，并且子结构体都在microSecondsSinceEpoch_为0的结构体 *中进行运算操作*/ #include <muduo/base/copyable.h> #include <muduo/base/Types.h> #include <boost/operators.hpp> namespace muduo { ///Timestamp /// Time stamp in UTC, in microseconds resolution. /// /// This class is immutable. /// It's recommended to pass it by value, since it's passed in register on x64. /// class Timestamp : public muduo::copyable, public boost::less_than_comparable<Timestamp>//继承这个类，对于<,>,<=,>=这些运算符号，只需要定义 //<号，其他的都可以自动帮你定义了 { public: /// /// Constucts an invalid Timestamp. /// Timestamp() : microSecondsSinceEpoch_(0) { } /// /// Constucts a Timestamp at specific time /// /// @param microSecondsSinceEpoch explicit Timestamp(int64_t microSecondsSinceEpoch); void swap(Timestamp &that)//将两个Timestamp类中的microSecondsSinceEpoch_变量交换 { std::swap(microSecondsSinceEpoch_, that.microSecondsSinceEpoch_); } // default copy/assignment/dtor are Okay string toString() const; string toFormattedString() const; bool valid() const { return microSecondsSinceEpoch_ > 0; }//判断microSecondsSinceEpoch_是否有效，大于0就有效 // for internal usage. int64_t microSecondsSinceEpoch() const { return microSecondsSinceEpoch_; }//返回microSecondsSinceEpoch_ time_t secondsSinceEpoch() const//返回以秒为单位的microSecondsSinceEpoch_ { return static_cast<time_t>(microSecondsSinceEpoch_ / kMicroSecondsPerSecond); } /// /// Get time of now. /// static Timestamp now();//创建一个当前的时间的Timestamp结构体 static Timestamp invalid();//创建一个microSecondsSinceEpoch_=0的Timestamp结构体,都是静态函数，可以直接调用 static const int kMicroSecondsPerSecond = 1000 * 1000; private: int64_t microSecondsSinceEpoch_;//表示到1970-01-01 00:00:00 UTC的微秒数。 }; /*放在类外重载，但是普通数据类型可以使用原来的，遇到特定类型才会使用这个*/ inline bool operator<(Timestamp lhs, Timestamp rhs)//只需要定义<号，其他都自动定义，less_than_comparable模板作用 { return lhs.microSecondsSinceEpoch() < rhs.microSecondsSinceEpoch(); } inline bool operator==(Timestamp lhs, Timestamp rhs) { return lhs.microSecondsSinceEpoch() == rhs.microSecondsSinceEpoch(); } /// /// Gets time difference of two timestamps, result in seconds. /// /// @param high, low /// @return (high-low) in seconds /// @c double has 52-bit precision, enough for one-microseciond /// resolution for next 100 years. //计算两个Timestamp之间的差，以秒为单位 inline double timeDifference(Timestamp high, Timestamp low) { int64_t diff = high.microSecondsSinceEpoch() - low.microSecondsSinceEpoch(); return static_cast<double>(diff) / Timestamp::kMicroSecondsPerSecond; } /// /// Add @c seconds to given timestamp. /// /// @return timestamp+seconds as Timestamp /// //加时间 inline Timestamp addTime(Timestamp timestamp, double seconds) { int64_t delta = static_cast<int64_t>(seconds * Timestamp::kMicroSecondsPerSecond); return Timestamp(timestamp.microSecondsSinceEpoch() + delta); } } #endif // MUDUO_BASE_TIMESTAMP_H
Timestamp.cc源码（带注释）
#include <muduo/base/Timestamp.h> #include <sys/time.h> #include <stdio.h> #define __STDC_FORMAT_MACROS #include <inttypes.h> #undef __STDC_FORMAT_MACROS #include <boost/static_assert.hpp> using namespace muduo; BOOST_STATIC_ASSERT(sizeof(Timestamp) == sizeof(int64_t)); Timestamp::Timestamp(int64_t microseconds) : microSecondsSinceEpoch_(microseconds) { } string Timestamp::toString() const//转化成xxx.xxx秒的格式 { char buf[32] = {0}; int64_t seconds = microSecondsSinceEpoch_ / kMicroSecondsPerSecond; int64_t microseconds = microSecondsSinceEpoch_ % kMicroSecondsPerSecond; snprintf(buf, sizeof(buf) - 1, "%" PRId64 ".%06" PRId64 "", seconds, microseconds); return buf; } //将时间加上1900年1月1日之后转成"年月日 小时:分钟:秒"的格式 string Timestamp::toFormattedString() const { char buf[32] = {0}; time_t seconds = static_cast<time_t>(microSecondsSinceEpoch_ / kMicroSecondsPerSecond); // 秒数 int microseconds = static_cast<int>(microSecondsSinceEpoch_ % kMicroSecondsPerSecond); struct tm tm_time;// 微秒数 // 把time_t结构中的信息转换成真实世界所使用的时间日期，存储在tm_time结构中 gmtime_r(&seconds, &tm_time);//将总秒数转换成————多少年多少月多少日多少小时多少分多少秒为单位 // 格式化输出时间戳 snprintf(buf, sizeof(buf), "%4d%02d%02d %02d:%02d:%02d.%06d", tm_time.tm_year + 1900, tm_time.tm_mon + 1, tm_time.tm_mday, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, microseconds);//总秒数加上1900年1月1日然后转换成固定格式 return buf; } Timestamp Timestamp::now() { struct timeval tv; gettimeofday(&tv, NULL);//得到的是系统从当前时间从1900年1月1日开始算起的总秒数 int64_t seconds = tv.tv_sec; return Timestamp(seconds * kMicroSecondsPerSecond + tv.tv_usec); //返回一个Timestamp结构体，相当于创建一个当前时间的Timestamp结构体 } Timestamp Timestamp::invalid() { return Timestamp(); }
TimerQueue
虽然TimerQueue中有Queue，但是其实现时基于Set的，而不是Queue。这样可以高效地插入、删除定时器，且找到当前已经超时的定时器。TimerQueue的public接口只有两个，添加和删除。
void addTimerInLoop(Timer* timer); void cancelInLoop(TimerId timerId);
定时器管理类，其中timer类就是TimerQueue需要管理的元素，而timerId就是一个简单的timer封装，避免销毁和创建操作
但是要注意的是timer并没有自己计时的功能，所以需要依靠timerfd这个系统函数统一计时timerfd是一个系统计时函数，当所设置的时间到了，会通过timerfd这个文件描述符进行提示通信，而其他计时函数可能是通过信号量，或者其他方式，但是都没有文件描述符好，并且也可以用timerfd监听，具体原因可以查看一下博客的网络库定时器实现
如何使用timerfd来为所有的计时器计时：timerfd每次都设置在计时器列表中到期时间最近的那个到期时间，这样timerfd到期以后，也就是最近的那个计时器到期，所以每次都是手动重置timerfd的计时时间，为最近的计时器到期时间
内部有channel，和timerfd关联。添加新的Timer后，在超时后，timerfd可读，会处理channel事件，之后调用Timer的回调函数；在timerfd的事件处理后，还有检查一遍超时定时器，如果其属性为重复还有再次添加到定时器集合中。
内部有两种类型的Set
typedef std::pair<Timestamp, Timer*> Entry; typedef std::set<Entry> TimerList; typedef std::pair<Timer*, int64_t> ActiveTimer; typedef std::set<ActiveTimer> ActiveTimerSet;
下面给出TimerQueue.h和TimerQueue.cc源码分析有详细的注释
TimerQueue.h
// Copyright 2010, Shuo Chen. All rights reserved. // http://code.google.com/p/muduo/ // // Use of this source code is governed by a BSD-style license // that can be found in the License file. // Author: Shuo Chen (chenshuo at chenshuo dot com) // // This is an internal header file, you should not include this. /* 定时器管理类，其中timer类就是TimerQueue需要管理的元素，而timerId就是一个简单的timer封装，避免销毁和创建操作 * 但是要注意的是timer并没有自己计时的功能，所以需要依靠timerfd这个系统函数统一计时 * timerfd是一个系统计时函数，当所设置的时间到了，会通过timerfd这个文件描述符进行提示通信，而其他计时函数可能是通过信号量，或者 * 其他方式，但是都没有文件描述符好，并且也可以用timerfd监听，具体原因可以查看一下博客的网络库定时器实现 * 如何使用timerfd来为所有的计时器计时：timerfd每次都设置在计时器列表中到期时间最近的那个到期时间，这样timerfd到期以后，也就是最近的那个计时器到期 * 所以每次都是手动重置timerfd的计时时间，为最近的计时器到期时间 * ？timestamp::now获得的时间是从1960年1月1日开始的，但是timerfd据说是从系统开机的那一刻开始的，那么在设置timefd时时间不统一怎么办 * 注意在timerfd设置延时的时候，使用的是相对时间，所以无所谓最终时间是多少，只要相对时间没问题就好了 * ？重置timerfd导致延时怎么办 * ？关于线程执行，究竟哪些函数靠IO线程来执行 * * */ #ifndef MUDUO_NET_TIMERQUEUE_H #define MUDUO_NET_TIMERQUEUE_H #include <set> #include <vector> #include <boost/noncopyable.hpp> #include <muduo/base/Mutex.h> #include <muduo/base/Timestamp.h> #include <muduo/net/Callbacks.h> #include <muduo/net/Channel.h> namespace muduo { namespace net { class EventLoop; class Timer; class TimerId; /// /// A best efforts timer queue. /// No guarantee that the callback will be on time. /// 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); void cancel(TimerId timerId); private: // FIXME: use unique_ptr<Timer> instead of raw pointers. // unique_ptr是C++ 11标准的一个独享所有权的智能指针 // 无法得到指向同一对象的两个unique_ptr指针 // 但可以进行移动构造与移动赋值操作，即所有权可以移动到另一个对象（而非拷贝构造） typedef std::pair<Timestamp, Timer *> Entry; typedef std::set <Entry> TimerList; typedef std::pair<Timer *, int64_t> ActiveTimer; typedef std::set <ActiveTimer> ActiveTimerSet; //set中存储的是pair类型，那么默认先按照pair的第一个元素排序，如果相同，再按照第二个元素排序。 //所以这两种set都是存放定时器的列表，但是一个根据定时器的到时时间来存储， //一个根据定时器地址来存储，但是存储的定时器都是同一个，目的是为了区分同一到期时间的定时器？？？ // 以下成员函数只可能在其所属的I/O线程中调用，因而不必加锁。 // 服务器性能杀手之一是锁竞争，所以要尽可能少用锁 void addTimerInLoop(Timer *timer); void cancelInLoop(TimerId timerId); // called when timerfd alarms void handleRead();//timerfdChannel_的读函数 // 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_; // 所属EventLoop const int timerfd_; //过一段事件，就筛选一次，看看TimerList中有多少定时器到时间了，就处理一下，但是这样延迟很高，不太理解 Channel timerfdChannel_;//与timefd绑定 // Timer list sorted by expiration TimerList timers_; // timers_是按到期时间排序，也是存放未到时间的定时器 // for cancel() // timers_与activeTimers_保存的是相同的数据 // timers_是按到期时间排序，activeTimers_是按对象地址排序 ActiveTimerSet activeTimers_;//还未到时间的定时器,这里面存放的定时器是和timers_一样的，只是顺序不同 bool callingExpiredTimers_; /* atomic *///是否在处理过期定时器的标志 ActiveTimerSet cancelingTimers_; // 保存的是被取消的定时器 // 用这个列表的作用是，当出现一个循环的计时器被取消时，就要通过reset函数中对 //ActiveTimerSet列表来暂停对这个计时器的重置 }; } } #endif // MUDUO_NET_TIMERQUEUE_H
TimerQueue.cc
// Copyright 2010, Shuo Chen. All rights reserved. // http://code.google.com/p/muduo/ // // Use of this source code is governed by a BSD-style license // that can be found in the License file. // Author: Shuo Chen (chenshuo at chenshuo dot com) #define __STDC_LIMIT_MACROS #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);//CLOCK_MONOTONIC参数表明计时器的时间是从系统打开开始计时的 //CLOCK_MONOTONIC表示的是时间类型 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) { 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); LOG_TRACE << "TimerQueue::handleRead() " << howmany << " at " << now.toString(); if (n != sizeof howmany) { LOG_ERROR << "TimerQueue::handleRead() reads " << n << " bytes instead of 8"; } } // 重置定时器的超时时间（不是周期性的定时器，时间到expiration就结束了） // 在这里面itimerspec.it_interval都是设置的0，每次都是计时结束以后手动重新设置，然后再计时的。 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); 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()), timerfdChannel_(loop, timerfd_),//timerfd相关的channel timers_(), callingExpiredTimers_(false) { timerfdChannel_.setReadCallback( boost::bind(&TimerQueue::handleRead, this)); // we are always reading the timerfd, we disarm it with timerfd_settime. timerfdChannel_.enableReading();//设置关注读事件，并且加入epoll队列 } TimerQueue::~TimerQueue() { ::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; } } TimerId TimerQueue::addTimer(const TimerCallback &cb, Timestamp when, double interval)//创建并增加Timer进队列中 { Timer *timer = new Timer(cb, when, interval); loop_->runInLoop( boost::bind(&TimerQueue::addTimerInLoop, this, timer)); //addTimerInLoop(timer); return TimerId(timer, timer->sequence()); } void TimerQueue::cancel(TimerId timerId)//取消 { loop_->runInLoop( boost::bind(&TimerQueue::cancelInLoop, this, timerId)); //cancelInLoop(timerId); } void TimerQueue::addTimerInLoop(Timer *timer) { loop_->assertInLoopThread(); // 插入一个定时器，有可能会使得最早到期的定时器发生改变 bool earliestChanged = insert(timer); if (earliestChanged) { // 重置timefd定时器的超时时刻(timerfd_settime) resetTimerfd(timerfd_, timer->expiration()); } } void TimerQueue::cancelInLoop(TimerId timerId)//取消的回调函数 //取消计时器，就是把该计时器从两个队列中删除， //现在有一种特殊情况，就是如果刚好在处理定时器的过程中，并且这个要取消的定时器就是在被处理的，并且是循环定时器，那么如果不加入cancelingTimers_列表 //就会出现，在重置时又把这个定时器重启了，但是这个定时器应该是要被取消的 { 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; delete it->first; // FIXME: no delete please,如果用了unique_ptr,这里就不需要手动删除了 activeTimers_.erase(it); }//用activeTimers_列表来搜索，然后找到先删除timers_，再删除activeTimers_ else if (callingExpiredTimers_) //如果在未到时间的定时器中没有找到，并且线程正在处理过期的定时器，那么可能这个定时器正在被处理，就将这些定时器放到cancelingTimers_数组中 { // 已经到期，并且正在调用回调函数的定时器，为了在重置时，避免被重置，而是被忽略 cancelingTimers_.insert(timer); } assert(timers_.size() == activeTimers_.size()); } void TimerQueue::handleRead()//TimerChannel的回调函数，也就是当timefd定时器到时的时候，就会调用这个函数 { loop_->assertInLoopThread(); Timestamp now(Timestamp::now()); readTimerfd(timerfd_, now); // 清除该事件，避免一直触发 // 获取该时刻之前所有的定时器列表(即超时定时器列表) 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) { // 这里回调定时器timer处理函数 it->second->run(); } callingExpiredTimers_ = false; // 不是一次性定时器，需要重启 reset(expired, now);//如果之前处理定时器回调函数时间较长，那么在这段时间中，已经有定时器到期了，轻则产生延迟，重则 } // rvo 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));//我理解是找了一个指针可以取到的最大数，为了避免和其他指针冲突， //因为这个指针没有什么意义，仅仅是为了构成一个Entry结构体，有意义的是第一个元素now // 返回第一个未到期的Timer的迭代器 // lower_bound的含义是返回第一个值>=sentry的元素的iterator // 即*end >= sentry，从而end->first > now TimerList::iterator end = timers_.lower_bound(sentry); assert(end == timers_.end() || now < end->first); // 将到期的定时器插入到expired中 std::copy(timers_.begin(), end, back_inserter(expired));//back_inserter是迭代器的一种操作，效果和expired.push_back()一样 // 从timers_中移除到期的定时器 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;//避免编译器出现变量n未使用的警告？？？ } assert(timers_.size() == activeTimers_.size()); return expired; } void TimerQueue::reset(const std::vector <Entry> &expired, Timestamp now)//重启两种定时器，一种是timefd，另外一种是定时器列表中需要重复的定时器 { 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); insert(it->second); } else//不需要重复就删除这个定时器 { // 一次性定时器或者已被取消的定时器是不能重置的，因此删除该定时器 // FIXME move to a free list delete it->second; // FIXME: no delete please } } //重启timefd，设置的时间就是定时器列表中最快到期的时间 if (!timers_.empty()) { // 获取最早到期的定时器超时时间 nextExpire = timers_.begin()->second->expiration(); } if (nextExpire.valid()) { // 重置定时器的超时时刻(timerfd_settime) resetTimerfd(timerfd_, nextExpire); } } bool TimerQueue::insert(Timer *timer)//把定时器插入到timers_和activeTimers_队列中去 { loop_->assertInLoopThread(); assert(timers_.size() == activeTimers_.size()); // 最早到期时间是否改变 bool earliestChanged = false;//这个变量的意义是显示最早到期时间是否改变，通俗点说就是这个插入的定时器的位置在timers_的 //首位，也就是这个插入的定时器的到期时间是timers_中已经存储的定时器中最早的，那么这个标志位就会置true Timestamp when = timer->expiration();//超时时刻 TimerList::iterator it = timers_.begin(); // 如果timers_为空或者when小于timers_中的最早到期时间 if (it == timers_.end() || when < it->first) { earliestChanged = true;//表示定时器最早，所以置true } //要分别插入到两个set中 { // 插入到timers_中 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;//返回最早到期的时间有没有改变 }
