经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C++ » 查看文章
muduo网络库学习笔记(三)TimerQueue定时器队列
来源：cnblogs　　作者：艾露米婭娜　　时间：2018/11/12 9:45:00　　对本文有异议

目录

muduo网络库学习笔记(三)TimerQueue定时器队列

本章整理muduo中的TimerQueue，会简述关于timerfd系统定时函数的基本使用，和TimerQueue类的封装结构,最后给出TimerQueue::addTimer()接口的时序图与使用例子.

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(2)
·usleep(3)
·nanosleep(2)
·clock_nanosleep(2)
·getitimer(2) / setitimer(2)
·timer_create(2) / timer_settime(2) / timer_gettime(2) / timer_delete(2)
·timerfd_create(2) / timerfd_gettime(2) / timerfd_settime(2)

muduo中做的取舍如下
·（计时） 只使用gettimeofday(2)来获取当前时间。
·（定时） 只使用timerfd_*系列函数来处理定时任务。

gettimeofday(2)入选原因（这也是muduo::Timestamp class的主要设计考虑） ：
1． time(2)的精度太低， ftime(3)已被废弃； clock_gettime(2)精度最高， 但是其系统调用的开销比gettimeofday(2)大。
2． 在x86-64平台上， gettimeofday(2)不是系统调用， 而是在用户态实现的， 没有上下文切换和陷入内核的开销32。
3． gettimeofday(2)的分辨率（resolution） 是1微秒， 现在的实现确实能达到这个计时精度， 足以满足日常计时的需要。 muduo::Timestamp用一个int64_t来表示从Unix Epoch到现在的微秒数， 其范围可达上下30万年。

timerfd_*入选的原因：
1． sleep(3) / alarm(2) / usleep(3)在实现时有可能用了SIGALRM信号， 在多线程程序中处理信号是个相当麻烦的事情， 应当尽量避免， 再说， 如果主程序和程序库都使用SIGALRM， 就糟糕了。
2． nanosleep(2)和clock_nanosleep(2)是线程安全的， 但是在非阻塞网络编程中， 绝对不能用让线程挂起的方式来等待一段时间， 这样一来程序会失去响应。 正确的做法是注册一个时间回调函数。
3． getitimer(2)和timer_create(2)也是用信号来deliver超时，在多线程程序中也会有麻烦。timer_create(2)可以指定信号的接收方是进程还是线程， 算是一个进步， 不过信号处理函数（signal handler） 能做的事情实在很受限。
4．timerfd_create(2)把时间变成了一个文件描述符， 该“文件”在定时器超时的那一刻变得可读， 这样就能很方便地融入select(2)/poll(2)框架中， 用统一的方式来处理IO事件和超时事件， 这也正是Reactor模式的长处。
5． 传统的Reactor利用select(2)/poll(2)/epoll(4)的timeout来实现定时功能， 但poll(2)和epoll_wait(2)的定时精度只有毫秒，远低于timerfd_settime(2)的定时精度。

timerfd简单使用介绍

本章使用到的两个系统函数:

  1. #include <sys/timerfd.h>
  2. int timerfd_create(int clockid, int flags);
  3. int timerfd_settime(int fd, int flags, const struct itimerspec *new_value,struct itimerspec *old_value);

1、timerfd_create函数生成一个定时器,返回与之关联的文件描述,其中的clockid可以设成CLOCK_REALTIME和CLOCK_MONOTONIC
CLOCK_REALTIME:系统实时时间,随系统实时时间改变而改变,即从UTC1970-1-1 0:0:0开始计时,中间时刻如果系统时间被用户改成其他,则对应的时间相应改变
CLOCK_MONOTONIC:从系统启动这一刻起开始计时,不受系统时间被用户改变的影响

2、timerfd_settime用于启停定时器,new_value为超时时间,old_value为周期性定时时间，为0表示不进行周期性定时.

  1.  struct timespec {
  2.       time_t tv_sec;                /* Seconds */
  3.       long   tv_nsec;               /* Nanoseconds */
  4.   };
  6.   struct itimerspec {
  7.      struct timespec it_interval;  /* Interval for periodic timer */
  8.      struct timespec it_value;     /* Initial expiration */
  9.   };

timerfd示例

通过select 监听timerfd，可读时表明到达定时时间.

  1. #include <sys/timerfd.h>
  2. #include <sys/select.h>
  3. /* According to earlier standards */
  4. #include <sys/time.h>
  5. #include <sys/types.h>
  6. #include <unistd.h>
  9. int main()
  10. {
  12.   int timerfd = ::timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK |TFD_CLOEXEC);
  14.   struct itimerspec howlong;
  15.   bzero(&howlong, sizeof howlong);
  16.   howlong.it_value.tv_sec = 3;
  17.   timerfd_settime(timerfd, 0, &howlong, NULL);
  19.   fd_set rdset;
  20.   FD_ZERO(&rdset);
  21.   FD_SET(timerfd, &rdset);
  23.   struct timeval timeout;
  24.   timeout.tv_sec = 1;
  25.   timeout.tv_usec = 0;
  26.   while(1)
  27.   {
  28.     if(select(timerfd + 1, &rdset, NULL, NULL, &timeout) == 0)
  29.     {
  30.       std::cout << "timeout\n";
  31.       timeout.tv_sec = 1;
  32.       timeout.tv_usec = 0;
  33.       FD_SET(timerfd, &rdset);
  34.         continue;
  35.     }
  36.     std::cout << " timer happend\n";
  37.     break;
  38.   }
  41.   close(timerfd);
  43.   return 0;
  44. }
  46. /* print
  47. timeout
  48. timeout
  49. timer happend
  50. */

muduo中对timerfd的封装

  1. int createTimerfd()
  2. {
  3.   int timerfd = ::timerfd_create(CLOCK_MONOTONIC,
  4.                                  TFD_NONBLOCK | TFD_CLOEXEC);
  5.   if (timerfd < 0)
  6.   {
  7.     std::cout << "Failed in timerfd_create" << std::endl;
  8.     abort();
  9.   }
  10.   return timerfd;
  11. }
  13. struct timespec howMuchTimeFromNow(TimeStamp when)
  14. {
  15.   int64_t microseconds = when.microSecondsSinceEpoch()
  16.                          - TimeStamp::now().microSecondsSinceEpoch();
  17.   if (microseconds < 100)
  18.   {
  19.     microseconds = 100;
  20.   }
  21.   struct timespec ts;
  22.   ts.tv_sec = static_cast<time_t>(
  23.       microseconds / TimeStamp::kMicroSecondsPerSecond);
  24.   ts.tv_nsec = static_cast<long>(
  25.       (microseconds % TimeStamp::kMicroSecondsPerSecond) * 1000);
  26.   return ts;
  27. }
  29. void readTimerfd(int timerfd, TimeStamp now)
  30. {
  31.   uint64_t howmany;
  32.   ssize_t n = ::read(timerfd, &howmany, sizeof howmany);
  33.   std::cout << "TimerQueue::handleRead() " << howmany << " at " << now.toString() << std::endl;
  34.   if (n != sizeof howmany)
  35.   {
  36.     std::cout << "TimerQueue::handleRead() reads " << n << " bytes instead of 8" << std::endl;
  37.   }
  38. }
  40. void resetTimerfd(int timerfd, TimeStamp expiration)
  41. {
  42.   // wake up loop by timerfd_settime()
  43.   struct itimerspec newValue;
  44.   struct itimerspec oldValue;
  45.   bzero(&newValue, sizeof newValue);
  46.   bzero(&oldValue, sizeof oldValue);
  47.   newValue.it_value = howMuchTimeFromNow(expiration);
  48.   int ret = ::timerfd_settime(timerfd, 0, &newValue, &oldValue);
  49.   if (ret)
  50.   {
  51.     std::cout << "timerfd_settime()" << std::endl;
  52.   }
  53. }

TimerQueue的结构.

TimerQueue只提供了两个对外的接口
addTimer() 添加一个定时器超时执行回调函数cb. interval是周期性定时时间，本章不讲,置零不打开.
cancel() 取消一个定时器,本章也不细述,本章只介绍addTimer()接口.后面如果需要会补充本章.

TimerQueue定义如下

  1. class TimerQueue
  2. {
  3. public:
  4.   TimerQueue(EventLoop* loop);
  5.   ~TimerQueue();
  7.   // Schedules the callback to be run at given time,
  9.   TimerId addTimer(const NetCallBacks::TimerCallBack& cb, TimeStamp when, double interval = 0.0);
  11.   void cancel(TimerId timerId);
  13. private:
  14.   /*
  15.     .....
  16.   */
  17.   EventLoop* p_loop;
  18.   const int m_timerfd;
  19.   Channel m_timerfdChannel;
  21.   //Timer List sorted by expiration
  22.   TimerList m_timers;
  23.   ActiveTimerSet m_activeTimers;
  24. };

虽然只提供了两个对外接口，但是私有成比较复杂,首先简介成员Timer.

Timer

Timer类作为TimerQueue的内部成员使用,封装一个定时器,addTimer()接口调用后生成一个Timer()，外头的回调函数和定时反应时间会封装再此Timer中.
Tiemr主要接口都是获取这些构造时配置的成员值
run() 调用回调函数.
expiration 定时器过期时间.
interval 周期性定时时间.
repeat 是否是周期性定时.
sequence 一个静态成员,用于记录Timer创建的个数. 为了保证它的线程安全性，使用AtomicInt64封装了一层原子操作.

TimerId 用于Cancel Timer的标志Id, 这两个类都不复杂，可自行参看muduo源码，也可翻我github上的SimpleMuduo单独类文件夹下的测试代码.

  1.   Timer(const NetCallBacks::TimerCallBack& cb, TimeStamp when, double interval)
  2.   :m_callBack(cb),
  3.   m_expiration(when),
  4.   m_interval(interval),
  5.   m_repeat(interval > 0.0),
  6.   m_sequence(s_numCreated.incrementAndGet())
  1. TimerId TimerQueue::addTimer(const NetCallBacks::TimerCallBack& cb, TimeStamp when, double interval)
  2. {
  3.   Timer* timer = new Timer(cb, when, interval);
  4.   //p_loop->runInLoop(std::bind(&TimerQueue::addTimerInLoop, this, timer));
  5.   return TimerId(timer, timer->sequence());
  6. }

Timer的容器.

  1.   typedef std::pair<TimeStamp, Timer*> Entry;
  2.   typedef std::set<Entry> TimerList;
  3.   typedef std::pair<Timer*, int64_t> ActiveTimer;
  4.   typedef std::set<ActiveTimer> ActiveTimerSet;

为了解决无法处理两个Timer到期时间相同的情况。使用了pair将时间戳和Timer的地址组成了一对.然后使用Set存储.
ActiveTimer 将Timer和sequence组成一对主要作用来索引迭代的.

TimerQueue私有接口介绍.

  1.   void addTimerInLoop(Timer* timer);
  2.   void cancelInLoop(TimerId timerId);
  3.   //called when timerfd alarms
  4.   void handleRead();
  5.   //move out all expired timers and return they.
  6.   std::vector<Entry> getExpired(TimeStamp now);
  7.   bool insert(Timer* timer);
  8.   void reset(const std::vector<Entry>& expired, TimeStamp now);

添加定时器

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

EventLoop添加了一个runInLoop接口： 在它的IO线程内执行某个用户
任务回调， 即EventLoop::runInLoop(const Functor& cb)， 其中Functor是
std::function<void()>。 如果用户在当前IO线程调用这个函数， 回调会
同步进行； 如果用户在其他线程调用runInLoop()， cb会被加入队列， IO
线程会被唤醒来调用这个Functor。

addTimer()使用了EventLoop的runInLoop接口(这个接口主要来保证线程安全性的，暂不讲)，来执行addTimerInLoop().addTimerInLoop()调用insert()插入定时器.
如果此定时器是最早触发的那一个则会调用resetTimerfd()->timerfd_settime()启动定时器.

addTimer()->addTimerInLoop()->insert()->resetTimerfd()->timerfd_settime()

更新定时器

添加逻辑就在上面了，下面给出处理逻辑.
三个接口.
void handleRead(); //定时器触发回调.获取已过期的事件并处理随后更新列表.
std::vector

handleRead()->getExpired()->Timer->run(cb)->reset()->resetTimerfd()->timerfd_settime()

时序图

TimerQueue源码

  1. #ifndef _NET_TIMERQUEUE_HH
  2. #define _NET_TIMERQUEUE_HH
  3. #include "TimerId.hh"
  4. #include "CallBacks.hh"
  5. #include "TimeStamp.hh"
  6. #include "Channel.hh"
  7. #include <set>
  8. #include <vector>
  10. class EventLoop;
  12. class TimerQueue
  13. {
  14. public:
  15.   TimerQueue(EventLoop* loop);
  16.   ~TimerQueue();
  18.   // Schedules the callback to be run at given time,
  20.   TimerId addTimer(const NetCallBacks::TimerCallBack& cb, TimeStamp when, double interval = 0.0);
  22.   void cancel(TimerId timerId);
  24. private:
  25.   typedef std::pair<TimeStamp, Timer*> Entry;
  26.   typedef std::set<Entry> TimerList;
  27.   typedef std::pair<Timer*, int64_t> ActiveTimer;
  28.   typedef std::set<ActiveTimer> ActiveTimerSet;
  30.   void addTimerInLoop(Timer* timer);
  31.   void cancelInLoop(TimerId timerId);
  32.   //called when timerfd alarms
  33.   void handleRead();
  34.   //move out all expired timers and return they.
  35.   std::vector<Entry> getExpired(TimeStamp now);
  36.   bool insert(Timer* timer);
  37.   void reset(const std::vector<Entry>& expired, TimeStamp now);
  39.   EventLoop* p_loop;
  40.   const int m_timerfd;
  41.   Channel m_timerfdChannel;
  43.   //Timer List sorted by expiration
  44.   TimerList m_timers;
  45.   ActiveTimerSet m_activeTimers;
  47.   bool m_callingExpiredTimers; /*atomic*/
  48.   ActiveTimerSet m_cancelingTimers;
  50. };
  52. #endif
  54. //TimerQueeu.cpp
  56. #include <stdint.h>
  57. #include <assert.h>
  58. #include <sys/timerfd.h>
  59. #include <unistd.h>
  61. #include "Logger.hh"
  62. #include "EventLoop.hh"
  63. #include "Timer.hh"
  64. #include "TimerQueue.hh"
  66. namespace TimerFd
  67. {
  69. int createTimerfd()
  70. {
  71.   int timerfd = ::timerfd_create(CLOCK_MONOTONIC,
  72.                                  TFD_NONBLOCK | TFD_CLOEXEC);
  73.   if (timerfd < 0)
  74.   {
  75.     LOG_SYSFATAL << "Failed in timerfd_create";
  76.   }
  77.   return timerfd;
  78. }
  80. struct timespec howMuchTimeFromNow(TimeStamp when)
  81. {
  82.   int64_t microseconds = when.microSecondsSinceEpoch()
  83.                          - TimeStamp::now().microSecondsSinceEpoch();
  84.   if (microseconds < 100)
  85.   {
  86.     microseconds = 100;
  87.   }
  88.   struct timespec ts;
  89.   ts.tv_sec = static_cast<time_t>(
  90.       microseconds / TimeStamp::kMicroSecondsPerSecond);
  91.   ts.tv_nsec = static_cast<long>(
  92.       (microseconds % TimeStamp::kMicroSecondsPerSecond) * 1000);
  93.   return ts;
  94. }
  96. void readTimerfd(int timerfd, TimeStamp now)
  97. {
  98.   uint64_t howmany;
  99.   ssize_t n = ::read(timerfd, &howmany, sizeof howmany);
  100.   LOG_TRACE << "TimerQueue::handleRead() " << howmany << " at " << now.toString();
  101.   if (n != sizeof howmany)
  102.   {
  103.     LOG_ERROR << "TimerQueue::handleRead() reads " << n << " bytes instead of 8";
  104.   }
  105. }
  107. void resetTimerfd(int timerfd, TimeStamp expiration)
  108. {
  109.   // wake up loop by timerfd_settime()
  110.   LOG_TRACE << "resetTimerfd()";
  111.   struct itimerspec newValue;
  112.   struct itimerspec oldValue;
  113.   bzero(&newValue, sizeof newValue);
  114.   bzero(&oldValue, sizeof oldValue);
  115.   newValue.it_value = howMuchTimeFromNow(expiration);
  116.   int ret = ::timerfd_settime(timerfd, 0, &newValue, &oldValue);
  117.   if (ret)
  118.   {
  119.     LOG_SYSERR << "timerfd_settime()";
  120.   }
  121. }
  123. };
  125. using namespace TimerFd;
  127. TimerQueue::TimerQueue(EventLoop* loop)
  128.   :p_loop(loop),
  129.    m_timerfd(createTimerfd()),
  130.    m_timerfdChannel(p_loop, m_timerfd),
  131.    m_timers(),
  132.    m_callingExpiredTimers(false)
  133. {
  134.   m_timerfdChannel.setReadCallBack(std::bind(&TimerQueue::handleRead, this));
  135.   m_timerfdChannel.enableReading();
  136. }
  138. TimerQueue::~TimerQueue()
  139. {
  140.   m_timerfdChannel.disableAll();
  141.   m_timerfdChannel.remove();
  142.   ::close(m_timerfd);
  143.   for (TimerList::iterator it = m_timers.begin();
  144.       it != m_timers.end(); ++it)
  145.   {
  146.     delete it->second;
  147.   }
  148. }
  150. std::vector<TimerQueue::Entry> TimerQueue::getExpired(TimeStamp now)
  151. {
  152.   std::vector<Entry> expired;
  153.   Entry sentry = std::make_pair(now, reinterpret_cast<Timer*>UINTPTR_MAX);
  154.   TimerList::iterator it = m_timers.lower_bound(sentry);
  155.   assert(it == m_timers.end() || now < it->first);
  156.   std::copy(m_timers.begin(), it, back_inserter(expired));
  157.   m_timers.erase(m_timers.begin(), it);
  159.   for(std::vector<Entry>::iterator it = expired.begin();
  160.       it != expired.end(); ++it)
  161.   {
  162.     ActiveTimer timer(it->second, it->second->sequence());
  163.     size_t n = m_activeTimers.erase(timer);
  164.     assert(n == 1); (void)n;
  165.   }
  167.   assert(m_timers.size() == m_activeTimers.size());
  169.   return expired;
  170. }
  173. TimerId TimerQueue::addTimer(const NetCallBacks::TimerCallBack& cb, TimeStamp when, double interval)
  174. {
  175.   Timer* timer = new Timer(cb, when, interval);
  176.   p_loop->runInLoop(std::bind(&TimerQueue::addTimerInLoop, this, timer));
  177.   return TimerId(timer, timer->sequence());
  178. }
  180. void TimerQueue::addTimerInLoop(Timer* timer)
  181. {
  182.   p_loop->assertInLoopThread();
  183.   bool earliestChanged = insert(timer);
  185.   if (earliestChanged)
  186.   {
  187.     resetTimerfd(m_timerfd, timer->expiration());
  188.   }
  189. }
  191. void TimerQueue::cancel(TimerId timerId)
  192. {
  193.   p_loop->runInLoop(std::bind(&TimerQueue::cancelInLoop, this, timerId));
  194. }
  196. void TimerQueue::cancelInLoop(TimerId timerId)
  197. {
  198.   p_loop->assertInLoopThread();
  199.   assert(m_timers.size() ==  m_activeTimers.size());
  200.   ActiveTimer timer(timerId.m_timer, timerId.m_sequence);
  201.   ActiveTimerSet::iterator it = m_activeTimers.find(timer);
  202.   if(it != m_activeTimers.end())
  203.   {
  204.     size_t n = m_timers.erase(Entry(it->first->expiration(), it->first));
  205.     assert(n == 1);
  206.     delete it->first;
  207.   }
  208.   else if (m_callingExpiredTimers)
  209.   {
  210.     m_cancelingTimers.insert(timer);
  211.   }
  212.   assert(m_timers.size() == m_activeTimers.size());
  213. }
  215. bool TimerQueue::insert(Timer* timer)
  216. {
  217.   p_loop->assertInLoopThread();
  218.   assert(m_timers.size() == m_activeTimers.size());
  219.   bool earliestChanged = false;
  220.   TimeStamp when = timer->expiration();
  221.   TimerList::iterator it = m_timers.begin();
  222.   if (it == m_timers.end() || when < it->first)
  223.   {
  224.     earliestChanged = true;
  225.   }
  226.   {
  227.     std::pair<TimerList::iterator, bool> result
  228.       = m_timers.insert(Entry(when, timer));
  229.     assert(result.second); (void)result;
  230.   }
  231.   {
  232.     std::pair<ActiveTimerSet::iterator, bool> result
  233.       = m_activeTimers.insert(ActiveTimer(timer, timer->sequence()));
  234.     assert(result.second); (void)result;
  235.   }
  237.   LOG_TRACE << "TimerQueue::insert() " << "m_timers.size() : "
  238.   << m_timers.size() << " m_activeTimers.size() : " << m_activeTimers.size();
  240.   assert(m_timers.size() == m_activeTimers.size());
  241.   return earliestChanged;
  242. }
  245. void TimerQueue::handleRead()
  246. {
  247.   p_loop->assertInLoopThread();
  248.   TimeStamp now(TimeStamp::now());
  249.   readTimerfd(m_timerfd, now);
  251.   std::vector<Entry> expired = getExpired(now);
  253.   LOG_TRACE << "Expired Timer size " << expired.size() << "  ";
  255.   m_callingExpiredTimers = true;
  256.   m_cancelingTimers.clear();
  258.   for(std::vector<Entry>::iterator it = expired.begin();
  259.       it != expired.end(); ++it )
  260.   {
  261.     it->second->run();
  262.   }
  264.   m_callingExpiredTimers = false;
  266.   reset(expired, now);
  267. }
  270. void TimerQueue::reset(const std::vector<Entry>& expired, TimeStamp now)
  271. {
  272.   TimeStamp nextExpire;
  274.   for(std::vector<Entry>::const_iterator it = expired.begin();
  275.       it != expired.end(); ++it)
  276.   {
  277.     ActiveTimer timer(it->second, it->second->sequence());
  278.     if(it->second->repeat()
  279.       && m_cancelingTimers.find(timer) == m_cancelingTimers.end())
  280.     {//如果是周期定时器则重新设定时间插入. 否则delete.
  281.       it->second->restart(now);
  282.       insert(it->second);
  283.     }
  284.     else
  285.     {// FIXME move to a free list no delete please
  286.       delete it->second;
  287.     }
  288.   }
  290.   if (!m_timers.empty())
  291.   {
  292.     nextExpire = m_timers.begin()->second->expiration();
  293.   }
  295.   if (nextExpire.valid())
  296.   {
  297.     resetTimerfd(m_timerfd, nextExpire);
  298.   }
  299. }

TimerQueue使用示例

测试TimerQueue的addTimer接口.

  1. #include <errno.h>
  2. #include <thread>
  3. #include <strings.h>
  4. #include <poll.h>
  5. #include <functional>
  6. #include "EventLoop.hh"
  7. #include "Channel.hh"
  8. #include "Poller.hh"
  9. #include "Logger.hh"
  10. #include "Timer.hh"
  11. #include "TimeStamp.hh"
  12. #include "TimerQueue.hh"
  14. EventLoop* g_loop;
  16. void print() { LOG_DEBUG << "test print()";  }
  18. void test()
  19. {
  21.   LOG_DEBUG << "[test] : test timerQue";
  23. }
  26. int main()
  27. {
  28.   EventLoop loop;
  29.   g_loop = &loop;
  31.   TimerQueue timerQue(&loop);
  32.   timerQue.addTimer(test, times::addTime(TimeStamp::now(), 3.0));
  33.   timerQue.addTimer(test, times::addTime(TimeStamp::now(), 3.0));
  34.   timerQue.addTimer(test, times::addTime(TimeStamp::now(), 5.0));
  36.   loop.loop();
  38.   return 0;
  39. }
  1. ./test.out 
  2. 2018-11-11 15:49:22.493990 [TRACE] [Poller.cpp:64] [updateChannel] fd= 3 events3
  3. 2018-11-11 15:49:22.494042 [TRACE] [EventLoop.cpp:34] [EventLoop] EventLoop Create 0x7FFFBD3C39B0 in thread 3262
  4. 2018-11-11 15:49:22.494047 [TRACE] [Poller.cpp:64] [updateChannel] fd= 5 events3
  5. 2018-11-11 15:49:22.494055 [TRACE] [TimerQueue.cpp:172] [insert] TimerQueue::insert() m_timers.size() : 1 m_activeTimers.size() : 1
  6. 2018-11-11 15:49:22.494058 [TRACE] [TimerQueue.cpp:55] [resetTimerfd] resetTimerfd()
  7. 2018-11-11 15:49:22.494066 [TRACE] [TimerQueue.cpp:172] [insert] TimerQueue::insert() m_timers.size() : 2 m_activeTimers.size() : 2
  8. 2018-11-11 15:49:22.494070 [TRACE] [TimerQueue.cpp:172] [insert] TimerQueue::insert() m_timers.size() : 3 m_activeTimers.size() : 3
  9. 2018-11-11 15:49:22.494073 [TRACE] [EventLoop.cpp:59] [loop] EventLoop 0x7FFFBD3C39B0 start loopig
  10. 2018-11-11 15:49:22.494075 [TRACE] [Poller.cpp:20] [poll] Poller::poll()
  11. 2018-11-11 15:49:23.495462 [TRACE] [Poller.cpp:28] [poll]  nothing happended
  12. 2018-11-11 15:49:23.495488 [TRACE] [Poller.cpp:20] [poll] Poller::poll()
  13. 2018-11-11 15:49:24.496618 [TRACE] [Poller.cpp:28] [poll]  nothing happended
  14. 2018-11-11 15:49:24.496640 [TRACE] [Poller.cpp:20] [poll] Poller::poll()
  15. 2018-11-11 15:49:25.494222 [TRACE] [Poller.cpp:24] [poll] 1 events happended
  16. 2018-11-11 15:49:25.494253 [TRACE] [TimerQueue.cpp:45] [readTimerfd] TimerQueue::handleRead() 1 at 1541922565.494251
  17. 2018-11-11 15:49:25.494316 [TRACE] [TimerQueue.cpp:188] [handleRead] Expired Timer size 2  
  19. 2018-11-11 15:49:25.494320 [DEBUG] [main.cpp:50] [test] [test] : test timerQue
  20. 2018-11-11 15:49:25.494322 [DEBUG] [main.cpp:50] [test] [test] : test timerQue
  22. 2018-11-11 15:49:25.494325 [TRACE] [TimerQueue.cpp:55] [resetTimerfd] resetTimerfd()
  23. 2018-11-11 15:49:25.494332 [TRACE] [Poller.cpp:20] [poll] Poller::poll()
  24. 2018-11-11 15:49:26.496293 [TRACE] [Poller.cpp:28] [poll]  nothing happended
  25. 2018-11-11 15:49:26.496318 [TRACE] [Poller.cpp:20] [poll] Poller::poll()
  26. 2018-11-11 15:49:27.494291 [TRACE] [Poller.cpp:24] [poll] 1 events happended
  27. 2018-11-11 15:49:27.494319 [TRACE] [TimerQueue.cpp:45] [readTimerfd] TimerQueue::handleRead() 1 at 1541922567.494317
  28. 2018-11-11 15:49:27.494328 [TRACE] [TimerQueue.cpp:188] [handleRead] Expired Timer size 1  
  30. 2018-11-11 15:49:27.494331 [DEBUG] [main.cpp:50] [test] [test] : test timerQue
  32. 2018-11-11 15:49:27.494334 [TRACE] [Poller.cpp:20] [poll] Poller::poll()
  33. 2018-11-11 15:49:28.495665 [TRACE] [Poller.cpp:28] [poll]  nothing happended
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C++热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C++推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号