303-重写C++muduo库(EventLoopThreadPool池)

这个很明显，是池的概念。是一个事件线程池，管理EventLoop，EventLoop绑定的就是一个线程。

在EventLoopThread类中，会创建EventLoop，会返回EventLoop的地址：

注意： 线程初始化的回调函数是从上面传下来的。

#pragma once
#include "noncopyable.h"

#include 
#include 
#include 
#include 

class EventLoop;
class EventLoopThread;

class EventLoopThreadPool : noncopyable
{
public:
    using ThreadInitCallback = std::function; 

    EventLoopThreadPool(EventLoop *baseLoop, const std::string &nameArg);
    ~EventLoopThreadPool();

    void setThreadNum(int numThreads) { numThreads_ = numThreads; }//设置底层线程的数量 

    void start(const ThreadInitCallback &cb = ThreadInitCallback());//开启整个事件循环线程 

    //如果工作在多线程中，baseLoop_默认以轮询的方式分配channel给subloop
    EventLoop* getNextLoop();

    std::vector getAllLoops();//返回池里的所有loop 
 
    bool started() const { return started_; }
    const std::string name() const { return name_; }
private:

    EventLoop *baseLoop_;//最基本的loop,
	//对应一个线程，就是当前用户使用线程 EventLoop loop;负责用户的连接，已连接用户的读写 
	
    std::string name_;
    bool started_;
    int numThreads_;
    int next_;//做轮询的下标使用的
    std::vector> threads_;//所有事件的线程 
    std::vector loops_;//事件线程EventLoopThread里面的EventLoop指针 
};

这个是在线程函数的线程栈上创建的，出作用域会自动析构的，不需要析构。

• IO线程运行着baseloop_，只做新用户的连接使用；
• 工作线程运行着subloop，处理连接用户的读写事件。

#include "EventLoopThreadPool.h"
#include "EventLoopThread.h"

#include 

EventLoopThreadPool::EventLoopThreadPool(EventLoop *baseLoop, const std::string &nameArg)
    : baseLoop_(baseLoop)
    , name_(nameArg)
    , started_(false)
    , numThreads_(0)
    , next_(0)
{}

EventLoopThreadPool::~EventLoopThreadPool()
{}

void EventLoopThreadPool::start(const ThreadInitCallback &cb)
{
    started_ = true;

    for (int i = 0; i < numThreads_; ++i)
    {
        char buf[name_.size() + 32];
        snprintf(buf, sizeof buf, "%s%d", name_.c_str(), i);
        EventLoopThread *t = new EventLoopThread(cb, buf);
        threads_.push_back(std::unique_ptr(t));//unique_ptr，不想手动delete
        loops_.push_back(t->startLoop());//底层创建线程，绑定一个新的EventLoop，并返回该loop的地址
    }

    //整个服务端只有一个线程，运行着baseloop，就是用户创建的mainloop
    if (numThreads_ == 0 && cb)
    {
        cb(baseLoop_);
    }
}

//如果工作在多线程中，baseLoop_默认以轮询的方式分配channel给subloop
EventLoop* EventLoopThreadPool::getNextLoop()
{
    EventLoop *loop = baseLoop_;//用户创建的mainloop

    if (!loops_.empty())//通过轮询获取下一个处理事件的loop
    {
        loop = loops_[next_];
        ++next_;
        if (next_ >= loops_.size())
        {
            next_ = 0;
        }
    }

    return loop;
}

std::vector EventLoopThreadPool::getAllLoops()
{
    if (loops_.empty())
    {
        return std::vector(1, baseLoop_);
    }
    else
    {
        loops_;
    }
}

OK的！