478-手写C++muduo库(Channel)

本是古典何须时尚 2022-09-08 03:53 137阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_33_color_FFFFFF_t_70_g_se_x_16]  
**TcpServer相当于是**muduo库提供给外部编写服务器程序的入口的一个类，相当于一个大箱子，把muduo库有关服务器的编程相关的东西，包括反应堆，事件分发器，事件回调都打包一块了。  
**我们看看它的成员变量。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_29_color_FFFFFF_t_70_g_se_x_16]  
**eventloop事件循环相当于是一个epoll，管理**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_36_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_33_color_FFFFFF_t_70_g_se_x_16 1]  
![在这里插入图片描述][4fc047e4864e4a22806567a34745acb7.png]

pooller相当于是epoll抽象的概念，用poller当做1个基类，在派生类中实现了poll和epoll  
**epoll里面还得需要监听socket**  
我们注意到，还有channel  
![在这里插入图片描述][868739d99a19449281f0bc99480cf02d.png]

**事件分发器在这里面最重要的两个东西：poller和channel**

**我们看一下channel是什么**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_34_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][65ae4e8c0cf2415aaffd1f2ae3702356.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_33_color_FFFFFF_t_70_g_se_x_16 2]

**revents是具体的发生的事件**  
channel我们理解成通道，相当于就是fd和它所绑定的感兴趣的事件 和实际上发生事件epoll\_wait返回以后在fd上发生的事件（绑定）。

**我们创建EventLoop.cc  
EventLoop.h  
TcpServer.cc  
TcpServer.h**  
**channel.cc  
channel.h**

**eventloop包含channel**  
eventloop是事件循环，相当于事件分发器一样，包含了epoll，也就是poller，另外就是epoll感兴趣的fd，以及它对应的事件和最终发生的事件被muduo库封装成channel  
这些事件最终要向poller注册，发生的事件由poller给channel通知，channel得到相应fd的事件通知 调用预置的回调操作。  
**一个线程有一个eventloop，一个eventloop有一个poller，一个poller可以监听多个channel，每个channel属于1个eventloop，1个eventloop有很多channel，这就是多路。**

## 重写channel ##

**Channel.h**

#pragma once
    
    #include "noncopyable.h"
    #include "Timestamp.h"
    
    #include <functional>
    #include <memory>
    
    class EventLoop;
    
    /**
     * 理清楚  EventLoop、Channel、Poller之间的关系   《= Reactor模型上对应 Demultiplex
     * Channel 理解为通道，封装了sockfd和其感兴趣的event，如EPOLLIN、EPOLLOUT事件
     * 还绑定了poller返回的具体事件
     */ 
     
    class Channel : noncopyable
    {
        
    public:
        using EventCallback = std::function<void()>;//事件回调 
        using ReadEventCallback = std::function<void(Timestamp)>;//只读事件的回调 
    
        Channel(EventLoop *loop, int fd);//构造函数 
        ~Channel();//析构函数 
    
        //fd得到poller通知以后，处理事件的
        //调用相应的回调方法来处理事件 
        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); }
    
        //防止当channel被手动remove掉，channel还在执行回调操作，就是上面这些回调操作 
        void tie(const std::shared_ptr<void>&);
    
        int fd() const {
         return fd_; }
        int events() const {
         return events_; }//fd所感兴趣的事件 
        int set_revents(int revt) {
         revents_ = revt; }//poller监听事件，设置了channel的fd相应事件 
    
        //设置fd相应的事件状态，要让fd对这个事件感兴趣 
        //update就是调用epoll_ctrl，通知poller把fd感兴趣的事件添加到fd上
        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(); }
    
        //返回fd当前的事件状态
        bool isNoneEvent() const {
         return events_ == kNoneEvent; }
        bool isWriting() const {
         return events_ & kWriteEvent; }
        bool isReading() const {
         return events_ & kReadEvent; }
    
        int index() {
         return index_; }
        void set_index(int idx) {
         index_ = idx; }
    
        //one loop per thread
        EventLoop* ownerLoop() {
         return loop_; }//当前channel属于哪个eventloop 
        void remove();//删除channel 
    private:
    
        void update();//更新，内部对象调用 
        void handleEventWithGuard(Timestamp receiveTime);//受保护的处理事件 
        
        //表示当前fd和其状态，是没有对任何事件感兴趣，还是对读或者写感兴趣 
        static const int kNoneEvent;//都不感兴趣 
        static const int kReadEvent;//事件 
        static const int kWriteEvent;//写事件 
    
        EventLoop *loop_;//事件循环
        const int fd_;//fd, Poller监听的对象
        int events_;//注册fd感兴趣的事件
        int revents_;//poller返回的具体发生的事件
        int index_;
    
        std::weak_ptr<void> tie_;//绑定自己 
        bool tied_;
    
        //因为channel通道里面能够获知fd最终发生的具体的事件revents，所以它负责调用具体事件的回调操作
        //这些回调是用户设定的，通过接口传给channel来负责调用 ，channel才知道fd上是什么事件 
        ReadEventCallback readCallback_;
        EventCallback writeCallback_;
        EventCallback closeCallback_;
        EventCallback errorCallback_;
    };

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_29_color_FFFFFF_t_70_g_se_x_16 1]  
**析构函数的if：如果这个channel是在当前的事件循环所在的线程里面**

**Channel.cc**

#include "Channel.h"
    #include "EventLoop.h"
    #include "Logger.h"
    
    #include <sys/epoll.h>//epoll的表示 
    
    const int Channel::kNoneEvent = 0;
    const int Channel::kReadEvent = EPOLLIN | EPOLLPRI;//epoll的表示 
    const int Channel::kWriteEvent = EPOLLOUT;//epoll的表示 
    
    //EventLoop底层: ChannelList  Poller 每个channel属于1个loop 
    Channel::Channel(EventLoop *loop, int fd)
        : loop_(loop), fd_(fd), events_(0), revents_(0), index_(-1), tied_(false)
    {
        
    }
    
    Channel::~Channel()//析构函数 
    {
        
    }
    
    //channel的tie方法什么时候调用过？一个TcpConnection新连接创建的时候 TcpConnection => Channel 
    void Channel::tie(const std::shared_ptr<void> &obj)
    {
        
        tie_ = obj;
        tied_ = true;
    }
    
    /**
     * 当改变channel所表示fd的events事件后，update负责在poller里面更改fd相应的事件epoll_ctl
     * EventLoop => ChannelList   Poller
     */ 
    void Channel::update()
    {
        
        //通过channel所属的EventLoop，调用poller的相应方法，注册fd的events事件
        loop_->updateChannel(this);
    }
    
    //在channel所属的EventLoop中， 把当前的channel删除掉
    void Channel::remove()
    {
        
        loop_->removeChannel(this);
    }
    
    //fd得到poller通知以后，处理事件的
    void Channel::handleEvent(Timestamp receiveTime)
    {
        
        if (tied_)//绑定过 
        {
        
            std::shared_ptr<void> guard = tie_.lock();//弱智能指针-》强智能指针 
            if (guard)//是否存活 
            {
        
                handleEventWithGuard(receiveTime);
            }
        }
        else
        {
        
            handleEventWithGuard(receiveTime);
        }
    }
    
    //根据poller通知的channel发生的具体事件， 由channel负责调用具体的回调操作
    void Channel::handleEventWithGuard(Timestamp receiveTime)
    {
        
        LOG_INFO("channel handleEvent revents:%d\n", revents_);
    
        if ((revents_ & EPOLLHUP) && !(revents_ & EPOLLIN))
        {
        
            if (closeCallback_)
            {
        
                closeCallback_();
            }
        }
    
        if (revents_ & EPOLLERR)
        {
        
            if (errorCallback_)
            {
        
                errorCallback_();
            }
        }
    
        if (revents_ & (EPOLLIN | EPOLLPRI))
        {
        
            if (readCallback_)
            {
        
                readCallback_(receiveTime);
            }
        }
    
        if (revents_ & EPOLLOUT)
        {
        
            if (writeCallback_)
            {
        
                writeCallback_();
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_33_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/6c7ec1c91f8044358e27391f6d86d2fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_29_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/2ef1da636567499aaedc2aeb3b68fdaa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_36_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/df8e72e2387a4a848f816add1a0834c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_33_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/2b7257c0d2524a85ac71ce95a2d8c9c5.png
[4fc047e4864e4a22806567a34745acb7.png]: /images/20220829/0cb3c43d454340f4a70d84525455322e.png
[868739d99a19449281f0bc99480cf02d.png]: /images/20220829/01ca5502b7ea4a7799e91beed583d151.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_34_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/322851d63e8245508a164428d097ed7d.png
[65ae4e8c0cf2415aaffd1f2ae3702356.png]: /images/20220829/6ffb4a508b0f40b4b6fe5ce357834a90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_33_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/ef0f18aee19248d1bdfb982c8a078881.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBALeael-azveWuhw_size_29_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/09f1b57b2f254b42bd15f1e5ad4b80ce.png