muduo::EventLoopThread、EventLoopThreadPool分析

muduo的并发模型为one loop per thread+ threadpool。为了方便使用，muduo封装了EventLoop和Thread为EventLoopThread，为了方便使用线程池，又把EventLoopThread封装为EventLoopThreadPool。

EventLoopThread

任何一个线程，只要创建并运行了EventLoop，就是一个IO线程。
EventLoopThread类就是一个封装了的IO线程。
EventLoopThread的工作流程为：
1、在主线程（暂且这么称呼）创建EventLoopThread对象。
2、主线程调用EventLoopThread.start()，启动EventLoopThread中的线程（称为IO线程），这是主线程要等待IO线程创建完成EventLoop对象。
3、IO线程调用threadFunc创建EventLoop对象。通知主线程已经创建完成。
4、主线程返回创建的EventLoop对象。

EventLoopThread.h

class EventLoopThread : boost::noncopyable{ public:  typedef boost::function<void(EventLoop*)> ThreadInitCallback;  EventLoopThread(const ThreadInitCallback& cb = ThreadInitCallback(),                  const string& name = string());  ~EventLoopThread();  EventLoop* startLoop();//启动本线程，返回本线程中的EventLoop private:  void threadFunc();  EventLoop* loop_;//本线程持有的EventLoop对象指针  bool exiting_;//是否已经退出  Thread thread_;//本线程  MutexLock mutex_;  Condition cond_;  ThreadInitCallback callback_;//回调函数};

EventLoopThread.cc

EventLoopThread::EventLoopThread(const ThreadInitCallback& cb,                                 const string& name)  : loop_(NULL),    exiting_(false),    thread_(boost::bind(&EventLoopThread::threadFunc, this), name),//创建线程，在回调函数创建EventLoop    mutex_(),    cond_(mutex_),    callback_(cb){}EventLoopThread::~EventLoopThread(){  exiting_ = true;  if (loop_ != NULL) // not 100% race-free, eg. threadFunc could be running callback_.  {    // still a tiny chance to call destructed object, if threadFunc exits just now.    // but when EventLoopThread destructs, usually programming is exiting anyway.    loop_->quit();//退出loop循环    thread_.join();//等待线程退出  }}EventLoop* EventLoopThread::startLoop()//另一个线程在调用这个函数{  assert(!thread_.started());  thread_.start();//当前线程启动，调用threadFunc()  {    MutexLockGuard lock(mutex_);    while (loop_ == NULL)    {      cond_.wait();//等待创建好当前IO线程    }  }  return loop_;}void EventLoopThread::threadFunc(){  EventLoop loop;//创建EventLoop对象。注意，在栈上  if (callback_)  {    callback_(&loop);  }  {    MutexLockGuard lock(mutex_);    loop_ = &loop;    cond_.notify();//通知startLoop  }  loop.loop();//会在这里循环，直到EventLoopThread析构。此后不再使用loop_访问EventLoop了  //assert(exiting_);  loop_ = NULL;}

EventLoopThreadPool

muduo的思想时eventLoop+thread pool，为了更方便使用，将EventLoopThread做了封装。main reactor可以创建sub reactor，并发一些任务分发到sub reactor中去。

EventLoopThreadPool的思想比较简单，用一个main reactor创建EventLoopThreadPool。在EventLoopThreadPool中将EventLoop和Thread绑定，可以返回EventLoop对象来使用EventLoopThreadPool中的Thread。

EventLoopThreadPool.h

class EventLoop;class EventLoopThread : boost::noncopyable{ public:  typedef boost::function<void(EventLoop*)> ThreadInitCallback;  EventLoopThread(const ThreadInitCallback& cb = ThreadInitCallback(),                  const string& name = string());  ~EventLoopThread();  EventLoop* startLoop();//启动本线程，返回本线程中的EventLoop private:  void threadFunc();  EventLoop* loop_;//本线程持有的EventLoop对象指针  bool exiting_;//是否已经退出  Thread thread_;//本线程  MutexLock mutex_;  Condition cond_;  ThreadInitCallback callback_;//回调函数};

EventLoopThreadPool.cc

EventLoopThreadPool::EventLoopThreadPool(EventLoop* baseLoop, const string& nameArg)  : baseLoop_(baseLoop),    name_(nameArg),    started_(false),    numThreads_(0),    next_(0){}EventLoopThreadPool::~EventLoopThreadPool(){  // Don't delete loop, it's stack variable}void EventLoopThreadPool::start(const ThreadInitCallback& cb){  assert(!started_);  baseLoop_->assertInLoopThread();  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(t);    loops_.push_back(t->startLoop());  }  if (numThreads_ == 0 && cb)  {    cb(baseLoop_);  }}EventLoop* EventLoopThreadPool::getNextLoop(){  baseLoop_->assertInLoopThread();  assert(started_);  EventLoop* loop = baseLoop_;//loops_为空，则返回baseloop  if (!loops_.empty())//循环分配  {    // round-robin    loop = loops_[next_];    ++next_;    if (implicit_cast<size_t>(next_) >= loops_.size())    {      next_ = 0;    }  }  return loop;}EventLoop* EventLoopThreadPool::getLoopForHash(size_t hashCode){  baseLoop_->assertInLoopThread();  EventLoop* loop = baseLoop_;  if (!loops_.empty())  {    loop = loops_[hashCode % loops_.size()];//根据hashCode分配  }  return loop;}std::vector<EventLoop*> EventLoopThreadPool::getAllLoops(){  baseLoop_->assertInLoopThread();  assert(started_);  if (loops_.empty())  {    return std::vector<EventLoop*>(1, baseLoop_);  }  else  {    return loops_;  }}

可以写个简单的测试程序，创建一个EventLoopThreadPool，打印其中线程的ID和name。

#include <muduo/net/EventLoop.h>#include <muduo/net/EventLoopThread.h>#include <muduo/net/EventLoopThreadPool.h>#include <stdio.h>using namespace muduo;using namespace muduo::net;void runInThread(){    printf("runInThread(): name = %s, tid = %d\n",           CurrentThread::name(), CurrentThread::tid());}int main(){    printf("main(): pid = %d, tid = %d\n",           getpid(), CurrentThread::tid());    runInThread();    EventLoop loop;    EventLoopThreadPool loopThreadPool(&loop, "sub Reactor");    loopThreadPool.setThreadNum(5);    loopThreadPool.start();    for(int i=0; i<10; ++i)    {        EventLoop* loopFromPool=loopThreadPool.getNextLoop();        loopFromPool->runInLoop(runInThread);    }    sleep(3);    printf("exit main().\n");}