muduo 23 TcpServer

目录

TCP server成员变量：

TcpServer成员函数：

TcpServer::TcpServer

TcpServer::~TcpServer()

TcpServer::setThreadNum

TcpServer::start()

TcpServer::newConnection

TcpServer::removeConnection

TcpServer::removeConnectionInLoop

TcpServer.h

TcpServer.cc

---

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)
    );
}