muduo源码剖析-TcpServer连接关闭

最新推荐文章于 2023-04-08 22:51:18 发布
最新推荐文章于 2023-04-08 22:51:18 发布
阅读量500 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingchengf/article/details/107669956
版权

Server关闭连接的情况有两种，一种是被动关闭，即对方先关闭连接，本地read(2)返回零，触发关闭逻辑。另一种是主动断开连接，即调用TcpConnection::forceClose()函数。

1 被动关闭

时序图如下
在这里插入图片描述
对方关闭时，read(2)会收到0字节，因此触发关闭逻辑。首先loop事件循环中channel触发handleEvent，然后调用readCallback_()，readCallback_在TcpConnection的构造函数中已绑定在TTcpConnection::handleRead上，如下：


void Channel::handleEvent(Timestamp receiveTime)
{
  std::shared_ptr<void> guard;
  if (tied_)
  {
    guard = tie_.lock();
    if (guard)
    {
      handleEventWithGuard(receiveTime);
    }
  }
  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;
}
//TcpConnection的构造函数
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)
{
    //通道可读事件到来的时候，回调TcpConnection::handleRead，_1是事件发生的时间
  channel_->setReadCallback(
      std::bind(&TcpConnection::handleRead, this, _1));
  //通道可写事件到来的时候，回调cpConnection::handleWrite
  channel_->setWriteCallback(
      std::bind(&TcpConnection::handleWrite, this));
  //连接关闭，回调TcpConnection::handleClose
  channel_->setCloseCallback(
      std::bind(&TcpConnection::handleClose, this));
  //发生错误，回调TcpConnection::handleError
  channel_->setErrorCallback(
      std::bind(&TcpConnection::handleError, this));
  LOG_DEBUG << "TcpConnection::ctor[" <<  name_ << "] at " << this
            << " fd=" << sockfd;
  socket_->setKeepAlive(true);
}
void TcpConnection::handleRead(Timestamp receiveTime)
{
  loop_->assertInLoopThread();
  int savedErrno = 0;
  ssize_t n = inputBuffer_.readFd(channel_->fd(), &savedErrno); //接受数据
  if (n > 0) //读取n字节数据
  {
    messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
  }
  else if (n == 0) //对端关闭连接
  {
    handleClose();
  }
  else
  {
    errno = savedErrno;
    LOG_SYSERR << "TcpConnection::handleRead";
    handleError();
  }
}

void TcpConnection::handleClose()
{
  loop_->assertInLoopThread();
  LOG_TRACE << "fd = " << channel_->fd() << " state = " << stateToString();
  assert(state_ == kConnected || state_ == kDisconnecting);
  // we don't close fd, leave it to dtor, so we can find leaks easily.
  setState(kDisconnected);
  channel_->disableAll(); //取消对channel的关注，并更新poller
  TcpConnectionPtr guardThis(shared_from_this());
  connectionCallback_(guardThis);
  // must be the last line
  closeCallback_(guardThis); //调用TcpServer::removeConnection()
}

由于读取到了0字节，因此inputBuffer_.readFd函数返回0，回调TcpConnection::handleClose，TcpConnection::handleClose()会取消channel的关注，并且调用调用connectionCallback_和closeCallback_，closeCallback_这个回调绑定到TcpServer::removeConnection().这个绑定发生在TcpConnection对象建立的时候，如下：

void TcpServer::newConnection(int sockfd, const InetAddress& peerAddr)
{
  loop_->assertInLoopThread();
  EventLoop* ioLoop = threadPool_->getNextLoop();
  char buf[64];
  snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_);
  ++nextConnId_;
  string connName = name_ + buf;

  LOG_INFO << "TcpServer::newConnection [" << name_
           << "] - new connection [" << connName
           << "] from " << peerAddr.toIpPort();
  InetAddress localAddr(sockets::getLocalAddr(sockfd));
  // FIXME poll with zero timeout to double confirm the new connection
  // FIXME use make_shared if necessary
  TcpConnectionPtr conn(new TcpConnection(ioLoop,
                                          connName,
                                          sockfd,//客户端socket文件描述符
                                          localAddr,
                                          peerAddr));
  connections_[connName] = conn;
  conn->setConnectionCallback(connectionCallback_);
  conn->setMessageCallback(messageCallback_);
  conn->setWriteCompleteCallback(writeCompleteCallback_);
  //设置CloseCallback
  conn->setCloseCallback(
      std::bind(&TcpServer::removeConnection, this, _1)); // FIXME: unsafe
  ioLoop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn));
}

在TcpServer::removeConnection()会把conn从ConnectionMap（TcpServer的数据成员，记录连接列表，即TcpConnection（share_ptr形式）和其名称）中移除，并将TcpConnection::connectionDestroyed()函数加入pendingFunctors_，在事件循环时调用TcpConnection::connectionDestroyed()。

void TcpServer::removeConnection(const TcpConnectionPtr& conn)
{
  // FIXME: unsafe
  loop_->runInLoop(std::bind(&TcpServer::removeConnectionInLoop, this, conn));
}

void TcpServer::removeConnectionInLoop(const TcpConnectionPtr& conn)
{
  loop_->assertInLoopThread();
  LOG_INFO << "TcpServer::removeConnectionInLoop [" << name_
           << "] - connection " << conn->name();
  size_t n = connections_.erase(conn->name());//返回key为conn->name()的value的个数
  (void)n;
  assert(n == 1);
  EventLoop* ioLoop = conn->getLoop();
  ioLoop->queueInLoop(
      std::bind(&TcpConnection::connectDestroyed, conn));
}
void TcpConnection::connectDestroyed()
{
  loop_->assertInLoopThread();
  //在TCphandleClose中已经设置了state_和使channel取消关注事件，因此下面if语句正常情况条件为假
  if (state_ == kConnected)
  {
    setState(kDisconnected);
    channel_->disableAll();

    connectionCallback_(shared_from_this());
  }
  channel_->remove();
}

在TcpConnection::connectDestroyed()中，会移除channel，下面附上channel的移除逻辑

void Channel::remove()
{
  assert(isNoneEvent()); //移除前需要使channel取消关注事件
  addedToLoop_ = false;
  loop_->removeChannel(this);
}
void EventLoop::removeChannel(Channel* channel)
{
  assert(channel->ownerLoop() == this);
  assertInLoopThread();
  if (eventHandling_)
  {
    assert(currentActiveChannel_ == channel ||
        std::find(activeChannels_.begin(), activeChannels_.end(), channel) == activeChannels_.end());
  }
  poller_->removeChannel(channel);
}
void EPollPoller::removeChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  int fd = channel->fd();
  LOG_TRACE << "fd = " << fd;
  assert(channels_.find(fd) != channels_.end());
  assert(channels_[fd] == channel);
  assert(channel->isNoneEvent());
  int index = channel->index();
  assert(index == kAdded || index == kDeleted);
  size_t n = channels_.erase(fd);
  (void)n;
  assert(n == 1);

  if (index == kAdded)
  {
    update(EPOLL_CTL_DEL, channel);
  }
  channel->set_index(kNew);
}

2 主动关闭

（1）调用TcpConnection::forceClose()函数。

void TcpConnection::forceClose()
{
  // FIXME: use compare and swap
  if (state_ == kConnected || state_ == kDisconnecting)
  {
    setState(kDisconnecting);
    loop_->queueInLoop(std::bind(&TcpConnection::forceCloseInLoop, shared_from_this()));
  }
}

void TcpConnection::forceCloseWithDelay(double seconds)
{
  if (state_ == kConnected || state_ == kDisconnecting)
  {
    setState(kDisconnecting);
    loop_->runAfter(
        seconds,
        makeWeakCallback(shared_from_this(),
                         &TcpConnection::forceClose));  // not forceCloseInLoop to avoid race condition
  }
}

void TcpConnection::forceCloseInLoop()
{
  loop_->assertInLoopThread();
  if (state_ == kConnected || state_ == kDisconnecting)
  {
    // as if we received 0 byte in handleRead();
    handleClose();
  }

（2）主动断开连接之半关闭
用户可以在相关回调函数（messageCallback_，writeCompleteCallback_，connectionCallback_）中调用TcpConnecion::shutdown函数来实现半关闭。函数如下：

void TcpConnection::shutdown()
{
  // FIXME: use compare and swap
  if (state_ == kConnected)
  {
    setState(kDisconnecting);
    // FIXME: shared_from_this()?
    loop_->runInLoop(std::bind(&TcpConnection::shutdownInLoop, this));
  }
}

void TcpConnection::shutdownInLoop()
{
  loop_->assertInLoopThread();
  if (!channel_->isWriting()) //当channel不关注可写事件时才能关闭连接
  {
    // we are not writing
    socket_->shutdownWrite(); //关闭写端
  }
}

shutdown为半关闭状态，即关闭写端，但仍然能接收到对端发送来的数据。shutdown()函数中将连接的状态设置为了state_ = kdisConnecting，然后将shutdownInLoop加入事件循环中去处理。
观察shutdownInLoop()我们会发现存在一些情况导致该函数无法执行socket_->shutdownWrite()。

  1. 当outputBuffer_中的数据没有发送完成时，此时仍关注着写事件，因此导致channel_->isWriting()条件为真，无法执行socket_->shutdownWrite()。
    别急，由于此时仍关注着POLLOUT事件，因此在事件循环中会触发handleWrite来发送数据。我们不妨先看看handleWrite函数：
void TcpConnection::handleWrite()
{
  loop_->assertInLoopThread();
  if (channel_->isWriting()) //如果关注了可写事件，则直接往套接字文件描述符中写数据
  {
    ssize_t n = sockets::write(channel_->fd(),
                               outputBuffer_.peek(),
                               outputBuffer_.readableBytes());
    if (n > 0)
    {
      outputBuffer_.retrieve(n);
      if (outputBuffer_.readableBytes() == 0) //说明发送缓冲区已经清空
      {
        channel_->disableWriting(); //停止关注POLLOUT事件，以免出现busy loop
        if (writeCompleteCallback_) //回调writeCompleteCallback_
        {
          loop_->queueInLoop(std::bind(writeCompleteCallback_, shared_from_this()));
        }
        if (state_ == kDisconnecting) //发送缓冲区已经清空，并且连接状态为kDisconnecting，要关闭连接
        {
          shutdownInLoop(); //关闭连接
        }
      }
    }
    else
    {
      LOG_SYSERR << "TcpConnection::handleWrite";
      // if (state_ == kDisconnecting)
      // {
      //   shutdownInLoop();
      // }
    }
  }
  else
  {
    LOG_TRACE << "Connection fd = " << channel_->fd()
              << " is down, no more writing";
  }
}
  1. 在handleWrite函数中我们会发现，当缓冲区中有数据时，会将数据发送完毕，当数据发送完毕时，由于在上面的shutdown函数中我们已经设置连接状态为kdisConnecting，因此在handleWrite函数中会调用shutdownInLoop()来确保完成半关闭。
  2. 此外，思考一下完成半关闭后如何最后完成关闭呢？半关闭时我们会发送TCP FIN分节，对方会收到0字节，然后对方通常会关闭连接。这样我们会读到0字节，触发handleRead函数，读到0字节时触发handleClose()函数完成连接的关闭。
void TcpConnection::handleRead(Timestamp receiveTime)
{
  loop_->assertInLoopThread();
  int savedErrno = 0;
  ssize_t n = inputBuffer_.readFd(channel_->fd(), &savedErrno); //接受数据
  if (n > 0) //读取n字节数据
  {
    messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
  }
  else if (n == 0) //对端关闭连接
  {
    handleClose();
  }
  else
  {
    errno = savedErrno;
    LOG_SYSERR << "TcpConnection::handleRead";
    handleError();
  }
}
qingchengf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【Muduo源码分析】 解读muduo如何断开连接 TcpConnection
08-14 620
在muduo中只有一种连接断开方式，就是被动关闭，也就是套接字上read返回0.(当然现在也加上了主动关闭），本文探讨被动关闭的流程。 首先TcpConnection::handleRead中，如果read 返回0，去执行handleClose。 void TcpConnection::handleRead(Timestamp receiveTime) { loop_->asser...
TCP连接关闭总结
Shallway
01-24 1万+
由于涉及面太广，只作简单整理，有兴趣的可参考《UNIX Networking Programming》volum 1, Section 5.7, 5.12, 5.14, 5.15, 6.6 以及7.5 SO_LINGER选项。以一个简单的echo服务器为例，客户端从标准输入读入字符，发送给服务器，服务器收到后再原样返回，客户端收到后打印到标准输出。那么，关于套接字的关闭有以下几种情形：
TCP关闭
MyObject-C的专栏
12-05 783
以下描述主要是针对windows平台下的TCP socket而言。 首先需要区分一下关闭socket和关闭TCP连接的区别，关闭TCP连接是指TCP协议层的东西，就是两个TCP端之间交换了一些协议包（FIN，RST等），具体的交换过程可以看TCP协议，这里不详细描述了。而关闭socket是指关闭用户应用程序中的socket句柄，释放相关资源。但是当用户关闭socket句柄时会隐含的触发TCP
muduo库的学习10---TcpServer与TcpClient的基本设计---TcpConnection建立与关闭
山鸡哥的专栏
02-29 1498
aa
muduo库学习之设计与实现07——TcpConnection 断开连接
qq_22473333的博客
02-07 389
东阳的学习笔记 muduo 只有一种关闭连接的方式：被动关闭（p. 191）。 即：对方先关闭连接，本地 read(2) 返回0，触发关闭逻辑。 如果有必要也可给 TcpConnection 新增 forceClose() 成员函数，用于主动关闭连接，实现很简单，调用 handleClose() 即可。 函数调用的逻辑如下图： 一般来说数据的删除比新建要麻烦，TCP 连接也不例外。关闭连接的流程看上去有点 “绕”，原因是对象生命期管理的需要（p. 274） 其中 X 表示 TcpConnect.
muduo-0.9.1-beta.tar.gz
11-30
3. 处理连接：通过`TcpServer::newConnection`方法处理新的客户端连接，并定义相应的回调函数处理数据读写。 4. 定义事件处理器：muduo库中的`EventLoop`和`Channel`类是处理事件的基础，你可以自定义事件处理器类...
muduo-release.zip
06-30
使用muduo最新版编译后的文件以及头文件，可以直接放入项目中使用。注：编译之后，会在用户目录下生成一个build文件夹，该文件夹下有release-install-cpp11文件夹，里面有两个文件夹分别是include和lib，这是编译后...
WebServer-reference-muduo
03-15
本项目是由C ++ 11编写的一个静态Web服务器，能够解析GET请求，参考了陈硕大佬的muduo网络库，linya的WebServer和游双的《 Linux高效服务器编程》。在本机上使用webbench并发1000个客户端访问，短连接能达到大约3...
muduo_server_learn.zip
03-12
6. **完整的TCP和UDP网络编程接口**：muduo提供了易于使用的接口，包括TCP连接管理、UDP套接字操作等。 在实际学习过程中，你将通过以下步骤逐步掌握muduo的使用： 1. **环境配置**：确保你有一个支持C++11的...
muduo源码注释（非常详细）
10-10
个人在阅读muduo源码时，做的注释，非常详细，可以配合我的博客一起阅读。
c#杀死对应端口的TCP进程
KingOfBadLuck的博客
01-14 818
c#、端口、杀死进程，端口8080被占用
服务器开发中的错误处理与连接关闭-结合muduo库
hdadiao的博客
03-20 577
服务器开发中的错误处理与连接关闭 RST包和IO函数 收到RST包的情况 RST包即复位包，一般在连接发生错误的时候由传输层发送的一个包，R ST用来异常的关闭连接。发送RST包关闭连接时，不必等待缓冲区的数据都发出去（普通的close会先将发送缓冲区中的数据发送完毕后再发送fin包），直接就丢弃缓冲区的包发送RST包，而接收端收到RST后，也不必发送ACK确认。常见的收到RST包的情况有...
谈谈muduo库的销毁连接对象——C++程序内存管理和线程安全的极致体现
weixin_45685193的博客
09-24 693
浅谈muduo库的连接销毁过程
TCP连接关闭
屌丝的天空
04-17 842
一般来说，tcp正常关闭需要四个包。比如a和b关闭连接，a先 给b发一个fin，b会进行确认ack，然后b也会发出fin，当a接受到这个fin，并发出最后一个ack后，就会处于time_wait状态。这个时 间长短跟操作系统有关，一般会在1-4分钟，也就是两倍的数据包(2msl)最大生存时间。TCP主动关闭方采用TIME_WAIT主要是为了实现终止 TCP全双工连接的可靠性及允许老的重复分节在网络
C# 建立Tcp 的 阻止同步模式的客户端和服务器端例子
thanklife的专栏
02-16 1283
1，这是MSDN的使用TcpListener建立TcpServer的同步方法，读socket的时候会堵塞 using System; using System.IO; using System.Net; using System.Net.Sockets; using System.Text; class MyTcpListener { public static void Main() { TcpListener server = null; try
TCP关闭连接
kk的任意门
10-13 4531
TCP关闭连接
TCP连接的状态与关闭方式，及其对Server与Client的影响
weixin_30443075的博客
04-05 292
1.TCP连接的状态 　　首先介绍一下TCP连接建立与关闭过程中的状态。TCP连接过程是状态的转换，促使状态发生转换的因素包括用户调用、特定数据包以及超时等，具体状态如下所示： CLOSED：初始状态，表示没有任何连接。 LISTEN：Server端的某个Socket正在监听来自远方的TCP端口的连接请求。 SYN_SENT：发送连接请求后等待确认信息。当客户端Socket进行Con...
好用的TCP_Server代码
qq_44712722的博客
04-08 670
分享一个好用的TCP_Server代码
Golang Socket Tcp 连接优雅关闭
热门推荐
soekchl521的博客
03-26 1万+
主要是利用 系统监听Interrupt 信号，并且提前关闭服务器 监听，并且等待先前连接处理完毕后在退出程序。 Server 代码： package main import (     "net"     "os"     "os/signal"     "strings"     "sync"     "time"     . "github.com/soek
muduo connector
最新发布
01-11
Muduo的连接器类主要有两个：TcpClient和TcpServer。TcpClient用于作为TCP客户端，TcpServer用于作为TCP服务器。 TcpClient类提供了一些方法来建立和管理TCP连接。例如，可以使用connect()方法来连接到服务器，使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值