muduo网络库浅谈（一）
muduo网络库浅谈（一）
- 序言
- 第一章 muduo的关键结构
-
- class EventLoop
- class Channel
- class Poller
- 番外
-
- 定时任务
-
- class Timestamp
- class Timer
- class TimerQueue
- class EventLoop调整
- 在线程中创建并执行EventLoop
序言
C++的学习过程充满着迷茫，C++primer，侯捷老师的STL源码剖析，再到boost库，C++多线程库，纷繁复杂的数据结构，以及为了效率无所不用其极的函数重载，shared_ptr的线程安全性，多线程访问时数据竞争，C++对于C的进步在于安全的内存管理，以及大量库支持，避免了我们重复造轮子的过程。最近看了陈硕老师的muduo网络库，该网络库是一个C++网络服务中的经典，muduo库的意义在于：“奋木铎以警众，使明听也”，为了不至于看久了忘记，就撰写这篇博文，本博客将会从程硕老师的出版图书《Linux多线程服务端编程 使用muduo C++网络库》的第八章开始讲解（某东上打折很给力，买来看看还是很值得的！希望大家支持正版）。
在正式介绍之前不妨先思考一下网络库的设计需求，设立几个小目标。
1.一个单线程的事件处理机制。
2.一个基于网络通信的事件处理（举例来说，对通信时间进行处理以及处理后发送的处理机制）。
3.多线程下实现上述1，2要求。
接下来将分为三个章节来讲述要求1,2,3，的源码解读。
第一章 muduo的关键结构
class EventLoop
muduo网络库将网络服务通信的各个流程中的环节封装成不同的class，高度模块化的设计使得以后拓展接口提供了极大地便利，class EventLoop是网络库的重要组成部分，初始EventLoop什么也不做，代码如下：
#ifndef MUDUO_NET_EVENTLOOP_H
#define MUDUO_NET_EVENTLOOP_H
#include "thread/Thread.h"
namespace muduo
{
class EventLoop : boost::noncopyable
{
public:
EventLoop();
~EventLoop();
void loop();
void assertInLoopThread()
{
if (!isInLoopThread())
{
abortNotInLoopThread();
}
}
bool isInLoopThread() const {
return threadId_ == CurrentThread::tid(); }
private:
void abortNotInLoopThread();
bool looping_;
const pid_t threadId_;
};
}
#endif
可以看到EventLoop定义有构造，析构，loop，isInLoopThread，abortNotInLoopThread等函数，成员函数的定义如下：
#include "EventLoop.h"
#include "logging/Logging.h"
#include 其中t_loopInThisThread属于thread变量，存储当前线程的EventLoop指针，初始为0，在构造函数中，对事件循环的looping_标志位，以及线程号进行初始化（一个EventLoop对应一个线程，避免多线程下的数据竞争以及访问逻辑混乱的情况，所以使用大量assertInLoopThread以及boost：noncopyable以保证EventLoop在本线程中运行），LOG_TRACE 等属于日志，便于意外情况下对服务器运行情况的分析，以后不再赘述。
析构函数太过简单不需要解释；loop（）函数用于正式启用事件循环，本例中loop（）并不完全，poll函数属于IO复用，之后会讲解。abortNotInLoopThread()将线程运行错误输入日志。以上便是一个EventLoop的基本结构，但并不涉及具体的事件处理机制。
class Channel
在介绍class Channel之前，不得不说说Linux下IO复用——poll函数。
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
pollfd为poll函数需要监听的事件，nfds为需要监听事件的数量，pollfd为
struct pollfd{
int fd; //文件描述符
short events; //需要监听的事件
short revents; //实际发生的事件
};
Linux一大特色便是万物皆文件，int fd指定了一个文件描述符，poll函数会根据events（用户设置）来监听fd，并根据发生的事件重写revents，并返回具体事件发生的数量。
因此对于上述调用poll环节可以分为class Channel和class Poller两部分！以下为class Channel的源码：
#ifndef MUDUO_NET_CHANNEL_H
#define MUDUO_NET_CHANNEL_H
#include 成员函数的实现：
#include "Channel.h"
#include "EventLoop.h"
#include "logging/Logging.h"
#include 可以看出，class Channel的功能主要在于创建事件pollfd以及相应的回调函数（一个需要监听的事件pollfd对应一个Channel，一个Channel也唯一属于一个EventLoop，相同的事件不需要在不同的EventLoop中重复的监听，逻辑上是没必要的，因此一个事件的Channel具有唯一性，boost::noncopyable），唯一没有介绍的是 enableReading()以及int index，enableReading()代表一个Channel实例已经可读，并调用自身的私有函数update（），继而调用EventLoop的updateChannel()成员函数向EventLoop注册自己，表示自己需要加入到poll的监听队列（此处的队列是一种说法，并非数据结构）中，index用于表明在监听队列中的编号。
那么问题来了，具体内部注册具有是怎么实现的呢？不妨将这个问题设为问题1
根据上述问题，EventLoop则需要改变一下，增加新的成员函数，新的代码如下：
#ifndef MUDUO_NET_EVENTLOOP_H
#define MUDUO_NET_EVENTLOOP_H
#include "thread/Thread.h"
#include 成员函数如下：
#include "EventLoop.h"
#include "Channel.h"
#include "Poller.h"
#include "logging/Logging.h"
#include 以上的代码并没有增加太多的成员函数，但也没有解释问题1——Channel是怎么注册的（EventLoop把问题推给了Class Poller），同时在loop（）函数中调用了Class Poller的成员函数，私有成员中增加boost::scoped_ptr poller_（这很好理解，Poller内部封装由poll的功能，EventLoop独自拥有一个Class Poller的实例就可以实现监听所有的Channel），至此，所有的问题都推给了Class Poller，代码如下：
class Poller
#ifndef MUDUO_NET_POLLER_H
#define MUDUO_NET_POLLER_H
#include
#include 中int为pollfd->fd,也就是时class Channel的成员fd_。
EventLoop* ownerLoop_;//
PollFdList pollfds_;//
ChannelMap channels_;//
};
}
#endif
上述中pollfds_为vector，用于高效地随机访问（Channel中保存了在vector中的下标index），channels_使用map来管理，实现高效地查找，删除和插入Channel（尽管当前没有实现删除）。
再看看成员函数的实现：
#include "Poller.h"
#include "Channel.h"
#include "logging/Logging.h"
#include class Poller的主要作用是维护EventLoop所拥有的的Channel，其成员函数poll用于事件的监听，并返回活跃事件，以及updateChannel（）函数向Poller中添加Channel，不过当前的class Poller不具有移除Channel的作用，只能不断的向pollfds_和channels_添加。
以下为三个class的关键函数loop（）和enableReading（）的调用循序：
番外
为了给EventLoop根据一定周期执行某个函数，设计出响应的定时器功能，定时器由class TimerId，Timer，TimerQueue，三个来实现的，接下来将一一介绍。
定时任务
首先需要明确两点：1、定时器的作用，无论EventLoop由多少个定时任务，仅需要一个class就可以集中的管理；2、poll是阻塞的，一旦监听的文件描述符没有发生事件，则会阻塞，那么定时任务无法得到及时的执行，所以需要将计时任务作为一个监听事件（也就是Channel）来实现定时的唤醒，计算有哪些计时器到期，执行对应的函数。这样我们就明确了class TimerQueue的功能了！
但在介绍class TimerQueue之前，需要先介绍几个class以便更好地理解定时器的实现：
class Timestamp
class Timestamp的主要作用是保存时间戳（int64_t microSecondsSinceEpoch_;），以及重载了一些运算符，提供了一些如toString()，now（）等接口，具体的成员函数的实现不讲了，简单讲一下头文件中成员的作用。
#ifndef MUDUO_BASE_TIMESTAMP_H
#define MUDUO_BASE_TIMESTAMP_H
#include "copyable.h"
#include class Timer
上小节class Timestamp构成class Timer的成员，class Timer顾名思义：定时器！首先来明确定时器的作用，EventLoop可以拥有数个定时任务，那么单个定时器不仅需要保存时间戳，定时时间，是否循环，以及相应的时间回调函数。一下为class Timer的头文件：
#ifndef MUDUO_NET_TIMER_H
#define MUDUO_NET_TIMER_H
#include class TimerQueue
接下来就是class TimerQueue的正体了，class TimerQueue为定时器队列，先来明确class TimerQueue的实现任务：1、提供对外接口——增加定时任务；2、创建一个timerfd（LInux新增了timerfd作为定时任务，用法和上文的pollfd一样，当超时后发生可读事件，所以同样需要Channel，暂且把这个Channel叫他timerqueue Channel，timerqueue Channel对应一个回调函数），并使用poll来监听，对该文件描述符可读事件进行超时通知，从poll返回后调用timerqueue Channel的回调函数，该回调函数会检查class TimerQueue所有定时器是否到期，调用其到期的Timer的回调函数。上代码直接看：
#ifndef MUDUO_NET_TIMERQUEUE_H
#define MUDUO_NET_TIMERQUEUE_H
#include 成员函数定义如下：
#define __STDC_LIMIT_MACROS
#include "TimerQueue.h"
#include "logging/Logging.h"
#include "EventLoop.h"
#include "Timer.h"
#include "TimerId.h"
#include 中，并返回一个bool值，表示是否需要重新设置timerfd的超时时间
if (earliestChanged)
{
resetTimerfd(timerfd_, timer->expiration());
}
return TimerId(timer);
}
void TimerQueue::handleRead()//handleRead()为向Channel注册的可读事件的回调函数，主要功能是找到到期的Timer，并执行响应的Timer中的回调函数
{
loop_->assertInLoopThread();
Timestamp now(Timestamp::now());
readTimerfd(timerfd_, now);
std::vector<Entry> expired = getExpired(now);//getExpired（）返回到期的Timer的vector
// safe to callback outside critical section
for (std::vector<Entry>::iterator it = expired.begin();
it != expired.end(); ++it)
{
it->second->run();//执行Timer的回调函数
}
reset(expired, now);//重新将Timer加入到set中，set会自动对定时器的时间卓先后顺序排序
}
std::vector<TimerQueue::Entry> TimerQueue::getExpired(Timestamp now)//返回到期的Timer的vector
{
std::vector<Entry> expired;
Entry sentry = std::make_pair(now, reinterpret_cast<Timer*>(UINTPTR_MAX));//设置到期的最大值
TimerList::iterator it = timers_.lower_bound(sentry);//找到lower_bound
assert(it == timers_.end() || now < it->first);
std::copy(timers_.begin(), it, back_inserter(expired));//将到期Timer拷贝至vector expired中
timers_.erase(timers_.begin(), it);删除set<Entry>中到期Timer
return expired;//返回到期的Timer
}
void TimerQueue::reset(const std::vector<Entry>& expired, Timestamp now)//将expired中的Timer根据循环间隔重新加入到set的Timer队列
{
Timestamp nextExpire;
for (std::vector<Entry>::const_iterator it = expired.begin();
it != expired.end(); ++it)
{
if (it->second->repeat())
{
it->second->restart(now);
insert(it->second);
}
else
{
// FIXME move to a free list
delete it->second;
}
}
if (!timers_.empty())
{
nextExpire = timers_.begin()->second->expiration();
}
if (nextExpire.valid())
{
resetTimerfd(timerfd_, nextExpire);
}
}
bool TimerQueue::insert(Timer* timer)//插入一个timer
{
bool earliestChanged = false;
Timestamp when = timer->expiration();//返回时间戳
TimerList::iterator it = timers_.begin();
if (it == timers_.end() || when < it->first)//settimers_的第一Entry为最小的时间戳
{
earliestChanged = true;//需要重设timerfd的超时时间的bool标志
}
std::pair<TimerList::iterator, bool> result =
timers_.insert(std::make_pair(when, timer));//将Timer插入到settimers_中
assert(result.second);
return earliestChanged;//返回需要重设timerfd的超时时间的bool标志
}
洋洋洒洒标注了那么多，估计会看晕，但要点只有3个：
1、从构造函数上看，只有创建timerfd，创建Channel，注册回调函数和Channel，之后的事情就是其他class的问题了。
2、而另一个重要的功能就是添加定时器——TimerQueue::addTimer(const TimerCallback& cb,…)，该函数添加一个定时器需要维护timerfd的超时时间（超时时间需要根据timers中最小的时间戳来决定），以及一个定时器列表，该列表根据时间戳从小到大排列，这也是为什么该列表使用set来实现的且set
3、timerfd超时后调用的回调函数handleRead()，该函数会从set
实际流程图如下：
构造函数注册
poll对timerfd超时后的调用顺序
addtimer函数的调用顺序就不写了，基本也就那么个顺序。
TimerQueue对外接口的函数只有一个，addtimer（），只要在EventLoop中加入TimerQueue，定义相关调用addtimer（）成员函数就可实现定时任务。
EventLoop新增：
TimerId EventLoop::runAt(const Timestamp& time, const TimerCallback& cb)
{
return timerQueue_->addTimer(cb, time, 0.0);
}
TimerId EventLoop::runAfter(double delay, const TimerCallback& cb)
{
Timestamp time(addTime(Timestamp::now(), delay));
return runAt(time, cb);
}
TimerId EventLoop::runEvery(double interval, const TimerCallback& cb)
{
Timestamp time(addTime(Timestamp::now(), interval));
return timerQueue_->addTimer(cb, time, interval);
}
private:
boost::scoped_ptr<TimerQueue> timerQueue_;
至此定时器暂且还算是大功告成， 需要注意的是，为了不造成数据竞争等严重问题，addtimer（）加入了loop_->assertInLoopThread()，因为如果有两个线程A，B，A线程调用addtimer（），B线程为EventLoop的所属线程，并且B线程正在调用了reset（）或getExpired(Timestamp now)，以上三个函数都会对set容器进行操作，线程安全不法保证！ 但加入了断言，使得A线程无法随心所欲的使用addtimer等函数，解决方法是EventLoop加入一个函数队列，如果不在函数执行不在B线程中则加入B线程中EventLoop的函数队列，B线程在poll阻塞结束后执行完时间，再执行函数队列中的函数，当然得考虑B线程一直阻塞的情况，那么这个函数队列永远得不到执行，继而需要增加一个Channel，用于将poll从阻塞中及时唤醒。
那么新的EventLoop如下：
class EventLoop调整
class EventLoop : boost::noncopyable
{
public:
typedef boost::function<void()> Functor;
EventLoop();
~EventLoop();
void loop();
void quit();
Timestamp pollReturnTime() const {
return pollReturnTime_; }
void runInLoop(const Functor& cb);//可以暴露给其他线程的成员，线程安全性得以保证。
void queueInLoop(const Functor& cb);//将函数加入函数队列
TimerId runAt(const Timestamp& time, const TimerCallback& cb);
TimerId runAfter(double delay, const TimerCallback& cb);
TimerId runEvery(double interval, const TimerCallback& cb);
void wakeup();//使线程从poll阻塞中返回
void updateChannel(Channel* channel);
void assertInLoopThread()
{
if (!isInLoopThread())
{
abortNotInLoopThread();
}
}
bool isInLoopThread() const {
return threadId_ == CurrentThread::tid(); }
private:
void abortNotInLoopThread();
void handleRead(); // 事件回调
void doPendingFunctors();//执行函数队列
typedef std::vector<Channel*> ChannelList;
bool looping_; /* atomic */
bool quit_; /* atomic */
bool callingPendingFunctors_; //正在执行函数队列的标识符，具有深意，能够及时的wakeup（）
const pid_t threadId_;
Timestamp pollReturnTime_;
boost::scoped_ptr<Poller> poller_;
boost::scoped_ptr<TimerQueue> timerQueue_;
int wakeupFd_;//文件描述符，属于EventLoop，对wakeupFd_写入后，poll会从阻塞中返回，及时的唤醒
boost::scoped_ptr<Channel> wakeupChannel_;
ChannelList activeChannels_;
MutexLock mutex_;//锁
std::vector<Functor> pendingFunctors_; // 函数队列
};
}
#endif
成员函数如下：
#include "EventLoop.h"
#include "Channel.h"
#include "Poller.h"
#include "TimerQueue.h"
#include "logging/Logging.h"
#include 有了runInLoop（）函数就可以对EventLoop的公有函数进行调整，实现公有函数在不同线程调用的安全性。
代码如下，因为很简单就不注释了：
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);
}
void TimerQueue::addTimerInLoop(Timer* timer)
{
loop_->assertInLoopThread();
bool earliestChanged = insert(timer);
if (earliestChanged)
{
resetTimerfd(timerfd_, timer->expiration());
}
}
在线程中创建并执行EventLoop
class EventLoopThread
上文EventLoop已经实现了大部分的功能，但无法在线程中使用，具体以代码展示来说明：
#include "EventLoop.h"
#include 在该程序中loop只能在该进程中执行，无法直接放入一个新线程中执行，或者说需要每次写一个函数来执行EventLoop的创建和运行，再将这个函数放入新线程中执行，这样不如直接提供一个线程运行的class，用于在新线程中创建EventLoop的实例，并执行loop（），返回EventLoop的指针，代码如下：
#ifndef MUDUO_NET_EVENTLOOPTHREAD_H
#define MUDUO_NET_EVENTLOOPTHREAD_H
#include "thread/Condition.h"
#include "thread/Mutex.h"
#include "thread/Thread.h"
#include 成员函数如下：
EventLoopThread::EventLoopThread()
: loop_(NULL),
exiting_(false),
thread_(boost::bind(&EventLoopThread::threadFunc, this)),//新线程执行函数的绑定
mutex_(),
cond_(mutex_)
{
}
EventLoopThread::~EventLoopThread()
{
exiting_ = true;
loop_->quit();
thread_.join();
}
EventLoop* EventLoopThread::startLoop()//启动线程
{
assert(!thread_.started());
thread_.start();
{
MutexLockGuard lock(mutex_);
while (loop_ == NULL)
{
cond_.wait();
}
}
return loop_;
}
void EventLoopThread::threadFunc()//创建EventLoop，并运行loop
{
EventLoop loop;
{
MutexLockGuard lock(mutex_);
loop_ = &loop;
cond_.notify();
}
loop.loop();
//assert(exiting_);
}
至此，muduo网络库的基本框架已经介绍完毕，第二章网络库的实现同样是基于第一章的结构之上。。。
未完待续