muduo_net库源码分析（二）（EventLoop类、Channel类、Poller类）

最新推荐文章于 2022-05-07 21:53:54 发布
最新推荐文章于 2022-05-07 21:53:54 发布
阅读量223 收藏
点赞数
分类专栏： 大并发服务器 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShenHang_/article/details/115201561
版权

1.类图

在这里插入图片描述
白色的是外部类，表示对外可见，灰色的是内部类，表示对外不可见，实心的菱形表示类之间是组合关系，空心的菱形表示类之间是聚合关系（ 处于聚合关系的两个类生命周期不同步，简单来说就是在类里面以指针形式定义其它类的对象；处于组合关系的两个类的生命周期同步）。
EventLoop类中就体现了与Poller类的组合关系，与Channel类的聚合关系，EventLoop类的几个主要的成员如下：

boost::scoped_ptr<Poller> poller_;//智能指针对象，与Poller对象关联（体现了Poller与EventLoop的组合关系）
typedef std::vector<Channel*> ChannelList;
ChannelList activeChannels_;		// Poller返回活动的通道（一个EventLoop包含多个Channel对象指针，体现了Channel与EventLoop的聚合关系）
Channel* currentActiveChannel_;	// 当前正在处理的活动通道

EventLoop类是对事件循环的抽象，一个EventLoop对象就是一个reactor，一个EventLoop对象中包含多个Channel对象指针（EventLoop类中std::vector<Channel*> activeChannels_;）；

Poller类是对IO复用的抽象，它有两个派生类PollPoller和EPollPoller，分别是对poll和epoll的封装（这里Poller是抽象类，是muduo库中唯一使用面向对象思想编程的地方，其他地方都是基于对象的思想）；

Channel类是对IO事件注册与响应的封装，它把文件描述符和所关注的事件绑定在一起，即一个Channel对象（通道）就是一个事件，Channel::update负责注册或更新IO的可读、可写等事件【调用顺序为Channel::update–>EventLoop::updateChannel–>Poller::updateChannel（多态，以PollPoller::updateChannel为例），即注册或更新IO可读、可写等事件的核心操作是在Poller::updateChannel函数中实现的，Channel::update只是一个接口】，Channel::handleEvent负责对所发生的IO事件进行处理，当Channel对象销毁的时候不关闭文件描述符，文件描述符的生存期由Socket类来控制；

Acceptor类是对被动连接的抽象，它关注的是监听套接字的可读事件（可读事件发生时通过Channel::handleEvent回调Acceptor::handleRead）；Connector类是对主动连接的抽象。

2.Channel

1.Channel是 selectable IO channel，负责注册与响应IO事件，它把文件描述符和所关注的事件绑定在一起，即一个Channel对象（通道）就是一个事件（非常关键！！！）。
2.Channel是 Acceptor、Connector、EventLoop、TimerQueue、TcpConnection的成员，生命期由后者控制（组合关系）。
3.Channel与EventLoop是聚合关系。

::poll

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
	struct pollfd {
		int fd; /* 文件描述符 */
		short events; /* 监控的事件 */
		short revents; /* 监控事件中满足条件返回的事件 */
	};

3.时序图（很重要！）

在这里插入图片描述
EventLoop::loop中调用Poller::poll（多态，以PollPoller::poll为例）–>在PollPoller::poll中调用PollPoller::fillActiveChannels返回活动的通道activeChannels_（EventLoop类的成员std::vector<Channel*>activeChannels_;）–>遍历返回的活动通道，调用Channel::handleEvent进行事件处理–>在Channel::handleEvent中判断是可读、可写等事件后再调用Channel类中相应事件的回调函数。
在这里插入图片描述
Channel类中有几个主要的public函数：

void enableReading() { events_ |= kReadEvent; update(); }//注册可读事件
void enableWriting() { events_ |= kWriteEvent; update(); }//注册可写事件
void disableWriting() { events_ &= ~kWriteEvent; update(); }
void disableAll() { events_ = kNoneEvent; update(); }//更新为“不关注事件”
void remove();//移除事件，调用这个函数之前必须先调用disableAll

Channel::enableReading–>Channel::update–>通过Channel的成员loop_（EventLoop* loop_; // 所属的EventLoop对象（一个Channel对象只能属于一个EventLoop对象））调用EventLoop::updateChannel–>Poller::updateChannel（多态，以PollPoller::updateChannel为例），也就是说，注册或更新IO的可读、可写等事件的核心操作最终都是在Poller::updateChannel函数中实现的。

至此，代码的整体架构应该大致清楚了！

4.源码

理解全在注释里。

EventLoop.h

#ifndef MUDUO_NET_EVENTLOOP_H
#define MUDUO_NET_EVENTLOOP_H

#include <vector>

#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>

#include <muduo/base/CurrentThread.h>
#include <muduo/base/Thread.h>
#include <muduo/base/Timestamp.h>

namespace muduo
{
namespace net
{

class Channel;
class Poller;
///
/// Reactor, at most one per thread.
///
/// This is an interface class, so don't expose too much details.
//EventLoop类其实就是Reactor模式的封装
class EventLoop : boost::noncopyable
{
 public:
  EventLoop();
  ~EventLoop();  // force out-line dtor, for scoped_ptr members.

  ///
  /// Loops forever.
  ///
  /// Must be called in the same thread as creation of the object.
  ///
  void loop();//该函数不能跨线程调用，只能在创建该对象的线程中调用！

  void quit();//该函数可以跨线程调用！

  ///
  /// Time when poll returns, usually means data arrivial.
  ///
  Timestamp pollReturnTime() const { return pollReturnTime_; }

  // internal usage
  void updateChannel(Channel* channel);		// 在Poller中添加或者更新通道
  void removeChannel(Channel* channel);		// 从Poller中移除通道

  void assertInLoopThread()
  {
    if (!isInLoopThread())
    {
      abortNotInLoopThread();
    }
  }
  bool isInLoopThread() const { return threadId_ == CurrentThread::tid(); }

  static EventLoop* getEventLoopOfCurrentThread();

 private:
  void abortNotInLoopThread();

  void printActiveChannels() const; // DEBUG

  typedef std::vector<Channel*> ChannelList;
  //多个线程对bool类型的变量赋值本身就是原子性操作（atomic），不需要额外处理
  bool looping_; //当前是否在执行loop函数
  bool quit_;
  bool eventHandling_;//当前是否处于事件处理状态
  const pid_t threadId_;		// 当前对象所属线程ID
  Timestamp pollReturnTime_;
  boost::scoped_ptr<Poller> poller_;//智能指针对象，与Poller对象关联（体现了Poller与EventLoop的组合关系）
  ChannelList activeChannels_;		// Poller返回活动的通道（一个EventLoop包含多个Channel对象指针，体现了Channel与EventLoop的聚合关系）
  Channel* currentActiveChannel_;	// 当前正在处理的活动通道
};

}
}
#endif  // MUDUO_NET_EVENTLOOP_H

EventLoop.cc

#include <muduo/net/EventLoop.h>

#include <muduo/base/Logging.h>
#include <muduo/net/Channel.h>
#include <muduo/net/Poller.h>

//#include <poll.h>

using namespace muduo;
using namespace muduo::net;

namespace
{
// 当前线程EventLoop对象指针
// 线程局部存储，每个线程都有，相互独立
__thread EventLoop* t_loopInThisThread = 0;

const int kPollTimeMs = 10000;
}

EventLoop* EventLoop::getEventLoopOfCurrentThread()
{
  return t_loopInThisThread;
}

EventLoop::EventLoop()
  : looping_(false),
    quit_(false),
    eventHandling_(false),
    threadId_(CurrentThread::tid()),
	poller_(Poller::newDefaultPoller(this)),//重点
	currentActiveChannel_(NULL)
{
  LOG_TRACE << "EventLoop created " << this << " in thread " << threadId_;
  // 如果当前线程已经创建了EventLoop对象，终止(LOG_FATAL)
  if (t_loopInThisThread)
  {
    LOG_FATAL << "Another EventLoop " << t_loopInThisThread
              << " exists in this thread " << threadId_;
  }
  else
  {
    t_loopInThisThread = this;
  }
}

EventLoop::~EventLoop()
{
  t_loopInThisThread = NULL;
}

// 事件循环，该函数不能跨线程调用
// 只能在创建该对象的线程中调用
void EventLoop::loop()
{
  assert(!looping_);
  // 断言当前处于创建该对象的线程中
  assertInLoopThread();
  looping_ = true;
  LOG_TRACE << "EventLoop " << this << " start looping";

  //::poll(NULL, 0, 5*1000);
  while (!quit_)
  {
    activeChannels_.clear();
    pollReturnTime_ = poller_->poll(kPollTimeMs, &activeChannels_);//返回活动的通道
    //++iteration_;
    if (Logger::logLevel() <= Logger::TRACE)
    {
      printActiveChannels();//日志记录活动的通道
    }
    // TODO sort channel by priority
    eventHandling_ = true;
    for (ChannelList::iterator it = activeChannels_.begin();
        it != activeChannels_.end(); ++it)//遍历活动的通道进行处理
    {
      currentActiveChannel_ = *it;
      currentActiveChannel_->handleEvent(pollReturnTime_);
    }
    currentActiveChannel_ = NULL;
    eventHandling_ = false;
    //doPendingFunctors();
  }

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

//该函数可以跨线程调用
void EventLoop::quit()
{
  quit_ = true;
  //如果不是在IO线程(即reactor)中调用quit，那么需要先唤醒该IO线程，因为IO线程可能处于阻塞状态
  if (!isInLoopThread())
  {
    //wakeup();//后续会给出实现
  }
}

void EventLoop::updateChannel(Channel* channel)
{
  assert(channel->ownerLoop() == this);
  assertInLoopThread();
  poller_->updateChannel(channel);
}

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

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

void EventLoop::printActiveChannels() const
{
  for (ChannelList::const_iterator it = activeChannels_.begin();
      it != activeChannels_.end(); ++it)
  {
    const Channel* ch = *it;
    LOG_TRACE << "{" << ch->reventsToString() << "} ";
  }
}

Poller.h

#ifndef MUDUO_NET_POLLER_H
#define MUDUO_NET_POLLER_H

#include <vector>
#include <boost/noncopyable.hpp>

#include <muduo/base/Timestamp.h>
#include <muduo/net/EventLoop.h>

namespace muduo
{
namespace net
{

class Channel;

///
/// Base class for IO Multiplexing
///
/// This class doesn't own the Channel objects.
class Poller : boost::noncopyable//Poller是一个抽象类
{
 public:
  typedef std::vector<Channel*> ChannelList;

  Poller(EventLoop* loop);
  virtual ~Poller();

  /// Polls the I/O events.
  /// Must be called in the loop thread.
  virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels) = 0;

  /// Changes the interested I/O events.
  /// Must be called in the loop thread.
  virtual void updateChannel(Channel* channel) = 0;

  /// Remove the channel, when it destructs.
  /// Must be called in the loop thread.
  virtual void removeChannel(Channel* channel) = 0;

  static Poller* newDefaultPoller(EventLoop* loop);

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

 private:
  EventLoop* ownerLoop_;	// 记录Poller所属的EventLoop
};

}
}
#endif  // MUDUO_NET_POLLER_H

Poller.cc

#include <muduo/net/Poller.h>

using namespace muduo;
using namespace muduo::net;

Poller::Poller(EventLoop* loop)
  : ownerLoop_(loop)
{
}

Poller::~Poller()
{
}

PollPoller.h

#ifndef MUDUO_NET_POLLER_POLLPOLLER_H
#define MUDUO_NET_POLLER_POLLPOLLER_H

#include <muduo/net/Poller.h>

#include <map>
#include <vector>

struct pollfd;

namespace muduo
{
namespace net
{

///
/// IO Multiplexing with poll(2).
///
class PollPoller : public Poller//继承于抽象类Poller
{
 public:

  PollPoller(EventLoop* loop);
  virtual ~PollPoller();

  virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels);
  virtual void updateChannel(Channel* channel);
  virtual void removeChannel(Channel* channel);

 private:
  void fillActiveChannels(int numEvents,
                          ChannelList* activeChannels) const;

  typedef std::vector<struct pollfd> PollFdList;
  typedef std::map<int, Channel*> ChannelMap;	// key是文件描述符，value是Channel*
  PollFdList pollfds_;//::poll监控的事件数组pollfds_，::poll函数的第一个参数是struct pollfd数组的首地址
  ChannelMap channels_;
};

}
}
#endif  // MUDUO_NET_POLLER_POLLPOLLER_H

PollPoller.cc

#include <muduo/net/poller/PollPoller.h>

#include <muduo/base/Logging.h>
#include <muduo/base/Types.h>
#include <muduo/net/Channel.h>

#include <assert.h>
#include <poll.h>

using namespace muduo;
using namespace muduo::net;

PollPoller::PollPoller(EventLoop* loop)
  : Poller(loop)
{
}

PollPoller::~PollPoller()
{
}

Timestamp PollPoller::poll(int timeoutMs, ChannelList* activeChannels)//timeoutMs是::poll的超时时间
{
  // XXX pollfds_ shouldn't change
  
  int numEvents = ::poll(&*pollfds_.begin(), pollfds_.size(), timeoutMs);

  /*man page中的定义
  int poll(struct pollfd *fds, nfds_t nfds, int timeout);
	struct pollfd {
		int fd; // 文件描述符
		short events; // 监控的事件
		short revents; // 监控事件中满足条件返回的事件
	};
  */

  Timestamp now(Timestamp::now());
  if (numEvents > 0)
  {
    LOG_TRACE << numEvents << " events happended";
    fillActiveChannels(numEvents, activeChannels);//将::poll返回的numEvents个事件放入活动通道中
  }
  else if (numEvents == 0)//说明::poll超时了还没有事件发生
  {
    LOG_TRACE << " nothing happended";
  }
  else
  {
    LOG_SYSERR << "PollPoller::poll()";
  }
  return now;
}

void PollPoller::fillActiveChannels(int numEvents,
                                    ChannelList* activeChannels) const
{
  for (PollFdList::const_iterator pfd = pollfds_.begin();
      pfd != pollfds_.end() && numEvents > 0; ++pfd)//遍历::poll监控的事件数组pollfds_，从中寻找::poll返回的numEvents个事件
  {
    if (pfd->revents > 0)//说明是返回的事件
    {
      --numEvents;
      ChannelMap::const_iterator ch = channels_.find(pfd->fd);//std::map<int, Channel*> channels_;// key是文件描述符，value是Channel*
      assert(ch != channels_.end());
      Channel* channel = ch->second;
      assert(channel->fd() == pfd->fd);
      channel->set_revents(pfd->revents);
      // pfd->revents = 0;
      activeChannels->push_back(channel);//把对应的channel对象指针放入活动通道
    }
  }
}

void PollPoller::updateChannel(Channel* channel)//用于注册新通道（Channel对象）或者更新已有通道（Channel对象）
{
  Poller::assertInLoopThread();//确保在Poller所属EventLoop的线程中调用
  LOG_TRACE << "fd = " << channel->fd() << " events = " << channel->events();
  if (channel->index() < 0)
  {
	  // index为-1说明是一个新的通道（新的Channel对象），需要进行注册
    // a new one, add to pollfds_
    assert(channels_.find(channel->fd()) == channels_.end());
    struct pollfd pfd;//新建一个struct pollfd类型的变量
    //对结构体变量的属性（文件描述符及要监控的事件）进行设置
    /*
    struct pollfd {
		int fd; //文件描述符
		short events; //监控的事件
		short revents; //监控事件中满足条件返回的事件
	  };
    */
    pfd.fd = channel->fd();
    pfd.events = static_cast<short>(channel->events());
    pfd.revents = 0;
    //将该变量添加到事件::poll监控的事件数组pollfds_中//std::vector<struct pollfd> pollfds_;
    pollfds_.push_back(pfd);
    int idx = static_cast<int>(pollfds_.size())-1;
    channel->set_index(idx);//一个Channel对象就是一个事件，此时就可以知道当前事件在::poll监控的事件数组pollfds_中的序号index_了
    channels_[pfd.fd] = channel;//将新组成的key-value加入channels_//std::map<int, Channel*>channels_;
  }
  else
  {
    //说明是一个已有的通道（已有的Channel对象），需要进行更新
    // update existing one
    assert(channels_.find(channel->fd()) != channels_.end());
    assert(channels_[channel->fd()] == channel);
    int idx = channel->index();
    assert(0 <= idx && idx < static_cast<int>(pollfds_.size()));
    struct pollfd& pfd = pollfds_[idx];//注意是引用
    assert(pfd.fd == channel->fd() || pfd.fd == -channel->fd()-1);
    pfd.events = static_cast<short>(channel->events());//更新struct pollfd变量中的监控事件
    pfd.revents = 0;
	  // 将一个通道暂时更改为不关注事件，但不从PollPoller中移除该通道（removeChannel中也会用到）
    if (channel->isNoneEvent())
    {
      // temporarily ignore this pollfd
	    // 暂时忽略该文件描述符的事件
	    // 这里pfd.fd可以直接设置为-1
      pfd.fd = -channel->fd()-1;	// 这样子设置是为了removeChannel优化
    }
  }
}

void PollPoller::removeChannel(Channel* channel)//用于移除已有的通道（Channel对象）
//调用顺序如下：
//1.把将要移除的Channel对象的events_成员设置成Channel::kNoneEvent//const int Channel::kNoneEvent = 0;
//2.对该Channel对象调用updateChannel
//3.对该Channel对象调用removeChannel（2和3顺序绝对不能反）
{
  Poller::assertInLoopThread();
  LOG_TRACE << "fd = " << channel->fd();
  assert(channels_.find(channel->fd()) != channels_.end());
  assert(channels_[channel->fd()] == channel);
  assert(channel->isNoneEvent());
  int idx = channel->index();
  assert(0 <= idx && idx < static_cast<int>(pollfds_.size()));
  const struct pollfd& pfd = pollfds_[idx]; (void)pfd;
  assert(pfd.fd == -channel->fd()-1 && pfd.events == channel->events());//因为将要移除的通道已经调用过updateChannel了
  size_t n = channels_.erase(channel->fd());//根据key从channels_中移除key-value
  assert(n == 1); (void)n;
  //把当前事件从::poll监控的事件数组pollfds_中移除
  if (implicit_cast<size_t>(idx) == pollfds_.size()-1)
  {
    pollfds_.pop_back();
  }
  else
  {
	// 这里移除的算法复杂度是O(1)，将待删除元素与最后一个元素交换再pop_back
    int channelAtEnd = pollfds_.back().fd;
    iter_swap(pollfds_.begin()+idx, pollfds_.end()-1);//交换迭代器
    if (channelAtEnd < 0)//取出的struct pollfd变量中的fd小于0说明最后一个元素的事件恰好是“暂时不关注事件”，需要进行还原
    {
      channelAtEnd = -channelAtEnd-1;
    }
    channels_[channelAtEnd]->set_index(idx);
    pollfds_.pop_back();
  }
}

Channel.h

// This is an internal header file, you should not include this.

#ifndef MUDUO_NET_CHANNEL_H
#define MUDUO_NET_CHANNEL_H

#include <boost/function.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

#include <muduo/base/Timestamp.h>

namespace muduo
{
namespace net
{

class EventLoop;

///
/// A selectable I/O channel.
///
/// This class doesn't own the file descriptor.
/// The file descriptor could be a socket,
/// an eventfd, a timerfd, or a signalfd
class Channel : boost::noncopyable
{
 public:
  typedef boost::function<void()> EventCallback;
  typedef boost::function<void(Timestamp)> ReadEventCallback;

  Channel(EventLoop* loop, int fd);
  ~Channel();

  void handleEvent(Timestamp receiveTime);
  void setReadCallback(const ReadEventCallback& cb)
  { readCallback_ = cb; }
  void setWriteCallback(const EventCallback& cb)
  { writeCallback_ = cb; }
  void setCloseCallback(const EventCallback& cb)
  { closeCallback_ = cb; }
  void setErrorCallback(const EventCallback& cb)
  { errorCallback_ = cb; }

  /// Tie this channel to the owner object managed by shared_ptr,
  /// prevent the owner object being destroyed in handleEvent.
  void tie(const boost::shared_ptr<void>&);

  int fd() const { return fd_; }
  int events() const { return events_; }
  void set_revents(int revt) { revents_ = revt; } // used by pollers
  // int revents() const { return revents_; }
  bool isNoneEvent() const { return events_ == kNoneEvent; }

  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(); }//更新为“不关注事件”
  bool isWriting() const { return events_ & kWriteEvent; }

  // for Poller
  int index() { return index_; }
  void set_index(int idx) { index_ = idx; }

  // for debug
  string reventsToString() const;

  void doNotLogHup() { logHup_ = false; }

  EventLoop* ownerLoop() { return loop_; }
  void remove();//移除事件，调用这个函数之前必须先调用disableAll

 private:
  void update();
  void handleEventWithGuard(Timestamp receiveTime);

  static const int kNoneEvent;//0
  static const int kReadEvent;//POLLIN | POLLPRI
  static const int kWriteEvent;//POLLOUT

  EventLoop* loop_;			// 所属的EventLoop对象（一个Channel对象只能属于一个EventLoop对象）
  const int  fd_;			// 文件描述符，但不负责关闭该文件描述符
  int        events_;		// 关注的事件
  int        revents_;		// poll/epoll实际返回的事件
  int        index_;		// used by Poller类。对于PollPoller类，index_表示Channel*在::poll的事件数组中的序号；对于EPollPoller类，index_表示事件的状态
  bool       logHup_;		// for POLLHUP

  boost::weak_ptr<void> tie_;
  bool tied_;
  bool eventHandling_;		// 是否处于处理事件中
  ReadEventCallback readCallback_;
  EventCallback writeCallback_;
  EventCallback closeCallback_;
  EventCallback errorCallback_;
};

}
}
#endif  // MUDUO_NET_CHANNEL_H

Channel.cc

#include <muduo/base/Logging.h>
#include <muduo/net/Channel.h>
#include <muduo/net/EventLoop.h>

#include <sstream>

#include <poll.h>

using namespace muduo;
using namespace muduo::net;

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

Channel::Channel(EventLoop* loop, int fd__)
  : loop_(loop),
    fd_(fd__),
    events_(0),
    revents_(0),
    index_(-1),
    //初始化列表中将index_设置为-1
    //一个Channel对象就代表一个事件
    //对于PollPoller类：
    //因为此时还没有将当前事件放入PollPoller类的成员pollfds_中//std::vector<struct pollfd> pollfds_;
    //也没有将当前Channel对象指针和fd_放入PollPoller类的成员channels_中//std::map<int, Channel*> channels_;	
    //所以在::poll监控的事件数组pollfds_中的序号index_此时并不存在，故置为-1
    //对于EPollPoller类：和PollPoller类不同，index_代表事件的状态

    logHup_(true),
    tied_(false),
    eventHandling_(false)
{
}

Channel::~Channel()
{
  assert(!eventHandling_);
}

void Channel::tie(const boost::shared_ptr<void>& obj)
{
  tie_ = obj;
  tied_ = true;
}

void Channel::update()
{
  loop_->updateChannel(this);
}

// 调用这个函数之前确保调用disableAll
void Channel::remove()
{
  assert(isNoneEvent());
  loop_->removeChannel(this);
}

void Channel::handleEvent(Timestamp receiveTime)//事件处理
{
  boost::shared_ptr<void> guard;
  if (tied_)
  {
    guard = tie_.lock();
    if (guard)
    {
      handleEventWithGuard(receiveTime);
    }
  }
  else
  {
    handleEventWithGuard(receiveTime);
  }
}

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_ & POLLNVAL)
  {
    LOG_WARN << "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;
}

string Channel::reventsToString() const
{
  std::ostringstream oss;
  oss << fd_ << ": ";
  if (revents_ & POLLIN)
    oss << "IN ";
  if (revents_ & POLLPRI)
    oss << "PRI ";
  if (revents_ & POLLOUT)
    oss << "OUT ";
  if (revents_ & POLLHUP)
    oss << "HUP ";
  if (revents_ & POLLRDHUP)
    oss << "RDHUP ";
  if (revents_ & POLLERR)
    oss << "ERR ";
  if (revents_ & POLLNVAL)
    oss << "NVAL ";

  return oss.str().c_str();
}
ShenHang_
关注
专栏目录
muduo net库学习笔记2——muduo网络库相关类图的关系、EventLoop、Channel、 Poller
qq_37299596的博客
07-18 638
Acceptor接收到客户端请求，调用TcpServer回调函数 TcpServer回调函数中创建TcpConnection对象，代表着一个Tcp连接 TcpConnection构造函数中创建Channel对象，保存客户端套接字fd和关心的事件（可读） Channel 注册自己到所属事件驱动循环（EventLoop）中的Poller上 Poller开始监听，当发现Channel被激活后将其添加到EventLoop的激活队列中 EventLoop在poll返回后处理激活队列中的Channel，调用其处理函数
Net——EventLoop类（二）、Channel类、Poller类、PollPoller类
神秘的火柴人的专栏
05-17 319
Channel的update（）会调用EventLoop的updateChannel（），会调用Poller的updateChannel（） 一个EventLoop包含多个Channel Acceptor是被动连接的抽象 Connector是主动连接的抽象 ////Channel类 ...
muduo网络库学习—EventLoop，Channel，Poller（2）
qq_41409979的博客
05-07 917
muduo网络库学习（2） 文章目录muduo网络库学习（2）前言一、oneloop per thread二、EventLoop事件循环流程1.事件循环流程2.读入数据总结 前言 本章主要记录muduo库中的事件循环功能实现即EventLoop类实现。 一、oneloop per thread 为了保证每一个线程只有一个loop循环，muduo在每个线程中创建了一个变量记录EventLoop的指针。 namespace mduo{ namespace net{ // 当前线程EventLoop对象指
26muduo_net库源码分析（二）
INGNIGHT的专栏
08-23 402
1.类图 2.Channel （1）Channel是selectable IO channel，负责注册与响应IO事件，它不拥有filedescriptor。 （2）Channel是Acceptor、Connector、EventLoop、TimerQueue、TcpConnection的成员，生命期由后者控制。 3.时序图 4.代码 EvevtLoop.h
muduo_net库源码分析（十）
ShenHang_的博客
05-06 204
创建EventLoop类的对象–>通过该对象调用EventLoop::loop–>EventLoop::loop中调用Poller::poll（多态）返回活跃的Channel对象–>调用Channel::handleEvent–>在Channel::handleEvent中，如果到来的是连接关闭事件，由于该事件是读事件，所以调用读事件回调函数（这里已经在TcpConnection类的构造函数中通过其Channel对象调用Channel::setReadCallback将TcpCo..
34muduo_net库源码分析（十）
INGNIGHT的专栏
09-10 551
1.连接关闭时序图 2.代码 1.TcpConnection.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
muduo库net源码分析二（类之间的关系）
侯彩桦
02-21 288
muduo 网络库相关的类图 白色部分是外部类，对外可见的。灰色部分是内部类，对外不可见。 EventLoop是对事件的抽象 Poller 是对IO 复用的抽象，有两个派生类，PollPoller 对poll 的封装，EPollPoller对epoll的封装 。这个地方是muduo 唯一使用面向对象封装的。 Channel 是对IO事件的注册和响应的封装 。Channel 的Update成员函数负责注册和更新IO的可读可写等事件。Channel 的handleEvent()成员函数是对所发生的IO事
muduo源码分析：EventLoop类 （核心）
amoscykl的博客
10-31 1057
4.EventLoop类的实现 EventLoop类实现了reactor的基本模式 ，它的数据定义如下： void abortNotInLoopThread(); //不在主I/O线程 void handleRead(); // waked up //将事件通知描述符里的内容读走,以便让其继续检测事件通知 void doPendingFunctors(); ...
27muduo_net库源码分析（三）
INGNIGHT的专栏
08-23 421
1.定时器函数选择 1.定时函数，用于让程序等待一段时间或安排计划任务： sleep alarm usleep nanosleep clock_nanosleep getitimer / setitimer timer_create / timer_settime / timer_gettime / timer_delete timerfd_create
muduo C++网络库 源码（linux）
05-12
深入研究muduo源码，开发者不仅可以学习到如何编写高性能的网络服务，还能理解多线程编程、事件驱动模型、时间轮算法等高级技术。通过分析muduo的实现，开发者能够提升自己在系统级编程和网络编程方面的能力，这对于...
【Muduo源码分析】muduo的EventLoop 解读
08-13 556
Muduo奉行的是每个one loop per thread，意思是每个线程只有一个EventLoop对象。在Muduo中，称创建了EventLoop对象的线程是IO线程。 我主要关注大体框架，有些细节暂时不关注。首先看看构造函数（下列源码源自Muduo的教程示例） EventLoop::EventLoop() : looping_(false), quit_(false), ...
muduo源码分析：Channel类 (事件分发器)
amoscykl的博客
10-31 2241
事件分发类Channel 事件分发器Channel的数据成员如下: //定义事件类型变量 static const int kNoneEvent; //无事件 static const int kReadEvent; //可读事件 static const int kWriteEvent; //可写事件 ...
fflush()函数
热门推荐
ShenHang_的博客
03-18 3万+
fflush()函数：更新缓存区。 头文件：#include<stdio.h> 函数定义：int fflush(FILE *stream); 函数说明：调用fflush()会将缓冲区中的内容写到stream所指的文件中去.若stream为NULL，则会将所有打开的文件进行数据更新。 fflush(stdin)：刷新缓冲区,将缓冲区内的数据清空并丢弃。 fflush(stdout)：刷新缓冲区,将缓冲区内的数据输出到设备。 看如下代码： #inlcude<stdio.h> int ma
std::bind
ShenHang_的博客
08-16 820
其实std::bind和boost::bind几乎完全一样。 普通函数使用std::bind #include <iostream> #include <functional> double callableFunc (double x, double y,double z) {return x+y-z;} int main() { std::function<double(double)> NewCallable1 = std::bind (callableF
muduo_net库源码分析（九）（TcpServer类、TcpConnection类）
ShenHang_的博客
05-02 745
Acceptor类的对象是TcpServer类的成员！Acceptor类与TcpServer类是组合关系。 Acceptor::handleRead–>在Acceptor::handleRead中，除了调用::accept外，还调用了应用层回调函数 newConnectionCallback_（这里通过Acceptor::setNewConnectionCallback将应用层回调函数newConnectionCallback_设置为TcpServer::newConnection） ...
linux pthread_atfork函数（解决在多线程程序中fork可能造成的死锁问题）
ShenHang_的博客
03-09 541
首先来看一个问题，在linux系统中，我们都知道fork会产生一个调用进程的复制，创建出一个新的进程，那么如果父进程有多个线程会不会复制父进程的多个线程呢？ 答案：子进程创建出来时只有一个线程，就是调用fork()函数的那个线程。也就是说，父进程在复制子进程的时候，只会复制当前线程的执行状态，其它线程不会复制。（https://www.cnblogs.com/wenxuanh/p/12573966.html） 在linux下，经常会调用fork来产生一个子进程，如果出现既要考虑多线程，又要考虑多进程的情况，
多线程与并发服务器常见模型
ShenHang_的博客
03-24 479
常见并发服务器方案 1.iterative(循环式/迭代式)服务器 iterative 只能使用短连接（每处理完一个连接，然后就关闭连接，称为短连接），不能使用长连接，如果使用长连接，意味着write需要转到read，那么整个程序就是一个单线程程序，如果此时有其它线程过来，没有办法接受连接，因为前一个线程还在read->write的循环中。也就是说如果使用长连接的话，这个程序只能够处理一个客户端，而不能处理多个客户端。要想让程序处理多个客户端，只能使用短连接。这种服务器不是真正意义上的并发服务器，
C++类中使用typedef和类中使用枚举类型（muduo日志类中遇到的问题）
ShenHang_的博客
03-15 448
在学习muduo_base库中的日志类时，发现了一种新鲜的语法。 1.在类的public中typedef定义的新类型，可以在类外使用类名::新类型名的方式调用。 class Test { public: 　　typedef int integer; ... }; 如果该语句放在public段中，则可以在类外部使用，如： Test::integer a=1;//声明一个变量 2.在类的public中声明了枚举类，那么可以通过类名::enum值直接访问枚举值，不需要通过对象。 测试代码如下（自己写的挺好的例
Muduo库的Buffer类设计与应用：多线程与IO模型
本文主要讲述了Muduo网络库中的Buffer类设计与使用，以及在嵌入式系统和多线程服务器环境中的应用。Muduo是一个专门针对高性能网络编程设计的C++库，它在设计上强调了线程安全性和非阻塞I/O模型，适合于多核系统中的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值