muduo库阅读（35）——Net部分：用于执行事件循环（EventLoop）的线程类EventLoopThread

/*
* 用于执行Reactor（EventLoop）循环的线程
*/
namespace muduo
{
namespace net
{
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();

private:

// 线程函数用于执行EventLoop的循环
void threadFunc();

// 对应的Reactor
EventLoop* loop_;

// 是否正在退出
bool exiting_;

// 执行Reactor循环的线程
Thread thread_;
// 锁，条件变量的锁
MutexLock mutex_;
// 条件变量，用于exiting_变化的通知
Condition cond_;

// 线程初始化回调函数
ThreadInitCallback callback_;
};

}
}

using namespace muduo;
using namespace muduo::net;

/*
* 构造函数
*/
EventLoopThread::EventLoopThread(const ThreadInitCallback& cb,
const string& name)
: loop_(NULL),
exiting_(false),
thread_(boost::bind(&EventLoopThread::threadFunc, this), name),
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();

// 等待线程结束
thread_.join();
}
}

// 开始循环
EventLoop* EventLoopThread::startLoop()
{
assert(!thread_.started());

// 启动线程
thread_.start();

{
// 等待线程启动完毕
MutexLockGuard lock(mutex_);
while (loop_ == NULL)
{
cond_.wait();
}
}

return loop_;
}

// 线程函数：用于执行EVentLoop的循环
void EventLoopThread::threadFunc()
{
EventLoop loop;

// 如果有初始化函数，就先调用初始化函数
if (callback_)
{
callback_(&loop);
}

{
MutexLockGuard lock(mutex_);
loop_ = &loop;

// 通知startLoop线程已经启动完毕
cond_.notify();
}

// 事件循环
loop.loop();

loop_ = NULL;
}