• 【MUDUO 】Channel通道

    Reactor模型图 

     

    目前 TcpServer 类需要封装的两个类， 一个是事件循环类 ，一个是IP地址端口打包类，IP地址打包的类封装完。

    而EventLoop 下还需要两个重要类：一个是channel通道类，一个是poller抽象类

    现在我们需要的补上TcpServer类 EventLoop类

    TcpServer.h

    对外使用编程服务器的类

    1. #pragma once
    2.  
    3.  
    4. class TcpServer 
    5. {
    6.     public:
    7.     private:
    8. };

    EventLoop.h

    事件循环类 主要包含了两大模块， channel poller(epoll的抽象，muduo库中也实现了poll) 

    1. #pragma once 
    2.  
    3. class EventLoop
    4. {
    5.     public:
    6.     private:
    7. };

    Channel.h

    EventLoop、Channel、Poller之间的关系 是EventLoop 包含了它两， Readctor模型上的Demultipex

    channel 理解为通道，封装了sockfd和其感兴趣的event， 如EPOLLIN、EPOLLOUT事件。 还绑定了poller返回的事件

    Channel的成员变量：

    1. static const int kNoneEvent；            没有对任何事件感兴趣

    2. static const int kReadEvent;              对读事件感兴趣

    3. static const int kWriteEvent;              对写事件感兴趣

    4. EventLoop *loop_;                             事件循环

    5. const int fd_;                                       fd, poller监听的对象

    6. int events_;                                         注册fd感兴趣的事件

    7. int revents_;                                        poller返回具体发生的事件

    8. int index_;

    9. std::weak_ptr tie_;                   绑定的自己

    10. bool tied_;                                          

    11. ReadEventCallback readCallback_;  用户注册的读回调

    12. EventCallback writeCallback_;          用户注册的写回调

    13. EventCallback closeCallback_;         用户注册的关闭回调

    14. EventCallback errorCallback_;          用户注册的错误回调

    1. #pragma once
    2. #include 
    3. #include 
    4. #include "noncopyable.h"
    5. #include "Timestamp.h"
    6. //头文件里边只用了类型的声明，没有用到类型具体的定义以及方法，所以我们在这头文件中就只需要一些前置声明一下就好
    7. class EventLoop;
    8.  
    9.  
    10.  
    11. class Channel:public noncopyable
    12. {
    13.     public:
    14.         //绑定回调函数
    15.         using EventCallback = std::function<void()>;
    16.         using ReadEventCallback = std::function<void(Timestamp)>;
    17.  
    18.         //因为是指针都是4字节，不影响编译，所以前置声明就好了
    19.         Channel(EventLoop *loop, int fd);
    20.         ~Channel();
    21.         //这个Timestamp需要计算类大小，所以不能只做前置声明
    22.         //fd得到poller通知以后，处理事件，调用相应的回调方法
    23.         void handleEvent(Timestamp receiveTime);
    24.  
    25.         //设置回调
    26.         void setReadCallback(ReadEventCallback cb) 
    27.         { 
    28.             readCallback_ = std::move(cb); 
    29.         }
    30.         void setWriteCallback(EventCallback cb)
    31.         {
    32.             writeCallback_ = std::move(cb);
    33.         }
    34.         void setCloseCallback(EventCallback cb)
    35.         {
    36.             closeCallback_ = std::move(cb);
    37.         }
    38.         void setErrorCallback(EventCallback cb)
    39.         {
    40.             errorCallback_ = std::move(cb);
    41.         }
    42.         //防止channel被remove掉，channel还在执行回调
    43.         void tie(const std::shared_ptr<void>& );
    44.  
    45.         int fd()const { return fd_; }
    46.         int events() const { return events_; }
    47.  
    48.         //设置fd事件，因为是poller监听的，所以需要对外提供一个接口去设置
    49.         int set_revents(int rev) { events_ = rev ; }
    50.  
    51.         //设置fd相应的时间状态，也就是给epoll_ctl 设置
    52.         void enableReading() { events_ |= kReadEvent; update(); }
    53.         void disableReading() { events_ &= ~kReadEvent; update(); }
    54.         void enableWriting() { events_ |= kWriteEvent; update();}
    55.         void disableWriting() { events_ &= ~kWriteEvent; update();}
    56.         void disableAll() { events_ = kNoneEvent; update(); }
    57.  
    58.         //判断是否对任何事件都不感兴趣
    59.         bool isNoneEvent() const { return events_ == kNoneEvent; }
    60.         bool isWriting() const { return events_ & kWriteEvent; }
    61.         bool isReading() const { return events_ & kReadEvent; }
    62.  
    63.         int index() { return index_; }
    64.         void set_index(int idx) { index_ = idx; }
    65.  
    66.         //当前channel属于哪个eventLoop，一个EventLoop有很多个channel，一个线程一个EventLoop
    67.         EventLoop* ownerLoop() { return loop_; }
    68.         void remove();
    69.  
    70.     private:
    71.         void update();
    72.         void handleEventWithhGuard(Timestamp receiveTime);
    73.  
    74.     private:
    75.  
    76.         //表示FD的一个状态
    77.         static const int kNoneEvent; 
    78.         static const int kReadEvent;
    79.         static const int kWriteEvent;
    80.  
    81.         //事件循环
    82.         EventLoop *loop_;
    83.  
    84.         const int fd_;
    85.  
    86.         int events_;
    87.  
    88.         int revents_;
    89.  
    90.         int index_;
    91.  
    92.         //弱智能指针
    93.         std::weak_ptr<void> tie_; 
    94.         bool tied_; 
    95.  
    96.         //channel能获知fd最终发生的具体事件revents，所以它负责调用具体事件的回调操作
    97.         ReadEventCallback readCallback_;
    98.         EventCallback writeCallback_;
    99.         EventCallback closeCallback_;
    100.         EventCallback errorCallback_;
    101. };

    Channel.cc 

    1. #include "Channel.h"
    2. #include "EventLoop.h"
    3. #include "Logger.h"
    4.  
    5. #include 
    6.  
    7. const int Channel::kNoneEvent = 0; 
    8. const int Channel::kReadEvent = EPOLLIN | EPOLLPRI;
    9. const int Channel::kWriteEvent = EPOLLOUT;
    10.  
    11.  
    12. Channel::Channel(EventLoop *loop, int fd)
    13.     :loop_(loop),fd_(fd),events_(0),revents_(0),index_(-1),tied_(false)
    14. {}
    15.  
    16.  
    17. Channel::~Channel(){}
    18.  
    19. //channel里的tie方法什么时候被调用过？ 后边再看
    20. void Channel::tie(const std::shared_ptr<void> &obj)
    21. {
    22.     tie_ = obj; //绑定成弱智能指针观察强智能指针
    23.     tied_ = true;//绑定过了就置成true
    24. }
    25.  
    26. /**
    27.  * @brief 当改变channel所表示fd的events事件后，update负责在poller里面更改fd相应的时间epoll_ctl
    28.  * 
    29.  * poller在哪呢? poller 跟channel是两个不同的模块。因为epoll不属于channel管，但是他们两都是数据EventLoop的
    30.  * 
    31.  * EventLoop 包含了ChannelList"也就是一个channel列表"， 和一个poller
    32.  * 
    33.  * 所以channel本身想向Channel注册fd对应的事件是做不了的，因为它又没有poller对象，所以需要通过EventLoop来做这件事情
    34.  * 
    35.  */
    36. void Channel::update()
    37. {
    38.     //通过Channel所属的EventLoop,调用poller的相应方法，注册fd的Events事件
    39.     //add code
    40.     //loop_->updateChannel(this);
    41. }
    42.  
    43. //在channel所属的EventLoop中的容器，把自己给删除掉
    44. void Channel::remove()
    45. {
    46.     //add code
    47.     // loop_->removeChannel(this);
    48. }
    49.  
    50.  
    51. //fd得到poller通知以后，处理事件的
    52. void Channel::handleEvent(Timestamp receiveTime)
    53. {
    54.     if(tied_)
    55.     {
    56.         std::shared_ptr<void> guard = tie_.lock();
    57.         if(guard)
    58.         {
    59.             handleEventWithhGuard(receiveTime);
    60.         }
    61.     }
    62.     else
    63.     {
    64.         handleEventWithhGuard(receiveTime);
    65.     }
    66. }
    67.  
    68. //根据poller通知的channel发生的具体事件，由channel负责调用具体的回调操作
    69. void Channel::handleEventWithhGuard(Timestamp receiveTime)
    70. {
    71.     LOG_INFO("channel handleEvent revent:%d\n", revents_);
    72.  
    73.     if((revents_ & EPOLLHUP) && !(revents_ & EPOLLIN))
    74.     {
    75.         if(closeCallback_)
    76.         {
    77.             closeCallback_();
    78.         }
    79.     }
    80.     //事件发生错误
    81.     if(revents_ & EPOLLERR)
    82.     {
    83.         if(errorCallback_)
    84.         {
    85.             errorCallback_();
    86.         }
    87.     }
    88.     //可读事件
    89.     if(revents_ & (EPOLLIN | EPOLLPRI))
    90.     {
    91.         if(readCallback_)
    92.         {
    93.             readCallback_(receiveTime);
    94.         }
    95.     }
    96.  
    97.     if(revents_ & EPOLLOUT)
    98.     {
    99.         if(writeCallback_)
    100.         {
    101.             writeCallback_();
    102.         }
    103.     }
    104.  
    105. }

    channel.cc 中还有三个遗留问题：

    1.  void Channel::update() ：下次补全方法

    2. void Channel::remove()：下次补全方法

    3. 看看后边tie方法什么时候被调用过？ 因为它触发了之后才会触发void Channel::handleEvent里边的弱智能指针的提升

  • 相关阅读:
    canvas的基本使用
    编译器做了这么多，你知道吗？
    解密JavaChassis3：易扩展的多种注册中心支持
    机器人系统 ROS 常用命令行工具
    网络安全：常见的中间件以及环境搭建方法
    动态内存（进阶四）
    SpringMVC(JSR303和拦截器)
    JavaScript数据类型学习脑图
    云计算基础技术
    java毕业设计在线售药系统Mybatis+系统+数据库+调试部署
  • 原文地址：https://blog.csdn.net/weixin_40533189/article/details/125863566