创建异步计时器的新类后函数未返回

问：

我有一个类正在创建一个应该在后台运行的异步计时器。我创建了一个计时器类，该类使用其单独的线程创建一个对象，并且应该在后台运行。最重要的是，我有两个函数 CreateTimer 和 DeleteTimer，它们将用于访问计时器类对象。我的目的是为多个线程调用 CreateTimer 和 DeleteTimer。我有以下代码：

#include <condition_variable>
#include <chrono>
#include <vector>
#include <algorithm>
#include <iostream>
#include <thread>
#include <atomic>



typedef struct
{
    uint32_t  msgId;
    uint32_t  param1;
    uint32_t  param2;
}THRD_EVENT_T;


enum THRD_EVENTID_T
{
    THRD_MSGID_TIMER_FIRST,

    THRD_STATEA,
    THRD_STATEB,
    THRD_STATEC,

    THRD_MSGID_TIMER_LAST
};

std::mutex m;





void func_(THRD_EVENTID_T timerId_, int32_t pipeId_ )
{

    std::cout<<"done\n";
}


class Timer 
{

public:
    Timer(THRD_EVENTID_T timerId, int32_t pipeId, uint32_t msPeriod)
        : timerId_(timerId)
        , pipeId_(pipeId)
        , msPeriod_(msPeriod)
    {

    }


    Timer(const Timer &obj) // copy constructor
    {
        timerId_ = obj.timerId_;
        pipeId_ = obj.pipeId_;
        msPeriod_ = obj.msPeriod_; 
    }
    // Timer()
    // {

    // }

    Timer() = delete;
    Timer(Timer&&) = default;


    ~Timer() 
    {
        if (thread_.joinable())
            thread_.join();
    }

    void start()
    {
        std::cout<<"starting the timer\n";
        thread_ = std::thread
        { 
             [this]() 
            {
            std::unique_lock<std::mutex> lck(mutex_);
            cv_.wait_for(lck, msPeriod_, [this]() { return stop_waiting_.load(); });
            if (not stop_waiting_)
                func_(timerId_, pipeId_);
            }
        };
    }

    void stop()
    {
        stop_waiting_.store(true);
        std::cout<<"Stopping the timer\n";
        cv_.notify_one();
    }

    THRD_EVENTID_T GetTimerID()
    {
        return timerId_;
    }

private:
    std::chrono::milliseconds msPeriod_;
    THRD_EVENTID_T timerId_;
    int32_t pipeId_;
    std::thread thread_;
    std::condition_variable cv_;
    std::mutex mutex_;
    std::atomic<bool> stop_waiting_{false};
};


std::vector<Timer> tmrclass;

int32_t CreateTimer( const THRD_EVENTID_T timerId, const int32_t pipeId, const uint32_t msPeriod )
{
    std::cout<<"Creating the timer\n";
    std::unique_lock<std::mutex> lock(m);

    Timer c (timerId, pipeId, msPeriod);

    tmrclass.emplace_back(c);

    c.start();

    std::cout<<"exiting the createtimer function\n";

    std::cout<<"returning....\n";
    return 0;

}


int32_t Delete_Timer( const THRD_EVENTID_T timerId)
{
    int32_t ret = -1;
    std::cout<<"Deleting the timer function\n";
    std::unique_lock<std::mutex> lock(m);

    for (auto &f : tmrclass)
    {
        if(f.GetTimerID() == timerId)
        {
            std::cout<<"found the timer to delete\n";
            f.stop();
            break;
        }
        else
        {
            ret = -1;
        }

    }

     return ret;
}


int main(int argc, const char *argv[]) 
{

    THRD_EVENTID_T timerId;
    timerId  =  THRD_STATEA;
    int32_t pipeId = 0;
    uint32_t msPeriod = 5000;

    CreateTimer(timerId, pipeId, msPeriod);
    std::cout<<"Have I exited the resource\n";

    THRD_EVENTID_T timerId2;
    timerId2  =  THRD_STATEB;
    int32_t pipeId2 = 1;
    uint32_t msPeriod2 = 1000;
    CreateTimer(timerId2, pipeId2, msPeriod2);

    Delete_Timer(timerId);


    return 0;
}

当我运行它时，代码没有从函数返回，它最终在打印出来后被卡住了，我无法弄清楚为什么它没有从函数返回CreateTimerreturning....CreateTimer