muduo-net 源码分析（七）——TcpServer 和 TcpConnection（二）

已于 2022-06-07 20:43:37 修改
阅读量164 收藏
点赞数
分类专栏： muduo源码分析 文章标签： c++
于 2022-06-07 20:40:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50987639/article/details/125168965
版权

先序

这一节我们将继续完善 TcpServer 和 TCPConnection 类，并且解决上一节思考的问题【一定要理清思路】；

TcpServer 源码分析

重要的变量

ConnectionCallback connectionCallback_;       //连接到来和结束的回调函数

重要的函数

//可以自己设置，muduo 库是有默认的
void setConnectionCallback(const ConnectionCallback& cb)
  { connectionCallback_ = cb; }
void removeConnection(const TcpConnectionPtr& conn);
void removeConnectionInLoop(const TcpConnectionPtr& conn);

具体实现

TcpServer::TcpServer(EventLoop* loop,
                     const InetAddress& listenAddr,
                     const string& nameArg,
                     Option option)
  : loop_(CHECK_NOTNULL(loop)),   //检查 loop 指针是否为 NULL
    ipPort_(listenAddr.toIpPort()),
    name_(nameArg),
    acceptor_(new Acceptor(loop, listenAddr, option == kReusePort)),
    ------------------------------------------------------------------------
    //threadPool_(new EventLoopThreadPool(loop, name_)),
    //默认的连接回调函数，全局函数
    //这个函数的作用就是输出客户端套接字的状态
    connectionCallback_(defaultConnectionCallback),
    ------------------------------------------------------------------------
    // messageCallback_(defaultMessageCallback),
    nextConnId_(1)
{
  //设置 newConnection 的回调函数，因为有两个参数，所以有两个占位符
  //第一个参数是客户端套接字，第二个参数是客户端地址
  acceptor_->setNewConnectionCallback(
      std::bind(&TcpServer::newConnection, this, _1, _2));
}

//根据 conn 的状态判断现在是连接还是断开
void muduo::net::defaultConnectionCallback(const TcpConnectionPtr& conn)
{
  LOG_TRACE << conn->localAddress().toIpPort() << " -> "
            << conn->peerAddress().toIpPort() << " is "
            << (conn->connected() ? "UP" : "DOWN");
}


void TcpServer::newConnection(int sockfd, const InetAddress& peerAddr)
{
  //断言在 IO 线程中
  loop_->assertInLoopThread();
  //EventLoop* ioLoop = threadPool_->getNextLoop();
  char buf[64];
  snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_);
  ++nextConnId_;
  //连接的名称是 服务器名称 + 服务器端口号 + 连接 ID
  string connName = name_ + buf;

  //输出客户端的信息
  LOG_INFO << "TcpServer::newConnection [" << name_
           << "] - new connection [" << connName
           << "] from " << peerAddr.toIpPort();

  InetAddress localAddr(sockets::getLocalAddr(sockfd));
  
  // 创建一个 TcpConnectionPtr 对象指向一个 TCPConnection
  //不太理解的地方，传递的 peerAddr 是客户端的地址，localAddr 也是客户端的地址？
  TcpConnectionPtr conn(new TcpConnection(loop,
                                          connName,
                                          sockfd,
                                          localAddr,
                                          peerAddr));
  /*TcpConnectionPtr conn(new TcpConnection(ioLoop,
                                          connName,
                                          sockfd,
                                          localAddr,
                                          peerAddr));
                                          */
      
  //记录客户端连接                                        
  connections_[connName] = conn;
  
  --------------------------------------------------------------
  //注册 TCPConnection 的 connectionCallback 回调函数
  conn->setConnectionCallback(connectionCallback_);
  ----------------------------------------------------------------
  //conn->setMessageCallback(messageCallback_);
  //conn->setWriteCompleteCallback(writeCompleteCallback_);
  ------------------------------------------------------------------
  //注册 TCPConnection 的 CloseCallback 回调函数
  conn->setCloseCallback(
      std::bind(&TcpServer::removeConnection, this, _1)); 
  ---------------------------------------------------------------------
  
  //调用 TcpConnection::connectEstablished 函数
  loop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn));
  //ioLoop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn));
}

//removeConnection 可跨线程使用
void TcpServer::removeConnection(const TcpConnectionPtr& conn)
{
  loop_->runInLoop(std::bind(&TcpServer::removeConnectionInLoop, this, conn));
}

//只能在 IO 线程中使用
void TcpServer::removeConnectionInLoop(const TcpConnectionPtr& conn)
{
  loop_->assertInLoopThread();
  LOG_INFO << "TcpServer::removeConnectionInLoop [" << name_
           << "] - connection " << conn->name();
  
  //将对象从列表中移除，注意此时引用计数会减 1
  //如果不使用 tie，则是引用计数为 0
  //TcpConnection 对象被销毁，回国 TcpConnection 的 channel 对象就会被销毁，而此时我们处于 channel 对象的 handleEvent() 中，会造成 coredump
  //使用 tie 后，调用 handleEvent() 时，weak_ptr 会被升级为 share_ptr，所以此时删除并不会销毁 TcpConnection
  size_t n = connections_.erase(conn->name());

  (void)n;
  assert(n == 1);
  
  //注意，目前这里的 ioLoop 就是上面的 loop_
  EventLoop* ioLoop = conn->getLoop();

  //这里调用 queueInLoop 而不是调用 runInLoop 
  //这也是 queueInLoop  里面有两个条件的原因
  ioLoop->queueInLoop(
      std::bind(&TcpConnection::connectDestroyed, conn));
}

这里只是多给出了 TCPConnection 连接断开时触发的函数；

TCPConnection 源码分析

重要的变量

ConnectionCallback connectionCallback_;       //连接回调函数，包含连接建立和连接断开
CloseCallback closeCallback_;                 //连接断开回调函数

重要的函数

void setConnectionCallback(const ConnectionCallback& cb)
  { connectionCallback_ = cb; }

void setCloseCallback(const CloseCallback& cb)
  { closeCallback_ = cb; }

void connectDestroyed(); 

void handleRead(Timestamp receiveTime);
void handleClose();
void handleError();

具体实现

TcpConnection::TcpConnection(EventLoop* loop,
                             const string& nameArg,
                             int sockfd,
                             const InetAddress& localAddr,
                             const InetAddress& peerAddr)
  : loop_(CHECK_NOTNULL(loop)),
    name_(nameArg),
    state_(kConnecting),
    reading_(true),
    socket_(new Socket(sockfd)),
    channel_(new Channel(loop, sockfd)),
    localAddr_(localAddr),
    peerAddr_(peerAddr),
    highWaterMark_(64*1024*1024)
{
  channel_->setReadCallback(
      std::bind(&TcpConnection::handleRead, this, _1));
 /*
  channel_->setWriteCallback(
      std::bind(&TcpConnection::handleWrite, this));
  */
  ------------------------------------------------------------------
  channel_->setCloseCallback(
      std::bind(&TcpConnection::handleClose, this));
  //发生错误，回调 handleError
  channel_->setErrorCallback(
      std::bind(&TcpConnection::handleError, this));
  ------------------------------------------------------------------
  LOG_DEBUG << "TcpConnection::ctor[" <<  name_ << "] at " << this
            << " fd=" << sockfd;
  socket_->setKeepAlive(true);
}


void TcpConnection::connectEstablished()
{
  loop_->assertInLoopThread();
  assert(state_ == kConnecting);

  //设置状态为已连接
  setState( kConnected);
  
  //share_from_this 是根据裸指针创建一个 shared_ptr 对象
  //这里使用了 Channel 的 tie，这是 Channel 中没有讨论的地方，这里会将 Channel 完善
  channel_->tie(shared_from_this());
  
  //关注 TcpConnect 的可读事件
  channel_->enableReading();

 ---------------------------------------------------
  //这里输出成功连接
  connectionCallback_(shared_from_this());
 ---------------------------------------------------  
}


//接收客户端的信息
void TcpConnection::handleRead(Timestamp receiveTime)
{
  /* 以下是使用了应用层缓冲区
  loop_->assertInLoopThread();
  int savedErrno = 0;
  ssize_t n = inputBuffer_.readFd(channel_->fd(), &savedErrno);
  if (n > 0)
  {
    messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
  }
  else if (n == 0)
  {
    handleClose();
  }
  else
  {
    errno = savedErrno;
    LOG_SYSERR << "TcpConnection::handleRead";
    handleError();
  }
  */
 //以下是模拟普通的接收过程
 loop_->assertInLoopThread();
 int saveErrno = 0;
 char buf[65536];
 ssize_t n = ::read(channel->fd(), buf, sizeof buf);
 if (n > 0) {
   messageCallback(shared_from_this(), buf, n);
 }
 //处理连接断开
 else if (n == 0) {
   handleClose();
 }
 //处理错误情况 
 else {
   errno = saveErrno;
   LOG_SYSERR << "TcpConnection::handleRead";
   handleError();
 }
}


void TcpConnection::handleClose()
{
  loop_->assertInLoopThread();
  LOG_TRACE << "fd = " << channel_->fd() << " state = " << stateToString();
  assert(state_ == kConnected || state_ == kDisconnecting);
  
  //这里将状态设置为已断开连接
  setState(kDisconnected);

  //这里并没有调用 channel_ 的 remove()，因为当前还处于 channel_ 的 handleEvent() 函数中
  channel_->disableAll();
 
  
  TcpConnectionPtr guardThis(shared_from_this());
  //connectionCallback_ 函数在这里是显示连接断开
  connectionCallback_(guardThis);
  
  //这里调用的 TcpServer::removeConnection 函数
  closeCallback_(guardThis);
}

//错误输出
void TcpConnection::handleError()
{
  int err = sockets::getSocketError(channel_->fd());
  LOG_ERROR << "TcpConnection::handleError [" << name_
            << "] - SO_ERROR = " << err << " " << strerror_tl(err);
}


//connectDestroyed 将 channel 从管道中移除
void TcpConnection::connectDestroyed()
{
  loop_->assertInLoopThread();
  
  //前面设置过状态为 kDisconnected，所以这里为 fasle
  //前面可以不作处理，在这里进行处理
  if (state_ == kConnected)
  {
    setState(kDisconnected);
    channel_->disableAll();

    connectionCallback_(shared_from_this());
  }
  
  //此时 handleEvent() 已经处理完了，可以调用 remove() 函数了
  channel_->remove();
}

TcpConnection 的声明周期

流程

其实在上面的备注中我已经说明了问什么要使用 tie，但是为了理清整体的思路，这边会详细介绍一下整体的过程【直接从客户端发起连接开始说起】；

  1. 客户端发起连接，服务器的 Acceptor 读事件被触发，调用了 TcpServer::newConnection()；
  2. 创建了 TcpConnection 对象，将该对象传递给 channel 的 tie 对象；
  3. 调用 TcpConnection::connectEstablished()；客户端套接字的读事件被监听；
  4. 客户端主动发起关闭，客户端套接字的读事件被触发，调用 handleEvent()，注意此时因为有 tie 所以会将先将 weak_ptr 升级为 shared_ptr；然后发现是读事件，调用 TcpConnection::handleRead()；
  5. 因为是关闭连接，所以调用 handleClose()，这里会调用 TcpServer::removeConnection() 将 connections_ 中客户端的记录删除；
  6. 最后在队列中添加 TcpConnection::connectDestroyed 中将通道从列表中移除；

解析

  • 在第 4 步中，如果我们不使用 tie，而是像正常的处理方式调用 handleEvent()，此时引用计数的值为 1；
  • 在第 5 步中，我们调用 TcpServer::removeConnection() 将 connections_ 中客户端的记录删除；引用计数会减 1，很不幸，此时引用计数已经为 0 了，那么 TcpConnection 对象被释放，它的 channel 也被释放；但此时仍然处于 channel::handleEvent() 中，所以会发生 coredump；
  • 所以我们要保证 TcpConnection 要在 channel::handleEvent() 执行完之后被释放；所以就有了 tie；
  • 在使用 tie 的情况下，调用 TcpServer::removeConnection() 将 connections_ 中客户端的记录删除；引用计数会减 1，但此时引用计数为 1，并不会释放 TcpConnection 对象，那我们将这个对象传入到 handleEvent() 函数之后的 EvenLoop::doPendingFunctors() 中不就行了吗，在这个函数里面将对象释放；
//将 conn 传入到队列中，执行玩这个函数后，conn 会被释放，引用计数减 1，对象销毁
ioLoop->queueInLoop(
      std::bind(&TcpConnection::connectDestroyed, conn));

结束语

TcpServer 中还有多线程没有讨论，TcpConnection 中还有应用层缓冲和输入输出处理函数没有讨论，这是接下来讨论的重点；讨论完后，muduo 库的实现就差不多完成了！！！

cyjiayou
关注
专栏目录
muduo-0.9.1-beta.tar.gz
11-30
这个名为“muduo-0.9.1-beta.tar.gz”的压缩包是muduo的0.9.1 Beta版本，适用于Ubuntu等Linux发行版，提供了muduo库的安装和学习资源。 一、muduo库介绍 muduo由知名C++开发者陈硕开发，它以事件驱动的方式处理...
【Netty系列】使用Netty搭建TcpServer
秋装什么的博客
12-17 1282
【Netty系列】使用Netty搭建TcpServer
[Remoting] 三：激活模式
aome1470的博客
03-19 210
对于 MBR，我们可以指定不同的激活模式。 服务器激活(Server-Activated Objects / SAO)：只有在客户端调用代理对象第一个方法时才创建，区分为 Singleton 和 SingleCall 两种模式。Singleton 一如设计模式中的名称，无论有多少客户端都只有一个实例存在；而 SingleCall 则为每次调用创建一个新对象，因此它是无状态的...
仿Muduo库实现高并发服务器——TcpServer模块
最新发布
2201_75324712的博客
08-22 939
对于TcpServer对象设置回调函数，其实最终会被设置到Connection对象上，而每个客户端对于一个Connection对象。启动非活跃连接销毁，Tcpserver对象默认是关闭非活跃连接销毁的，添加定时任务下面会讲。TcpServer对象创建后，就需要调用Start()函数进行线程池的创建，以及主线程EventLooop对象的运行，这个就是死循环。
SocketChannel与ServerSocketChannel
ZERO
04-27 2347
转载自：http://ifeve.com/server-socket-channel/             http://ifeve.com/socket-channel/ SocketChannel Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。可以通过以下2种方式创建SocketChannel：     1.打开一个SocketChann
net8. 服务器类——TcpServer
TABE_的博客
03-29 1524
TcpServer类 TcpServer由用户直接使用，生命周期由用户控制，用户设置好相应的回调MessageCallback、ConnectionCallback传递给TcpServer即可；MessageCallback为连接上有接收数据时调用的回调（处理业务逻辑），这些数据存放在连接的应用层接收缓冲区中；ConnectionCallback在连接建立和断开时都会回调，主要是通知用户进行相应的处理。 在TcpServer中，建立连接描述符和TcpConnection之间的关系，通过stl中map来实现
【Muduo】TcpServer类
qq_20756957的博客
05-24 414
TcpServer统领之前所有的类，是用户直接使用的类。它通过ThreadPool管理所有的loopthread，保存所有的TcpConnection，保存用户提供的各种回调函数并向TcpConnection的Channel中注册回调。它负责监听指定的端口，并接受来自客户端的连接请求，为每个连接创建一个TcpConnection对象进行管理。它的业务逻辑较先前的三大组件来说，还是比较简明的。
muduo-release.zip
06-30
使用muduo最新版编译后的文件以及头文件，可以直接放入项目中使用。注：编译之后，会在用户目录下生成一个build文件夹，该文件夹下有release-install-cpp11文件夹，里面有两个文件夹分别是include和lib，这是编译后...
muduo网络库中核心模块TcpServer的核心知识梳理
06-06
### muduo网络库中核心模块TcpServer的核心知识梳理 #### 一、基础知识梳理 ##### 1. 阻塞、非阻塞、同步、异步 - **阻塞（Blocking）**：指当一个线程执行某操作时，如果该操作未完成，则线程将处于等待状态直到...
muduo-master.zip_BOOST服务器_muduo
09-20
这个名为“muduo-master.zip”的压缩包，包含了完整的muduo源码，以及可能的示例和文档，是深入理解和应用muduo的宝贵资源。 muduo库的核心设计目标是提供一个线程安全、非阻塞I/O模型，以充分利用多核处理器的性能...
chatserver:可以工作在nginx tcp负载均衡环境中的合并聊天服务器和客户端源码基于muduo实现-源码客
03-24
聊天服务器 可以工作在nginx tcp负载均衡环境中的合并聊天服务器和客户端源码基于muduo实现
muduo学习笔记：net部分之实现TCP网络编程库-TcpServer
热爱生活，忠于自己
09-01 790
前文博客【muduo学习笔记：net部分之实现TCP网络编程库TcpConnection】和【muduo学习笔记：net部分之实现TCP网络编程库Acceptor】 是TcpServer是基本组件，博文【muduo学习笔记：net部分之多线程TCP服务端的设计模式演进】介绍了TcpServer的各种设计方式以及muduo网络库的结构。本文主要介绍TcpServer代码结构、工作流程。 1、多线程 TcpServer 结构 作为服务器端，首先需要封装了listening socket的Acceptor来监听客
TcpServerTcpConnection(34)
lishenglong666的专栏
08-29 668
Acceptor类的主要功能是socket、bind、listen 一般来说，在上层应用程序中，我们不直接使用Acceptor，而是把它作为TcpServer的成员 TcpServer还包含了一个TcpConnection列表 TcpConnection与Acceptor类似，有两个重要的数据成员，Socket与Channel 时序图
muduo源码阅读笔记（9、TcpServer）
m0_52566365的博客
01-19 2120
Muduo高性能网络库，TcpServer的实现
muduo TcpServer类
长期更新自学笔记
05-03 688
文章目录一、Callbacks.h二、TcpServer.h三、TcpServer类 一、Callbacks.h #pragma once #include <memory> #include <functional> class Buffer; class TcpConnection; class Timestamp; using TcpConnectionPtr = std::shared_ptr<TcpConnection>; using Connection
重写muduo之TcpServer
m0_62689947的博客
05-11 397
C++11重写muduo的TcpServer模块
muduo网络库——TcpServer、Acceptor和TcpConnection
www_dong的博客
04-12 1504
本文主要介绍的是muduo网络库对于tcp通信的相关处理及源码分析，关于tcp相关知识，可以参考：https://blog.csdn.net/www_dong/category_10706734.html 模型 tcp相关类说明： TcpConnection: TCP连接管理 Acceptor: 接收连接 Connector: 发起连接 TcpServer: 管理Acceptor获取的连接 实现流程： 1）TcpServer构造时会创建Acceptor对象并设置新连接回调； 2）Acceptor接
muduo-net 源码分析（六）——TcpServer 和 TcpConnection（一）
m0_50987639的博客
06-07 234
muduo 源码分析
【muduo】net篇---TcpServer
青萍之末的博客
02-21 963
  TcpServer在创建的过程中，首先new出来自己的核心组件（Acceptor,loop,connectionMap,threadPool）之后TcpServer会向Acceptor注册一个新连接到来时的Connection回调函数。一旦接受到一个client的连接，就会调用TcpServer::newConnection()函数。这个函数使用round-robin算法从EventLoopT...
使用muduo库构建Linux多线程TCP服务器
muduo库是一个专门为多线程TCP服务器设计的现代C++库，适用于在x86-64架构的Linux系统上编写高性能的网络程序。文档的核心内容围绕“one loop per thread”模型展开，这是一种在Linux下编写用户态高性能网络程序的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值