【MUDUO】EventLoopThreadPool

EventLoopThreadPool.h

#pragma once
#include "noncopyable.h"
#include <functional>
#include <string>
#include <vector>
#include <memory>
class EventLoop;
class EventLoopThread;

class EventLoopThreadPool:noncopyable
{
    public:
        using threadInitCallback = std::function<void(EventLoop*)>;

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

        void setThreadNum(int numThreads) { numThreads_ = numThreads; }

        void start(const threadInitCallback &cb = threadInitCallback());

        // If you work in multithreading , baseLoop_ It will be allocated by polling by default Channel to 
        EventLoop* getNextLoop();

        std::vector<EventLoop*> getAllLoops();
        bool started() const { return started_ ; }

        const std::string name() const { return name_; }
    private:
        EventLoop* baseLoop_; 
        std::string name_;
        bool started_;
        int numThreads_;
        int next_;  // Poll subscripts 
        std::vector<std::unique_ptr<EventLoopThread>> threads_;
        std::vector<EventLoop *> loops_;

};

EventLoopThreadPool.cc

 

#include "EventLoopThreadPool.h"
#include "EventLoopThread.h"
#include <memory>
EventLoopThreadPool::EventLoopThreadPool(EventLoop* baseLoop, const std::string &nameArg)
    :baseLoop_(baseLoop)
    ,name_(nameArg)
    ,started_(false)
    ,numThreads_(0)
    ,next_(0)
{

}
EventLoopThreadPool::~EventLoopThreadPool()
{
    //EventLoopThread Inside is the object on the stack , So destructors don't need to make declarations 
}


void EventLoopThreadPool::start(const threadInitCallback &cb )
{
    started_ = true;
    // If the user sets the number of threads , It's going to get into this 
    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<EventLoopThread>(t));
        // The underlying thread is created , Bind a new EventLoop, And back to loop Address 
        loops_.push_back(t->startLoop()); 
    }
    // The whole server has only one thread , running baseloop ,
    if(numThreads_ == 0 && cb)
    {
        cb(baseLoop_);
    }
}

// If you work in multithreading , baseLoop_ It will be allocated by polling by default Channel to 
EventLoop* EventLoopThreadPool::getNextLoop()
{
    EventLoop *loop = baseLoop_;
    if(!loops_.empty())
    {
        loop = loops_[next_];
        ++next_;
        if(next_ >= loops_.size())
        {
            next_ = 0;
        }
    }
    return loop;
}

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