evpp网络库代码分析(二)

        开局一张图!

evpp网络库代码分析(二)_第1张图片

        上图是盗用自《Linux多线程服务端编程,使用muduo C++网络库》一书6.6.2章节(以及下面的时序图也是盗用该书的图)。该图列举出大部分常用的网络编程模型,当然了,这里并没有列出Boost.Asio的proactor模式。其中表中的“互通”是指多个客户端(连接)间是否能方便地交换数据,如chat聊天程序;UNP是指经典的《Unix网络编程卷一:套接字联网API》一书章节。而我们的evpp库实际上是用到了“方案9”,方案9的时序图如下:

evpp网络库代码分析(二)_第2张图片

        可以看出,每一个线程有一个EventLoop处理事件。这种方案是典型的“one loop per thread”流程,有一个“主EventLoop”负责accept连接,然后把连接通过round-robin(轮询调度)挂到底下的多个“子EventLoop”中(EventLoopThreadPool),每个连接都是由一个“子EventLoop”完成的,能保证请求的顺序性,也可以充分利用CPU,防止出现一个reactor的处理能力饱和,而且EventLoop线程池线程数量固定,不会因为连接数过多到达临界点(线程太多导致操作系统线程调度不过来)而性能下降!

        另外还有一种网络编程模型比较常用,就是“方案8”,这个模型在muduo中有现成方案,而在evpp中需要自己实现,时序图如下:

evpp网络库代码分析(二)_第3张图片

        这种方案,只有一个EventLoop,但它把计算密集的部分(decode、compute、encode)分派到一个线程池中处理,处理完后再返回到EventLoop中,这样即使decode、compute、encode这三部分是阻塞的也不影响并发连接,正因为是异步处理,导致打乱了返回的顺序性,即同为连接1(同一个连接),先后下发请求1(如Conn 1 readaable1)和请求2(如Conn 1 readaable2),有可能请求2先于请求1返回数据(响应)。如果处理的事情没有优先级之分或者计算密集型(大部分时间都是处于计算中)可以使用这种方案,如果有优先级之分,应该使用方案9,方案9算是一个各方面都比较均衡的网络编程模式,evpp库就优先使用这种模式!

        evpp中比较重要的基础类有:

EventLoop
EventWatcher
Buffer等

        EventLoop相关的类包含EventLoop、EventLoopThread和EventLoopThreadPool等类,它们提供事件循环、事件分发、为reactor网络编程模式提供一个基础框架。也提供了定时器,以及RunInLoop等接口,RunInLoop可在多线程环境下被调用,在本eventloop的IO线程内执行某个用户任务回调。我们提倡one loop per thread,顾名思义每个线程只能有一个EventLoop对象,因此EventLoop的构造函数会检查当前线程是否已经创建了其他EventLoop对象,遇到错误就终止程序。

        EventWatcher相关的类包含PipeEventWatcher、TimerEventWatcher和SignalEventWatcher能够注册管道、超时以及信号事件,底层是libevent2库。

        Buffer类则是类似libevent2中的evbuffer,供应用层读写,底下的socket读写操作也会频繁使用它。

        我们可以先阅读代码,证明evpp库是上述“方案9”的具体实现:

int main(int argc, char* argv[]) {
    std::string addr = "0.0.0.0:9099";
    int thread_num = 4;

    evpp::EventLoop loop;
    evpp::TCPServer server(&loop, addr, "TCPPingPongServer", thread_num);
    server.SetMessageCallback(&OnMessage);
    server.SetConnectionCallback(&OnConnection);
    server.Init();
    server.Start();
    loop.Run();

    return 0;
}

这是一个简单的server端代码,先是创建了一个EventLoop对象loop,然后把用loop创建TCPServer对象,继续跟进去发现这个loop对象就是“方案9”时序图里的“Base IO Thread”。

        我们再来看TCPServer对象的构造函数:

TCPServer::TCPServer(EventLoop* loop,
                     const std::string& laddr,
                     const std::string& name,
                     uint32_t thread_num)
    : loop_(loop)
    , listen_addr_(laddr)
    , name_(name)
    , conn_fn_(&internal::DefaultConnectionCallback)
    , msg_fn_(&internal::DefaultMessageCallback)
    , next_conn_id_(0) {
    tpool_.reset(new EventLoopThreadPool(loop_, thread_num));
}

它用“Base IO Thread”和线程数量作为参数创建了一个EventLoopThreadPool智能指针对象tpool_。

        我们看回main函数,它注册好必要的回调(后文会说到)后,调用server.Init()和server.Start()。

init函数主要是创建了一个Listener对象,然后监听socket:

bool TCPServer::Init() {
    listener_.reset(new Listener(loop_, listen_addr_));
    listener_->Listen();
    return true;
}

而Start函数则是重要函数:

bool TCPServer::Start() {
    bool rc = tpool_->Start(true);
    if (rc) {
        listener_->SetNewConnectionCallback(
            std::bind(&TCPServer::HandleNewConn,
                      this,
                      std::placeholders::_1,
                      std::placeholders::_2,
                      std::placeholders::_3));
        listener_->Accept();
    }
    return rc;
}

它让EventLoopThreadPool启动,并且注册一个回调,用于当accept到一个客户端连接后就回调。

最后我们来看下当Listener对象accept到一个连接后,回调函数HandleNewConn做了什么:

void TCPServer::HandleNewConn(evpp_socket_t sockfd,
                              const std::string& remote_addr/*ip:port*/,
                              const struct sockaddr_in* raddr) {
    if (IsStopping()) {
        EVUTIL_CLOSESOCKET(sockfd);
        return;
    }

    EventLoop* io_loop = GetNextLoop(raddr);
    std::string n = remote_addr;
    ++next_conn_id_;
    TCPConnPtr conn(new TCPConn(io_loop, n, sockfd, listen_addr_, remote_addr, next_conn_id_));
    conn->SetMessageCallback(msg_fn_);
    conn->SetConnectionCallback(conn_fn_);
    conn->SetCloseCallback(std::bind(&TCPServer::RemoveConnection, this, std::placeholders::_1));
    io_loop->RunInLoop(std::bind(&TCPConn::OnAttachedToLoop, conn));
    connections_[conn->id()] = conn;
}

里面有一个重要函数GetNextLoop(),该函数返回的io_loop就是“方案9”时序图里面的“IO Thread n”,最后 利用io_loop这个EventLoop对象创建一个TCPConn智能指针对象等待io,跟“方案9”的思路如出一辙,也是“one loop per thread”,一个EventLoop挂一个连接。

你可能感兴趣的:(TCP/IP网络)