muduo网络库之Channel类

本篇博客针对Channel类做下小结。

博客代码来自于陈硕的muduo网络库，github地址https://github.com/chenshuo/muduo

工作原理：

Channel对象自始至终负责一个文件描述符fd的IO事件分发，Channel对象通常被更上层的类拥有，比如TimerQueue，TimerQueue在构造期间会实例化一个定时器对象，timerfd_为该定时器fd，随后利用该定时器fd实例化一个Channel对象timerfdChannel_，设置该Channel的回调函数和events_后，Channel对象会被update到Poller的std::map<int, Channel*>映射表，这样每当Channel监听的事件得到响应时，EventLoop的loop循环会调用Channel相应的回调函数。而该Channel的回调函数和TimerQueue设置的用户回调函数通过std::bind绑定在一起，这样Channel就把事件通知和用户回调函数通过Poller::poll()连接起来了。

学习笔记：

在moduo网络库中通常将Channel对象和某个可读写的资源绑定在一起，用于实时监听该资源的读写情况。通过资源描述符fd和Channel对象注册到Poller的映射表中，将事件通知和用户回调函数连接了起来。Channel类不拥有fd，析构的时候也不需要关闭fd，Channel类会把不同的IO事件分发为不同的回调，例如ReadCallback、WriteCallback等，用户一般不会直接使用Channel类，而回使用更上层的类诸如TimerQueue、TcpConnection等。

Channel.h

#ifndef MUDUO_NET_CHANNEL_H
#define MUDUO_NET_CHANNEL_H

#include "muduo/base/noncopyable.h"
#include "muduo/base/Timestamp.h"

#include <functional>
#include <memory>

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 : noncopyable
{
 public:
  typedef std::function<void()> EventCallback;
  typedef std::function<void(Timestamp)> ReadEventCallback;

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

  //设置回调，一般是把该Channel拥有者的回调相应绑定到Channenl中
  void handleEvent(Timestamp receiveTime);
  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); }

  /// Tie this channel to the owner object managed by shared_ptr,
  /// prevent the owner object being destroyed in handleEvent.
  /*Channel通常作为其它类的成员，比如TcpConnection，而Channel的回调函数通常和TcpConnection
  通过std::bind绑定,当Poller通知该Channel的回调时，Channel会调用TcpConnection对应的回调，
  而此时TcpConnection的生命周期尚未可知，此时tie_保存TcpConnection的this指针，通过将tie_
  的weak_ptr提升为shared_ptr成功与否判断TcpConnection是否健在。*/
  void tie(const std::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; }

  //update()会将修改后的events_写入到Poller中，修改当前Channel的监听状态
  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; }
  bool isReading() const { return events_ & kReadEvent; }

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

  // for debug
  string reventsToString() const;
  string eventsToString() const;

  void doNotLogHup() { logHup_ = false; }

  EventLoop* ownerLoop() { return loop_; }
  //remove移除Poller映射表保存的Channel地址，避免悬垂指针
  void remove();

 private:
  static string eventsToString(int fd, int ev);
  //更新Channel在Poller中的监听状态(增、删、改)
  void update();
  //事件回调
  void handleEventWithGuard(Timestamp receiveTime);

  static const int kNoneEvent;
  static const int kReadEvent;
  static const int kWriteEvent;

  EventLoop* loop_;    //Channel所属的loop_
  const int  fd_;      //Channel和fd_打包注册到Poller的映射表
  int        events_;  //设置需要监听的事件类型(读、写、错误)
  int        revents_; // it's the received event types of epoll or poll
  int        index_;   // used by Poller.
  bool       logHup_;  //是否打印挂起日志

  std::weak_ptr<void> tie_; //绑定该Channel拥有者的this指针
  bool tied_;               //是否已把tie_和其他类this指针绑定
  bool eventHandling_;      //是否正在处理回调
  bool addedToLoop_;        //是否注册到Poller中监听
  ReadEventCallback readCallback_;
  EventCallback writeCallback_;
  EventCallback closeCallback_;
  EventCallback errorCallback_;
};

}  // namespace net
}  // namespace muduo

#endif  // MUDUO_NET_CHANNEL_H

Channel.cpp

#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),
    logHup_(true),
    tied_(false),
    eventHandling_(false),
    addedToLoop_(false)
{
}

Channel::~Channel()
{
  assert(!eventHandling_);
  assert(!addedToLoop_);
  if (loop_->isInLoopThread())
  {
    assert(!loop_->hasChannel(this));
  }
}

void Channel::tie(const std::shared_ptr<void>& obj)
{
  /*tie_绑定Channel拥有者的this指针，tie_是weak_ptr类型，不会延长obj的生命周期,
  当tie_提升shared_ptr失败表示Channel拥有者已经销毁了
  */
  tie_ = obj;
  tied_ = true;
}

void Channel::update()
{
  //需要通过loop_到Poller中修改Channel的监听状态
  addedToLoop_ = true;
  loop_->updateChannel(this);
}

void Channel::remove()
{
  //需要通过loop_到Poller的映射表中删除Channel的指针
  assert(isNoneEvent());
  addedToLoop_ = false;
  loop_->removeChannel(this);
}

void Channel::handleEvent(Timestamp receiveTime)
{
  std::shared_ptr<void> guard;
  if (tied_)
  {
    guard = tie_.lock();
    if (guard)
    {
      //tie_提升shared_ptr成功，说明该Channel拥有者仍然健在
      handleEventWithGuard(receiveTime);
    }
    //该Channel拥有者销毁了，什么也不做...
  }
  else
  {
    //该Channel没有拥有者
    handleEventWithGuard(receiveTime);
  }
}

void Channel::handleEventWithGuard(Timestamp receiveTime)
{
  //解析从Poller::poll()返回的revents_，执行相应的回调
  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;
}

string Channel::reventsToString() const
{
  return eventsToString(fd_, revents_);
}

string Channel::eventsToString() const
{
  return eventsToString(fd_, events_);
}

string Channel::eventsToString(int fd, int ev)
{
  std::ostringstream oss;
  oss << fd << ": ";
  if (ev & POLLIN)
    oss << "IN ";
  if (ev & POLLPRI)
    oss << "PRI ";
  if (ev & POLLOUT)
    oss << "OUT ";
  if (ev & POLLHUP)
    oss << "HUP ";
  if (ev & POLLRDHUP)
    oss << "RDHUP ";
  if (ev & POLLERR)
    oss << "ERR ";
  if (ev & POLLNVAL)
    oss << "NVAL ";

  return oss.str();
}