muduo-net 源码分析（一）——EvenLoop

已于 2022-07-14 17:35:56 修改
阅读量117 收藏
点赞数
分类专栏： muduo源码分析 文章标签： c++
于 2022-06-06 15:44:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50987639/article/details/125143130
版权

先序

对于事件的处理，一般来说都是使用 one loop pre thread + threadpool 的处理方式，也就是创建一个 I/O 线程用于监听文件描述符的事件，使用线程池来处理事件；每个线程只能创建一个 EvenLoop 对象，而创建 EvenLoop 的线程也就被称为 I/O 线程；

EvenLoop 的源码相当复杂，我们会先讲解 Channel 和 Poller 的源码，对于一些后面用到的代码我们会先省略不说；

这一节的主要思路在于理清 EvenLoop、Poller 和 Channel 的关系；

Channel 源码分析

重要的成员变量

对于文件套接字以及其对应的监听事件和触发事件都保存在 Channel 中；又因为 Channel 需要在其对应的 EvenLoop 中被管理，所以还会保存一个 EvenLoop 对象；
index 是一个很重要的参数，会在 Poller 中使用到，这里先不说；

EventLoop* loop_;     			//记录当前 channel 所属的 EvenLoop
const int  fd_;       			//套接字
int        events_;   			//关注事件
int        revents_;  			//触发事件
int        index_;    			//
bool       logHup_;

bool eventHandling_;                //是否处于处理事件中
bool addedToLoop_;                  //是否添加到 EvenLoop 中

//三个事件类型
static const int kNoneEvent;      
static const int kReadEvent;
static const int kWriteEvent;

const int Channel::kNoneEvent = 0;
const int Channel::kReadEvent = POLLIN | POLLPRI;   
const int Channel::kWriteEvent = POLLOUT;

//四种事件的函数指针
ReadEventCallback readCallback_;    
EventCallback writeCallback_;
EventCallback closeCallback_;
EventCallback errorCallback_;

/*以下变量本节并不讲解
std::weak_ptr<void> tie_;		
bool tied_;
*/

重要的成员函数

//构造函数和析构函数，只传递文件描述符和所属的 EvenLoop 对象
Channel(EventLoop* loop, int fd);
~Channel();

//事件处理函数
void handleEvent(Timestamp receiveTime);
void handleEventWithGuard(Timestamp receiveTime);

//注册、修改和删除事件
//注册和修改最终都是调用 update 函数
void enableReading() { events_ |= kReadEvent; update(); }
void disableReading() { events_ &= ~kReadEvent; update(); }
void enableWriting() { events_ |= kWriteEvent; update(); }
void disableWriting() { events_ &= ~kWriteEvent; update(); }
void disableAll() { events_ = kNoneEvent; update(); }
void remove();
void update();

//设置 Channel 的四种事情发生时调用的函数
typedef std::function<void()> EventCallback;      
typedef std::function<void(Timestamp)> ReadEventCallback;  
void setReadCallback(ReadEventCallback cb)
{ readCallback_ = std::move(cb); }
void setWriteCallback(EventCallback cb)
{ writeCallback_ = std::move(cb); }
void setCloseCallback(EventCallback cb)
{ closeCallback_ = std::move(cb); }
void setErrorCallback(EventCallback cb)
{ errorCallback_ = std::move(cb); }

/*以下函数本节并不讲解
void tie(const std::shared_ptr<void>&);
*/

具体函数实现

//构造函数，注意 index_ 默认是 -1，events_ 默认是 kNoneEvent 即没有任何事件
Channel::Channel(EventLoop* loop, int fd__)
  : loop_(loop),
    fd_(fd__),
    events_(0),
    revents_(0),
    index_(-1),
    logHup_(true),
    tied_(false),
    eventHandling_(false),
    addedToLoop_(false)
{
}

//析构函数只能在所属的 loop 中调用
Channel::~Channel()
{
  assert(!eventHandling_);
  assert(!addedToLoop_);
  if (loop_->isInLoopThread())
  {
    assert(!loop_->hasChannel(this));
  }
}

//调用 EvenLoop 的 updateChannel 函数
void Channel::update()
{
  addedToLoop_ = true;
  loop_->updateChannel(this);
}

//调用 EvenLoop 的 removeChannel 函数
void Channel::remove()
{
  //注意在调用 remove 之前一定要先调用 disableAll()，不然断言会失败
  assert(isNoneEvent());
  addedToLoop_ = false;
  loop_->removeChannel(this);
}

//handleEvent 实际上就是调用 handleEventWithGuard
void Channel::handleEvent(Timestamp receiveTime)
{
  /* 这一部分本节不讲解
  std::shared_ptr<void> guard;
  if (tied_)
  {
    //weak_ptr 的提升
    guard = tie_.lock();
    if (guard)
    {
      handleEventWithGuard(receiveTime);
    }
  }
  */
  else
  {
    handleEventWithGuard(receiveTime);
  }
}


//handleEventWithGuard() 函数本质上就是根据 revents 的类型来调用发生事件的函数
void Channel::handleEventWithGuard(Timestamp receiveTime)
{
  eventHandling_ = true;
  LOG_TRACE << reventsToString();
  if ((revents_ & POLLHUP) && !(revents_ & POLLIN))
  {
    if (logHup_)
    {
      LOG_WARN << "fd = " << fd_ << " Channel::handle_event() POLLHUP";
    }
    if (closeCallback_) closeCallback_();
  }

  if (revents_ & POLLNVAL)
  {
    LOG_WARN << "fd = " << fd_ << " Channel::handle_event() POLLNVAL";
  }

  if (revents_ & (POLLERR | POLLNVAL))
  {
    if (errorCallback_) errorCallback_();
  }
  if (revents_ & (POLLIN | POLLPRI | POLLRDHUP))
  {
    if (readCallback_) readCallback_(receiveTime);
  }
  if (revents_ & POLLOUT)
  {
    if (writeCallback_) writeCallback_();
  }
  eventHandling_ = false;
}

具体的函数实现后面会说，大致的过程如下：

EvenLoop ep
Channel ch(&ep, fd);
ch.setReadCallback(std::move(func));
ch.enableReading();
ch.disableAll();
ch.remove();

Poller 源码分析

muduo 中的 Poller 实际上是一个虚基类，实际的实现在 muduo/poller 目录下；也就是说 muduo 库中主要使用了 poll/epoll 进行事件监听；

重要的成员变量

EventLoop* ownerLoop_;			//所属的 EvenLoop 对象
typedef std::map<int, Channel*> ChannelMap;   //int 是文件描述符 
//注意 channels_ 访问级别是 protected，基类是可以访问的
ChannelMap channels_;			//使用 map 的原因是可以通过 key 快速定位 value

重要的成员变量及实现

//构造函数传递 EvenLoop 对象
Poller(EventLoop* loop)
  : ownerLoop_(loop)
{
}

virtual ~Poller() = default;

typedef std::vector<Channel*> ChannelList;

//非常重要的函数
virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels) = 0;

virtual void updateChannel(Channel* channel) = 0;

virtual void removeChannel(Channel* channel) = 0;

//该函数只能在所属的 evenloop 中调用
//功能就是查找当前 IO 线程是否否在 channel 对象，这也是用 map 的原因
bool hasChannel(Channel* channel) const
{
  assertInLoopThread();
  ChannelMap::const_iterator it = channels_.find(channel->fd());
  return it != channels_.end() && it->second == channel;
}

static Poller* newDefaultPoller(EventLoop* loop);

//根据环境变量生成一个子类对象传递给父类指针
//默认是使用 EPOLL 模式
Poller* Poller::newDefaultPoller(EventLoop* loop)
{
  if (::getenv("MUDUO_USE_POLL"))
  {
    return new PollPoller(loop);
  }
  else
  {
    return new EPollPoller(loop);
  }
}

void assertInLoopThread() const
{
  ownerLoop_->assertInLoopThread();
}

具体的实现先不说，主要是要理清每个类的主要作用；

EvenLoop 源码分析

EvenLoop 中的变量和函数很多，我们分开说；

重要的成员变量

bool looping_; 						//是不是在调用 poll() 中
std::atomic<bool> quit_;      		//是否退出
bool eventHandling_;				//是否在处理事件

//bool callingPendingFunctors_;		本节不讨论		

int64_t iteration_;

const pid_t threadId_;				//创建 EvenLoop 对象的线程 tid            
Timestamp pollReturnTime_;       	//调用 poll() 的时间戳，因为 readbackCall 需要一个时间戳
std::unique_ptr<Poller> poller_;  	//基类指针，这里使用 unique_ptr，说明 poller 的生命周期受 EvenLoop 管理

typedef std::vector<Channel*> ChannelList;
ChannelList activeChannels_;   		//EvenLoop 中活跃的通道
Channel* currentActiveChannel_;		//现在处理的通道

/*本节不讨论
std::unique_ptr<TimerQueue> timerQueue_;  

int wakeupFd_;                    

std::unique_ptr<Channel> wakeupChannel_;    
boost::any context_;   

mutable MutexLock mutex_;
std::vector<Functor> pendingFunctors_ GUARDED_BY(mutex_);
*/
  • 本节中最主要的变量就是 threadId_、poller_ 和 activeChannels_；
  • 一个线程只能有一个 EvenLoop，一个 EvenLoop 只能有一个 Poller，但一个 EvenLoop 可以有多个 Channel；

主要的成员函数

//本节只讨论一下函数，有一些返回参数的函数自己看看就行了
EventLoop();
~EventLoop();
void loop();
void quit();
void updateChannel(Channel* channel);       
void removeChannel(Channel* channel);       
bool hasChannel(Channel* channel);

//assertInLoopThread 函数是一个经常使用的函数，因为大部分的 EvenLoop 操作都需要在当前线程中使用
void assertInLoopThread()
{
  if (!isInLoopThread())
  {
    abortNotInLoopThread();
  }
}

//判断当前线程是不是 IO 线程
bool isInLoopThread() const { return threadId_ == CurrentThread::tid(); }

具体函数实现

__thread EventLoop* t_loopInThisThread = 0;   //线程的局部变量

//EvenLoop 需要判断当前线程有没有创建过 EvenLoop 对象
//创建一个 poller 对象
EventLoop::EventLoop()
  : looping_(false),
    quit_(false),
    eventHandling_(false),
    //callingPendingFunctors_(false),
    iteration_(0),
    threadId_(CurrentThread::tid()),		//获取创建 EvenLoop 对象的线程 tid
    poller_(Poller::newDefaultPoller(this)),	//这里是返回一个派生类指针，面向对象的思路
    //timerQueue_(new TimerQueue(this)),
    //wakeupFd_(createEventfd()),
    //wakeupChannel_(new Channel(this, wakeupFd_)),
    currentActiveChannel_(NULL)
{
  LOG_DEBUG << "EventLoop created " << this << " in thread " << threadId_;
  //判断当前线程是否已经存在 EvenLoop，如果已经存在则报错
  //一开始 t_loopInThisThread 为 0
  if (t_loopInThisThread)
  {
    LOG_FATAL << "Another EventLoop " << t_loopInThisThread
              << " exists in this thread " << threadId_;
  }
  else
  {
    t_loopInThisThread = this;
  }
  
  /*
  wakeupChannel_->setReadCallback(
      std::bind(&EventLoop::handleRead, this));
  wakeupChannel_->enableReading();
  */
}

//主要是将 t_loopInThisThread  置为 NULL
EventLoop::~EventLoop()
{
  LOG_DEBUG << "EventLoop " << this << " of thread " << threadId_
            << " destructs in thread " << CurrentThread::tid();
  /*
  wakeupChannel_->disableAll();
  wakeupChannel_->remove();
  ::close(wakeupFd_);
  */
  t_loopInThisThread = NULL;
}


//重点函数之一，只能在 IO 线程中调用
void EventLoop::loop()
{
  assert(!looping_);
  assertInLoopThread();
  looping_ = true;
  quit_ = false;  
  LOG_TRACE << "EventLoop " << this << " start looping";

  //循环条件，不退出
  while (!quit_)
  {
    //清空活跃列表
    activeChannels_.clear();
    
    //实际上 EvenLoop 的 poll() 函数就是调用 Poller 派生类的 poll() 函数
 	//在这里我们认为 poll() 函数是返回调用 poll() 的时间戳，以及返回 activeChannels_
	pollReturnTime_ = poller_->poll(kPollTimeMs, &activeChannels_);
    
    ++iteration_;

	//输出日志
    if (Logger::logLevel() <= Logger::TRACE)
    {
      printActiveChannels();
    }

    eventHandling_ = true;

    //遍历所有活跃事件，调用活跃事件的 handleEvent 函数
    //前面说过 Channel 的 handleEvent() 是根据活跃通道的 revent 来调用对应函数
    for (Channel* channel : activeChannels_)
    {
      currentActiveChannel_ = channel;
      currentActiveChannel_->handleEvent(pollReturnTime_);
    }
    
    //事件处理结束，当前没有活跃事件
    currentActiveChannel_ = NULL;
    eventHandling_ = false;
    
    //doPendingFunctors(); 		本节不解释
  }

  LOG_TRACE << "EventLoop " << this << " stop looping";
  looping_ = false;
}

//活跃事件处理完后退出循环
void EventLoop::quit()
{
  quit_ = true;
  /*
  if (!isInLoopThread())
  {
    wakeup();
  }
  */
}

//只能在 IO 线程中调用，实际上调用的是 Poller 的 updateChannel
//Channel 的 update 调用的是 EvenLoop 的 updateChannel，但实际都是调用 Poller 的 updateChannel
void EventLoop::updateChannel(Channel* channel)
{
  assert(channel->ownerLoop() == this);
  assertInLoopThread();
  poller_->updateChannel(channel);
}

//只能在 IO 线程中调用，实际上调用的是 Poller 的 removeChannel
//Channel 的 update 调用的是 EvenLoop 的 removeChannel，但实际都是调用 Poller 的 removeChannel
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);
}

bool EventLoop::hasChannel(Channel* channel)
{
  assert(channel->ownerLoop() == this);
  assertInLoopThread();
  return poller_->hasChannel(channel);
}

void EventLoop::abortNotInLoopThread()
{
  LOG_FATAL << "EventLoop::abortNotInLoopThread - EventLoop " << this
            << " was created in threadId_ = " << threadId_
            << ", current thread id = " <<  CurrentThread::tid();
}

总结

根据目前分析的函数和变量总结一下 Channel、Poller 和 EvenLoop 的关系；

  1. 首先在当前线程创建一个 EvenLoop 对象，这里会默认创建一个 Poller 对象；【默认是 epoll】
  2. 创建多个 Channel 对象，传递 EvenLoop 对象以及他们的 fd；
  3. 设置 Channel 的事件函数，并设置 Channel 对象的监听事件，enableReading()、enableWriting()…，这些函数会自动调用 update() 函数，最终调用 Poller 的 updateChannel() 函数；【uodateChannel() 的作用？】
  4. 开启循环，调用 EvenLoop 的 loop()，实际调用的是 Poller 中的 poll() 函数，然后处理活跃事件的任务；
  5. 关闭 Channel 的监听事件，调用 remove() ，实际上调用的是 Poller 的 removeChannel() 函数；
  6. 退出循环，调用 EvenLoop的 quit()；

下一节需要处理的 Poller 的派生类，主要是 poll()、updateChannel() 和 removeChannel()；我们主要以 poll 作为讲解，epoll 和 poll 差不多，对于不同的地方会做出讲解；

cyjiayou
关注
专栏目录
高并发服务器架构笔记（4）——muduo_net 源码分析
ize
08-09 761
TCP 网络编程最本质的是处理3.5个事件1. 连接建立：服务端 accept（被动）接受连接，客户端 connect （主动）发起连接。2.连接断开：主动断开（close、shutdown），被动断开（read 返回0）3 处理消息到达事件（核心）：当网络库事件循环中的可读事件触发时，将数据从内核缓冲区移动到应用缓冲区中。调用OnMessage( )函数，根据协议判断数据包是否一个完整的数据包（不
muduo-0.9.1-beta.tar.gz
11-30
这个名为“muduo-0.9.1-beta.tar.gz”的压缩包是muduo的0.9.1 Beta版本，适用于Ubuntu等Linux发行版，提供了muduo库的安装和学习资源。 一、muduo库介绍 muduo由知名C++开发者陈硕开发，它以事件驱动的方式处理...
Channel
qu1993的博客
11-09 5192
class Channel : noncopyable { public: typedef std::function<void()> EventCallback; typedef std::function<void(Timestamp)> ReadEventCallback; Channel(EventLoop* loop, int fd); ~Channel(); void handleEvent(Timestamp receiveTime); .
muduo-net 源码分析（五）——Acceptor
m0_50987639的博客
06-07 85
muduo 源码分析
muduo-net 源码分析（三）——定时器
m0_50987639的博客
06-07 333
源码分析
muduo-net 源码分析（四）—— 跨线程调用
m0_50987639的博客
06-07 279
muduo 源码分析
muduo-net 源码分析（二）——Poller 具体实现
m0_50987639的博客
06-06 100
muduo 库源码分析
muduo-net 源码分析（六）——TcpServer 和 TcpConnection（一）
m0_50987639的博客
06-07 237
muduo 源码分析
muduo-net 源码分析（七）——TcpServer 和 TcpConnection（二）
m0_50987639的博客
06-07 164
muduo 源码分析
muduo源码分析——EventLoopThreadPool和EventLoopThread
我的～～的博客
09-21 233
现在开始写EventLoop相关的类，我决定先写EventLoopThreadPool。 因为从拥有的关系上来看，TcpServer拥有一个EventLoopThreadPool，然后EventLoopThreadPool拥有若干个EventLoopThread（由TcpServer初始化时决定）。至于是不是直接拥有EventLoop，我觉得吧，可以说拥有，也不好说，因为它并没有去操作这些Even...
muduo-x:mudu-x 是一个跨平台的网络库
06-04
muduo-x就是这样一款致力于实现这一目标的网络库，它基于libuv和原始的muduo库，为开发者提供了强大的跨平台网络编程工具。 首先，我们来了解一下muduo-x的基础。muduo库最初由陈硕（Chen Shuo）设计并开源，它是一...
muduo-release.zip
06-30
使用muduo最新版编译后的文件以及头文件，可以直接放入项目中使用。注：编译之后，会在用户目录下生成一个build文件夹，该文件夹下有release-install-cpp11文件夹，里面有两个文件夹分别是include和lib，这是编译后...
muduo-master.zip_BOOST服务器_muduo
09-20
这个名为“muduo-master.zip”的压缩包，包含了完整的muduo源码，以及可能的示例和文档，是深入理解和应用muduo的宝贵资源。 muduo库的核心设计目标是提供一个线程安全、非阻塞I/O模型，以充分利用多核处理器的性能...
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1663
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
将脚本编译为pyd文件
cdinten的专栏
10-01 427
Python虽然作为一种解释性语言，通常是使用解释器处理脚本的方式完成工作，但是也具有和很多其他诸如C、C#语言等类似的方式，可以将.py文件编译为*.pyd文件，即Python动态链接库文件。关于动态链接库的优缺点这里就不展开细说了，具体介绍如何编译及使用。要将Python文件编译成.pyd文件，可以使用Cython，以下是基本的操作步骤。
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 410
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
C++：图的最短路径问题
han2205277149的博客
10-04 632
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
如何在Dev-C++中集成EasyX库：详细指南
最新发布
邓校长的编程课堂专栏
10-04 687
通过以上步骤，您已经成功在Dev-C++中集成了EasyX库。使用EasyX，您可以快速实现图形编程，绘制简单的几何图形或开发一些有趣的动画和小游戏。这对于少儿编程启蒙以及信息学竞赛的初学者来说，都是非常有用的工具。通过持续练习，孩子们不仅能掌握编程的基础，还能通过图形化编程提升逻辑思维和解决问题的能力。EasyX结合Dev-C++，为初学者提供了一个友好、易上手的编程环境，能够快速体验编程的乐趣并实现可视化的成果。
使用Muduo实现短URL服务 - Linux下的嵌入式系统实践
"Muduo网络库是一个专为Linux设计的C++网络库，用于构建高性能、多线程的网络应用程序。它不支持Windows或UDP，但提供了对TCP的高效处理。该库的一个特点是在Muduo的示例中包含了短URL服务的实现，这个服务基于一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值