[Muduo] package EventLoop and thread

EventLoopThread.h

#pragma once 
#include "noncopyable.h"
#include "Thread.h"
#include <functional>
#include <mutex>
#include <condition_variable>
#include <string>

class EventLoop;

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

        EventLoopThread(const ThreadInitCallback& cb = ThreadInitCallback(), 
                    const std::string &name = std::string()
        );

        ~EventLoopThread();
        // Turn on the cycle 
        EventLoop* startLoop();

    private:
        void threadFunc();
        
        // The event loop 
        EventLoop *loop_;
        // Whether to exit the cycle 
        bool exiting_;
        // Threads 
        Thread thread_;
        // Lock 
        std::mutex mutex_;
        // Condition variables, 
        std::condition_variable cond_;
        // Callback function initialization 
        ThreadInitCallback callback_;
};

EventLoopThread.cc

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



EventLoopThread::EventLoopThread(const ThreadInitCallback& cb , const std::string &name)
    :loop_(nullptr) // Only when it is empty will it create a thread 
    ,exiting_(false)
    ,thread_(std::bind(&EventLoopThread::threadFunc, this),name)
    ,mutex_()
    ,cond_()
    ,callback_(cb)
{

}

EventLoopThread::~EventLoopThread()
{
    exiting_ = true;
    if(loop_ == nullptr)
    {
        loop_->quit();
        thread_.join();
    }
}
// Turn on the cycle 
EventLoop* EventLoopThread::startLoop()
{
    thread_.start();//  Start the underlying thread 
    EventLoop *loop = nullptr;
    {
        std::unique_lock<std::mutex> lock(mutex_);
        // Wait for the thread to be created successfully void EventLoopThread::threadFunc()  Of cond_.notify_one(); notice 
        while(loop_ == nullptr)
        {
            cond_.wait(lock); // Wait for a notice 
        }
        loop = loop_;
    }
    return loop;

}

// This is thread creation , And started Poller Medium poll
void EventLoopThread::threadFunc()
{
    EventLoop loop; // Create an independent EventLoop, Correspond to the above thread one by one 
    if(callback_)
    {
        callback_(&loop);
    }
    {
        std::unique_lock<std::mutex> lock(mutex_);
        loop_ = &loop;
        cond_.notify_one(); // Notify the creation thread to complete 
    }
    loop.loop(); // The event loop is opened here ,
    // Come here to prove that the server is going to shut down this thread 
    std::unique_lock<std::mutex> lock(mutex_);
    loop_ = nullptr;
    
}