muduo网络库学习笔记(13)：TcpConnection生命期的管理

本篇通过分析muduo中TcpConnection对断开连接事件的处理，来学习muduo网络库对TcpConnection生命期的管理。

TcpConnection对连接断开事件的处理

首先，我们来看一下TcpConnection处理连接断开事件时函数调用的流程：



我们这里所指的连接断开，都是指被动关闭，即对方先关闭连接，本地read(2)返回0，触发关闭逻辑。

分析：一个服务器（TcpServer）维护了一个连接列表，当一个连接断开时，TcpConnection中的通道处于活跃的状态，EventLoop的事件循环返回了这个活跃的通道，然后调用通道的handleEvent()函数来处理。连接关闭是可读事件，进而回调了TcpConnection的handleRead()函数，handleRead()中又调用了read()返回为0，判断read()返回为0又会调用handleClose()函数。handleClose()函数会回调TcpServer的removeConnection()函数，其中会调用erase()将该连接从连接列表移除。

这里我们需要注意的是——一般情况下，将连接从连接列表移除后，我们就可以将这个连接对象销毁（delete）掉了，但是在这里我们不能立即销毁这个连接对象，原因如下：

如果我们销毁了这个对象，TcpConnection所包含的Channel对象也就跟着被销毁了，而我们当前正在调用Channel对象的handleEvent()函数，就会出现core dump。所以，我们必须保证TcpConnection的生存期长于Channel::handleEvent()函数。

muduo选择用智能指针shared_ptr来管理TcpConnection的生命期，并且让TcpConnection类继承自boost::enable_shared_from_this。

源码分析

具体代码改动如下：

代码片段1：Channel的改动
文件名：Channel.cc

// 析构函数中会判断Channel是否仍处于事件处理状态
// 在事件处理期间Channel对象不会析构
Channel::~Channel()
{
assert(!eventHandling_);
}

// 开始处理事件之前，会将事件处理标志位置为true
// 直到事件处理完，事件处理标志位再置为false
void Channel::handleEventWithGuard(Timestamp receiveTime)
{
eventHandling_ = true;
if ((revents_ & POLLHUP) && !(revents_ & POLLIN))
{
if (logHup_)
{
LOG_WARN << "Channel::handle_event() POLLHUP";
}
if (closeCallback_) closeCallback_();
}
if (revents_ & POLLNVAL)
{
LOG_WARN << "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;
}

代码片段2：TcpConnection::handleRead()函数的改动
文件名：TcpConnection.cc

void TcpConnection::handleRead(Timestamp receiveTime)
{
loop_->assertInLoopThread();
int savedErrno = 0;
char buf[65536];
ssize_t n = ::read(channel_->fd(), buf, sizeof buf);
// 根据read(2)的返回值分别调用messageCallback_()、handleClose()和handleError()
if (n > 0)
{
messageCallback_(shared_from_this(), buf, n);
}
else if (n == 0)
{
handleClose();
}
else
{
errno = savedErrno;
LOG_SYSERR << "TcpConnection::handleRead";
handleError();
}
}

代码片段3：TcpConnection::handleClose()函数
文件名：TcpConnection.cc

void TcpConnection::handleClose()
{
loop_->assertInLoopThread();
LOG_TRACE << "fd = " << channel_->fd() << " state = " << state_;
// 断定此时连接处于已连接状态
assert(state_ == kConnected);
// we don't close fd, leave it to dtor, so we can find leaks easily.
channel_->disableAll();

// must be the last line
// 调用所设置的连接关闭回调函数
closeCallback_(shared_from_this());
}

代码片段4：TcpServer::removeConnection()函数
文件名：TcpServer.cc

void TcpServer::removeConnection(const TcpConnectionPtr& conn)
{
loop_->assertInLoopThread();
LOG_INFO << "TcpServer::removeConnectionInLoop [" << name_
<< "] - connection " << conn->name();
// 将断开的连接从连接列表中移除
size_t n = connections_.erase(conn->name());
(void)n;
assert(n == 1);
// 此处一定要用EventLoop::queueInLoop()，避免Channel对象被提前销毁
// 这里用boost::bind让TcpConnection的生命期长到调用connectDestroyed()的时刻
// 使用boost::bind得到一个boost::function对象,会把conn传递进去，引用计数会加1
loop_->queueInLoop(
boost::bind(&TcpConnection::connectDestroyed, conn));
}

Channel::handleEvent()事件处理完后就会调用functors（见博客“muduo网络库学习笔记(11)：有用的runInLoop()函数”）即调用TcpConnection::connectDestroyed()。

代码片段5：TcpConnection::connectDestroyed()函数
文件名：TcpConnection.cc

// connectDestroyed()是TcpConnection析构前最后调用的一个成员函数
// 它通知用户连接已断开
void TcpConnection::connectDestroyed()
{
loop_->assertInLoopThread();
assert(state_ == kConnected);
setState(kDisconnected);
channel_->disableAll();
connectionCallback_(shared_from_this());  // 回调用户设定的回调函数
loop_->removeChannel(get_pointer(channel_));  // 从poll/epoll中移除channel
}

boost::enable_shared_from_this

由于TcpConnection模糊的生命期，我们用到了shared_ptr来管理它的生命期，并让TcpConnection类继承自boost::enable_shared_from_this。那么，boost::enable_shared_from_this的作用是什么呢？

使用示例：

#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <cassert>

// class Y继承自boost::enable_shared_from_this<Y>
class Y: public boost::enable_shared_from_this<Y>
{
public:
boost::shared_ptr<Y> f()
{
return shared_from_this();  // 返回指向自身的shared_ptr
}

Y* f2()
{
return this;
}
};

int main()
{
boost::shared_ptr<Y> p(new Y);  // p的引用计数为1
boost::shared_ptr<Y> q = p->f();  // 将当前对象转换为一个shared_ptr，赋值给q，此时p/q引用计数为2

Y* r = p->f2();
assert(p == q);  // 断言正确
assert(p.get() == r);  // 断言正确

std::cout << p.use_count() << std::endl;  // 输出：2

// 构造一个shared_ptr对象s,将r赋给s
// 打印出的s的引用计数应该为1，而不是3
// 因为此时构造了一个新的、独立的shared_ptr对象，而不是将一个shared_ptr对象赋值给另一个shared_ptr对象
boost::shared_ptr<Y> s(r);
std::cout << s.use_count() << std::endl;
assert(p == s);  // 断言失败

return 0;
}

测试结果如图：



所以，在TcpConnection的生命期管理过程中，如果我们直接用this指针传递对象，可能会构建一个新的shared_ptr对象，并不是直接将我们之前管理的对象的shared_ptr拷贝过去从而使引用计数加1，故我们需要用到boost::enable_shared_from_this的shared_from_this()函数。