C++ Muduo网络库基本流程跟踪，学习下

C++ Muduo网络库基本流程跟踪：

例子中的入口点：

int main()

{

EventLoop loop;

TcpServer server(&loop, listenAddr,"name");

server.start();

loop.loop();

}

看TcpServer构造函数：

TcpServer::TcpServer(EventLoop*
loop,
const
InetAddress& listenAddr,
const
string& nameArg,
Option
option)
: loop_(CHECK_NOTNULL(loop)),
hostport_(listenAddr.toIpPort()),
name_(nameArg),
acceptor_(new
Acceptor(loop,
listenAddr, option ==
kReusePort)),
threadPool_(new
EventLoopThreadPool(loop,
name_)),
connectionCallback_(defaultConnectionCallback),
messageCallback_(defaultMessageCallback),
nextConnId_(1)
{
acceptor_->setNewConnectionCallback(
boost::bind(&TcpServer::newConnection,
this, _1,
_2));
}

在声明server时候调用TcpServer的构造函数：

0.初始化线程池（暂不说)

1.初始化listen套接字类Acceptor

2.初始化默认的连接和接收消息回调

3.设置acceptor的新连接回调为TcpServer::newConnection

跟进server.start():

void
TcpServer::start()
{
if (started_.getAndSet(1) ==0)
{
threadPool_->start(threadInitCallback_);

assert(!acceptor_->listenning());
loop_->runInLoop(
boost::bind(&Acceptor::listen,
get_pointer(acceptor_)));
}
}

1.启动线程池

2.调用acceptor_->listen()开始监听新连接

void
Acceptor::listen()
{
loop_->assertInLoopThread();
listenning_ =
true;
acceptSocket_.listen();
acceptChannel_.enableReading();

}

acceptChannel_.enableReading();// 这里将acceptor套接字加入到loop中的poller的in事件中,当有新连接上来的时候，会回调到acceptor_->handleRead(),当连接成功，会回调到server->newConnection()，嘿嘿。

看看TcpServer::newConnection()做了什么：

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

LOG_INFO<<
"TcpServer::newConnection ["<< name_
<< "]- new connection [" <<
connName
<< "]from " <<
peerAddr.toIpPort();
InetAddress
localAddr(sockets::getLocalAddr(sockfd));
// FIXMEpoll with zero timeout to double confirm the new connection
// FIXMEuse make_shared if necessary
TcpConnectionPtr
conn(new
TcpConnection(ioLoop,
connName,
sockfd,
localAddr,
peerAddr));
connections_[connName] =
conn;
conn->setConnectionCallback(connectionCallback_);
conn->setMessageCallback(messageCallback_);
conn->setWriteCompleteCallback(writeCompleteCallback_);
conn->setCloseCallback(
boost::bind(&TcpServer::removeConnection,
this, _1));
//FIXME: unsafe
ioLoop->runInLoop(boost::bind(&TcpConnection::connectEstablished,
conn));
}

创建新连接shared_ptr对象：TcpConnectionPtr,设置Channel的读，写事件回调（TcpConnection构造函数中设置）,设置接收完整的一个packet的回调messageCallback,完全写出数据时候的回调writeCompleteCallback，关闭套接字回调removeConnection，执行TcpConnection::connectEstablish(这里只是回调到用户设置的新连接上来的回调)，所以当一个新连接上来的时候，流程是这样的：

Acceptor::handleRead()->TcpServer::newConnection()->TcpServer::connectionCallback_()

看看TcpConnection::connectionEstablished():

void
TcpConnection::connectEstablished()
{
loop_->assertInLoopThread();
assert(state_ ==
kConnecting);
setState(kConnected);
channel_->tie(shared_from_this());
channel_->enableReading();

connectionCallback_(shared_from_this());
}

1.设置状态为连接

2.将套接字加入到poller的in事件中

3.回调用户设置的connectionCallback_

接着看loop.loop():

void
EventLoop::loop()
{
assert(!looping_);
assertInLoopThread();
looping_ =
true;
quit_ =
false; //FIXME: what if someone calls quit() before loop() ?
LOG_TRACE<<
"EventLoop " << this <<
" start looping";

while (!quit_)
{
activeChannels_.clear();
pollReturnTime_ =
poller_->poll(kPollTimeMs, &activeChannels_);
++iteration_;
if (Logger::logLevel() <=Logger::TRACE)
{
printActiveChannels();
}
// TODOsort channel by priority
eventHandling_ =
true;
for (ChannelList::iterator
it = activeChannels_.begin();
it !=
activeChannels_.end(); ++it)
{
currentActiveChannel_ = *it;
currentActiveChannel_->handleEvent(pollReturnTime_);
}
currentActiveChannel_ = NULL;
eventHandling_ =
false;
doPendingFunctors();
}

LOG_TRACE<<
"EventLoop " << this <<
" stop looping";
looping_ =
false;
}

1.loop只能在本线程执行(assertInLoopThread())

2.循环执行网络poller

3.处理网络事件currentActiveChannel_->handleEvent(pollReturnTime_);当在poll所有channels的时候，会处理channel的读，写事件回调，这个时候会调用到TcpConnection的读写事件回调（在TcpConnection构造函数中不是设置了channel的回到么）

4.处理其他线程调用本线程事件？doPendingFunctors()

基本流程也就这样了吧，当然，里面还涉及很多细节。很多地方还是值得学习的。