[Muduo] thread package

  Open thread  sem_t Semaphore

If say started This thread runs fast , It's time to start this thread , The main thread goes directly to sem_wait(&sem), Since the sub thread is being created, it has not yet reached sem_post(&sem), Signal resources have not been added 1, therefore sem_wait Semaphore resources are simply unavailable , The main thread will be blocked in sem_wait. As long as the sub thread is successfully created, it will execute until sem_post, Semaphore resources will increase 1, This is the time tid And then there is

#include <semaphore.h>

void Thread::start()
{
    started_ = true;

    sem_t sem;
    sem_init(&sem,false,0);

    // Open thread 
    thread_ = std::shared_ptr<std::thread>(new std::thread(
        [&](){
            ...
            sem_post(&sem); // Thread signal 
            ...
        }
    ));

    // Here you have to wait to get the thread newly created above tid value 
    sem_wait(&sem); // Will block the main thread , Until the thread is created successfully 
}

Thread.h

#pragma once
#include "noncopyable.h"

#include <functional>
#include <thread>
#include <memory>
#include <unistd.h>
#include <atomic>
class Thread:noncopyable
{
    public:
        using ThreadFunc = std::function<void()>;
    
    public:
        explicit Thread(ThreadFunc, const std::string &name = std::string() );
        ~Thread();
        void start();
        void join();

        bool started()const { return started_; }
        pid_t pid() const {return tid_; }

        const std::string &name() const {return name_; }

        static int numCreated() { return numCreated_; }
    private:
        void setDautleName();

        bool started_;
        bool joined_;
        std::shared_ptr<std::thread> thread_; 
        pid_t tid_;
        ThreadFunc func_;
        std::string name_;
        static std::atomic_int numCreated_;
};

 Thread.cc

#include "Thread.h"
#include "CurrenThread.h"

#include <semaphore.h>

std::atomic_int Thread::numCreated_(0);

Thread::Thread(ThreadFunc func, const std::string &name )
    :started_(false)
    ,joined_(false)
    ,tid_(0)
    ,func_(std::move(func))
    ,name_(name)
{
    setDautleName();
}
Thread::~Thread()
{ 
    if(started_ && !joined_)
    {
        thread_->detach();
    }
}
void Thread::start() // One Thread object , What is recorded is the details of a new thread 
{
    started_ = true;

    sem_t sem;
    sem_init(&sem,false,0);

    // Open thread 
    thread_ = std::shared_ptr<std::thread>(new std::thread(
        [&](){
            // Get thread ID value 
            tid_ = CurrenThread::tid();
            sem_post(&sem); // Thread signal 
            // Start a new thread , Specifically execute the thread function 
            func_();
        }
    ));

    // Here you have to wait to get the thread newly created above tid value 
    sem_wait(&sem); // Will block the main thread , Until the thread is created successfully 
}
void Thread::join()
{
    joined_ = true;
    thread_->join();
}


void Thread::setDautleName()
{
    int num = ++numCreated_;
    if(name_.empty())
    {
        char buf[32] = {0};
        snprintf(buf,sizeof buf, "Thread %d", num);
        name_ = buf;
    }
}