1 muduo::net::EchoServer类 参考EchoServer类 参考

EchoServer 的协作图:

[图例]

Public 成员函数
	EchoServer (EventLoop *loop, const InetAddress &listenAddr)
void	start ()

Private 成员函数
void	onConnection (const TcpConnectionPtr &conn)
void	onMessage (const TcpConnectionPtr &conn, Buffer *buf, Timestamp time)

Private 属性
EventLoop *	loop_
TcpServer	server_

• 当事件到来，会调用channel::handleEvent()和Channel::handleEventWithGuard(Timestamp receiveTime)处理，channel类负责对事件的注册和响应的封装

void Channel::handleEventWithGuard(Timestamp receiveTime) {
eventHandling_ = true; // 将状态置于处理事件中if ((revents_ & POLLHUP) && !(revents_ & POLLIN)) // 如果已经半关闭并且没有数据要读{if (logHup_){LOG_WARN << "Channel::handle_event() POLLHUP";}if (closeCallback_)closeCallback_(); // 关闭的回调函数}if (revents_ & (POLLIN | POLLPRI | POLLRDHUP)) // 如果是读事件，需要多传递一个time时间戳对象进去{if (readCallback_)readCallback_(receiveTime);}if (revents_ & POLLOUT) // 如果是写事件{if (writeCallback_) // 并且事件已经被注册过了writeCallback_();}eventHandling_ = false;
}

• 更新和注册通道void Channel::update()调用void EventLoop::updateChannel(Channel *channel)

void EventLoop::updateChannel(Channel *channel){assert(channel->ownerLoop() == this); // 断言通道所属的loop对象assertInLoopThread();	 			  // loop是否处于开启事件循环中poller_->updateChannel(channel);	  // 
}

调用void PollPoller::updateChannel(Channel *channel)是一个纯虚函数，重写了父类的updateChannel

void PollPoller::fillActiveChannels(int numEvents,ChannelList *activeChannels) const
{for (PollFdList::const_iterator pfd = pollfds_.begin();pfd != pollfds_.end() && numEvents > 0; ++pfd) // 遍历vector容器std::vector<struct pollfd>{if (pfd->revents > 0){--numEvents;ChannelMap::const_iterator ch = channels_.find(pfd->fd); // 通过文件描述符查找通道assert(ch != channels_.end());	  	// 断言是否能查找到通道Channel *channel = ch->second;	  	// 获取到事件类型assert(channel->fd() == pfd->fd); 	// 对通道的文件描述符进行赋值操作channel->set_revents(pfd->revents); // 设置事件类型activeChannels->push_back(channel);}}
}

EPollPoller事件的注册的机制

class EPollPoller : public Poller
{public:void update(int operation, Channel *channel);private:typedef std::vector<struct epoll_event> EventList;typedef std::map<int, Channel *> ChannelMap; // 文件描述符和管道事件的注册EventList events_;ChannelMap channels_;
};

我写的方法和该方法不同的是，ChannelMap用的是基于对象的回调函数注册方式，我自己使用的是虚函数的方法，论性能和效率，还是回调函数的方法要更好，只是从代码阅读上，比较难以理解。

• EventLoop构造函数

EventLoop::EventLoop(): looping_(false),quit_(false),eventHandling_(false),threadId_(CurrentThread::tid()),poller_(Poller::newDefaultPoller(this)), // 会构建poller对象，会根据环境变量生成不同的io多路复用对象currentActiveChannel_(NULL){}
Poller* Poller::newDefaultPoller(EventLoop* loop)
{if (::getenv("MUDUO_USE_POLL")){return new PollPoller(loop); // 生成poll}else{return new EPollPoller(loop);// 生成epoll}
}

主要看epoll的封装

如果有返回就绪的事件fd，那么把这个返回集合和负责事件注册的管道压入函数中fillActiveChannels

说的不够清晰上一份伪代码

	int epfd = epoll_create(1);epollAddFd(sfd, epfd);epollAddFd(exitPipe[0],epfd); // 将管道读端纳入监听队列struct epoll_event evs[2]; // 事件的集合int newFd = 0;int sums = 0;while(1){ // 开启不间断的等待轮询-1就是不设置超时sums = epoll_wait(epfd, evs, 2, -1);for(int i = 0; i < sums; ++i){if(evs[i].data.fd == sfd) // evs[i].data.fd就是监听返回的就绪文件描述符跟需要关注的进行比较{newFd = accept(sfd, NULL, NULL);printf("成功建立连接\n");}}}   

struct epoll_event evs[2]就相当于& (*(events_.begin() ) )

sfd 就相当于ChannelList *activeChannels

Timestamp EPollPoller::poll(int timeoutMs, ChannelList *activeChannels)
{int numEvents = ::epoll_wait(epollfd_, & (*(events_.begin() ) ),static_cast<int>(events_.size()),timeoutMs);Timestamp now(Timestamp::now());if (numEvents > 0){fillActiveChannels(numEvents, activeChannels); // 在此函数中if (implicit_cast<size_t>(numEvents) == events_.size()) // 如果vector已经到了极限容量，就将其扩容两倍{events_.resize(events_.size() * 2);}}else if (numEvents == 0){LOG_TRACE << " nothing happended";}else{LOG_SYSERR << "EPollPoller::poll()";}return now;
}

fillActiveChannels函数

void EPollPoller::fillActiveChannels(int numEvents,ChannelList *activeChannels) const
{assert(implicit_cast<size_t>(numEvents) <= events_.size()); // 断言返回的就绪事件fd不能乱了套for (unsigned long i = 0; i < static_cast<unsigned>(numEvents); ++i) // 循环扫描就绪的文件描述符{Channel *channel = static_cast<Channel *>(events_[i].data.ptr);  // 返回注册的事件列表,ptr是可以附带在epoll红黑树上的一些关键信息,还需要判定哪些事件返回
#ifndef NDEBUG int fd = channel->fd();ChannelMap::const_iterator it = channels_.find(fd);assert(it != channels_.end());assert(it->second == channel);
#endifchannel->set_revents(static_cast<int>(events_[i].events)); 	// 设置每个管道注册的事件activeChannels->push_back(channel); 						// 把管道事件添加到管道集合中去}
}

那么在调用中是这样使用的，封装起来很复杂

while (!quit_){activeChannels_.clear();pollReturnTime_ = poller_->poll(kPollTimeMs, &activeChannels_); // epoll返回的事件要保存到该列表当中if (Logger::logLevel() <= Logger::TRACE){printActiveChannels();}eventHandling_ = true;for (ChannelList::iterator it = activeChannels_.begin();it != activeChannels_.end(); ++it){currentActiveChannel_ = *it;currentActiveChannel_->handleEvent(pollReturnTime_);}currentActiveChannel_ = NULL;eventHandling_ = false; // 终止事件处理标识}

• updateChannel函数，用于更新和添加事件

void EPollPoller::updateChannel(Channel *channel)
{Poller::assertInLoopThread(); // 断言是否处于io线程LOG_TRACE << "fd = " << channel->fd() << " events = " << channel->events(); // 输出文件描述符和事件类型const int index = channel->index();if (index == kNew || index == kDeleted){// a new one, add with EPOLL_CTL_ADDint fd = channel->fd();if (index == kNew){assert(channels_.find(fd) == channels_.end()); // 断言该文件描述符在管道事件中没有被注册过channels_[fd] = channel;        // 注册事件,跟我自己写的也是差不多的方法 ["cmd 命令"]="task_data* 父类指针"}else // index == kDeleted {assert(channels_.find(fd) != channels_.end());assert(channels_[fd] == channel); // 再次断言，是否已经注册成功}channel->set_index(kAdded);      // 设置这个通道当前状态是已经添加的状态update(EPOLL_CTL_ADD, channel);	 // epoll_ctr_add 添加到红黑树中}else{// …… EPOLL_CTL_MOD}
}

• update将事件添加到红黑树中

void EPollPoller::update(int operation, Channel *channel)
{struct epoll_event event;bzero(&event, sizeof event);event.events = static_cast<uint32_t>(channel->events()); // epoll关注的读写，超时，以及各种事件，signalfd，管道fdevent.data.ptr = channel;   // 将channel通道作为携带的数据，把通道也给返回回来了，到时候就知道是哪个通道产生得事件int fd = channel->fd();     // 文件描述符// 注册到红黑树上if (::epoll_ctl(epollfd_, operation, fd, &event) < 0){if (operation == EPOLL_CTL_DEL){LOG_SYSERR << "epoll_ctl op=" << operation << " fd=" << fd;}else{LOG_SYSFATAL << "epoll_ctl op=" << operation << " fd=" << fd;}}
}

• 删除红黑树上的事件关注

void EventLoop::removeChannel(Channel *channel)
{assert(channel->ownerLoop() == this);assertInLoopThread();if (eventHandling_){assert(currentActiveChannel_ == channel ||std::find(activeChannels_.begin(), activeChannels_.end(), channel) == activeChannels_.end());}poller_->removeChannel(channel);
}
// 由poller重写的removeChannel来调用
void EPollPoller::removeChannel(Channel *channel)
{Poller::assertInLoopThread();int fd = channel->fd();LOG_TRACE << "fd = " << fd;assert(channels_.find(fd) != channels_.end());assert(channels_[fd] == channel);assert(channel->isNoneEvent());int index = channel->index();assert(index == kAdded || index == kDeleted); // 断言是否添加或者删除标识size_t n = channels_.erase(fd);(void)n;assert(n == 1);if (index == kAdded){update(EPOLL_CTL_DEL, channel);}channel->set_index(kNew);
}

2 定时器的实现

Timerld、Timer、TimerQueue

后两个类都是内部实现细节

muduo::net::Timer类 参考 还是对muduo/base/Timestamp.cc进行操作

#include <Timer.h>

Public 成员函数
	Timer (const TimerCallback &cb, Timestamp when, double interval)
void	run () const
Timestamp	expiration () const
bool	repeat () const
int64_t	sequence () const
void	restart (Timestamp now)

静态 Public 成员函数
static int64_t	numCreated ()

Private 属性
const TimerCallback	callback_ 定时器激活的回调函数
Timestamp	expiration_ 下一次时间间隔
const double	interval_ 超时时间间隔，如果是一次性设置0
const bool	repeat_ 是否重复
const int64_t	sequence_ 定时器序号

静态 Private 属性
static AtomicInt64	s_numCreated_ 定时器的计数

#ifdef __GXX_EXPERIMENTAL_CXX0X__Timer(TimerCallback&& cb, Timestamp when, double interval): callback_(cb),expiration_(when),interval_(interval),repeat_(interval > 0.0),sequence_(s_numCreated_.incrementAndGet()) // 定时器的序号= 定时器计数+1，计数从0开始// incrementAndGet是一个一个加1的原子操作{ }
void run() const
{callback_(); // 执行回调函数
}
// 重置定时器
void Timer::restart(Timestamp now)
{if (repeat_) // 重新计算下一个超时时刻{expiration_ = addTime(now, interval_); // 将当前时间+时间间隔，得出下一个时刻// 这个对象只有一个64位整数，就懒得用引用传递了，直接把值放到8字节的寄存器当中}else{expiration_ = Timestamp::invalid(); // 如果不是一个重复的定时器，就意味着非法时间}
}

在对用户操作上，定时器并没有去直接调用而是在EventLoop

1. runAt 在某个时刻运行定时器
2. runAfter 过一段时间运行定时器
3. runEvery 每隔一段时间运行定时器
4. cancel 取消定时器

TimerQueue内部维护了一个定时器列表，Timer只是对定时逻辑的操作并没有直接调用定时器相关函数，是一种高层次的抽象封装

muduo::net::TimerQueue类 参考

#include <TimerQueue.h>

继承自 noncopyable .

muduo::net::TimerQueue 的协作图:

[图例]

Public 成员函数

Public 成员函数
	TimerQueue (EventLoop *loop
	~TimerQueue ()
TimerId	addTimer (const TimerCallback &cb, Timestamp when, double interval)
void	cancel (TimerId timerId)

Private 类型
typedef std::pair< Timestamp, Timer * >	Entry
typedef std::set< Entry >	TimerList
typedef std::pair< Timer *, int64_t >	ActiveTimer
typedef std::set< ActiveTimer >	ActiveTimerSet

Private 成员函数
void	addTimerInLoop (Timer *timer)
void	cancelInLoop (TimerId timerId)
void	handleRead ()
std::vector< Entry >	getExpired (Timestamp now) 返回超时的定时器列表
void	reset (const std::vector< Entry > &expired, Timestamp now)
bool	insert (Timer *timer)

Private 属性
EventLoop *	loop_ 所属的eventloop
const int	timerfd_ 保存的是定时器的文件描述符
Channel	timerfdChannel_ 定时器的通道，当定时器到期可读事件产生，回调函数 handleRead()
TimerList	timers_ 按照到期时间排序的定时器列表
ActiveTimerSet	activeTimers 按照对象地址进行排序的定时器列表
bool	callingExpiredTimers_ 是否处理调用处理超时定时器当中
ActiveTimerSet	cancelingTimers_ 被取消的定时器列表

TimerQueue值对外提供了addTimer和cancel添加和取消定时器

typedef std::pair< Timestamp, Timer * > 存储定时器对象和定时器的地址

typedef std::set< Entry > 存储的是唯一的key值对

typedef std::pair<Timestamp, Timer*> Entry; typedef std::set<Entry> TimerList; // 存储定时器的列表typedef std::pair<Timer*, int64_t> ActiveTimer; // 定时器地址和序号typedef std::set<ActiveTimer> ActiveTimerSet;
// 存储的是一样的，这两个集合都是定时器列表，只是一个以时间排序一个以地址排序

可以被其他线程调用，意味着可以属于不同的eventloop调用

需要能够快速根据当前时间找到已到期的定时器，也要高效的添加和删除定时器，因此使用二叉树

两个对外暴露的接口addTimer添加一个定时器

/// 构造函数
TimerQueue::TimerQueue(EventLoop *loop): loop_(loop),timerfd_(createTimerfd()), // 创建一个定时器timerfdChannel_(loop, timerfd_),timers_(),callingExpiredTimers_(false)
{timerfdChannel_.setReadCallback(boost::bind(&TimerQueue::handleRead, this));timerfdChannel_.enableReading();
}

​ timerfdChannel_.enableReading();

将定时器的文件描述符添加到epoller类中

->update->UpdateChannel->updateChannel

/*** @brief 增加一个定时器* * @param cb  定时器的回调函数* @param when 超时事件* @param interval 间隔时间* @return TimerId */
TimerId TimerQueue::addTimer(const TimerCallback &cb, Timestamp when,double interval)
{ Timer *timer = new Timer(cb, when, interval); // 构造定时器对象 是线程安全的，并且注册回调函数/* 原有写法，线程安全loop_->runInLoop(boost::bind(&TimerQueue::addTimerInLoop, this, timer));return TimerId(timer, timer->sequence());*/addTimerInLoop(timer);return TimerId(timer,timer->sequence());
}

构造函数中timerfd_(createTimerfd()) 创建一个被用于监听的定时器文件描述符

1 timerfd 介绍

timerfd是Linux为用户程序提供的一个定时器接口。
这个接口基于文件描述符，通过文件描述符的可读事件进行超时通知，所以能够被用于select/poll/epoll的应用场景。

man 2 timerfd_create

These system calls create and operate on a timer that delivers timer expiration notifications via a file descriptor. They provide an alternative to the use of setitimer(2) or timer_create(2), with the advantage
that the file descriptor may be monitored by select(2), poll(2), and epoll(7).

// 创建定时器文件描述符
#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/timerfd.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <atomic>#define handle_error(msg)   \do                      \{                       \perror(msg);        \exit(EXIT_FAILURE); \} while (0)
using namespace std;
atomic<int> fd_;
static void print_elapsed_time()
{static struct timespec start;struct timespec curr;static int first_call = 1;int secs, nsecs;if (first_call){first_call = 0;if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)handle_error("clock_gettime");}if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1)handle_error("clock_gettime");secs = curr.tv_sec - start.tv_sec;nsecs = curr.tv_nsec - start.tv_nsec;if (nsecs < 0){secs--;nsecs += 1000000000;}printf("%d.%03d: ", secs, (nsecs + 500000) / 1000000);
}
void printids(const char *s)
{uint64_t exp;pid_t pid;pthread_t tid;pid = getpid();tid = pthread_self();int fd = fd_.load();read(fd_.load(),&exp,0);cout<<"exp = "<<(unsigned long long)exp<<endl;printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,(unsigned int)tid, (unsigned int)tid);
}
void *thr_fn(void *arg)
{printids("new thread: ");return NULL;
}int main(int argc, char *argv[])
{itimerspec new_value;int max_exp, fd;struct timespec now;uint64_t exp, tot_exp;ssize_t s;if ((argc != 2) && (argc != 4)){fprintf(stderr, "%s init-secs [interval-secs max-exp]\n",argv[0]);exit(EXIT_FAILURE);}if (clock_gettime(CLOCK_REALTIME, &now) == -1)handle_error("clock_gettime");new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]); // 定时器的初始到期时间 秒new_value.it_value.tv_nsec = now.tv_nsec;           // 纳秒单位if (argc == 2){new_value.it_interval.tv_sec = 0; // 周期性间隔max_exp = 1;}else{new_value.it_interval.tv_sec = atoi(argv[2]); // 定时器的周期性间隔max_exp = atoi(argv[3]);        }new_value.it_interval.tv_nsec = 0;int t = timerfd_create(CLOCK_REALTIME, 0);fd_.exchange(t);fd = timerfd_create(CLOCK_REALTIME, 0); // 创建定时器文件描述符if (fd_.load() == -1)handle_error("timerfd_create");if (timerfd_settime(fd_.load(), TFD_TIMER_ABSTIME, &new_value, NULL) == -1) // 启动定时器文件描述符handle_error("timerfd_settime");int err;pthread_t ntid;print_elapsed_time(); // 打印当前时钟的值printf("timer started\n");for (tot_exp = 0; tot_exp < max_exp;){cout << "等待中" << endl;err = pthread_create(&ntid, NULL, thr_fn, NULL);s = read(fd_.load(), &exp, sizeof(uint64_t)); // 一旦文件描述符就绪了，才会解除阻塞状态if (s != sizeof(uint64_t))handle_error("read");tot_exp += exp;print_elapsed_time();printf("read: %llu; total=%llu\n",(unsigned long long)exp,(unsigned long long)tot_exp);}exit(EXIT_SUCCESS);
}

$g++ test_timer.cc -lpthread -std=c++11
$./a.out 2 5 2 
# 定时器测试用例

2 创建定时器，设置非阻塞模式

int createTimerfd(){int timerfd = ::timerfd_create(CLOCK_MONOTONIC,TFD_NONBLOCK | TFD_CLOEXEC); // 创建一个定时器，非阻塞模式if (timerfd < 0){LOG_SYSFATAL << "Failed in timerfd_create";}return timerfd;}

3 插入定时器

该接口对外暴露的是addTimer 真正工作的是insert函数，具体实现并不暴露给用户

void TimerQueue::addTimerInLoop(Timer *timer)
{loop_->assertInLoopThread();bool earliestChanged = insert(timer); // 插入一个定时器时，它的过期时间可能会影响到最先到期的定时器，改变序列if (earliestChanged) // 是否需要改变序列,并且重置定时器的超时时刻{resetTimerfd(timerfd_, timer->expiration());}
}

1 对内封装的插入实现

bool TimerQueue::insert(Timer *timer)
{loop_->assertInLoopThread();assert(timers_.size() == activeTimers_.size()); // 断言，两个列表大小是否一样bool earliestChanged = false;					// 到期时间是否需要改变标志位Timestamp when = timer->expiration();			// 取出要添加的定时器的到期时间TimerList::iterator it = timers_.begin();		// 时间最早的定时器，set默认是从小到大排列的if (it == timers_.end() || when < it->first)	// 如果新插入的定时器到期时间小于 容器中定时器的最小时间 或者该容器为空的情况下{earliestChanged = true;						// 将标志置为1}{std::pair<TimerList::iterator, bool> result = timers_.insert(Entry(when, timer)); // 把新的定时器分别插入到两个容器中去assert(result.second);(void)result; // 写法还是为了取消wall}{std::pair<ActiveTimerSet::iterator, bool> result = activeTimers_.insert(ActiveTimer(timer, timer->sequence()));assert(result.second);(void)result;}assert(timers_.size() == activeTimers_.size());return earliestChanged;
}

2 插入时需要重置超时时刻

void resetTimerfd(int timerfd, Timestamp expiration) // 把当前新插入的超时时间取出来{struct itimerspec newValue{};struct itimerspec oldValue{}; // 这里稍微改了一下，使用列表初始化为空就不需要调用memset或者bzero了newValue.it_value = howMuchTimeFromNow(expiration); // 是把muduo/base的类转成了一个可用于时间的类型int ret = ::timerfd_settime(timerfd, 0, &newValue, &oldValue); // 把新的超时时间设置进去if (ret){ LOG_SYSERR << "timerfd_settime()";}}

3 重置时需要对时间类和时间戳进行换算

struct timespec howMuchTimeFromNow(Timestamp when){int64_t microseconds = when.microSecondsSinceEpoch() - Timestamp::now().microSecondsSinceEpoch(); // 获取传入的时间戳-当前的时间戳if (microseconds < 100){microseconds = 100; // 精确到100}struct timespec ts;ts.tv_sec = static_cast<time_t>(microseconds / Timestamp::kMicroSecondsPerSecond); // 除以100W 换算到秒单位ts.tv_nsec = static_cast<long>((microseconds % Timestamp::kMicroSecondsPerSecond) * 1000); // 换算到纳秒单位return ts;}

3 定时器回调事件

TimerQueue::TimerQueue(EventLoop *loop)中已经通过setReadCallback设置了事件回调函数：TimerQueue::handleRead把传入的所属eventloop和定时器文件描述符传入

void TimerQueue::handleRead()
{loop_->assertInLoopThread();Timestamp now(Timestamp::now()); // 获取当前时间readTimerfd(timerfd_, now);		 // 处理就绪的文件描述符std::vector<Entry> expired = getExpired(now); // 获取该时刻的所有定时器列表，即超时被就绪的定时器callingExpiredTimers_ = true; // 处于处理定时器到期状态中cancelingTimers_.clear();	  // 把已经被取消的定时器清空掉for (std::vector<Entry>::iterator it = expired.begin();it != expired.end(); ++it){it->second->run(); // 循环调用定时器处理的回调函数}callingExpiredTimers_ = false; // 处理完毕reset(expired, now); // 不是一次性定时器，需要重启
}

1 处理就绪定时器文件描述符

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";}}

2 获取该时刻所有定时器，即超时的定时器

getExpired (Timestamp now) 返回超时的定时器列表

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));// UINTPTR_MAX设置最大地址// 防止有可能，now 和Timer是一样大的TimerList::iterator end = timers_.lower_bound(sentry);// lower_bound二分查找返回第一个值 >= sentry的迭代器，返回第一个大于当前时间片的迭代器位置assert(end == timers_.end() || now < end->first); // 断言当前时间片的定时器是最大的，跑到整个迭代器后面了// 或者当前时间小于返回的第一个大于当前的时间的位置// 如果now == *end(),会激发UINTPTR_MAX的作用，哨兵值std::copy(timers_.begin(), end, back_inserter(expired));// 把从begin()->第一个未到期的定时器的区间，用push_back()的方法拷贝到expired列表里面timers_.erase(timers_.begin(), end); // 把到期的定时器给移除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;
}

queue只关注最早的定时器时间片

3 使用实例

/// 探究是否像对源码分析一样定时器重置条件
void prints(const char *msg)
{printf("==========================\n,%s\n",msg);
}
int main()
{printTid();sleep(1);{EventLoop loop;g_loop = &loop;print("main");loop.runAfter(2,boost::bind(prints,"打我呀"));// 注册的回调函数和定时器，分别是2秒和1秒loop.runAfter(1,boost::bind(prints,"哈哈哈"));loop.loop(); // 开启事件轮询print("main loop exits");}
}

输出结果

因为1秒这个定时器，会导致之前2秒的定时器不再是最小的过期时间了

msg 1642152525.200913 main
插入一个定时器
需要重置定时器的超时时刻
插入一个定时器
需要重置定时器的超时时刻
20220114 09:28:45.200953Z 19142 TRACE loop EventLoop 0x7FFD2E1BA050 start looping - EventLoop.cc:70
20220114 09:28:46.200961Z 19142 TRACE poll 1 events happended - EPollPoller.cc:65
20220114 09:28:46.201379Z 19142 TRACE printActiveChannels {4: IN } - EventLoop.cc:163

4 重启非一次性定时器

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);insert(it->second);}else{// 一次性定时器或者已被取消的定时器是不能重置的，因此删除该定时器delete it->second; // FIXME: no delete please}}if (!timers_.empty()){// 获取最早到期的定时器超时时间nextExpire = timers_.begin()->second->expiration();}if (nextExpire.valid()){// 重置定时器的超时时刻(timerfd_settime)resetTimerfd(timerfd_, nextExpire);}
}

5 取消定时器

TimerId一个可见的类，用于取消定时器

class TimerId : public muduo::copyable
{public:TimerId(): timer_(NULL),sequence_(0){}TimerId(Timer* timer, int64_t seq): timer_(timer),sequence_(seq){}friend class TimerQueue;private:Timer* timer_; // 定时器的地址int64_t sequence_;// 定时器的序号
};
}
}

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;delete it->first; // FIXME: no delete pleaseactiveTimers_.erase(it); // 两个列表的都要移除}else if (callingExpiredTimers_) // 如果不在列表中，说明已经被移除了{cancelingTimers_.insert(timer); // 把定时器插入到取消列表中}assert(timers_.size() == activeTimers_.size());
}

pyable
{
public:
TimerId()
: timer_(NULL),
sequence_(0)
{
}

TimerId(Timer* timer, int64_t seq)

timer_(timer),
sequence_(seq)
{
}
friend class TimerQueue;
private:
Timer* timer_; // 定时器的地址
int64_t sequence_;// 定时器的序号
};
}
}

```cpp
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;delete it->first; // FIXME: no delete pleaseactiveTimers_.erase(it); // 两个列表的都要移除}else if (callingExpiredTimers_) // 如果不在列表中，说明已经被移除了{cancelingTimers_.insert(timer); // 把定时器插入到取消列表中}assert(timers_.size() == activeTimers_.size());
}