目录
TcpServer::removeConnectionInLoop
TCP server成员变量:
里有event loop,有acceptor跟accept相关的操作全部打包进去,事件循环的这个线程池,有一系列的回调,再者它就有一个connection map,它维护了所有的连接。
TcpServer成员函数:
TcpServer::TcpServer
TcpServer构造函数要做的事情:
1. TcpServer构造函数,传入当前mainloop,当前InetAddress,当前服务器name,创建一个Acceptor;
2. Acceptor构造函数通过createNoblock函数创建一个用于监听的Listenfd,并将其封装成一个acceptChannel_;
3. TcpServer::start()调用Acceptor::listen(),通过acceptChannel_.enableReading将该channel注册到Poller中,交给Poller监听;
4. Poller监听到acceptorChannel_上有事件发生,通过acceptChannel_.setReadCallback(std::bind(&Acceptor::handleRead, this))中handleRead返回一个connfd,并且去执行newConnectionCallback_回调(由TcpServer::newConnection设置的)
①:因为这个TcpServer工作在主线程,所以要保证mainloop不为空,写了一个判断函数:
②: acceptor_的创建,调用acceptor的构造函数
创建listenfd、打包成acceptChannel、设置回调函数handleRead。
handleRead返回connfd、调用newConnectionCallback_(connfd, peerAddr)这个由④设置。
③: 去执行线程池构造函数,开启线程池
④: 设置回调函数这个在下面具体说TcpServer::newConnection
TcpServer::~TcpServer()
轮询存放TcpConnectionPtr的容器,依次断开连接。
TcpServer::setThreadNum
设置线程数量
TcpServer::start()
服务器监听开始:
1. 开启线程池;
2. 在mianloop下把acceptor启动起来;通过执行loop的回调
Acceptor::listen
把这个channel注册到poller中
调用完TcpServer.start()函数后,接着执行loop.loop()函数,开启事件循环,对应mainloop的Poller开启事件循环了,执行epoll_wait了!开始监听acceptChannel_有没有新的连接。
TcpServer::newConnection
①: 从EventLoopThreadPool轮询拿一个loop出来;
②:组装本机的ip地址和端口信息InetAddress localAddr(local);
③:新建一个TcpConnection并用TcpConnectionPtr智能指针管理
④:把新建好的TcpConnection放到ConnectionMap容器中,设置一系列的回调函数(给底层的Channel中);
⑤:建立连接:只要有一个新的客户端连接,最终就会生成响应的TCP connection对象,并直接调用TcpConnection::connectEstablished->做的事情就是把这个连接的state从刚开始的connecting变成connected连接建立。 然后tie绑定自己一下,然后channel_->enableReading()向poller中注册这个Channel的epollin事件,开始监听 EventLoop *ioLoop = threadPool_->getNextLoop()上面这里选择了一个loop监听事件后 connectionCallback_(shared_from_this())可以开始执行回调了,用户调用connected()判断是否连接成功。
TcpServer::removeConnection
TcpServer::removeConnectionInLoop
TcpServer.h
#pragma once
/**
* 用户使用muduo编写服务器程序
*/
#include "EventLoop.h"
#include "Acceptor.h"
#include "InetAddress.h"
#include "noncopyable.h"
#include "EventLoopThreadPool.h"
#include "Callbacks.h"
#include "TcpConnection.h"
#include "Buffer.h"
#include <functional>
#include <string>
#include <memory>
#include <atomic>
#include <unordered_map>//哈希表
//我们把需要用到的头文件都包含在这里,方便用户使用
//对外的服务器编程使用的类
class TcpServer : noncopyable
{
public:
using ThreadInitCallback = std::function<void(EventLoop*)>;
enum Option//选项,是否对端口可重用
{
kNoReusePort,
kReusePort,
};
TcpServer(EventLoop *loop,
const InetAddress &listenAddr,
const std::string &nameArg, //服务器名称
Option option = kNoReusePort);
~TcpServer();
//用户在使用muduo库必须设置的
void setThreadInitcallback(const ThreadInitCallback &cb) { threadInitCallback_ = cb; }
void setConnectionCallback(const ConnectionCallback &cb) { connectionCallback_ = cb; }
void setMessageCallback(const MessageCallback &cb) { messageCallback_ = cb; }
void setWriteCompleteCallback(const WriteCompleteCallback &cb) { writeCompleteCallback_ = cb; }
//设置底层subloop的个数
void setThreadNum(int numThreads);
//开启服务器监听 实际上就是开启mainloop的acceptor的listen
void start();
private:
//私有的内部使用的接口
void newConnection(int sockfd, const InetAddress &peerAddr);//有新连接来了
void removeConnection(const TcpConnectionPtr &conn);//有连接断开了,不要这条连接了
void removeConnectionInLoop(const TcpConnectionPtr &conn);
EventLoop *loop_;//baseLoop 用户定义的loop 一个线程一个loop循环
const std::string ipPort_;//服务器的IP地址端口号
const std::string name_;//服务器的名称
std::unique_ptr<Acceptor> acceptor_;//运行在mainLoop,任务就是监听新连接事件
std::shared_ptr<EventLoopThreadPool> threadPool_;//线程池 one loop per thread
ConnectionCallback connectionCallback_;//有新连接时的回调
MessageCallback messageCallback_;//已连接用户有读写消息时的回调 reactor调用
WriteCompleteCallback writeCompleteCallback_;//消息发送完成以后的回调
ThreadInitCallback threadInitCallback_;//loop线程初始化的回调
std::atomic_int started_;//标志
int nextConnId_;
using ConnectionMap = std::unordered_map<std::string, TcpConnectionPtr>;
ConnectionMap connections_;//保存所有的连接
};
TcpServer.cc
#include "TcpServer.h"
#include "Logger.h"
#include "TcpConnection.h"
#include <strings.h>
#include <functional>
static EventLoop* CheckLoopNotNull(EventLoop *loop)
{
if (loop == nullptr)
{
LOG_FATAL("%s:%s:%d mainLoop is null! \n", __FILE__, __FUNCTION__, __LINE__);
}
return loop;
}
TcpServer::TcpServer(EventLoop *loop,
const InetAddress &listenAddr,
const std::string &nameArg,
Option option)
: loop_(CheckLoopNotNull(loop))//mainloop不能为空
, ipPort_(listenAddr.toIpPort())
, name_(nameArg)
, acceptor_(new Acceptor(loop, listenAddr, option == kReusePort))
, threadPool_(new EventLoopThreadPool(loop, name_))
, connectionCallback_()
, messageCallback_()
, nextConnId_(1)
, started_(0)
{
//当有新用户连接时,会执行TcpServer::newConnection回调
//两个参数 fd 地址
acceptor_->setNewConnectionCallback(std::bind(&TcpServer::newConnection, this,
std::placeholders::_1, std::placeholders::_2));
}
TcpServer::~TcpServer()
{
for (auto &item : connections_)
{
//这个局部的shared_ptr智能指针对象,出右括号,可以自动释放new出来的TcpConnection对象资源了
TcpConnectionPtr conn(item.second);
item.second.reset();
//销毁连接
conn->getLoop()->runInLoop(
std::bind(&TcpConnection::connectDestroyed, conn)
);
}
}
//设置底层subloop的个数
void TcpServer::setThreadNum(int numThreads)
{
threadPool_->setThreadNum(numThreads);
}
//开启服务器监听 loop.loop()
void TcpServer::start()
{
if (started_++ == 0)//防止一个TcpServer对象被start多次
{
threadPool_->start(threadInitCallback_);//启动底层的loop线程池
//TcpServer开始监听 启动listen监听新用户的连接 返回通信用的connectfd =>执行newConnection函数
loop_->runInLoop(std::bind(&Acceptor::listen, acceptor_.get()));
}
}
//有一个新的客户端的连接,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;// IPv4 地址
::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连接对象
//TcpConnection用智能指针管理
TcpConnectionPtr conn(new TcpConnection(
ioLoop, //所在的事件循环
connName, //名字
sockfd, // Socket Channel
localAddr, // 本地IP和端口号
peerAddr // 客户端IP和端口号
));
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)
);
/*只要有一个新的客户端连接,最终就会生成响应的TCP connection对象,并直接
调用TcpConnection::connectEstablished->做的事情就是把这个连接的state从刚开始的connecting变成connected连接建立。
然后tie绑定自己一下,然后channel_->enableReading()向poller中注册这个Channel的epollin事件,开始监听
EventLoop *ioLoop = threadPool_->getNextLoop()上面这里选择了一个loop
监听事件后 connectionCallback_(shared_from_this())可以开始执行回调了,用户调用connected()判断是否连接成功
*/
ioLoop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn));
}
void TcpServer::removeConnection(const TcpConnectionPtr &conn)
{
loop_->runInLoop(
std::bind(&TcpServer::removeConnectionInLoop, this, conn)
);
}
void TcpServer::removeConnectionInLoop(const TcpConnectionPtr &conn)
{
LOG_INFO("TcpServer::removeConnectionInLoop [%s] - connection %s\n",
name_.c_str(), conn->name().c_str());
connections_.erase(conn->name());
EventLoop *ioLoop = conn->getLoop(); //拿这条连接对应的loop
ioLoop->queueInLoop( //去执行该连接的关闭
std::bind(&TcpConnection::connectDestroyed, conn)
);
}