muduo_net库源码分析（六）（EventLoopThread类创建IO线程）

EventLoopThread类

注意：并不是说创建EventLoopThread类的对象就创建了IO线程，而是创建EventLoopThread类的对象后，该对象调用EventLoopThread::startLoop后才创建了一个IO线程。
调用顺序：
主线程中：EventLoopThread::startLoop–>在EventLoopThread::startLoop调用Thread::start创建子线程，即通过Thread::start中的::pthread_create创建子线程。
子线程中：当::pthread_create创建子线程成功后子线程会自动调用线程函数EventLoopThread::threadFunc–>EventLoopThread::threadFunc的任务就是创建EventLoop对象（此时该子线程就成为了IO线程），并调用EventLoop::loop启动事件循环。

由于主线程和新创建的子线程执行的先后顺序未知，而主线程中的EventLoopThread::startLoop函数的返回值是子线程中创建的EventLoop对象指针，所以需要用到条件变量。

源码

EventLoopThread.h

#ifndef MUDUO_NET_EVENTLOOPTHREAD_H
#define MUDUO_NET_EVENTLOOPTHREAD_H

#include <muduo/base/Condition.h>
#include <muduo/base/Mutex.h>
#include <muduo/base/Thread.h>

#include <boost/noncopyable.hpp>

namespace muduo
{
namespace net
{

class EventLoop;

class EventLoopThread : boost::noncopyable
{
 public:
  typedef boost::function<void(EventLoop*)> ThreadInitCallback;

  EventLoopThread(const ThreadInitCallback& cb = ThreadInitCallback());
  ~EventLoopThread();
  EventLoop* startLoop();	// 启动线程（即创建一个子线程）

 private:
  void threadFunc();		// 线程函数，这里线程函数的任务就是在子线程中创建一个EventLoop对象（该子线程就成为了IO线程），并运行EventLoop::loop

  EventLoop* loop_;			// loop_指针指向一个EventLoop对象
  bool exiting_;
  Thread thread_;       //EventLoopThread类中包含了一个Thread对象
  MutexLock mutex_;     //配合条件变量使用
  Condition cond_;      //条件变量
  ThreadInitCallback callback_;		//EventLoopThread类的回调函数在EventLoop::loop事件循环之前被调用（这样设计也是为了更灵活，可以处理一些简单的计算任务）
};

}
}

#endif  // MUDUO_NET_EVENTLOOPTHREAD_H

EventLoopThread.cc

#include <muduo/net/EventLoopThread.h>

#include <muduo/net/EventLoop.h>

#include <boost/bind.hpp>

using namespace muduo;
using namespace muduo::net;


EventLoopThread::EventLoopThread(const ThreadInitCallback& cb)
  : loop_(NULL),
    exiting_(false),
    thread_(boost::bind(&EventLoopThread::threadFunc, this)),//线程函数初始化，类的成员函数使用boost::bind，所以要传this
    mutex_(),
    cond_(mutex_),
    callback_(cb)
{
}

EventLoopThread::~EventLoopThread()
{
  exiting_ = true;
  loop_->quit();		// 退出IO线程，让IO线程的loop循环退出，从而退出了IO线程
  thread_.join();
}

EventLoop* EventLoopThread::startLoop()
{
  assert(!thread_.started());
  thread_.start();//创建子线程，::pthread_create成功后会在子线程中自动调用线程函数EventLoopThread::threadFunc

  {
    MutexLockGuard lock(mutex_);
    while (loop_ == NULL)
    {
      cond_.wait();
    }
  }

  return loop_;
}

void EventLoopThread::threadFunc()
{
  EventLoop loop;//创建EventLoop对象

  if (callback_)
  {
    callback_(&loop);
  }

  {
    MutexLockGuard lock(mutex_);
    // loop_指针指向了一个栈上的对象，threadFunc函数退出之后，这个指针就失效了
    // 因为当threadFunc函数运行结束，就意味着线程退出了，EventLoopThread对象也就没有存在的价值了。
    // 所以不会有什么大的问题
    loop_ = &loop;
    cond_.notify();
  }

  loop.loop();
  //assert(exiting_);
}

测试代码（重点！）

Reactor_test06.cc
Reactor_test06.cc在Reactor_test05.cc的基础上进行了跨线程调用测试。
该程序中，主线程中创建一个EventLoopThread类的对象，通过该对象调用EventLoopThread::startLoop后就创建了一个IO线程，并通过该函数的返回值得到了IO线程中EventLoop对象指针。然后在主线程中就可以通过该EventLoop对象指针跨线程调用EventLoop::runAfter、EventLoop::runInLoop、EventLoop::quit等函数。

#include <muduo/net/EventLoop.h>
#include <muduo/net/EventLoopThread.h>

#include <stdio.h>

using namespace muduo;
using namespace muduo::net;

void myfun()
{
  printf("myfun(): pid = %d, tid = %d\n",
         getpid(), CurrentThread::tid());
}

int main()
{
  printf("main(): pid = %d, tid = %d\n",
         getpid(), CurrentThread::tid());

  EventLoopThread loopThread;
  EventLoop* loop = loopThread.startLoop();
  // 异步调用（即跨线程调用）EventLoop::runInLoop，即将myfun添加到loop对象所在IO线程的任务队列，让该IO线程执行
  //EventLoop::runInLoop在muduo_net库源码分析（五）中进行了详细分析
  loop->runInLoop(myfun);
  sleep(1);
  //EventLoop::runAfter内部也调用了EventLoop::runInLoop，所以这里也是异步调用
  loop->runAfter(2, myfun);
  sleep(3);
  //异步调用EventLoop::quit
  loop->quit();

  printf("exit main().\n");
}