muduo源码分析：Channel类 (事件分发器)

蔚落 2022-05-15 19:00 245阅读 0赞

### 事件分发类Channel ###

事件分发器Channel的数据成员如下:

//定义事件类型变量
                static const int kNoneEvent;    //无事件
                static const int kReadEvent;    //可读事件
                static const int kWriteEvent;   //可写事件
    
                EventLoop *loop_;               //channel所属的loop
                const int fd_;                  //channel负责的文件描述符
                int events_;                    //注册的事件
                int revents_;                   //poller设置的就绪的事件
                int index_;                     //被poller使用的下标
                bool logHup_;                   //是否生成某些日志
    
                boost::weak_ptr<void> tie_; //
                bool tied_;
                bool eventHandling_;                //是否处于处理事件中
                bool addedToLoop_;
                ReadEventCallback readCallback_;    //读事件回调
                EventCallback writeCallback_;       //写事件回调
                EventCallback closeCallback_;       //关闭事件回调
                ReadEventCallback errorCallback_;   //错误事件回调

其中EventCallback和ReadEventCallback的声明如下:

typedef boost::function<void()> EventCallback;        //事件回调函数对象类型
     typedef boost::function<void(Timestamp)> ReadEventCallback;    //读事件回调函数对象类型

//处理事件
            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;
            }
    
            void tie(const boost::shared_ptr<void>&);
    
    
    
            //返回注册的事件
            int events()const
            {
                return events_;
            }
    
            //设置就绪的事件
            void set_revents(int revt)
            {
                revents_ = revt;
            }
    
            //判断是否注册的事件
            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;
            }
    
            //是否注册可读事件
            bool isReading() const
            {
                return events_ & kReadEvent;
            }

Channel的主要功能为管理各种注册给poller的套接字描述符及其上发生的事件，以及事件发生了调用事件的回调函数。

Channel的主要作用如下：

1.首先我们给定Channel所属的loop以及其要处理的fd
    2.接着我们开始注册fd_上需要监听的事件,如果是常用事件(读写等)的话，我们可以直接调用接口enable***来注册对应fd上的事件，与之对应的是disable***用来销毁特定的事件
    3.再然后我们通过set***Callback来事件发生时的回调

### Channel完整代码： ###

**Channel.h:**

#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;
    
    
    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; }
    
      void tie(const boost::shared_ptr<void>&);
    
      int fd() const { return fd_; }
      int events() const { return events_; }			//返回注册的事件
      void set_revents(int revt) { revents_ = revt; }		// 设置发生的事件:poller中调用
      // 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; }	//是否注册可写事件
      bool isReading() const { return events_ & kReadEvent; }	//是否注册可读事件
    
      // for Poller
      int index() { return index_; }			//返回poll事件数组中的序号
      void set_index(int idx) { index_ = idx; }
    
      // for debug
      string reventsToString() const;
      string eventsToString() const;
    
      void doNotLogHup() { logHup_ = false; }
    
      EventLoop* ownerLoop() { return loop_; }
      void remove();
    
     private:
      static string eventsToString(int fd, int ev);
    
      void update();
      void handleEventWithGuard(Timestamp receiveTime);
    
      static const int kNoneEvent;	//无事件
      static const int kReadEvent;	//可读事件
      static const int kWriteEvent;	//可写事件
    
      EventLoop* loop_;				//channel所属的EventLoop
      const int  fd_;				//channel负责的文件描述符，但不负责关闭该文件描述符
      int        events_;			//注册的事件
      int        revents_;			//poller返回的就绪的事件
      int        index_;			//表示在poll的事件数组中的序号
      bool       logHup_;			//是否生成某些日志
    
      boost::weak_ptr<void> tie_;
      bool tied_;
      bool eventHandling_;			//是否处于处理事件中
      bool addedToLoop_;
      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),
        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 boost::shared_ptr<void>& obj)
    {
      tie_ = obj;
      tied_ = true;
    }
    
    void Channel::update()			//添加事件分发器
    {
      addedToLoop_ = true;
      loop_->updateChannel(this);
    }
    
    void Channel::remove()			//移除事件分发器
    {
      assert(isNoneEvent());
      addedToLoop_ = false;
      loop_->removeChannel(this);
    }
    
    void Channel::handleEvent(Timestamp receiveTime)		//核心：事件处理函数
    {
      boost::shared_ptr<void> guard;
      if (tied_)
      {
        guard = tie_.lock();
        if (guard)
        {
          handleEventWithGuard(receiveTime);				//调用handleEventWithGuard
        }
      }
      else
      {
        handleEventWithGuard(receiveTime);
      }
    }
    
    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;
    }
    
    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().c_str();
    }