muduo网络库源码详解(4) 以EchoServer为例子，从一次连接的建立说起，分析TcpConnection
主要参考了陈硕的书《Linux多线程服务端编程》，结合自己的逻辑摘了一些重要的的句子和函数、数据成员进行分析。
EchoServer的main函数代码
int main()
{
muduo::net::EventLoop loop; // 构造一个loop
muduo::net::InetAddress listenAddr(8888); // sockaddr_in的封装，服务地址未填写默认本地
EchoServer server(&loop, listenAddr); // TcpServer的初始化、构造函数里 手动绑定回调函数
server.start();
loop.loop();
}
文章目录
在我的muduo源码分析的第二篇文章 讲解了 ConnectionCallback回调函数是如何一步步设置到Channel里的（如下图黄线，单击放大），
- EchoServer（用户）设置TcpServer的 connectionCallback_成员 为 EchoServer::onConnection
- TcpServer设置Acceptor的 newConnectionCallback_成员 为 TcpServer::newConnection —— （负责调用 connectionCallback_）
- Acceptor 设置 Channel 的 readCallback_ 成员为 Acceptor::handleRead —— （负责调用 newConnectionCallback_)
- 总计进行了3层封装
总览图！
多线程情况
-
TcpServer 创建一个 TcpConnection
-
该TcpConnection 将 所接收到的 套接字 封装成 Channel 被设置read、write、close、error回调函数
-
mainLoop 唤醒 subLoop （方法是往 subLoop 的 wakeupFd 写一个字）
-
被唤醒的 subLoop 会执行 被mainLoop 放到 std::vector<Functor> pendingFunctors_ 的函数
-
最后TcpConnection 会为往 subLoop的poller 注册设置好的 Channel
下面进行代码分析（多线程版），从Acceptor的回调handleRead说起
Acceptor::handleRead
loop中Acceptor::handleRead的调用过程
// listenfd有事件发生了，就是有新用户连接了
void Acceptor::handleRead()
{
InetAddress peerAddr;
int connfd = acceptSocket_.accept(&peerAddr);
if (connfd >= 0)
{
if (newConnectionCallback_)
{
newConnectionCallback_(connfd, peerAddr); // 轮询找到subLoop，唤醒，分发当前的新客户端的Channel
}
else
{
::close(connfd);
}
}
else
{
LOG_ERROR("%s:%s:%d accept err:%d \n", __FILE__, __FUNCTION__, __LINE__, errno);
if (errno == EMFILE)
{
LOG_ERROR("%s:%s:%d sockfd reached limit! \n", __FILE__, __FUNCTION__, __LINE__);
}
}
}
文件描述符耗尽不处理，则监听套接字仍然是活跃的，不接收会一直活跃，陷入死循环，muduo通过设置了一个指向空的文件描述符解决该问题
void TcpServer::newConnection
// 有一个新的客户端的连接，acceptor会执行这个回调操作
void TcpServer::newConnection(int sockfd, const InetAddress &peerAddr)
{
// 轮询算法，选择一个subLoop，来管理channel
EventLoop *ioLoop = threadPool_->getNextLoop();
char buf[64] = {0};
snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_);
++nextConnId_;
std::string connName = name_ + buf;
LOG_INFO("TcpServer::newConnection [%s] - new connection [%s] from %s \n",
name_.c_str(), connName.c_str(), peerAddr.toIpPort().c_str());
// 通过sockfd获取其绑定的本机的ip地址和端口信息
sockaddr_in local;
::bzero(&local, sizeof local);
socklen_t addrlen = sizeof local;
if (::getsockname(sockfd, (sockaddr*)&local, &addrlen) < 0)
{
LOG_ERROR("sockets::getLocalAddr");
}
InetAddress localAddr(local);
// 根据连接成功的sockfd，创建TcpConnection连接对象
TcpConnectionPtr conn(new TcpConnection(
ioLoop,
connName,
sockfd, // Socket Channel
localAddr,
peerAddr));
connections_[connName] = conn;
// 下面的回调都是用户设置给TcpServer=>TcpConnection=>Channel=>Poller=>notify channel调用回调
conn->setConnectionCallback(connectionCallback_);
conn->setMessageCallback(messageCallback_);
conn->setWriteCompleteCallback(writeCompleteCallback_);
// 设置了如何关闭连接的回调 conn->shutDown()
conn->setCloseCallback(
std::bind(&TcpServer::removeConnection, this, std::placeholders::_1)
);
// 直接调用TcpConnection::connectEstablished
ioLoop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn));
}
TcpConnection::TcpConnection
TcpConnection::TcpConnection(EventLoop *loop,
const std::string &nameArg,
int sockfd,
const InetAddress& localAddr,
const InetAddress& peerAddr)
: loop_(CheckLoopNotNull(loop))
, name_(nameArg)
, state_(kConnecting)
, reading_(true)
, socket_(new Socket(sockfd))
, channel_(new Channel(loop, sockfd))
, localAddr_(localAddr)
, peerAddr_(peerAddr)
, highWaterMark_(64*1024*1024) // 64M
{
// 下面给channel设置相应的回调函数，poller给channel通知感兴趣的事件发生了，channel会回调相应的操作函数
channel_->setReadCallback(
std::bind(&TcpConnection::handleRead, this, std::placeholders::_1)
);
channel_->setWriteCallback(
std::bind(&TcpConnection::handleWrite, this)
);
channel_->setCloseCallback(
std::bind(&TcpConnection::handleClose, this)
);
channel_->setErrorCallback(
std::bind(&TcpConnection::handleError, this)
);
LOG_INFO("TcpConnection::ctor[%s] at fd=%d\n", name_.c_str(), sockfd);
socket_->setKeepAlive(true);
}
EventLoop::runInLoop
// 在当前loop中执行cb
void EventLoop::runInLoop(Functor cb)
{
if (isInLoopThread()) // 判断 当前loop是否在所对应的线程中
{
cb();
}
else // 在非当前loop线程中执行cb , 就需要唤醒loop所在线程，执行cb
{
queueInLoop(cb);
}
}
void EventLoop::queueInLoop(Functor cb)
// 把cb放入队列中，唤醒loop所在的线程，执行cb
void EventLoop::queueInLoop(Functor cb)
{
{
std::unique_lock<std::mutex> lock(mutex_);
pendingFunctors_.emplace_back(cb);
}
// 唤醒相应的，需要执行上面回调操作的loop的线程了
// || callingPendingFunctors_的意思是：当前loop正在执行回调，但是loop又有了新的回调，具体与doPendingFunctors()函数有关
if (!isInLoopThread() || callingPendingFunctors_)
{
wakeup(); // 唤醒loop所在线程
}
}
EventLoop::wakeup()
// 用来唤醒loop所在的线程的 向wakeupfd_写一个数据，wakeupChannel就发生读事件，当前loop线程就会被唤醒
void EventLoop::wakeup()
{
uint64_t one = 1;
ssize_t n = write(wakeupFd_, &one, sizeof one);
if (n != sizeof one)
{
LOG_ERROR("EventLoop::wakeup() writes %lu bytes instead of 8 \n", n);
}
}
EventLoop::handleRead()
void EventLoop::handleRead()
{
uint64_t one = 1;
ssize_t n = read(wakeupFd_, &one, sizeof one);
if (n != sizeof one)
{
LOG_ERROR("EventLoop::handleRead() reads %lu bytes instead of 8", n);
}
}
void EventLoop::doPendingFunctors()
void EventLoop::doPendingFunctors() // 执行回调
{
std::vector<Functor> functors;
callingPendingFunctors_ = true;
{
std::unique_lock<std::mutex> lock(mutex_);
functors.swap(pendingFunctors_);
}
for (const Functor &functor : functors)
{
functor(); // 执行当前loop需要执行的回调操作
}
callingPendingFunctors_ = false;
}
TcpConnection::connectEstablished
// 连接建立
void TcpConnection::connectEstablished()
{
setState(kConnected);
channel_->tie(shared_from_this());
channel_->enableReading(); // 向poller注册channel的epollin事件
// 新连接建立，执行回调
connectionCallback_(shared_from_this()); // 调用(用户设置)在连接建立时的回调函数
}
// 在当前loop中执行cb
void EventLoop::runInLoop(Functor cb)
{
if (isInLoopThread()) // 在当前的loop线程中，执行cb
{
cb();
}
else // 在非当前loop线程中执行cb , 就需要唤醒loop所在线程，执行cb
{
queueInLoop(cb);
}
}
// 把cb放入队列中，唤醒loop所在的线程，执行cb
void EventLoop::queueInLoop(Functor cb)
{
{
std::unique_lock<std::mutex> lock(mutex_);
pendingFunctors_.emplace_back(cb);
}
// 唤醒相应的，需要执行上面回调操作的loop的线程了
// callingPendingFunctors_的意思是：当前loop正在执行回调，但是loop又有了新的回调
if (!isInLoopThread() || callingPendingFunctors_)
{
wakeup(); // 唤醒loop所在线程
}
}
// 用来唤醒loop所在的线程的 向wakeupfd_写一个数据，wakeupChannel就发生读事件，当前loop线程就会被唤醒
void EventLoop::wakeup()
{
uint64_t one = 1;
ssize_t n = write(wakeupFd_, &one, sizeof one);
if (n != sizeof one)
{
LOG_ERROR("EventLoop::wakeup() writes %lu bytes instead of 8 \n", n);
}
}
EventLoop::EventLoop()
: looping_(false)
, quit_(false)
, callingPendingFunctors_(false)
, threadId_(CurrentThread::tid())
, poller_(Poller::newDefaultPoller(this))
, wakeupFd_(createEventfd())
, wakeupChannel_(new Channel(this, wakeupFd_))
{
LOG_DEBUG("EventLoop created %p in thread %d \n", this, threadId_);
if (t_loopInThisThread)
{
LOG_FATAL("Another EventLoop %p exists in this thread %d \n", t_loopInThisThread, threadId_);
}
else
{
t_loopInThisThread = this;
}
// 设置wakeupfd的事件类型以及发生事件后的回调操作
wakeupChannel_->setReadCallback(std::bind(&EventLoop::handleRead, this));
// 每一个eventloop都将监听wakeupchannel的EPOLLIN读事件了
wakeupChannel_->enableReading();
}
void EventLoop::handleRead()
{
uint64_t one = 1;
ssize_t n = read(wakeupFd_, &one, sizeof one);
if (n != sizeof one)
{
LOG_ERROR("EventLoop::handleRead() reads %lu bytes instead of 8", n);
}
}
300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
