Muduo分析及总结（六）TcpConnection

最新推荐文章于 2024-05-13 07:59:59 发布
最新推荐文章于 2024-05-13 07:59:59 发布
阅读量1.3k 收藏 10
点赞数 2
分类专栏： Muduo Muduo源码阅读总结 文章标签： Muduo TcpConnection
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H514434485/article/details/95108114
版权
一、类关系图

首先看TcpConnection在整个Muduo结构中的关系，如下图
图1

  1. TcpConnection是整个网络库的核心，封装一次Tcp连接，注意它不能发起连接。
  2. TcpServer和TcpClient都用到了TcpConnection。
二、源码分析

TcpConnection.h

///
/// TCP connection, for both client and server usage.
///
/// This is an interface class, so don't expose too much details.
class TcpConnection : boost::noncopyable,
					  public boost::enable_shared_from_this<TcpConnection>
{
 public:
  /// Constructs a TcpConnection with a connected sockfd
  ///
  /// User should not create this object.
  TcpConnection(EventLoop* loop,
				const string& name,
				int sockfd,
				const InetAddress& localAddr,
				const InetAddress& peerAddr);
  ~TcpConnection();

  EventLoop* getLoop() const { return loop_; } //获取当前TcpConnection所在的EventLoop
  const string& name() const { return name_; } //TcpConnection名称
  const InetAddress& localAddress() { return localAddr_; }//当前服务端地址
  const InetAddress& peerAddress() { return peerAddr_; }//远程连接客户端地址
  bool connected() const { return state_ == kConnected; }//检测是否连接

  //发送数据
  // void send(string&& message); // C++11
  void send(const void* message, size_t len);
  void send(const StringPiece& message);
  // void send(Buffer&& message); // C++11
  void send(Buffer* message);  // this one will swap data

  //关闭，里面有一定的处理逻辑
  void shutdown(); // NOT thread safe, no simultaneous calling

  //设置tcpNoDelay
  void setTcpNoDelay(bool on);

  //设置内容。这个内容可以是任何数据，主要是用着一个临时存储作用。
  void setContext(const boost::any& context)
  { context_ = context; }

  //获取内容的引用(获取当前内容，一般在回调中使用)
  const boost::any& getContext() const
  { return context_; }

  //获取内容的地址(获取当前内容，一般在回调中使用)
  boost::any* getMutableContext()
  { return &context_; }

  //设置连接回调。一般用于做什么?
  //a、连接的建立、连接的销毁、产生关闭事件时会调用此回调，通知外部状态。
  void setConnectionCallback(const ConnectionCallback& cb)
  { connectionCallback_ = cb; }

  //设置消息回调。一般接收到数据之后会回调此方法
  void setMessageCallback(const MessageCallback& cb)
  { messageCallback_ = cb; }


  //写完成回调。
  void setWriteCompleteCallback(const WriteCompleteCallback& cb)
  { writeCompleteCallback_ = cb; }

  //设置高水位回调。
  void setHighWaterMarkCallback(const HighWaterMarkCallback& cb, size_t highWaterMark)
  { highWaterMarkCallback_ = cb; highWaterMark_ = highWaterMark; }

  //获取输入Buffer地址
  Buffer* inputBuffer()
  { return &inputBuffer_; }

   ///关闭回调
  /// Internal use only.
  void setCloseCallback(const CloseCallback& cb)
  { closeCallback_ = cb; }

  // called when TcpServer accepts a new connection
  void connectEstablished();   // should be called only once
  // called when TcpServer has removed me from its map
  void connectDestroyed();	// should be called only once

 private:
  enum StateE { kDisconnected, kConnecting, kConnected, kDisconnecting };
  void handleRead(Timestamp receiveTime);
  void handleWrite();
  void handleClose();
  void handleError();
  //void sendInLoop(string&& message);
  void sendInLoop(const StringPiece& message);
  void sendInLoop(const void* message, size_t len);
  void shutdownInLoop();
  void setState(StateE s) { state_ = s; }

  EventLoop* loop_;
  string name_;
  StateE state_;  // FIXME: use atomic variable
  // we don't expose those classes to client.
  boost::scoped_ptr<Socket> socket_;  //连接Socket
  boost::scoped_ptr<Channel> channel_;//通道
  InetAddress localAddr_;  //当前服务端地址
  InetAddress peerAddr_; //当前连接客户端地址

  //回调函数
  ConnectionCallback connectionCallback_;
  MessageCallback messageCallback_;
  WriteCompleteCallback writeCompleteCallback_;
  HighWaterMarkCallback highWaterMarkCallback_;
  CloseCallback closeCallback_;
  size_t highWaterMark_;//高水位线
  Buffer inputBuffer_; //输入Buffer
  Buffer outputBuffer_; // FIXME: use list<Buffer> as output buffer.
  boost::any context_; //?
  // FIXME: creationTime_, lastReceiveTime_
  //		bytesReceived_, bytesSent_
};

typedef boost::shared_ptr<TcpConnection> TcpConnectionPtr;

TcpConnection.cc

/默认连接回调。输出连接状态
void muduo::net::defaultConnectionCallback(const TcpConnectionPtr& conn)
{
  LOG_TRACE << conn->localAddress().toIpPort() << " -> "
			<< conn->peerAddress().toIpPort() << " is "
			<< (conn->connected() ? "UP" : "DOWN");
}

//默认的有消息时执行的回调。默认取走所有数据
void muduo::net::defaultMessageCallback(const TcpConnectionPtr&,
										Buffer* buf,
										Timestamp)
{
  buf->retrieveAll();
}

//TcpConnection创建时的值
//Eventloop、名称、套接字、本地服务端地址、客户端地址

//初始化的默认值
//状态、创建一个Socket管理、创建一个通道
//本地地址、远程客户端地址
//高水位标志。FIXME 这个标志目前没理解


//a、sockfd是已连接上的句柄。
//b、TcpConnection的名称。
//c、连接状态初始化正在连接中。
//d、封装sockfd为Socket。
//e、利用loop和sockfd，创建一个通道。
//f、本地地址+ 客户端地址。
//g、设置默认高水位阀值

TcpConnection::TcpConnection(EventLoop* loop,
							 const string& nameArg,
							 int sockfd,
							 const InetAddress& localAddr,
							 const InetAddress& peerAddr)
  : loop_(CHECK_NOTNULL(loop)),
	name_(nameArg),
	state_(kConnecting),
	socket_(new Socket(sockfd)),
	channel_(new Channel(loop, sockfd)),
	localAddr_(localAddr),
	peerAddr_(peerAddr),
	highWaterMark_(64*1024*1024)
{

  //设置读回调，会传一个参数
  channel_->setReadCallback(
	  boost::bind(&TcpConnection::handleRead, this, _1));

  //设置写回调。
  channel_->setWriteCallback(
	  boost::bind(&TcpConnection::handleWrite, this));

  //设置关回调。
  channel_->setCloseCallback(
	  boost::bind(&TcpConnection::handleClose, this));

  //设置错误回调
  channel_->setErrorCallback(
	  boost::bind(&TcpConnection::handleError, this));
  LOG_DEBUG << "TcpConnection::ctor[" <<  name_ << "] at " << this
			<< " fd=" << sockfd;
  socket_->setKeepAlive(true); //开启协议栈层心跳
}


//析构时就输出下日志，这里没任何资源的释放，
//应该都是外部进行管理。FIXME 待确认。
TcpConnection::~TcpConnection()
{
  LOG_DEBUG << "TcpConnection::dtor[" <<  name_ << "] at " << this
			<< " fd=" << channel_->fd();
}


void TcpConnection::send(const void* data, size_t len)
{

  //处于连接状态才发送
  if (state_ == kConnected)
  {
	if (loop_->isInLoopThread())
	{

	  //如果是当前线程就直接发送
	  sendInLoop(data, len);
	}
	else
	{

	  //如果Loop在别的线程中这放到loop待执行回调队列执行。
	  //会涉及到数据拷贝
	  string message(static_cast<const char*>(data), len);
	  loop_->runInLoop(
		  boost::bind(&TcpConnection::sendInLoop,
					  this, 	// FIXME
					  message));
	}
  }
}


//功能同上，都是发送数据
void TcpConnection::send(const StringPiece& message)
{
  if (state_ == kConnected)
  {
	if (loop_->isInLoopThread())
	{
	  sendInLoop(message);
	}
	else
	{
	  loop_->runInLoop(
		  boost::bind(&TcpConnection::sendInLoop,
					  this, 	// FIXME
					  message.as_string()));
					//std::forward<string>(message)));
	}
  }
}


//这个send是发送所有数据，要注意效率问题
// FIXME efficiency!!!
void TcpConnection::send(Buffer* buf)
{
  if (state_ == kConnected)
  {
	if (loop_->isInLoopThread())
	{
	  sendInLoop(buf->peek(), buf->readableBytes());
	  buf->retrieveAll();
	}
	else
	{
	  loop_->runInLoop(
		  boost::bind(&TcpConnection::sendInLoop,
					  this, 	// FIXME
					  buf->retrieveAllAsString()));
					//std::forward<string>(message)));
	}
  }
}

void TcpConnection::sendInLoop(const StringPiece& message)
{
  sendInLoop(message.data(), message.size());
}


//发送数据重点函数
void TcpConnection::sendInLoop(const void* data, size_t len)
{
  loop_->assertInLoopThread();
  ssize_t nwrote = 0;  //已经发送数据长度
  size_t remaining = len; //还剩要发送的

  
  // if no thing in output queue, try writing directly
  if (!channel_->isWriting() && outputBuffer_.readableBytes() == 0)
  {
        //如果通道没在写数据，同时输出缓存是空的
        //则直接往fd中写数据，即发送
	nwrote = sockets::write(channel_->fd(), data, len);
	if (nwrote >= 0)
	{
	  //发送数据 >= 0
	  remaining = len - nwrote;
	  if (remaining == 0 && writeCompleteCallback_)
	  {
	        //若数据一次性都发完了，同时也设置了写完成回调。
	        //则调用下写完成回调函数。
		loop_->queueInLoop(boost::bind(writeCompleteCallback_, shared_from_this()));
	  }
	}
	else // nwrote < 0
	{

	  //如果写返回值小于0，表示写出错
	  //则把已写数据大小设置为0。
	  nwrote = 0;
	  if (errno != EWOULDBLOCK)
	  {
		LOG_SYSERR << "TcpConnection::sendInLoop";
	  }
	}
  }


  //a、不直接发送数据情况。
  //b、数据未发送完的情况。
  assert(remaining <= len);
  if (remaining > 0)
  {
	LOG_TRACE << "I am going to write more data";
	size_t oldLen = outputBuffer_.readableBytes();
	if (oldLen + remaining >= highWaterMark_
		&& oldLen < highWaterMark_
		&& highWaterMarkCallback_)
	{

	  //添加新的待发送数据之后，如果数据大小已超过设置的警戒线
	  //则回调下设置的高水平阀值回调函数，对现有的长度做出处理。
	  //高水平水位线的使用场景?
	  loop_->queueInLoop(boost::bind(highWaterMarkCallback_, shared_from_this(), oldLen + remaining));
	}

	//往outputBuffer后面添加数据。涉及到数据的拷贝
	outputBuffer_.append(static_cast<const char*>(data)+nwrote, remaining);
	if (!channel_->isWriting())
	{

	  //将通道置成可写状态。这样当通道活跃时，
	  //就好调用TcpConnection的可写方法。
	  //对实时要求高的数据，这种处理方法可能有一定的延时。
	  channel_->enableWriting();
	}
  }
}

//关闭动作，如果状态是连接，
//则要调用下关闭动作。
void TcpConnection::shutdown()
{
  // FIXME: use compare and swap
  if (state_ == kConnected)
  {
	setState(kDisconnecting);
	// FIXME: shared_from_this()?
	loop_->runInLoop(boost::bind(&TcpConnection::shutdownInLoop, this));
  }
}

//a、通道不再写数据，则直接关闭写
//b、通道若处于写数据状态，则不做
//   处理，留给后面处理。
//   后面是指在handleWrite的时候，
//   如果发现状态是断开，则调用shutdownWrite
void TcpConnection::shutdownInLoop()
{
  loop_->assertInLoopThread();
  if (!channel_->isWriting())
  {
	// we are not writing
	socket_->shutdownWrite();
  }
}

//开启TcpNoDelay状态，禁用Nagle算法。
//开启目的是避免连续发包出现延迟，
//这对编写低延迟网络服务很重要
void TcpConnection::setTcpNoDelay(bool on)
{
  socket_->setTcpNoDelay(on);
}

//连接建立完成方法，
//当TcpServer accepts a new connection时，调用此方法
//a、设置下状态
//b、通道tie下，并设置可读
//c、调用下连接建立完成的回调函数
void TcpConnection::connectEstablished()
{
  loop_->assertInLoopThread();
  assert(state_ == kConnecting);
  setState(kConnected);
  channel_->tie(shared_from_this());
  channel_->enableReading();

  //输出一些信息
  connectionCallback_(shared_from_this());
}

//连接销毁。当TcpServer将TcpConnection从
//map列表中清除时，会调用此方法。
//a、设置下状态
//b、关闭通道
//c、调用下连接回调函数。
//d、移除通道。
void TcpConnection::connectDestroyed()
{
  loop_->assertInLoopThread();
  if (state_ == kConnected)
  {
	setState(kDisconnected);
	channel_->disableAll();

	connectionCallback_(shared_from_this());
  }
  channel_->remove(); //移除当前通道
}

//有可读事件时.
void TcpConnection::handleRead(Timestamp receiveTime)
{
  loop_->assertInLoopThread();
  int savedErrno = 0;

  //直接将数据读到inputBuffer
  ssize_t n = inputBuffer_.readFd(channel_->fd(), &savedErrno);
  if (n > 0)
  {
        //a、读取数据大于0，调用下回调
	messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
  }
  else if (n == 0)
  {
        //b、等于0表示要socket关闭
	handleClose();
  }
  else
  {
        //c、小于0表示有错误。 
	errno = savedErrno;
	LOG_SYSERR << "TcpConnection::handleRead";
	handleError();
  }
}

//回调调用可写函数
void TcpConnection::handleWrite()
{
  loop_->assertInLoopThread();
  if (channel_->isWriting())
  {
       //通道可写才进入

	//写缓存里所有数据   
	ssize_t n = sockets::write(channel_->fd(),
							   outputBuffer_.peek(),
							   outputBuffer_.readableBytes());
	if (n > 0)
	{

	  //发送了多少数据，设置Buffer索引，
	  //当外部调用TcpConnection::shutdown时也不直接关闭
	  //要等数据发送完了之后再关闭。
	  outputBuffer_.retrieve(n);
	  if (outputBuffer_.readableBytes() == 0)
	  {
	        //如果Buffer可读数据为0表示都已经发送完毕。
	        //关闭通道的写状态。
		channel_->disableWriting();
		if (writeCompleteCallback_)
		{
		  //如果有写完成回调函数，就调用下。
		  loop_->queueInLoop(boost::bind(writeCompleteCallback_, shared_from_this()));
		}

		//如果状态已经是断开中，
		//则要关闭。FIXME_hqb 是哪里设置的呢?
		//TcpConnection::shutdown调用时会设置状态为kDisconnecting
		if (state_ == kDisconnecting)
		{
		  shutdownInLoop();
		}
	  }
	  else
	  {
	        //未写完，则继续写
		LOG_TRACE << "I am going to write more data";
	  }
	}
	else
	{
	  LOG_SYSERR << "TcpConnection::handleWrite";
	  // if (state_ == kDisconnecting)
	  // {
	  //   shutdownInLoop();
	  // }
	}
  }
  else
  {
	LOG_TRACE << "Connection is down, no more writing";
  }
}

//连接关闭
//这里fd不关闭，fd是外部传入的
//当TcpConnection析构时，Sockets会析构
//由Sockets去关闭socket
void TcpConnection::handleClose()
{
  loop_->assertInLoopThread();
  LOG_TRACE << "TcpConnection::handleClose state = " << state_;
  assert(state_ == kConnected || state_ == kDisconnecting);
  // we don't close fd, leave it to dtor, so we can find leaks easily.
  setState(kDisconnected);
  channel_->disableAll();

  TcpConnectionPtr guardThis(shared_from_this());
  connectionCallback_(guardThis);
  // must be the last line
  closeCallback_(guardThis);
}

//输出下错误日志。
void TcpConnection::handleError()
{
  int err = sockets::getSocketError(channel_->fd());
  LOG_ERROR << "TcpConnection::handleError [" << name_
			<< "] - SO_ERROR = " << err << " " << strerror_tl(err);
}
三、连接的建立

在这里插入图片描述
当有新连接到达时，TcpServer会为新连接创建对应的TcpConnection对象，即每个连接一个TcpConnection对象。

四、连接的断开

在这里插入图片描述
Muduo只有一种关闭连接的方式：被动关闭。即对方先关闭连接，本地read(2)返回0，触发关闭逻辑。

  1. 当TcpServer或者TcpClinet析构时会涉及到TcpConnection::connectDestroyed()关闭本端连接。
  2. 远程的TcpClinet或者TcpServer就好read(2)返回0，最后关闭本端连接。
五、关键点总结
1、高低水位问题

非阻塞网络编程中的发送数据比读取数据要困难的多：

  1. 一方面什么时候关注“writable事件”问题，这只是带来编码方面的难度。
  2. 一方面如果发送数据的速度高于对方接受数据的速度，会造成数据在本地内存中的堆积，
    这带来设计及安全性方面的难度。

Muduo对此解决办法是提供两个回调，有的网络库把它们称为“高水位回调”和“低水位回调”，Muduo使用
HighWaterMarkCallback和WriteCompleCallback这两个名字。

1.1 WriteCompleCallback

如果发送缓存区被清空，就调用它。TcpConnection有两处可能触发此回调。

  1. TcpConnection::sendInLoop()。
  2. TcpConnection::handleWrite()。
1.2 HighWaterMarkCallback

如果输出缓冲的长度超过用户指定大小，就会触发回调（只在上升沿触发一次）。
在非阻塞的发送数据情况下，假设Server发给Client数据流，为防止Server发过来的数据撑爆Client的输出缓冲区，一种做法是在Client的HighWaterMarkCallback中停止读取Server的数据，而在Client的WriteCompleteCallback中恢复读取Server的数据。

2、TcpConnection::shutdown没直接关闭Tcp连接

Muduo TcpConnection没有提供close，而只提供shutdown()，这么做是为了收发数据的完整性。

  • Tcp是一个全双工协议，同一个文件描述符即可读又可写，shutdownWrite() 关闭了 “ 写”
    方向的连接，保留了“ 读 ”方向，这称为Tcphalf-close。如果直接close(socket_fd)，
    那么socket_fd就不能读或写了。

  • 用shutdown而不用close的效果是，如果对方已经发送了数据，这些数据还“ 在路上 ”，
    那么muduo不会漏收这些数据。换句话说，muduo在TCP这一层面解决了“当你打算关闭网络忘记的时候，如何得知对方是否发了一些数据而你还没有收到？”这一问题。当然，这个问题也可以在上面的协议层解决，双方协商好不再互发数据，就可以直接断开连接了。

Muduo把“主动关闭连接”这件事分成两步来做，如果要主动关闭连接，它先关闭本地的“写”端，等对方关闭之后，再关闭本地“读”端。
另外如果当前output buffer里面还有数据尚未发出的话，Muduo也不会立刻调用shutwownWrite，而是等到数据发送完毕再shutdown，可以避免对方漏收数据。

3、Muduo什么时候真正close socket

在TcpConnection对象析构的时候，TcpConnection持有一个Socket对象，Socket是一个RAII handler，它的析构函数会close(sockfd_)。

muduo源码分析——TcpConnection
我的～～的博客
09-21 307
muduo中的TcpConnection算是整个框架中的大头吧，因为每个客户端连接对应一个Channel和一个TcpConnection，而之前已经说了，Channel只是一个通道，那么对于客户端连接的各种处理，基本都是在TcpConnection上完成的了。 这个类的cpp文件算是muduo里比较长的了，有400+行。 注意我参考的代码时flamingo的代码，是基于muduo，或者会有些出入。...
muduo库的TcpConnection类剖析
Mr_scott_j的博客
12-12 2696
TcpConnection是muduo中最为复杂的类，其实就是对已连接套接字的一个抽象。 TcpConnection使用Channel来获得socket上的IO事件，它可以自己处理writable事件，而把readable事件通过MessageCallback传达给客户。在TcpConnection析构时候会close(fd)（在Socket析构函数中发生）。
muduo : TcpConnection
Huntinux
08-11 1203
引用前面学习了TcpServer的实现，TcpServer对每个连接都会新建一个TcpConnection（使用shared_ptr管理）。接下来学习一下TcpConnection的设计细节。连接状态muduo对于一个连接的从生到死进行了状态的定义，类似一个状态机。enum States { kDisconnected, kConnecting, kConnected, kDisconnecting
muduo-tcpConnection
Tzecto
05-19 108
tcpConnection tcpserver 通过accepter，有一个新用户连接，accep拿到connfd tcpconnection设置channel相应回调，poller调用回调 class TcpConnection : NonCopyable, public enable_shared_from_this<TcpConnection> { private: enum StateE { k_disconnected, k_conn
muduo库 TcpConnection
weixin_50911232的博客
02-17 290
#pragma once #include"Callbacks.h" #include"noncopyable.h" #include"InetAddress.h" #include"Buffer.h" #include"Timestamp.h" #include<memory> #include<atomic> #include<string> class EventLoop; class Socket; class Channel; /* * TcpSer
muduo Tcpconnection类
xufengyongyou的专栏
04-26 377
muduo  Tcpconnection 封装一次连接
【Muduo源码分析】 解读muduo如何断开连接 TcpConnection
08-14 700
在muduo中只有一种连接断开方式，就是被动关闭，也就是套接字上read返回0.(当然现在也加上了主动关闭），本文探讨被动关闭的流程。 首先TcpConnection::handleRead中，如果read 返回0，去执行handleClose。 void TcpConnection::handleRead(Timestamp receiveTime) { loop_->asser...
【Muduo源码分析】 解读muduo如何发送数据 TcpConnection Buffer
08-14 442
本文旨在讲述muduo网络库数据的发送流程。 首先明确一点，Muduo中的epoll使用了水平触发方式，而不是边缘触发。 TcpConnection首先需要增加应用层的缓冲区 Buffer outputBuffer_; 我们看到在TcpConnection类内，提供了两个数据发送函数，分别是TcpConnection::send,TcpConnection::sendInLoop。前者...
Muduo网络库源码分析（六）TcpConnection 的生存期管理
NK_test的博客
04-22 7835
TcpConnection是使用shared_ptr来管理的类，因为它的生命周期模糊。TcpConnection表示已经建立或正在建立的连接，建立连接后，用户只需要在上层类如TcpServer中设置连接到来和消息到来的处理函数，继而回调TcpConnection中的 setConnectionCallback和setMessageCallback函数，实现对事件的处理。用户需要关心的事件是有限的，
【Muduo源码剖析笔记】 网络库之TcpConnection
LeeEdgar的博客
06-06 151
Muduo库源码阅读笔记
muduo_net代码剖析之TcpConnection
JaweG
11-29 331
1、TcpServer在接收并建立连接的过程中，TcpConnection做了什么工作？ 经过前文对TcpServer类的讲解以及上图的展示，我们知道： TcpConnection是TcpServer的一个成员变量 当TcpServer接收到client的连接请求后，将会回调newConnection()函数：先创建TcpConnection对象用来与client连接，再执行connectEs...
5.muduo之TcpConnection类
qq_42987442的博客
09-09 216
介绍： 1.TcpConnection.h文件 ///该类对象，客户端和服务器都会用到 ///这是一个接口类，所以不用暴露太多细节 class TcpConnection : noncopyable, public std::enable_shared_from_this<TcpConnection> { public: /// Constructs a TcpConnection with a connected sockfd ///用一个
[muduo网络库]——muduo库TcpConnection类，万字总结（剖析muduo网络库核心部分、设计思想）
最新发布
m0_73537205的博客
05-13 3339
muduo 是由陈硕大佬个人开发的 TCP 网络库，本专栏使用c++11重构了Muduo库中核心的Multi-Reactor架构，剖析大佬核心的代码设计思想，希望能够理清自己的思路，也希望能够帮助到大家。
Muduo之TcpConnection源码分析笔记
Aaron的专栏
05-04 510
Muduo之TcpConnection源码分析笔记
muduo源码分析之TcpConnection发送数据
上善若水
12-12 1168
muduo源码分析之TcpConnection发送数据
muduo学习笔记：net部分之实现TCP网络编程库-TcpConnection
热爱生活，忠于自己
08-31 717
TcpConnection是TCP网络库的核心，封装了一次TCP连接，但是它不能发起连接。当TcpServer和TcpCliet成功建立连接后，都会通过TcpConnection对象进行收发数据通信。 1、TCP连接的建立、断开流程 TcpServer新建连接的函数相关调用时序见下图。 ...
muduo中TcpServer、TcpConnection执行过程
wk_bjut_edu_cn的博客
07-03 732
muduo中的Acceptor类的主要功能是socket、bind、listen，Acceptor用于accept接受TCP连接 一般来说，在上层应用程序中，我们不直接使用Acceptor，而是把它作为TcpServer的成员 TcpServer还包含了一个TcpConnection列表这是一个已连接列表。TcpConnection与Acceptor类似，有两个重要的数据成员，Socket与...
muduo网络库学习之EventLoop（五）：TcpConnection生存期管理（连接关闭）
Meditation
11-09 4542
监听套接字可读事件是POLLIN; 已连接套接字正常可读是POLLIN; 正常可写是POLLOUT; 对等方close/shutdown关闭连接，已连接套接字可读是POLLIN | POLLHUP; 时序图分析： 注意：将TcpConnectionPtr 在connections_ 中 erase 掉，时并不会马上 析构TcpConnection 对象（引用计数不为0），
muduo库的学习10---TcpServer与TcpClient的基本设计---TcpConnection建立与关闭
山鸡哥的专栏
02-29 1535
aa
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值