302-重写C++muduo库(EventLoopThread事件线程类)

• 前面的Thread类，只是封装了一个线程；
• EventLoopThread：one loop per thread，一个线程中有一个loop，一个loop运行在一个线程上！

muduo库中的信号量和互斥锁的相关操作，我们直接使用C++11里面的Thread类相关操作，不使用Linux系统的了，更加方便快捷！

ThreadInitCallback线程初始化的一个回调操作，因为底层一个loop运行在一个线程，要做一些初始化的操作的话，可以给它传递一些操作，可以传递回调函数，在EventLoopThread刚创建时，即线程中刚创建一个EventLoop后，可以调用ThreadInitCallback函数，进行一个初始化操作！如果没有传，什么也不用做！

ThreadInitCallback执行时机：底层起一个新线程，去绑定一个loop的时候，此时什么事情都没做，先检查有没有ThreadInitCallback回调操作，有回调操作，就对loop进行操作！

#pragma once

#include "noncopyable.h"
#include "Thread.h"

#include 
#include 
#include 
#include 

class EventLoop;

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

    EventLoopThread(const ThreadInitCallback &cb = ThreadInitCallback(), //线程初始化的回调 
        const std::string &name = std::string());
    ~EventLoopThread();

    EventLoop* startLoop();//开启循环 
private:
    void threadFunc();//线程函数，创建loop 

    EventLoop *loop_;
    bool exiting_;//是否退出循环 
    Thread thread_;
    std::mutex mutex_;
    std::condition_variable cond_;
    ThreadInitCallback callback_;//初始化操作 
};

notify_one()：通知一个等待在mutex_上的线程，将其唤醒！

通知谁呢，就是startLoop函数所在的线程，让它获取互斥锁mutex_！

当我们调用startloop函数时，底层才创建一个新线程（即threadFunc中，就是真正执行loop的线程）

在threadFunc线程中，loop有没有初始化好，我们不知道，因此用条件变量进行通知！

初始化好了在startloop中才可以继续执行！

最后，在threadFunc线程函数中，开启loop循环。

#include "EventLoopThread.h"
#include "EventLoop.h"


EventLoopThread::EventLoopThread(const ThreadInitCallback &cb, 
        const std::string &name)
        : loop_(nullptr)
        , exiting_(false)
        , thread_(std::bind(&EventLoopThread::threadFunc, this), name)//绑定回调函数
        , mutex_()
        , cond_()
        , callback_(cb)
{

}

EventLoopThread::~EventLoopThread()//析构函数
{
    exiting_ = true;
    if (loop_ != nullptr)
    {
        loop_->quit();
        thread_.join();
    }
}

EventLoop* EventLoopThread::startLoop()//开启循环
{
    thread_.start();//启动底层的新线程
	//启动后执行的是EventLoopThread::threadFunc
    EventLoop *loop = nullptr;
    {
        std::unique_lock lock(mutex_);
        while ( loop_ == nullptr )
        {
            cond_.wait(lock);//挂起，等待
        }
        loop = loop_;
    }
    return loop;
}

//下面这个方法，start（）后的执行的，也就是在单独的新线程里面运行的1
void EventLoopThread::threadFunc()
{
    EventLoop loop;//创建一个独立的eventloop，和上面的线程是一一对应的，one loop per thread

    if (callback_)//如果有回调
    {
        callback_(&loop);//绑定loop做一些事情
    }

    {
        std::unique_lock lock(mutex_);
        loop_ = &loop;//就是运行在这个线程的loop对象
        cond_.notify_one();//唤醒1个线程
    }

    loop.loop();//相当于EventLoop loop  => Poller.poll
    std::unique_lock lock(mutex_);
    loop_ = nullptr;
}

Thread类执行的线程函数，就是EventLoopThread就是在构造构造函数绑定的threadFunc回调函数。

OK的！